├── .gitignore
├── .rspec
├── .travis.yml
├── CODE_OF_CONDUCT.md
├── Gemfile
├── LICENSE.txt
├── README.md
├── Rakefile
├── bin
    ├── console
    └── setup
├── jquery_with_bootstrap-0.1.1.gem
├── jquery_with_bootstrap.gemspec
├── lib
    ├── jquery_with_bootstrap.rb
    └── jquery_with_bootstrap
    │   └── version.rb
├── spec
    ├── jquery_with_bootstrap_spec.rb
    └── spec_helper.rb
└── vendor
    └── assets
        ├── javascripts
            ├── bootstrap.js
            ├── jquery.js
            ├── jquery_with_bootstrap.js
            └── popper.js
        └── stylesheets
            ├── bootstrap.css
            └── jquery_with_bootstrap.scss


/.gitignore:
--------------------------------------------------------------------------------
 1 | /.bundle/
 2 | /.yardoc
 3 | /_yardoc/
 4 | /coverage/
 5 | /doc/
 6 | /pkg/
 7 | /spec/reports/
 8 | /tmp/
 9 | 
10 | # rspec failure tracking
11 | .rspec_status
12 | 


--------------------------------------------------------------------------------
/.rspec:
--------------------------------------------------------------------------------
1 | --format documentation
2 | --color
3 | --require spec_helper
4 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | ---
2 | sudo: false
3 | language: ruby
4 | cache: bundler
5 | rvm:
6 |   - 2.5.1
7 | before_install: gem install bundler -v 2.0.1
8 | 


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | # Contributor Covenant Code of Conduct
 2 | 
 3 | ## Our Pledge
 4 | 
 5 | In the interest of fostering an open and welcoming environment, we as
 6 | contributors and maintainers pledge to making participation in our project and
 7 | our community a harassment-free experience for everyone, regardless of age, body
 8 | size, disability, ethnicity, gender identity and expression, level of experience,
 9 | nationality, personal appearance, race, religion, or sexual identity and
10 | orientation.
11 | 
12 | ## Our Standards
13 | 
14 | Examples of behavior that contributes to creating a positive environment
15 | include:
16 | 
17 | * Using welcoming and inclusive language
18 | * Being respectful of differing viewpoints and experiences
19 | * Gracefully accepting constructive criticism
20 | * Focusing on what is best for the community
21 | * Showing empathy towards other community members
22 | 
23 | Examples of unacceptable behavior by participants include:
24 | 
25 | * The use of sexualized language or imagery and unwelcome sexual attention or
26 | advances
27 | * Trolling, insulting/derogatory comments, and personal or political attacks
28 | * Public or private harassment
29 | * Publishing others' private information, such as a physical or electronic
30 |   address, without explicit permission
31 | * Other conduct which could reasonably be considered inappropriate in a
32 |   professional setting
33 | 
34 | ## Our Responsibilities
35 | 
36 | Project maintainers are responsible for clarifying the standards of acceptable
37 | behavior and are expected to take appropriate and fair corrective action in
38 | response to any instances of unacceptable behavior.
39 | 
40 | Project maintainers have the right and responsibility to remove, edit, or
41 | reject comments, commits, code, wiki edits, issues, and other contributions
42 | that are not aligned to this Code of Conduct, or to ban temporarily or
43 | permanently any contributor for other behaviors that they deem inappropriate,
44 | threatening, offensive, or harmful.
45 | 
46 | ## Scope
47 | 
48 | This Code of Conduct applies both within project spaces and in public spaces
49 | when an individual is representing the project or its community. Examples of
50 | representing a project or community include using an official project e-mail
51 | address, posting via an official social media account, or acting as an appointed
52 | representative at an online or offline event. Representation of a project may be
53 | further defined and clarified by project maintainers.
54 | 
55 | ## Enforcement
56 | 
57 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
58 | reported by contacting the project team at shashi.we@gmail.com. All
59 | complaints will be reviewed and investigated and will result in a response that
60 | is deemed necessary and appropriate to the circumstances. The project team is
61 | obligated to maintain confidentiality with regard to the reporter of an incident.
62 | Further details of specific enforcement policies may be posted separately.
63 | 
64 | Project maintainers who do not follow or enforce the Code of Conduct in good
65 | faith may face temporary or permanent repercussions as determined by other
66 | members of the project's leadership.
67 | 
68 | ## Attribution
69 | 
70 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
71 | available at [http://contributor-covenant.org/version/1/4][version]
72 | 
73 | [homepage]: http://contributor-covenant.org
74 | [version]: http://contributor-covenant.org/version/1/4/
75 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source "https://rubygems.org"
2 | 
3 | # Specify your gem's dependencies in jquery_with_bootstrap.gemspec
4 | gemspec
5 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2019 Shashi Singh
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # JqueryWithBootstrap
 2 | 
 3 | jquery_with_bootstrap gem is just a simple replacement for bootstrap-sass and jquery-rails gem. This gem will bundle both bootstrap and jquery in a single gem. 
 4 | 
 5 | ## Installation
 6 | 
 7 | Add this line to your application's Gemfile:
 8 | 
 9 | ```ruby
10 | gem 'jquery_with_bootstrap'
11 | ```
12 | 
13 | And then execute:
14 | 
15 |     $ bundle
16 | 
17 | Or install it yourself as:
18 | 
19 |     $ gem install jquery_with_bootstrap
20 | 
21 | ## Usage
22 | First convert your application.css into application.scss and add following line to this
23 | ```scss
24 | @import "jquery_with_bootstrap";
25 | ```
26 | 
27 | Now add following line to your application.js
28 | ```js
29 | //= require jquery_with_bootstrap
30 | ```
31 | 
32 | ## Development
33 | 
34 | After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
35 | 
36 | To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
37 | 
38 | ## Contributing
39 | 
40 | Bug reports and pull requests are welcome on GitHub at https://github.com/ravi4rails/jquery_with_bootstrap. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
41 | 
42 | ## License
43 | 
44 | The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
45 | 
46 | ## Code of Conduct
47 | 
48 | Everyone interacting in the JqueryWithBootstrap project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/ravi4rails/jquery_with_bootstrap/blob/master/CODE_OF_CONDUCT.md).
49 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
1 | require "bundler/gem_tasks"
2 | require "rspec/core/rake_task"
3 | 
4 | RSpec::Core::RakeTask.new(:spec)
5 | 
6 | task :default => :spec
7 | 


--------------------------------------------------------------------------------
/bin/console:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | 
 3 | require "bundler/setup"
 4 | require "jquery_with_bootstrap"
 5 | 
 6 | # You can add fixtures and/or initialization code here to make experimenting
 7 | # with your gem easier. You can also use a different console, if you like.
 8 | 
 9 | # (If you use this, don't forget to add pry to your Gemfile!)
10 | # require "pry"
11 | # Pry.start
12 | 
13 | require "irb"
14 | IRB.start(__FILE__)
15 | 


--------------------------------------------------------------------------------
/bin/setup:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | set -euo pipefail
3 | IFS=$'\n\t'
4 | set -vx
5 | 
6 | bundle install
7 | 
8 | # Do any other automated setup that you need to do here
9 | 


--------------------------------------------------------------------------------
/jquery_with_bootstrap-0.1.1.gem:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ravi4rails/jquery_with_bootstrap/5737b21e85fa69cf61e1428bff85fdfdc4047c0d/jquery_with_bootstrap-0.1.1.gem


--------------------------------------------------------------------------------
/jquery_with_bootstrap.gemspec:
--------------------------------------------------------------------------------
 1 | 
 2 | lib = File.expand_path("../lib", __FILE__)
 3 | $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 4 | require "jquery_with_bootstrap/version"
 5 | 
 6 | Gem::Specification.new do |spec|
 7 |   spec.name          = "jquery_with_bootstrap"
 8 |   spec.version       = JqueryWithBootstrap::VERSION
 9 |   spec.authors       = ["Ravi Singh"]
10 |   spec.email         = ["ravionrails@gmail.com"]
11 | 
12 |   spec.summary       = %q{Simple}
13 |   spec.description   = %q{Simple}
14 |   spec.homepage      = "https://rubygems.org/gems/jquery_with_bootstrap"
15 |   spec.license       = "MIT"
16 | 
17 |   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
18 |   # to allow pushing to a single host or delete this section to allow pushing to any host.
19 |   if spec.respond_to?(:metadata)
20 |     # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
21 | 
22 |     spec.metadata["homepage_uri"] = spec.homepage
23 |     spec.metadata["source_code_uri"] = "https://github.com/ravi4rails/jquery_with_bootstrap"
24 |     # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
25 |   else
26 |     raise "RubyGems 2.0 or newer is required to protect against " \
27 |       "public gem pushes."
28 |   end
29 | 
30 |   # Specify which files should be added to the gem when it is released.
31 |   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
32 |   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
33 |     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
34 |   end
35 |   spec.bindir        = "exe"
36 |   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
37 |   spec.require_paths = ["lib"]
38 | 
39 |   spec.add_development_dependency "bundler", "~> 2.0"
40 |   spec.add_development_dependency "rake", "~> 10.0"
41 |   spec.add_development_dependency "rspec", "~> 3.0"
42 |   spec.add_dependency "rails"
43 |   spec.add_dependency "sass"
44 |   spec.add_dependency "sass-rails"
45 | end
46 | 


--------------------------------------------------------------------------------
/lib/jquery_with_bootstrap.rb:
--------------------------------------------------------------------------------
1 | require "jquery_with_bootstrap/version"
2 | 
3 | module JqueryWithBootstrap
4 |   class Error < StandardError; end
5 |   class Engine < ::Rails::Engine
6 |   end
7 |   # Your code goes here...
8 | end
9 | 


--------------------------------------------------------------------------------
/lib/jquery_with_bootstrap/version.rb:
--------------------------------------------------------------------------------
1 | module JqueryWithBootstrap
2 |   VERSION = "0.1.1"
3 | end
4 | 


--------------------------------------------------------------------------------
/spec/jquery_with_bootstrap_spec.rb:
--------------------------------------------------------------------------------
 1 | RSpec.describe JqueryWithBootstrap do
 2 |   it "has a version number" do
 3 |     expect(JqueryWithBootstrap::VERSION).not_to be nil
 4 |   end
 5 | 
 6 |   it "does something useful" do
 7 |     expect(false).to eq(true)
 8 |   end
 9 | end
10 | 


--------------------------------------------------------------------------------
/spec/spec_helper.rb:
--------------------------------------------------------------------------------
 1 | require "bundler/setup"
 2 | require "jquery_with_bootstrap"
 3 | 
 4 | RSpec.configure do |config|
 5 |   # Enable flags like --only-failures and --next-failure
 6 |   config.example_status_persistence_file_path = ".rspec_status"
 7 | 
 8 |   # Disable RSpec exposing methods globally on `Module` and `main`
 9 |   config.disable_monkey_patching!
10 | 
11 |   config.expect_with :rspec do |c|
12 |     c.syntax = :expect
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/vendor/assets/javascripts/jquery_with_bootstrap.js:
--------------------------------------------------------------------------------
1 | //= require jquery
2 | //= require popper
3 | //= require bootstrap
4 | 


--------------------------------------------------------------------------------
/vendor/assets/javascripts/popper.js:
--------------------------------------------------------------------------------
   1 | /**!
   2 |  * @fileOverview Kickass library to create and place poppers near their reference elements.
   3 |  * @version 1.14.7
   4 |  * @license
   5 |  * Copyright (c) 2016 Federico Zivolo and contributors
   6 |  *
   7 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8 |  * of this software and associated documentation files (the "Software"), to deal
   9 |  * in the Software without restriction, including without limitation the rights
  10 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 |  * copies of the Software, and to permit persons to whom the Software is
  12 |  * furnished to do so, subject to the following conditions:
  13 |  *
  14 |  * The above copyright notice and this permission notice shall be included in all
  15 |  * copies or substantial portions of the Software.
  16 |  *
  17 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23 |  * SOFTWARE.
  24 |  */
  25 | (function (global, factory) {
  26 |   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  27 |   typeof define === 'function' && define.amd ? define(factory) :
  28 |   (global.Popper = factory());
  29 | }(this, (function () { 'use strict';
  30 | 
  31 | var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
  32 | 
  33 | var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
  34 | var timeoutDuration = 0;
  35 | for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
  36 |   if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
  37 |     timeoutDuration = 1;
  38 |     break;
  39 |   }
  40 | }
  41 | 
  42 | function microtaskDebounce(fn) {
  43 |   var called = false;
  44 |   return function () {
  45 |     if (called) {
  46 |       return;
  47 |     }
  48 |     called = true;
  49 |     window.Promise.resolve().then(function () {
  50 |       called = false;
  51 |       fn();
  52 |     });
  53 |   };
  54 | }
  55 | 
  56 | function taskDebounce(fn) {
  57 |   var scheduled = false;
  58 |   return function () {
  59 |     if (!scheduled) {
  60 |       scheduled = true;
  61 |       setTimeout(function () {
  62 |         scheduled = false;
  63 |         fn();
  64 |       }, timeoutDuration);
  65 |     }
  66 |   };
  67 | }
  68 | 
  69 | var supportsMicroTasks = isBrowser && window.Promise;
  70 | 
  71 | /**
  72 | * Create a debounced version of a method, that's asynchronously deferred
  73 | * but called in the minimum time possible.
  74 | *
  75 | * @method
  76 | * @memberof Popper.Utils
  77 | * @argument {Function} fn
  78 | * @returns {Function}
  79 | */
  80 | var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
  81 | 
  82 | /**
  83 |  * Check if the given variable is a function
  84 |  * @method
  85 |  * @memberof Popper.Utils
  86 |  * @argument {Any} functionToCheck - variable to check
  87 |  * @returns {Boolean} answer to: is a function?
  88 |  */
  89 | function isFunction(functionToCheck) {
  90 |   var getType = {};
  91 |   return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
  92 | }
  93 | 
  94 | /**
  95 |  * Get CSS computed property of the given element
  96 |  * @method
  97 |  * @memberof Popper.Utils
  98 |  * @argument {Eement} element
  99 |  * @argument {String} property
 100 |  */
 101 | function getStyleComputedProperty(element, property) {
 102 |   if (element.nodeType !== 1) {
 103 |     return [];
 104 |   }
 105 |   // NOTE: 1 DOM access here
 106 |   var window = element.ownerDocument.defaultView;
 107 |   var css = window.getComputedStyle(element, null);
 108 |   return property ? css[property] : css;
 109 | }
 110 | 
 111 | /**
 112 |  * Returns the parentNode or the host of the element
 113 |  * @method
 114 |  * @memberof Popper.Utils
 115 |  * @argument {Element} element
 116 |  * @returns {Element} parent
 117 |  */
 118 | function getParentNode(element) {
 119 |   if (element.nodeName === 'HTML') {
 120 |     return element;
 121 |   }
 122 |   return element.parentNode || element.host;
 123 | }
 124 | 
 125 | /**
 126 |  * Returns the scrolling parent of the given element
 127 |  * @method
 128 |  * @memberof Popper.Utils
 129 |  * @argument {Element} element
 130 |  * @returns {Element} scroll parent
 131 |  */
 132 | function getScrollParent(element) {
 133 |   // Return body, `getScroll` will take care to get the correct `scrollTop` from it
 134 |   if (!element) {
 135 |     return document.body;
 136 |   }
 137 | 
 138 |   switch (element.nodeName) {
 139 |     case 'HTML':
 140 |     case 'BODY':
 141 |       return element.ownerDocument.body;
 142 |     case '#document':
 143 |       return element.body;
 144 |   }
 145 | 
 146 |   // Firefox want us to check `-x` and `-y` variations as well
 147 | 
 148 |   var _getStyleComputedProp = getStyleComputedProperty(element),
 149 |       overflow = _getStyleComputedProp.overflow,
 150 |       overflowX = _getStyleComputedProp.overflowX,
 151 |       overflowY = _getStyleComputedProp.overflowY;
 152 | 
 153 |   if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
 154 |     return element;
 155 |   }
 156 | 
 157 |   return getScrollParent(getParentNode(element));
 158 | }
 159 | 
 160 | var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
 161 | var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
 162 | 
 163 | /**
 164 |  * Determines if the browser is Internet Explorer
 165 |  * @method
 166 |  * @memberof Popper.Utils
 167 |  * @param {Number} version to check
 168 |  * @returns {Boolean} isIE
 169 |  */
 170 | function isIE(version) {
 171 |   if (version === 11) {
 172 |     return isIE11;
 173 |   }
 174 |   if (version === 10) {
 175 |     return isIE10;
 176 |   }
 177 |   return isIE11 || isIE10;
 178 | }
 179 | 
 180 | /**
 181 |  * Returns the offset parent of the given element
 182 |  * @method
 183 |  * @memberof Popper.Utils
 184 |  * @argument {Element} element
 185 |  * @returns {Element} offset parent
 186 |  */
 187 | function getOffsetParent(element) {
 188 |   if (!element) {
 189 |     return document.documentElement;
 190 |   }
 191 | 
 192 |   var noOffsetParent = isIE(10) ? document.body : null;
 193 | 
 194 |   // NOTE: 1 DOM access here
 195 |   var offsetParent = element.offsetParent || null;
 196 |   // Skip hidden elements which don't have an offsetParent
 197 |   while (offsetParent === noOffsetParent && element.nextElementSibling) {
 198 |     offsetParent = (element = element.nextElementSibling).offsetParent;
 199 |   }
 200 | 
 201 |   var nodeName = offsetParent && offsetParent.nodeName;
 202 | 
 203 |   if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
 204 |     return element ? element.ownerDocument.documentElement : document.documentElement;
 205 |   }
 206 | 
 207 |   // .offsetParent will return the closest TH, TD or TABLE in case
 208 |   // no offsetParent is present, I hate this job...
 209 |   if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
 210 |     return getOffsetParent(offsetParent);
 211 |   }
 212 | 
 213 |   return offsetParent;
 214 | }
 215 | 
 216 | function isOffsetContainer(element) {
 217 |   var nodeName = element.nodeName;
 218 | 
 219 |   if (nodeName === 'BODY') {
 220 |     return false;
 221 |   }
 222 |   return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
 223 | }
 224 | 
 225 | /**
 226 |  * Finds the root node (document, shadowDOM root) of the given element
 227 |  * @method
 228 |  * @memberof Popper.Utils
 229 |  * @argument {Element} node
 230 |  * @returns {Element} root node
 231 |  */
 232 | function getRoot(node) {
 233 |   if (node.parentNode !== null) {
 234 |     return getRoot(node.parentNode);
 235 |   }
 236 | 
 237 |   return node;
 238 | }
 239 | 
 240 | /**
 241 |  * Finds the offset parent common to the two provided nodes
 242 |  * @method
 243 |  * @memberof Popper.Utils
 244 |  * @argument {Element} element1
 245 |  * @argument {Element} element2
 246 |  * @returns {Element} common offset parent
 247 |  */
 248 | function findCommonOffsetParent(element1, element2) {
 249 |   // This check is needed to avoid errors in case one of the elements isn't defined for any reason
 250 |   if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
 251 |     return document.documentElement;
 252 |   }
 253 | 
 254 |   // Here we make sure to give as "start" the element that comes first in the DOM
 255 |   var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
 256 |   var start = order ? element1 : element2;
 257 |   var end = order ? element2 : element1;
 258 | 
 259 |   // Get common ancestor container
 260 |   var range = document.createRange();
 261 |   range.setStart(start, 0);
 262 |   range.setEnd(end, 0);
 263 |   var commonAncestorContainer = range.commonAncestorContainer;
 264 | 
 265 |   // Both nodes are inside #document
 266 | 
 267 |   if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
 268 |     if (isOffsetContainer(commonAncestorContainer)) {
 269 |       return commonAncestorContainer;
 270 |     }
 271 | 
 272 |     return getOffsetParent(commonAncestorContainer);
 273 |   }
 274 | 
 275 |   // one of the nodes is inside shadowDOM, find which one
 276 |   var element1root = getRoot(element1);
 277 |   if (element1root.host) {
 278 |     return findCommonOffsetParent(element1root.host, element2);
 279 |   } else {
 280 |     return findCommonOffsetParent(element1, getRoot(element2).host);
 281 |   }
 282 | }
 283 | 
 284 | /**
 285 |  * Gets the scroll value of the given element in the given side (top and left)
 286 |  * @method
 287 |  * @memberof Popper.Utils
 288 |  * @argument {Element} element
 289 |  * @argument {String} side `top` or `left`
 290 |  * @returns {number} amount of scrolled pixels
 291 |  */
 292 | function getScroll(element) {
 293 |   var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
 294 | 
 295 |   var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
 296 |   var nodeName = element.nodeName;
 297 | 
 298 |   if (nodeName === 'BODY' || nodeName === 'HTML') {
 299 |     var html = element.ownerDocument.documentElement;
 300 |     var scrollingElement = element.ownerDocument.scrollingElement || html;
 301 |     return scrollingElement[upperSide];
 302 |   }
 303 | 
 304 |   return element[upperSide];
 305 | }
 306 | 
 307 | /*
 308 |  * Sum or subtract the element scroll values (left and top) from a given rect object
 309 |  * @method
 310 |  * @memberof Popper.Utils
 311 |  * @param {Object} rect - Rect object you want to change
 312 |  * @param {HTMLElement} element - The element from the function reads the scroll values
 313 |  * @param {Boolean} subtract - set to true if you want to subtract the scroll values
 314 |  * @return {Object} rect - The modifier rect object
 315 |  */
 316 | function includeScroll(rect, element) {
 317 |   var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
 318 | 
 319 |   var scrollTop = getScroll(element, 'top');
 320 |   var scrollLeft = getScroll(element, 'left');
 321 |   var modifier = subtract ? -1 : 1;
 322 |   rect.top += scrollTop * modifier;
 323 |   rect.bottom += scrollTop * modifier;
 324 |   rect.left += scrollLeft * modifier;
 325 |   rect.right += scrollLeft * modifier;
 326 |   return rect;
 327 | }
 328 | 
 329 | /*
 330 |  * Helper to detect borders of a given element
 331 |  * @method
 332 |  * @memberof Popper.Utils
 333 |  * @param {CSSStyleDeclaration} styles
 334 |  * Result of `getStyleComputedProperty` on the given element
 335 |  * @param {String} axis - `x` or `y`
 336 |  * @return {number} borders - The borders size of the given axis
 337 |  */
 338 | 
 339 | function getBordersSize(styles, axis) {
 340 |   var sideA = axis === 'x' ? 'Left' : 'Top';
 341 |   var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
 342 | 
 343 |   return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10);
 344 | }
 345 | 
 346 | function getSize(axis, body, html, computedStyle) {
 347 |   return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0);
 348 | }
 349 | 
 350 | function getWindowSizes(document) {
 351 |   var body = document.body;
 352 |   var html = document.documentElement;
 353 |   var computedStyle = isIE(10) && getComputedStyle(html);
 354 | 
 355 |   return {
 356 |     height: getSize('Height', body, html, computedStyle),
 357 |     width: getSize('Width', body, html, computedStyle)
 358 |   };
 359 | }
 360 | 
 361 | var classCallCheck = function (instance, Constructor) {
 362 |   if (!(instance instanceof Constructor)) {
 363 |     throw new TypeError("Cannot call a class as a function");
 364 |   }
 365 | };
 366 | 
 367 | var createClass = function () {
 368 |   function defineProperties(target, props) {
 369 |     for (var i = 0; i < props.length; i++) {
 370 |       var descriptor = props[i];
 371 |       descriptor.enumerable = descriptor.enumerable || false;
 372 |       descriptor.configurable = true;
 373 |       if ("value" in descriptor) descriptor.writable = true;
 374 |       Object.defineProperty(target, descriptor.key, descriptor);
 375 |     }
 376 |   }
 377 | 
 378 |   return function (Constructor, protoProps, staticProps) {
 379 |     if (protoProps) defineProperties(Constructor.prototype, protoProps);
 380 |     if (staticProps) defineProperties(Constructor, staticProps);
 381 |     return Constructor;
 382 |   };
 383 | }();
 384 | 
 385 | 
 386 | 
 387 | 
 388 | 
 389 | var defineProperty = function (obj, key, value) {
 390 |   if (key in obj) {
 391 |     Object.defineProperty(obj, key, {
 392 |       value: value,
 393 |       enumerable: true,
 394 |       configurable: true,
 395 |       writable: true
 396 |     });
 397 |   } else {
 398 |     obj[key] = value;
 399 |   }
 400 | 
 401 |   return obj;
 402 | };
 403 | 
 404 | var _extends = Object.assign || function (target) {
 405 |   for (var i = 1; i < arguments.length; i++) {
 406 |     var source = arguments[i];
 407 | 
 408 |     for (var key in source) {
 409 |       if (Object.prototype.hasOwnProperty.call(source, key)) {
 410 |         target[key] = source[key];
 411 |       }
 412 |     }
 413 |   }
 414 | 
 415 |   return target;
 416 | };
 417 | 
 418 | /**
 419 |  * Given element offsets, generate an output similar to getBoundingClientRect
 420 |  * @method
 421 |  * @memberof Popper.Utils
 422 |  * @argument {Object} offsets
 423 |  * @returns {Object} ClientRect like output
 424 |  */
 425 | function getClientRect(offsets) {
 426 |   return _extends({}, offsets, {
 427 |     right: offsets.left + offsets.width,
 428 |     bottom: offsets.top + offsets.height
 429 |   });
 430 | }
 431 | 
 432 | /**
 433 |  * Get bounding client rect of given element
 434 |  * @method
 435 |  * @memberof Popper.Utils
 436 |  * @param {HTMLElement} element
 437 |  * @return {Object} client rect
 438 |  */
 439 | function getBoundingClientRect(element) {
 440 |   var rect = {};
 441 | 
 442 |   // IE10 10 FIX: Please, don't ask, the element isn't
 443 |   // considered in DOM in some circumstances...
 444 |   // This isn't reproducible in IE10 compatibility mode of IE11
 445 |   try {
 446 |     if (isIE(10)) {
 447 |       rect = element.getBoundingClientRect();
 448 |       var scrollTop = getScroll(element, 'top');
 449 |       var scrollLeft = getScroll(element, 'left');
 450 |       rect.top += scrollTop;
 451 |       rect.left += scrollLeft;
 452 |       rect.bottom += scrollTop;
 453 |       rect.right += scrollLeft;
 454 |     } else {
 455 |       rect = element.getBoundingClientRect();
 456 |     }
 457 |   } catch (e) {}
 458 | 
 459 |   var result = {
 460 |     left: rect.left,
 461 |     top: rect.top,
 462 |     width: rect.right - rect.left,
 463 |     height: rect.bottom - rect.top
 464 |   };
 465 | 
 466 |   // subtract scrollbar size from sizes
 467 |   var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
 468 |   var width = sizes.width || element.clientWidth || result.right - result.left;
 469 |   var height = sizes.height || element.clientHeight || result.bottom - result.top;
 470 | 
 471 |   var horizScrollbar = element.offsetWidth - width;
 472 |   var vertScrollbar = element.offsetHeight - height;
 473 | 
 474 |   // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
 475 |   // we make this check conditional for performance reasons
 476 |   if (horizScrollbar || vertScrollbar) {
 477 |     var styles = getStyleComputedProperty(element);
 478 |     horizScrollbar -= getBordersSize(styles, 'x');
 479 |     vertScrollbar -= getBordersSize(styles, 'y');
 480 | 
 481 |     result.width -= horizScrollbar;
 482 |     result.height -= vertScrollbar;
 483 |   }
 484 | 
 485 |   return getClientRect(result);
 486 | }
 487 | 
 488 | function getOffsetRectRelativeToArbitraryNode(children, parent) {
 489 |   var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
 490 | 
 491 |   var isIE10 = isIE(10);
 492 |   var isHTML = parent.nodeName === 'HTML';
 493 |   var childrenRect = getBoundingClientRect(children);
 494 |   var parentRect = getBoundingClientRect(parent);
 495 |   var scrollParent = getScrollParent(children);
 496 | 
 497 |   var styles = getStyleComputedProperty(parent);
 498 |   var borderTopWidth = parseFloat(styles.borderTopWidth, 10);
 499 |   var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);
 500 | 
 501 |   // In cases where the parent is fixed, we must ignore negative scroll in offset calc
 502 |   if (fixedPosition && isHTML) {
 503 |     parentRect.top = Math.max(parentRect.top, 0);
 504 |     parentRect.left = Math.max(parentRect.left, 0);
 505 |   }
 506 |   var offsets = getClientRect({
 507 |     top: childrenRect.top - parentRect.top - borderTopWidth,
 508 |     left: childrenRect.left - parentRect.left - borderLeftWidth,
 509 |     width: childrenRect.width,
 510 |     height: childrenRect.height
 511 |   });
 512 |   offsets.marginTop = 0;
 513 |   offsets.marginLeft = 0;
 514 | 
 515 |   // Subtract margins of documentElement in case it's being used as parent
 516 |   // we do this only on HTML because it's the only element that behaves
 517 |   // differently when margins are applied to it. The margins are included in
 518 |   // the box of the documentElement, in the other cases not.
 519 |   if (!isIE10 && isHTML) {
 520 |     var marginTop = parseFloat(styles.marginTop, 10);
 521 |     var marginLeft = parseFloat(styles.marginLeft, 10);
 522 | 
 523 |     offsets.top -= borderTopWidth - marginTop;
 524 |     offsets.bottom -= borderTopWidth - marginTop;
 525 |     offsets.left -= borderLeftWidth - marginLeft;
 526 |     offsets.right -= borderLeftWidth - marginLeft;
 527 | 
 528 |     // Attach marginTop and marginLeft because in some circumstances we may need them
 529 |     offsets.marginTop = marginTop;
 530 |     offsets.marginLeft = marginLeft;
 531 |   }
 532 | 
 533 |   if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
 534 |     offsets = includeScroll(offsets, parent);
 535 |   }
 536 | 
 537 |   return offsets;
 538 | }
 539 | 
 540 | function getViewportOffsetRectRelativeToArtbitraryNode(element) {
 541 |   var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 542 | 
 543 |   var html = element.ownerDocument.documentElement;
 544 |   var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
 545 |   var width = Math.max(html.clientWidth, window.innerWidth || 0);
 546 |   var height = Math.max(html.clientHeight, window.innerHeight || 0);
 547 | 
 548 |   var scrollTop = !excludeScroll ? getScroll(html) : 0;
 549 |   var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
 550 | 
 551 |   var offset = {
 552 |     top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
 553 |     left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
 554 |     width: width,
 555 |     height: height
 556 |   };
 557 | 
 558 |   return getClientRect(offset);
 559 | }
 560 | 
 561 | /**
 562 |  * Check if the given element is fixed or is inside a fixed parent
 563 |  * @method
 564 |  * @memberof Popper.Utils
 565 |  * @argument {Element} element
 566 |  * @argument {Element} customContainer
 567 |  * @returns {Boolean} answer to "isFixed?"
 568 |  */
 569 | function isFixed(element) {
 570 |   var nodeName = element.nodeName;
 571 |   if (nodeName === 'BODY' || nodeName === 'HTML') {
 572 |     return false;
 573 |   }
 574 |   if (getStyleComputedProperty(element, 'position') === 'fixed') {
 575 |     return true;
 576 |   }
 577 |   var parentNode = getParentNode(element);
 578 |   if (!parentNode) {
 579 |     return false;
 580 |   }
 581 |   return isFixed(parentNode);
 582 | }
 583 | 
 584 | /**
 585 |  * Finds the first parent of an element that has a transformed property defined
 586 |  * @method
 587 |  * @memberof Popper.Utils
 588 |  * @argument {Element} element
 589 |  * @returns {Element} first transformed parent or documentElement
 590 |  */
 591 | 
 592 | function getFixedPositionOffsetParent(element) {
 593 |   // This check is needed to avoid errors in case one of the elements isn't defined for any reason
 594 |   if (!element || !element.parentElement || isIE()) {
 595 |     return document.documentElement;
 596 |   }
 597 |   var el = element.parentElement;
 598 |   while (el && getStyleComputedProperty(el, 'transform') === 'none') {
 599 |     el = el.parentElement;
 600 |   }
 601 |   return el || document.documentElement;
 602 | }
 603 | 
 604 | /**
 605 |  * Computed the boundaries limits and return them
 606 |  * @method
 607 |  * @memberof Popper.Utils
 608 |  * @param {HTMLElement} popper
 609 |  * @param {HTMLElement} reference
 610 |  * @param {number} padding
 611 |  * @param {HTMLElement} boundariesElement - Element used to define the boundaries
 612 |  * @param {Boolean} fixedPosition - Is in fixed position mode
 613 |  * @returns {Object} Coordinates of the boundaries
 614 |  */
 615 | function getBoundaries(popper, reference, padding, boundariesElement) {
 616 |   var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
 617 | 
 618 |   // NOTE: 1 DOM access here
 619 | 
 620 |   var boundaries = { top: 0, left: 0 };
 621 |   var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);
 622 | 
 623 |   // Handle viewport case
 624 |   if (boundariesElement === 'viewport') {
 625 |     boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
 626 |   } else {
 627 |     // Handle other cases based on DOM element used as boundaries
 628 |     var boundariesNode = void 0;
 629 |     if (boundariesElement === 'scrollParent') {
 630 |       boundariesNode = getScrollParent(getParentNode(reference));
 631 |       if (boundariesNode.nodeName === 'BODY') {
 632 |         boundariesNode = popper.ownerDocument.documentElement;
 633 |       }
 634 |     } else if (boundariesElement === 'window') {
 635 |       boundariesNode = popper.ownerDocument.documentElement;
 636 |     } else {
 637 |       boundariesNode = boundariesElement;
 638 |     }
 639 | 
 640 |     var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
 641 | 
 642 |     // In case of HTML, we need a different computation
 643 |     if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
 644 |       var _getWindowSizes = getWindowSizes(popper.ownerDocument),
 645 |           height = _getWindowSizes.height,
 646 |           width = _getWindowSizes.width;
 647 | 
 648 |       boundaries.top += offsets.top - offsets.marginTop;
 649 |       boundaries.bottom = height + offsets.top;
 650 |       boundaries.left += offsets.left - offsets.marginLeft;
 651 |       boundaries.right = width + offsets.left;
 652 |     } else {
 653 |       // for all the other DOM elements, this one is good
 654 |       boundaries = offsets;
 655 |     }
 656 |   }
 657 | 
 658 |   // Add paddings
 659 |   padding = padding || 0;
 660 |   var isPaddingNumber = typeof padding === 'number';
 661 |   boundaries.left += isPaddingNumber ? padding : padding.left || 0;
 662 |   boundaries.top += isPaddingNumber ? padding : padding.top || 0;
 663 |   boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
 664 |   boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
 665 | 
 666 |   return boundaries;
 667 | }
 668 | 
 669 | function getArea(_ref) {
 670 |   var width = _ref.width,
 671 |       height = _ref.height;
 672 | 
 673 |   return width * height;
 674 | }
 675 | 
 676 | /**
 677 |  * Utility used to transform the `auto` placement to the placement with more
 678 |  * available space.
 679 |  * @method
 680 |  * @memberof Popper.Utils
 681 |  * @argument {Object} data - The data object generated by update method
 682 |  * @argument {Object} options - Modifiers configuration and options
 683 |  * @returns {Object} The data object, properly modified
 684 |  */
 685 | function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
 686 |   var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
 687 | 
 688 |   if (placement.indexOf('auto') === -1) {
 689 |     return placement;
 690 |   }
 691 | 
 692 |   var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
 693 | 
 694 |   var rects = {
 695 |     top: {
 696 |       width: boundaries.width,
 697 |       height: refRect.top - boundaries.top
 698 |     },
 699 |     right: {
 700 |       width: boundaries.right - refRect.right,
 701 |       height: boundaries.height
 702 |     },
 703 |     bottom: {
 704 |       width: boundaries.width,
 705 |       height: boundaries.bottom - refRect.bottom
 706 |     },
 707 |     left: {
 708 |       width: refRect.left - boundaries.left,
 709 |       height: boundaries.height
 710 |     }
 711 |   };
 712 | 
 713 |   var sortedAreas = Object.keys(rects).map(function (key) {
 714 |     return _extends({
 715 |       key: key
 716 |     }, rects[key], {
 717 |       area: getArea(rects[key])
 718 |     });
 719 |   }).sort(function (a, b) {
 720 |     return b.area - a.area;
 721 |   });
 722 | 
 723 |   var filteredAreas = sortedAreas.filter(function (_ref2) {
 724 |     var width = _ref2.width,
 725 |         height = _ref2.height;
 726 |     return width >= popper.clientWidth && height >= popper.clientHeight;
 727 |   });
 728 | 
 729 |   var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
 730 | 
 731 |   var variation = placement.split('-')[1];
 732 | 
 733 |   return computedPlacement + (variation ? '-' + variation : '');
 734 | }
 735 | 
 736 | /**
 737 |  * Get offsets to the reference element
 738 |  * @method
 739 |  * @memberof Popper.Utils
 740 |  * @param {Object} state
 741 |  * @param {Element} popper - the popper element
 742 |  * @param {Element} reference - the reference element (the popper will be relative to this)
 743 |  * @param {Element} fixedPosition - is in fixed position mode
 744 |  * @returns {Object} An object containing the offsets which will be applied to the popper
 745 |  */
 746 | function getReferenceOffsets(state, popper, reference) {
 747 |   var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
 748 | 
 749 |   var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);
 750 |   return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
 751 | }
 752 | 
 753 | /**
 754 |  * Get the outer sizes of the given element (offset size + margins)
 755 |  * @method
 756 |  * @memberof Popper.Utils
 757 |  * @argument {Element} element
 758 |  * @returns {Object} object containing width and height properties
 759 |  */
 760 | function getOuterSizes(element) {
 761 |   var window = element.ownerDocument.defaultView;
 762 |   var styles = window.getComputedStyle(element);
 763 |   var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
 764 |   var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
 765 |   var result = {
 766 |     width: element.offsetWidth + y,
 767 |     height: element.offsetHeight + x
 768 |   };
 769 |   return result;
 770 | }
 771 | 
 772 | /**
 773 |  * Get the opposite placement of the given one
 774 |  * @method
 775 |  * @memberof Popper.Utils
 776 |  * @argument {String} placement
 777 |  * @returns {String} flipped placement
 778 |  */
 779 | function getOppositePlacement(placement) {
 780 |   var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
 781 |   return placement.replace(/left|right|bottom|top/g, function (matched) {
 782 |     return hash[matched];
 783 |   });
 784 | }
 785 | 
 786 | /**
 787 |  * Get offsets to the popper
 788 |  * @method
 789 |  * @memberof Popper.Utils
 790 |  * @param {Object} position - CSS position the Popper will get applied
 791 |  * @param {HTMLElement} popper - the popper element
 792 |  * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
 793 |  * @param {String} placement - one of the valid placement options
 794 |  * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
 795 |  */
 796 | function getPopperOffsets(popper, referenceOffsets, placement) {
 797 |   placement = placement.split('-')[0];
 798 | 
 799 |   // Get popper node sizes
 800 |   var popperRect = getOuterSizes(popper);
 801 | 
 802 |   // Add position, width and height to our offsets object
 803 |   var popperOffsets = {
 804 |     width: popperRect.width,
 805 |     height: popperRect.height
 806 |   };
 807 | 
 808 |   // depending by the popper placement we have to compute its offsets slightly differently
 809 |   var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
 810 |   var mainSide = isHoriz ? 'top' : 'left';
 811 |   var secondarySide = isHoriz ? 'left' : 'top';
 812 |   var measurement = isHoriz ? 'height' : 'width';
 813 |   var secondaryMeasurement = !isHoriz ? 'height' : 'width';
 814 | 
 815 |   popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
 816 |   if (placement === secondarySide) {
 817 |     popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
 818 |   } else {
 819 |     popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
 820 |   }
 821 | 
 822 |   return popperOffsets;
 823 | }
 824 | 
 825 | /**
 826 |  * Mimics the `find` method of Array
 827 |  * @method
 828 |  * @memberof Popper.Utils
 829 |  * @argument {Array} arr
 830 |  * @argument prop
 831 |  * @argument value
 832 |  * @returns index or -1
 833 |  */
 834 | function find(arr, check) {
 835 |   // use native find if supported
 836 |   if (Array.prototype.find) {
 837 |     return arr.find(check);
 838 |   }
 839 | 
 840 |   // use `filter` to obtain the same behavior of `find`
 841 |   return arr.filter(check)[0];
 842 | }
 843 | 
 844 | /**
 845 |  * Return the index of the matching object
 846 |  * @method
 847 |  * @memberof Popper.Utils
 848 |  * @argument {Array} arr
 849 |  * @argument prop
 850 |  * @argument value
 851 |  * @returns index or -1
 852 |  */
 853 | function findIndex(arr, prop, value) {
 854 |   // use native findIndex if supported
 855 |   if (Array.prototype.findIndex) {
 856 |     return arr.findIndex(function (cur) {
 857 |       return cur[prop] === value;
 858 |     });
 859 |   }
 860 | 
 861 |   // use `find` + `indexOf` if `findIndex` isn't supported
 862 |   var match = find(arr, function (obj) {
 863 |     return obj[prop] === value;
 864 |   });
 865 |   return arr.indexOf(match);
 866 | }
 867 | 
 868 | /**
 869 |  * Loop trough the list of modifiers and run them in order,
 870 |  * each of them will then edit the data object.
 871 |  * @method
 872 |  * @memberof Popper.Utils
 873 |  * @param {dataObject} data
 874 |  * @param {Array} modifiers
 875 |  * @param {String} ends - Optional modifier name used as stopper
 876 |  * @returns {dataObject}
 877 |  */
 878 | function runModifiers(modifiers, data, ends) {
 879 |   var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
 880 | 
 881 |   modifiersToRun.forEach(function (modifier) {
 882 |     if (modifier['function']) {
 883 |       // eslint-disable-line dot-notation
 884 |       console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
 885 |     }
 886 |     var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
 887 |     if (modifier.enabled && isFunction(fn)) {
 888 |       // Add properties to offsets to make them a complete clientRect object
 889 |       // we do this before each modifier to make sure the previous one doesn't
 890 |       // mess with these values
 891 |       data.offsets.popper = getClientRect(data.offsets.popper);
 892 |       data.offsets.reference = getClientRect(data.offsets.reference);
 893 | 
 894 |       data = fn(data, modifier);
 895 |     }
 896 |   });
 897 | 
 898 |   return data;
 899 | }
 900 | 
 901 | /**
 902 |  * Updates the position of the popper, computing the new offsets and applying
 903 |  * the new style.<br />
 904 |  * Prefer `scheduleUpdate` over `update` because of performance reasons.
 905 |  * @method
 906 |  * @memberof Popper
 907 |  */
 908 | function update() {
 909 |   // if popper is destroyed, don't perform any further update
 910 |   if (this.state.isDestroyed) {
 911 |     return;
 912 |   }
 913 | 
 914 |   var data = {
 915 |     instance: this,
 916 |     styles: {},
 917 |     arrowStyles: {},
 918 |     attributes: {},
 919 |     flipped: false,
 920 |     offsets: {}
 921 |   };
 922 | 
 923 |   // compute reference element offsets
 924 |   data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
 925 | 
 926 |   // compute auto placement, store placement inside the data object,
 927 |   // modifiers will be able to edit `placement` if needed
 928 |   // and refer to originalPlacement to know the original value
 929 |   data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
 930 | 
 931 |   // store the computed placement inside `originalPlacement`
 932 |   data.originalPlacement = data.placement;
 933 | 
 934 |   data.positionFixed = this.options.positionFixed;
 935 | 
 936 |   // compute the popper offsets
 937 |   data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
 938 | 
 939 |   data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';
 940 | 
 941 |   // run the modifiers
 942 |   data = runModifiers(this.modifiers, data);
 943 | 
 944 |   // the first `update` will call `onCreate` callback
 945 |   // the other ones will call `onUpdate` callback
 946 |   if (!this.state.isCreated) {
 947 |     this.state.isCreated = true;
 948 |     this.options.onCreate(data);
 949 |   } else {
 950 |     this.options.onUpdate(data);
 951 |   }
 952 | }
 953 | 
 954 | /**
 955 |  * Helper used to know if the given modifier is enabled.
 956 |  * @method
 957 |  * @memberof Popper.Utils
 958 |  * @returns {Boolean}
 959 |  */
 960 | function isModifierEnabled(modifiers, modifierName) {
 961 |   return modifiers.some(function (_ref) {
 962 |     var name = _ref.name,
 963 |         enabled = _ref.enabled;
 964 |     return enabled && name === modifierName;
 965 |   });
 966 | }
 967 | 
 968 | /**
 969 |  * Get the prefixed supported property name
 970 |  * @method
 971 |  * @memberof Popper.Utils
 972 |  * @argument {String} property (camelCase)
 973 |  * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
 974 |  */
 975 | function getSupportedPropertyName(property) {
 976 |   var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
 977 |   var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
 978 | 
 979 |   for (var i = 0; i < prefixes.length; i++) {
 980 |     var prefix = prefixes[i];
 981 |     var toCheck = prefix ? '' + prefix + upperProp : property;
 982 |     if (typeof document.body.style[toCheck] !== 'undefined') {
 983 |       return toCheck;
 984 |     }
 985 |   }
 986 |   return null;
 987 | }
 988 | 
 989 | /**
 990 |  * Destroys the popper.
 991 |  * @method
 992 |  * @memberof Popper
 993 |  */
 994 | function destroy() {
 995 |   this.state.isDestroyed = true;
 996 | 
 997 |   // touch DOM only if `applyStyle` modifier is enabled
 998 |   if (isModifierEnabled(this.modifiers, 'applyStyle')) {
 999 |     this.popper.removeAttribute('x-placement');
1000 |     this.popper.style.position = '';
1001 |     this.popper.style.top = '';
1002 |     this.popper.style.left = '';
1003 |     this.popper.style.right = '';
1004 |     this.popper.style.bottom = '';
1005 |     this.popper.style.willChange = '';
1006 |     this.popper.style[getSupportedPropertyName('transform')] = '';
1007 |   }
1008 | 
1009 |   this.disableEventListeners();
1010 | 
1011 |   // remove the popper if user explicity asked for the deletion on destroy
1012 |   // do not use `remove` because IE11 doesn't support it
1013 |   if (this.options.removeOnDestroy) {
1014 |     this.popper.parentNode.removeChild(this.popper);
1015 |   }
1016 |   return this;
1017 | }
1018 | 
1019 | /**
1020 |  * Get the window associated with the element
1021 |  * @argument {Element} element
1022 |  * @returns {Window}
1023 |  */
1024 | function getWindow(element) {
1025 |   var ownerDocument = element.ownerDocument;
1026 |   return ownerDocument ? ownerDocument.defaultView : window;
1027 | }
1028 | 
1029 | function attachToScrollParents(scrollParent, event, callback, scrollParents) {
1030 |   var isBody = scrollParent.nodeName === 'BODY';
1031 |   var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
1032 |   target.addEventListener(event, callback, { passive: true });
1033 | 
1034 |   if (!isBody) {
1035 |     attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
1036 |   }
1037 |   scrollParents.push(target);
1038 | }
1039 | 
1040 | /**
1041 |  * Setup needed event listeners used to update the popper position
1042 |  * @method
1043 |  * @memberof Popper.Utils
1044 |  * @private
1045 |  */
1046 | function setupEventListeners(reference, options, state, updateBound) {
1047 |   // Resize event listener on window
1048 |   state.updateBound = updateBound;
1049 |   getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
1050 | 
1051 |   // Scroll event listener on scroll parents
1052 |   var scrollElement = getScrollParent(reference);
1053 |   attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
1054 |   state.scrollElement = scrollElement;
1055 |   state.eventsEnabled = true;
1056 | 
1057 |   return state;
1058 | }
1059 | 
1060 | /**
1061 |  * It will add resize/scroll events and start recalculating
1062 |  * position of the popper element when they are triggered.
1063 |  * @method
1064 |  * @memberof Popper
1065 |  */
1066 | function enableEventListeners() {
1067 |   if (!this.state.eventsEnabled) {
1068 |     this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
1069 |   }
1070 | }
1071 | 
1072 | /**
1073 |  * Remove event listeners used to update the popper position
1074 |  * @method
1075 |  * @memberof Popper.Utils
1076 |  * @private
1077 |  */
1078 | function removeEventListeners(reference, state) {
1079 |   // Remove resize event listener on window
1080 |   getWindow(reference).removeEventListener('resize', state.updateBound);
1081 | 
1082 |   // Remove scroll event listener on scroll parents
1083 |   state.scrollParents.forEach(function (target) {
1084 |     target.removeEventListener('scroll', state.updateBound);
1085 |   });
1086 | 
1087 |   // Reset state
1088 |   state.updateBound = null;
1089 |   state.scrollParents = [];
1090 |   state.scrollElement = null;
1091 |   state.eventsEnabled = false;
1092 |   return state;
1093 | }
1094 | 
1095 | /**
1096 |  * It will remove resize/scroll events and won't recalculate popper position
1097 |  * when they are triggered. It also won't trigger `onUpdate` callback anymore,
1098 |  * unless you call `update` method manually.
1099 |  * @method
1100 |  * @memberof Popper
1101 |  */
1102 | function disableEventListeners() {
1103 |   if (this.state.eventsEnabled) {
1104 |     cancelAnimationFrame(this.scheduleUpdate);
1105 |     this.state = removeEventListeners(this.reference, this.state);
1106 |   }
1107 | }
1108 | 
1109 | /**
1110 |  * Tells if a given input is a number
1111 |  * @method
1112 |  * @memberof Popper.Utils
1113 |  * @param {*} input to check
1114 |  * @return {Boolean}
1115 |  */
1116 | function isNumeric(n) {
1117 |   return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
1118 | }
1119 | 
1120 | /**
1121 |  * Set the style to the given popper
1122 |  * @method
1123 |  * @memberof Popper.Utils
1124 |  * @argument {Element} element - Element to apply the style to
1125 |  * @argument {Object} styles
1126 |  * Object with a list of properties and values which will be applied to the element
1127 |  */
1128 | function setStyles(element, styles) {
1129 |   Object.keys(styles).forEach(function (prop) {
1130 |     var unit = '';
1131 |     // add unit if the value is numeric and is one of the following
1132 |     if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
1133 |       unit = 'px';
1134 |     }
1135 |     element.style[prop] = styles[prop] + unit;
1136 |   });
1137 | }
1138 | 
1139 | /**
1140 |  * Set the attributes to the given popper
1141 |  * @method
1142 |  * @memberof Popper.Utils
1143 |  * @argument {Element} element - Element to apply the attributes to
1144 |  * @argument {Object} styles
1145 |  * Object with a list of properties and values which will be applied to the element
1146 |  */
1147 | function setAttributes(element, attributes) {
1148 |   Object.keys(attributes).forEach(function (prop) {
1149 |     var value = attributes[prop];
1150 |     if (value !== false) {
1151 |       element.setAttribute(prop, attributes[prop]);
1152 |     } else {
1153 |       element.removeAttribute(prop);
1154 |     }
1155 |   });
1156 | }
1157 | 
1158 | /**
1159 |  * @function
1160 |  * @memberof Modifiers
1161 |  * @argument {Object} data - The data object generated by `update` method
1162 |  * @argument {Object} data.styles - List of style properties - values to apply to popper element
1163 |  * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
1164 |  * @argument {Object} options - Modifiers configuration and options
1165 |  * @returns {Object} The same data object
1166 |  */
1167 | function applyStyle(data) {
1168 |   // any property present in `data.styles` will be applied to the popper,
1169 |   // in this way we can make the 3rd party modifiers add custom styles to it
1170 |   // Be aware, modifiers could override the properties defined in the previous
1171 |   // lines of this modifier!
1172 |   setStyles(data.instance.popper, data.styles);
1173 | 
1174 |   // any property present in `data.attributes` will be applied to the popper,
1175 |   // they will be set as HTML attributes of the element
1176 |   setAttributes(data.instance.popper, data.attributes);
1177 | 
1178 |   // if arrowElement is defined and arrowStyles has some properties
1179 |   if (data.arrowElement && Object.keys(data.arrowStyles).length) {
1180 |     setStyles(data.arrowElement, data.arrowStyles);
1181 |   }
1182 | 
1183 |   return data;
1184 | }
1185 | 
1186 | /**
1187 |  * Set the x-placement attribute before everything else because it could be used
1188 |  * to add margins to the popper margins needs to be calculated to get the
1189 |  * correct popper offsets.
1190 |  * @method
1191 |  * @memberof Popper.modifiers
1192 |  * @param {HTMLElement} reference - The reference element used to position the popper
1193 |  * @param {HTMLElement} popper - The HTML element used as popper
1194 |  * @param {Object} options - Popper.js options
1195 |  */
1196 | function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
1197 |   // compute reference element offsets
1198 |   var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
1199 | 
1200 |   // compute auto placement, store placement inside the data object,
1201 |   // modifiers will be able to edit `placement` if needed
1202 |   // and refer to originalPlacement to know the original value
1203 |   var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
1204 | 
1205 |   popper.setAttribute('x-placement', placement);
1206 | 
1207 |   // Apply `position` to popper before anything else because
1208 |   // without the position applied we can't guarantee correct computations
1209 |   setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });
1210 | 
1211 |   return options;
1212 | }
1213 | 
1214 | /**
1215 |  * @function
1216 |  * @memberof Popper.Utils
1217 |  * @argument {Object} data - The data object generated by `update` method
1218 |  * @argument {Boolean} shouldRound - If the offsets should be rounded at all
1219 |  * @returns {Object} The popper's position offsets rounded
1220 |  *
1221 |  * The tale of pixel-perfect positioning. It's still not 100% perfect, but as
1222 |  * good as it can be within reason.
1223 |  * Discussion here: https://github.com/FezVrasta/popper.js/pull/715
1224 |  *
1225 |  * Low DPI screens cause a popper to be blurry if not using full pixels (Safari
1226 |  * as well on High DPI screens).
1227 |  *
1228 |  * Firefox prefers no rounding for positioning and does not have blurriness on
1229 |  * high DPI screens.
1230 |  *
1231 |  * Only horizontal placement and left/right values need to be considered.
1232 |  */
1233 | function getRoundedOffsets(data, shouldRound) {
1234 |   var _data$offsets = data.offsets,
1235 |       popper = _data$offsets.popper,
1236 |       reference = _data$offsets.reference;
1237 |   var round = Math.round,
1238 |       floor = Math.floor;
1239 | 
1240 |   var noRound = function noRound(v) {
1241 |     return v;
1242 |   };
1243 | 
1244 |   var referenceWidth = round(reference.width);
1245 |   var popperWidth = round(popper.width);
1246 | 
1247 |   var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;
1248 |   var isVariation = data.placement.indexOf('-') !== -1;
1249 |   var sameWidthParity = referenceWidth % 2 === popperWidth % 2;
1250 |   var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
1251 | 
1252 |   var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
1253 |   var verticalToInteger = !shouldRound ? noRound : round;
1254 | 
1255 |   return {
1256 |     left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
1257 |     top: verticalToInteger(popper.top),
1258 |     bottom: verticalToInteger(popper.bottom),
1259 |     right: horizontalToInteger(popper.right)
1260 |   };
1261 | }
1262 | 
1263 | var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
1264 | 
1265 | /**
1266 |  * @function
1267 |  * @memberof Modifiers
1268 |  * @argument {Object} data - The data object generated by `update` method
1269 |  * @argument {Object} options - Modifiers configuration and options
1270 |  * @returns {Object} The data object, properly modified
1271 |  */
1272 | function computeStyle(data, options) {
1273 |   var x = options.x,
1274 |       y = options.y;
1275 |   var popper = data.offsets.popper;
1276 | 
1277 |   // Remove this legacy support in Popper.js v2
1278 | 
1279 |   var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
1280 |     return modifier.name === 'applyStyle';
1281 |   }).gpuAcceleration;
1282 |   if (legacyGpuAccelerationOption !== undefined) {
1283 |     console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
1284 |   }
1285 |   var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
1286 | 
1287 |   var offsetParent = getOffsetParent(data.instance.popper);
1288 |   var offsetParentRect = getBoundingClientRect(offsetParent);
1289 | 
1290 |   // Styles
1291 |   var styles = {
1292 |     position: popper.position
1293 |   };
1294 | 
1295 |   var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);
1296 | 
1297 |   var sideA = x === 'bottom' ? 'top' : 'bottom';
1298 |   var sideB = y === 'right' ? 'left' : 'right';
1299 | 
1300 |   // if gpuAcceleration is set to `true` and transform is supported,
1301 |   //  we use `translate3d` to apply the position to the popper we
1302 |   // automatically use the supported prefixed version if needed
1303 |   var prefixedProperty = getSupportedPropertyName('transform');
1304 | 
1305 |   // now, let's make a step back and look at this code closely (wtf?)
1306 |   // If the content of the popper grows once it's been positioned, it
1307 |   // may happen that the popper gets misplaced because of the new content
1308 |   // overflowing its reference element
1309 |   // To avoid this problem, we provide two options (x and y), which allow
1310 |   // the consumer to define the offset origin.
1311 |   // If we position a popper on top of a reference element, we can set
1312 |   // `x` to `top` to make the popper grow towards its top instead of
1313 |   // its bottom.
1314 |   var left = void 0,
1315 |       top = void 0;
1316 |   if (sideA === 'bottom') {
1317 |     // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)
1318 |     // and not the bottom of the html element
1319 |     if (offsetParent.nodeName === 'HTML') {
1320 |       top = -offsetParent.clientHeight + offsets.bottom;
1321 |     } else {
1322 |       top = -offsetParentRect.height + offsets.bottom;
1323 |     }
1324 |   } else {
1325 |     top = offsets.top;
1326 |   }
1327 |   if (sideB === 'right') {
1328 |     if (offsetParent.nodeName === 'HTML') {
1329 |       left = -offsetParent.clientWidth + offsets.right;
1330 |     } else {
1331 |       left = -offsetParentRect.width + offsets.right;
1332 |     }
1333 |   } else {
1334 |     left = offsets.left;
1335 |   }
1336 |   if (gpuAcceleration && prefixedProperty) {
1337 |     styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
1338 |     styles[sideA] = 0;
1339 |     styles[sideB] = 0;
1340 |     styles.willChange = 'transform';
1341 |   } else {
1342 |     // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
1343 |     var invertTop = sideA === 'bottom' ? -1 : 1;
1344 |     var invertLeft = sideB === 'right' ? -1 : 1;
1345 |     styles[sideA] = top * invertTop;
1346 |     styles[sideB] = left * invertLeft;
1347 |     styles.willChange = sideA + ', ' + sideB;
1348 |   }
1349 | 
1350 |   // Attributes
1351 |   var attributes = {
1352 |     'x-placement': data.placement
1353 |   };
1354 | 
1355 |   // Update `data` attributes, styles and arrowStyles
1356 |   data.attributes = _extends({}, attributes, data.attributes);
1357 |   data.styles = _extends({}, styles, data.styles);
1358 |   data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
1359 | 
1360 |   return data;
1361 | }
1362 | 
1363 | /**
1364 |  * Helper used to know if the given modifier depends from another one.<br />
1365 |  * It checks if the needed modifier is listed and enabled.
1366 |  * @method
1367 |  * @memberof Popper.Utils
1368 |  * @param {Array} modifiers - list of modifiers
1369 |  * @param {String} requestingName - name of requesting modifier
1370 |  * @param {String} requestedName - name of requested modifier
1371 |  * @returns {Boolean}
1372 |  */
1373 | function isModifierRequired(modifiers, requestingName, requestedName) {
1374 |   var requesting = find(modifiers, function (_ref) {
1375 |     var name = _ref.name;
1376 |     return name === requestingName;
1377 |   });
1378 | 
1379 |   var isRequired = !!requesting && modifiers.some(function (modifier) {
1380 |     return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
1381 |   });
1382 | 
1383 |   if (!isRequired) {
1384 |     var _requesting = '`' + requestingName + '`';
1385 |     var requested = '`' + requestedName + '`';
1386 |     console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
1387 |   }
1388 |   return isRequired;
1389 | }
1390 | 
1391 | /**
1392 |  * @function
1393 |  * @memberof Modifiers
1394 |  * @argument {Object} data - The data object generated by update method
1395 |  * @argument {Object} options - Modifiers configuration and options
1396 |  * @returns {Object} The data object, properly modified
1397 |  */
1398 | function arrow(data, options) {
1399 |   var _data$offsets$arrow;
1400 | 
1401 |   // arrow depends on keepTogether in order to work
1402 |   if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
1403 |     return data;
1404 |   }
1405 | 
1406 |   var arrowElement = options.element;
1407 | 
1408 |   // if arrowElement is a string, suppose it's a CSS selector
1409 |   if (typeof arrowElement === 'string') {
1410 |     arrowElement = data.instance.popper.querySelector(arrowElement);
1411 | 
1412 |     // if arrowElement is not found, don't run the modifier
1413 |     if (!arrowElement) {
1414 |       return data;
1415 |     }
1416 |   } else {
1417 |     // if the arrowElement isn't a query selector we must check that the
1418 |     // provided DOM node is child of its popper node
1419 |     if (!data.instance.popper.contains(arrowElement)) {
1420 |       console.warn('WARNING: `arrow.element` must be child of its popper element!');
1421 |       return data;
1422 |     }
1423 |   }
1424 | 
1425 |   var placement = data.placement.split('-')[0];
1426 |   var _data$offsets = data.offsets,
1427 |       popper = _data$offsets.popper,
1428 |       reference = _data$offsets.reference;
1429 | 
1430 |   var isVertical = ['left', 'right'].indexOf(placement) !== -1;
1431 | 
1432 |   var len = isVertical ? 'height' : 'width';
1433 |   var sideCapitalized = isVertical ? 'Top' : 'Left';
1434 |   var side = sideCapitalized.toLowerCase();
1435 |   var altSide = isVertical ? 'left' : 'top';
1436 |   var opSide = isVertical ? 'bottom' : 'right';
1437 |   var arrowElementSize = getOuterSizes(arrowElement)[len];
1438 | 
1439 |   //
1440 |   // extends keepTogether behavior making sure the popper and its
1441 |   // reference have enough pixels in conjunction
1442 |   //
1443 | 
1444 |   // top/left side
1445 |   if (reference[opSide] - arrowElementSize < popper[side]) {
1446 |     data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
1447 |   }
1448 |   // bottom/right side
1449 |   if (reference[side] + arrowElementSize > popper[opSide]) {
1450 |     data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
1451 |   }
1452 |   data.offsets.popper = getClientRect(data.offsets.popper);
1453 | 
1454 |   // compute center of the popper
1455 |   var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
1456 | 
1457 |   // Compute the sideValue using the updated popper offsets
1458 |   // take popper margin in account because we don't have this info available
1459 |   var css = getStyleComputedProperty(data.instance.popper);
1460 |   var popperMarginSide = parseFloat(css['margin' + sideCapitalized], 10);
1461 |   var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width'], 10);
1462 |   var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
1463 | 
1464 |   // prevent arrowElement from being placed not contiguously to its popper
1465 |   sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
1466 | 
1467 |   data.arrowElement = arrowElement;
1468 |   data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);
1469 | 
1470 |   return data;
1471 | }
1472 | 
1473 | /**
1474 |  * Get the opposite placement variation of the given one
1475 |  * @method
1476 |  * @memberof Popper.Utils
1477 |  * @argument {String} placement variation
1478 |  * @returns {String} flipped placement variation
1479 |  */
1480 | function getOppositeVariation(variation) {
1481 |   if (variation === 'end') {
1482 |     return 'start';
1483 |   } else if (variation === 'start') {
1484 |     return 'end';
1485 |   }
1486 |   return variation;
1487 | }
1488 | 
1489 | /**
1490 |  * List of accepted placements to use as values of the `placement` option.<br />
1491 |  * Valid placements are:
1492 |  * - `auto`
1493 |  * - `top`
1494 |  * - `right`
1495 |  * - `bottom`
1496 |  * - `left`
1497 |  *
1498 |  * Each placement can have a variation from this list:
1499 |  * - `-start`
1500 |  * - `-end`
1501 |  *
1502 |  * Variations are interpreted easily if you think of them as the left to right
1503 |  * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`
1504 |  * is right.<br />
1505 |  * Vertically (`left` and `right`), `start` is top and `end` is bottom.
1506 |  *
1507 |  * Some valid examples are:
1508 |  * - `top-end` (on top of reference, right aligned)
1509 |  * - `right-start` (on right of reference, top aligned)
1510 |  * - `bottom` (on bottom, centered)
1511 |  * - `auto-end` (on the side with more space available, alignment depends by placement)
1512 |  *
1513 |  * @static
1514 |  * @type {Array}
1515 |  * @enum {String}
1516 |  * @readonly
1517 |  * @method placements
1518 |  * @memberof Popper
1519 |  */
1520 | var placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];
1521 | 
1522 | // Get rid of `auto` `auto-start` and `auto-end`
1523 | var validPlacements = placements.slice(3);
1524 | 
1525 | /**
1526 |  * Given an initial placement, returns all the subsequent placements
1527 |  * clockwise (or counter-clockwise).
1528 |  *
1529 |  * @method
1530 |  * @memberof Popper.Utils
1531 |  * @argument {String} placement - A valid placement (it accepts variations)
1532 |  * @argument {Boolean} counter - Set to true to walk the placements counterclockwise
1533 |  * @returns {Array} placements including their variations
1534 |  */
1535 | function clockwise(placement) {
1536 |   var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
1537 | 
1538 |   var index = validPlacements.indexOf(placement);
1539 |   var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
1540 |   return counter ? arr.reverse() : arr;
1541 | }
1542 | 
1543 | var BEHAVIORS = {
1544 |   FLIP: 'flip',
1545 |   CLOCKWISE: 'clockwise',
1546 |   COUNTERCLOCKWISE: 'counterclockwise'
1547 | };
1548 | 
1549 | /**
1550 |  * @function
1551 |  * @memberof Modifiers
1552 |  * @argument {Object} data - The data object generated by update method
1553 |  * @argument {Object} options - Modifiers configuration and options
1554 |  * @returns {Object} The data object, properly modified
1555 |  */
1556 | function flip(data, options) {
1557 |   // if `inner` modifier is enabled, we can't use the `flip` modifier
1558 |   if (isModifierEnabled(data.instance.modifiers, 'inner')) {
1559 |     return data;
1560 |   }
1561 | 
1562 |   if (data.flipped && data.placement === data.originalPlacement) {
1563 |     // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides
1564 |     return data;
1565 |   }
1566 | 
1567 |   var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
1568 | 
1569 |   var placement = data.placement.split('-')[0];
1570 |   var placementOpposite = getOppositePlacement(placement);
1571 |   var variation = data.placement.split('-')[1] || '';
1572 | 
1573 |   var flipOrder = [];
1574 | 
1575 |   switch (options.behavior) {
1576 |     case BEHAVIORS.FLIP:
1577 |       flipOrder = [placement, placementOpposite];
1578 |       break;
1579 |     case BEHAVIORS.CLOCKWISE:
1580 |       flipOrder = clockwise(placement);
1581 |       break;
1582 |     case BEHAVIORS.COUNTERCLOCKWISE:
1583 |       flipOrder = clockwise(placement, true);
1584 |       break;
1585 |     default:
1586 |       flipOrder = options.behavior;
1587 |   }
1588 | 
1589 |   flipOrder.forEach(function (step, index) {
1590 |     if (placement !== step || flipOrder.length === index + 1) {
1591 |       return data;
1592 |     }
1593 | 
1594 |     placement = data.placement.split('-')[0];
1595 |     placementOpposite = getOppositePlacement(placement);
1596 | 
1597 |     var popperOffsets = data.offsets.popper;
1598 |     var refOffsets = data.offsets.reference;
1599 | 
1600 |     // using floor because the reference offsets may contain decimals we are not going to consider here
1601 |     var floor = Math.floor;
1602 |     var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);
1603 | 
1604 |     var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
1605 |     var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
1606 |     var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
1607 |     var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
1608 | 
1609 |     var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
1610 | 
1611 |     // flip the variation if required
1612 |     var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
1613 |     var flippedVariation = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
1614 | 
1615 |     if (overlapsRef || overflowsBoundaries || flippedVariation) {
1616 |       // this boolean to detect any flip loop
1617 |       data.flipped = true;
1618 | 
1619 |       if (overlapsRef || overflowsBoundaries) {
1620 |         placement = flipOrder[index + 1];
1621 |       }
1622 | 
1623 |       if (flippedVariation) {
1624 |         variation = getOppositeVariation(variation);
1625 |       }
1626 | 
1627 |       data.placement = placement + (variation ? '-' + variation : '');
1628 | 
1629 |       // this object contains `position`, we want to preserve it along with
1630 |       // any additional property we may add in the future
1631 |       data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
1632 | 
1633 |       data = runModifiers(data.instance.modifiers, data, 'flip');
1634 |     }
1635 |   });
1636 |   return data;
1637 | }
1638 | 
1639 | /**
1640 |  * @function
1641 |  * @memberof Modifiers
1642 |  * @argument {Object} data - The data object generated by update method
1643 |  * @argument {Object} options - Modifiers configuration and options
1644 |  * @returns {Object} The data object, properly modified
1645 |  */
1646 | function keepTogether(data) {
1647 |   var _data$offsets = data.offsets,
1648 |       popper = _data$offsets.popper,
1649 |       reference = _data$offsets.reference;
1650 | 
1651 |   var placement = data.placement.split('-')[0];
1652 |   var floor = Math.floor;
1653 |   var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
1654 |   var side = isVertical ? 'right' : 'bottom';
1655 |   var opSide = isVertical ? 'left' : 'top';
1656 |   var measurement = isVertical ? 'width' : 'height';
1657 | 
1658 |   if (popper[side] < floor(reference[opSide])) {
1659 |     data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
1660 |   }
1661 |   if (popper[opSide] > floor(reference[side])) {
1662 |     data.offsets.popper[opSide] = floor(reference[side]);
1663 |   }
1664 | 
1665 |   return data;
1666 | }
1667 | 
1668 | /**
1669 |  * Converts a string containing value + unit into a px value number
1670 |  * @function
1671 |  * @memberof {modifiers~offset}
1672 |  * @private
1673 |  * @argument {String} str - Value + unit string
1674 |  * @argument {String} measurement - `height` or `width`
1675 |  * @argument {Object} popperOffsets
1676 |  * @argument {Object} referenceOffsets
1677 |  * @returns {Number|String}
1678 |  * Value in pixels, or original string if no values were extracted
1679 |  */
1680 | function toValue(str, measurement, popperOffsets, referenceOffsets) {
1681 |   // separate value from unit
1682 |   var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
1683 |   var value = +split[1];
1684 |   var unit = split[2];
1685 | 
1686 |   // If it's not a number it's an operator, I guess
1687 |   if (!value) {
1688 |     return str;
1689 |   }
1690 | 
1691 |   if (unit.indexOf('%') === 0) {
1692 |     var element = void 0;
1693 |     switch (unit) {
1694 |       case '%p':
1695 |         element = popperOffsets;
1696 |         break;
1697 |       case '%':
1698 |       case '%r':
1699 |       default:
1700 |         element = referenceOffsets;
1701 |     }
1702 | 
1703 |     var rect = getClientRect(element);
1704 |     return rect[measurement] / 100 * value;
1705 |   } else if (unit === 'vh' || unit === 'vw') {
1706 |     // if is a vh or vw, we calculate the size based on the viewport
1707 |     var size = void 0;
1708 |     if (unit === 'vh') {
1709 |       size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
1710 |     } else {
1711 |       size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
1712 |     }
1713 |     return size / 100 * value;
1714 |   } else {
1715 |     // if is an explicit pixel unit, we get rid of the unit and keep the value
1716 |     // if is an implicit unit, it's px, and we return just the value
1717 |     return value;
1718 |   }
1719 | }
1720 | 
1721 | /**
1722 |  * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.
1723 |  * @function
1724 |  * @memberof {modifiers~offset}
1725 |  * @private
1726 |  * @argument {String} offset
1727 |  * @argument {Object} popperOffsets
1728 |  * @argument {Object} referenceOffsets
1729 |  * @argument {String} basePlacement
1730 |  * @returns {Array} a two cells array with x and y offsets in numbers
1731 |  */
1732 | function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
1733 |   var offsets = [0, 0];
1734 | 
1735 |   // Use height if placement is left or right and index is 0 otherwise use width
1736 |   // in this way the first offset will use an axis and the second one
1737 |   // will use the other one
1738 |   var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
1739 | 
1740 |   // Split the offset string to obtain a list of values and operands
1741 |   // The regex addresses values with the plus or minus sign in front (+10, -20, etc)
1742 |   var fragments = offset.split(/(\+|\-)/).map(function (frag) {
1743 |     return frag.trim();
1744 |   });
1745 | 
1746 |   // Detect if the offset string contains a pair of values or a single one
1747 |   // they could be separated by comma or space
1748 |   var divider = fragments.indexOf(find(fragments, function (frag) {
1749 |     return frag.search(/,|\s/) !== -1;
1750 |   }));
1751 | 
1752 |   if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
1753 |     console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
1754 |   }
1755 | 
1756 |   // If divider is found, we divide the list of values and operands to divide
1757 |   // them by ofset X and Y.
1758 |   var splitRegex = /\s*,\s*|\s+/;
1759 |   var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
1760 | 
1761 |   // Convert the values with units to absolute pixels to allow our computations
1762 |   ops = ops.map(function (op, index) {
1763 |     // Most of the units rely on the orientation of the popper
1764 |     var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
1765 |     var mergeWithPrevious = false;
1766 |     return op
1767 |     // This aggregates any `+` or `-` sign that aren't considered operators
1768 |     // e.g.: 10 + +5 => [10, +, +5]
1769 |     .reduce(function (a, b) {
1770 |       if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
1771 |         a[a.length - 1] = b;
1772 |         mergeWithPrevious = true;
1773 |         return a;
1774 |       } else if (mergeWithPrevious) {
1775 |         a[a.length - 1] += b;
1776 |         mergeWithPrevious = false;
1777 |         return a;
1778 |       } else {
1779 |         return a.concat(b);
1780 |       }
1781 |     }, [])
1782 |     // Here we convert the string values into number values (in px)
1783 |     .map(function (str) {
1784 |       return toValue(str, measurement, popperOffsets, referenceOffsets);
1785 |     });
1786 |   });
1787 | 
1788 |   // Loop trough the offsets arrays and execute the operations
1789 |   ops.forEach(function (op, index) {
1790 |     op.forEach(function (frag, index2) {
1791 |       if (isNumeric(frag)) {
1792 |         offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
1793 |       }
1794 |     });
1795 |   });
1796 |   return offsets;
1797 | }
1798 | 
1799 | /**
1800 |  * @function
1801 |  * @memberof Modifiers
1802 |  * @argument {Object} data - The data object generated by update method
1803 |  * @argument {Object} options - Modifiers configuration and options
1804 |  * @argument {Number|String} options.offset=0
1805 |  * The offset value as described in the modifier description
1806 |  * @returns {Object} The data object, properly modified
1807 |  */
1808 | function offset(data, _ref) {
1809 |   var offset = _ref.offset;
1810 |   var placement = data.placement,
1811 |       _data$offsets = data.offsets,
1812 |       popper = _data$offsets.popper,
1813 |       reference = _data$offsets.reference;
1814 | 
1815 |   var basePlacement = placement.split('-')[0];
1816 | 
1817 |   var offsets = void 0;
1818 |   if (isNumeric(+offset)) {
1819 |     offsets = [+offset, 0];
1820 |   } else {
1821 |     offsets = parseOffset(offset, popper, reference, basePlacement);
1822 |   }
1823 | 
1824 |   if (basePlacement === 'left') {
1825 |     popper.top += offsets[0];
1826 |     popper.left -= offsets[1];
1827 |   } else if (basePlacement === 'right') {
1828 |     popper.top += offsets[0];
1829 |     popper.left += offsets[1];
1830 |   } else if (basePlacement === 'top') {
1831 |     popper.left += offsets[0];
1832 |     popper.top -= offsets[1];
1833 |   } else if (basePlacement === 'bottom') {
1834 |     popper.left += offsets[0];
1835 |     popper.top += offsets[1];
1836 |   }
1837 | 
1838 |   data.popper = popper;
1839 |   return data;
1840 | }
1841 | 
1842 | /**
1843 |  * @function
1844 |  * @memberof Modifiers
1845 |  * @argument {Object} data - The data object generated by `update` method
1846 |  * @argument {Object} options - Modifiers configuration and options
1847 |  * @returns {Object} The data object, properly modified
1848 |  */
1849 | function preventOverflow(data, options) {
1850 |   var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
1851 | 
1852 |   // If offsetParent is the reference element, we really want to
1853 |   // go one step up and use the next offsetParent as reference to
1854 |   // avoid to make this modifier completely useless and look like broken
1855 |   if (data.instance.reference === boundariesElement) {
1856 |     boundariesElement = getOffsetParent(boundariesElement);
1857 |   }
1858 | 
1859 |   // NOTE: DOM access here
1860 |   // resets the popper's position so that the document size can be calculated excluding
1861 |   // the size of the popper element itself
1862 |   var transformProp = getSupportedPropertyName('transform');
1863 |   var popperStyles = data.instance.popper.style; // assignment to help minification
1864 |   var top = popperStyles.top,
1865 |       left = popperStyles.left,
1866 |       transform = popperStyles[transformProp];
1867 | 
1868 |   popperStyles.top = '';
1869 |   popperStyles.left = '';
1870 |   popperStyles[transformProp] = '';
1871 | 
1872 |   var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
1873 | 
1874 |   // NOTE: DOM access here
1875 |   // restores the original style properties after the offsets have been computed
1876 |   popperStyles.top = top;
1877 |   popperStyles.left = left;
1878 |   popperStyles[transformProp] = transform;
1879 | 
1880 |   options.boundaries = boundaries;
1881 | 
1882 |   var order = options.priority;
1883 |   var popper = data.offsets.popper;
1884 | 
1885 |   var check = {
1886 |     primary: function primary(placement) {
1887 |       var value = popper[placement];
1888 |       if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
1889 |         value = Math.max(popper[placement], boundaries[placement]);
1890 |       }
1891 |       return defineProperty({}, placement, value);
1892 |     },
1893 |     secondary: function secondary(placement) {
1894 |       var mainSide = placement === 'right' ? 'left' : 'top';
1895 |       var value = popper[mainSide];
1896 |       if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
1897 |         value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
1898 |       }
1899 |       return defineProperty({}, mainSide, value);
1900 |     }
1901 |   };
1902 | 
1903 |   order.forEach(function (placement) {
1904 |     var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
1905 |     popper = _extends({}, popper, check[side](placement));
1906 |   });
1907 | 
1908 |   data.offsets.popper = popper;
1909 | 
1910 |   return data;
1911 | }
1912 | 
1913 | /**
1914 |  * @function
1915 |  * @memberof Modifiers
1916 |  * @argument {Object} data - The data object generated by `update` method
1917 |  * @argument {Object} options - Modifiers configuration and options
1918 |  * @returns {Object} The data object, properly modified
1919 |  */
1920 | function shift(data) {
1921 |   var placement = data.placement;
1922 |   var basePlacement = placement.split('-')[0];
1923 |   var shiftvariation = placement.split('-')[1];
1924 | 
1925 |   // if shift shiftvariation is specified, run the modifier
1926 |   if (shiftvariation) {
1927 |     var _data$offsets = data.offsets,
1928 |         reference = _data$offsets.reference,
1929 |         popper = _data$offsets.popper;
1930 | 
1931 |     var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
1932 |     var side = isVertical ? 'left' : 'top';
1933 |     var measurement = isVertical ? 'width' : 'height';
1934 | 
1935 |     var shiftOffsets = {
1936 |       start: defineProperty({}, side, reference[side]),
1937 |       end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
1938 |     };
1939 | 
1940 |     data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);
1941 |   }
1942 | 
1943 |   return data;
1944 | }
1945 | 
1946 | /**
1947 |  * @function
1948 |  * @memberof Modifiers
1949 |  * @argument {Object} data - The data object generated by update method
1950 |  * @argument {Object} options - Modifiers configuration and options
1951 |  * @returns {Object} The data object, properly modified
1952 |  */
1953 | function hide(data) {
1954 |   if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {
1955 |     return data;
1956 |   }
1957 | 
1958 |   var refRect = data.offsets.reference;
1959 |   var bound = find(data.instance.modifiers, function (modifier) {
1960 |     return modifier.name === 'preventOverflow';
1961 |   }).boundaries;
1962 | 
1963 |   if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
1964 |     // Avoid unnecessary DOM access if visibility hasn't changed
1965 |     if (data.hide === true) {
1966 |       return data;
1967 |     }
1968 | 
1969 |     data.hide = true;
1970 |     data.attributes['x-out-of-boundaries'] = '';
1971 |   } else {
1972 |     // Avoid unnecessary DOM access if visibility hasn't changed
1973 |     if (data.hide === false) {
1974 |       return data;
1975 |     }
1976 | 
1977 |     data.hide = false;
1978 |     data.attributes['x-out-of-boundaries'] = false;
1979 |   }
1980 | 
1981 |   return data;
1982 | }
1983 | 
1984 | /**
1985 |  * @function
1986 |  * @memberof Modifiers
1987 |  * @argument {Object} data - The data object generated by `update` method
1988 |  * @argument {Object} options - Modifiers configuration and options
1989 |  * @returns {Object} The data object, properly modified
1990 |  */
1991 | function inner(data) {
1992 |   var placement = data.placement;
1993 |   var basePlacement = placement.split('-')[0];
1994 |   var _data$offsets = data.offsets,
1995 |       popper = _data$offsets.popper,
1996 |       reference = _data$offsets.reference;
1997 | 
1998 |   var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
1999 | 
2000 |   var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
2001 | 
2002 |   popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
2003 | 
2004 |   data.placement = getOppositePlacement(placement);
2005 |   data.offsets.popper = getClientRect(popper);
2006 | 
2007 |   return data;
2008 | }
2009 | 
2010 | /**
2011 |  * Modifier function, each modifier can have a function of this type assigned
2012 |  * to its `fn` property.<br />
2013 |  * These functions will be called on each update, this means that you must
2014 |  * make sure they are performant enough to avoid performance bottlenecks.
2015 |  *
2016 |  * @function ModifierFn
2017 |  * @argument {dataObject} data - The data object generated by `update` method
2018 |  * @argument {Object} options - Modifiers configuration and options
2019 |  * @returns {dataObject} The data object, properly modified
2020 |  */
2021 | 
2022 | /**
2023 |  * Modifiers are plugins used to alter the behavior of your poppers.<br />
2024 |  * Popper.js uses a set of 9 modifiers to provide all the basic functionalities
2025 |  * needed by the library.
2026 |  *
2027 |  * Usually you don't want to override the `order`, `fn` and `onLoad` props.
2028 |  * All the other properties are configurations that could be tweaked.
2029 |  * @namespace modifiers
2030 |  */
2031 | var modifiers = {
2032 |   /**
2033 |    * Modifier used to shift the popper on the start or end of its reference
2034 |    * element.<br />
2035 |    * It will read the variation of the `placement` property.<br />
2036 |    * It can be one either `-end` or `-start`.
2037 |    * @memberof modifiers
2038 |    * @inner
2039 |    */
2040 |   shift: {
2041 |     /** @prop {number} order=100 - Index used to define the order of execution */
2042 |     order: 100,
2043 |     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2044 |     enabled: true,
2045 |     /** @prop {ModifierFn} */
2046 |     fn: shift
2047 |   },
2048 | 
2049 |   /**
2050 |    * The `offset` modifier can shift your popper on both its axis.
2051 |    *
2052 |    * It accepts the following units:
2053 |    * - `px` or unit-less, interpreted as pixels
2054 |    * - `%` or `%r`, percentage relative to the length of the reference element
2055 |    * - `%p`, percentage relative to the length of the popper element
2056 |    * - `vw`, CSS viewport width unit
2057 |    * - `vh`, CSS viewport height unit
2058 |    *
2059 |    * For length is intended the main axis relative to the placement of the popper.<br />
2060 |    * This means that if the placement is `top` or `bottom`, the length will be the
2061 |    * `width`. In case of `left` or `right`, it will be the `height`.
2062 |    *
2063 |    * You can provide a single value (as `Number` or `String`), or a pair of values
2064 |    * as `String` divided by a comma or one (or more) white spaces.<br />
2065 |    * The latter is a deprecated method because it leads to confusion and will be
2066 |    * removed in v2.<br />
2067 |    * Additionally, it accepts additions and subtractions between different units.
2068 |    * Note that multiplications and divisions aren't supported.
2069 |    *
2070 |    * Valid examples are:
2071 |    * ```
2072 |    * 10
2073 |    * '10%'
2074 |    * '10, 10'
2075 |    * '10%, 10'
2076 |    * '10 + 10%'
2077 |    * '10 - 5vh + 3%'
2078 |    * '-10px + 5vh, 5px - 6%'
2079 |    * ```
2080 |    * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap
2081 |    * > with their reference element, unfortunately, you will have to disable the `flip` modifier.
2082 |    * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).
2083 |    *
2084 |    * @memberof modifiers
2085 |    * @inner
2086 |    */
2087 |   offset: {
2088 |     /** @prop {number} order=200 - Index used to define the order of execution */
2089 |     order: 200,
2090 |     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2091 |     enabled: true,
2092 |     /** @prop {ModifierFn} */
2093 |     fn: offset,
2094 |     /** @prop {Number|String} offset=0
2095 |      * The offset value as described in the modifier description
2096 |      */
2097 |     offset: 0
2098 |   },
2099 | 
2100 |   /**
2101 |    * Modifier used to prevent the popper from being positioned outside the boundary.
2102 |    *
2103 |    * A scenario exists where the reference itself is not within the boundaries.<br />
2104 |    * We can say it has "escaped the boundaries" — or just "escaped".<br />
2105 |    * In this case we need to decide whether the popper should either:
2106 |    *
2107 |    * - detach from the reference and remain "trapped" in the boundaries, or
2108 |    * - if it should ignore the boundary and "escape with its reference"
2109 |    *
2110 |    * When `escapeWithReference` is set to`true` and reference is completely
2111 |    * outside its boundaries, the popper will overflow (or completely leave)
2112 |    * the boundaries in order to remain attached to the edge of the reference.
2113 |    *
2114 |    * @memberof modifiers
2115 |    * @inner
2116 |    */
2117 |   preventOverflow: {
2118 |     /** @prop {number} order=300 - Index used to define the order of execution */
2119 |     order: 300,
2120 |     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2121 |     enabled: true,
2122 |     /** @prop {ModifierFn} */
2123 |     fn: preventOverflow,
2124 |     /**
2125 |      * @prop {Array} [priority=['left','right','top','bottom']]
2126 |      * Popper will try to prevent overflow following these priorities by default,
2127 |      * then, it could overflow on the left and on top of the `boundariesElement`
2128 |      */
2129 |     priority: ['left', 'right', 'top', 'bottom'],
2130 |     /**
2131 |      * @prop {number} padding=5
2132 |      * Amount of pixel used to define a minimum distance between the boundaries
2133 |      * and the popper. This makes sure the popper always has a little padding
2134 |      * between the edges of its container
2135 |      */
2136 |     padding: 5,
2137 |     /**
2138 |      * @prop {String|HTMLElement} boundariesElement='scrollParent'
2139 |      * Boundaries used by the modifier. Can be `scrollParent`, `window`,
2140 |      * `viewport` or any DOM element.
2141 |      */
2142 |     boundariesElement: 'scrollParent'
2143 |   },
2144 | 
2145 |   /**
2146 |    * Modifier used to make sure the reference and its popper stay near each other
2147 |    * without leaving any gap between the two. Especially useful when the arrow is
2148 |    * enabled and you want to ensure that it points to its reference element.
2149 |    * It cares only about the first axis. You can still have poppers with margin
2150 |    * between the popper and its reference element.
2151 |    * @memberof modifiers
2152 |    * @inner
2153 |    */
2154 |   keepTogether: {
2155 |     /** @prop {number} order=400 - Index used to define the order of execution */
2156 |     order: 400,
2157 |     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2158 |     enabled: true,
2159 |     /** @prop {ModifierFn} */
2160 |     fn: keepTogether
2161 |   },
2162 | 
2163 |   /**
2164 |    * This modifier is used to move the `arrowElement` of the popper to make
2165 |    * sure it is positioned between the reference element and its popper element.
2166 |    * It will read the outer size of the `arrowElement` node to detect how many
2167 |    * pixels of conjunction are needed.
2168 |    *
2169 |    * It has no effect if no `arrowElement` is provided.
2170 |    * @memberof modifiers
2171 |    * @inner
2172 |    */
2173 |   arrow: {
2174 |     /** @prop {number} order=500 - Index used to define the order of execution */
2175 |     order: 500,
2176 |     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2177 |     enabled: true,
2178 |     /** @prop {ModifierFn} */
2179 |     fn: arrow,
2180 |     /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */
2181 |     element: '[x-arrow]'
2182 |   },
2183 | 
2184 |   /**
2185 |    * Modifier used to flip the popper's placement when it starts to overlap its
2186 |    * reference element.
2187 |    *
2188 |    * Requires the `preventOverflow` modifier before it in order to work.
2189 |    *
2190 |    * **NOTE:** this modifier will interrupt the current update cycle and will
2191 |    * restart it if it detects the need to flip the placement.
2192 |    * @memberof modifiers
2193 |    * @inner
2194 |    */
2195 |   flip: {
2196 |     /** @prop {number} order=600 - Index used to define the order of execution */
2197 |     order: 600,
2198 |     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2199 |     enabled: true,
2200 |     /** @prop {ModifierFn} */
2201 |     fn: flip,
2202 |     /**
2203 |      * @prop {String|Array} behavior='flip'
2204 |      * The behavior used to change the popper's placement. It can be one of
2205 |      * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid
2206 |      * placements (with optional variations)
2207 |      */
2208 |     behavior: 'flip',
2209 |     /**
2210 |      * @prop {number} padding=5
2211 |      * The popper will flip if it hits the edges of the `boundariesElement`
2212 |      */
2213 |     padding: 5,
2214 |     /**
2215 |      * @prop {String|HTMLElement} boundariesElement='viewport'
2216 |      * The element which will define the boundaries of the popper position.
2217 |      * The popper will never be placed outside of the defined boundaries
2218 |      * (except if `keepTogether` is enabled)
2219 |      */
2220 |     boundariesElement: 'viewport'
2221 |   },
2222 | 
2223 |   /**
2224 |    * Modifier used to make the popper flow toward the inner of the reference element.
2225 |    * By default, when this modifier is disabled, the popper will be placed outside
2226 |    * the reference element.
2227 |    * @memberof modifiers
2228 |    * @inner
2229 |    */
2230 |   inner: {
2231 |     /** @prop {number} order=700 - Index used to define the order of execution */
2232 |     order: 700,
2233 |     /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */
2234 |     enabled: false,
2235 |     /** @prop {ModifierFn} */
2236 |     fn: inner
2237 |   },
2238 | 
2239 |   /**
2240 |    * Modifier used to hide the popper when its reference element is outside of the
2241 |    * popper boundaries. It will set a `x-out-of-boundaries` attribute which can
2242 |    * be used to hide with a CSS selector the popper when its reference is
2243 |    * out of boundaries.
2244 |    *
2245 |    * Requires the `preventOverflow` modifier before it in order to work.
2246 |    * @memberof modifiers
2247 |    * @inner
2248 |    */
2249 |   hide: {
2250 |     /** @prop {number} order=800 - Index used to define the order of execution */
2251 |     order: 800,
2252 |     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2253 |     enabled: true,
2254 |     /** @prop {ModifierFn} */
2255 |     fn: hide
2256 |   },
2257 | 
2258 |   /**
2259 |    * Computes the style that will be applied to the popper element to gets
2260 |    * properly positioned.
2261 |    *
2262 |    * Note that this modifier will not touch the DOM, it just prepares the styles
2263 |    * so that `applyStyle` modifier can apply it. This separation is useful
2264 |    * in case you need to replace `applyStyle` with a custom implementation.
2265 |    *
2266 |    * This modifier has `850` as `order` value to maintain backward compatibility
2267 |    * with previous versions of Popper.js. Expect the modifiers ordering method
2268 |    * to change in future major versions of the library.
2269 |    *
2270 |    * @memberof modifiers
2271 |    * @inner
2272 |    */
2273 |   computeStyle: {
2274 |     /** @prop {number} order=850 - Index used to define the order of execution */
2275 |     order: 850,
2276 |     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2277 |     enabled: true,
2278 |     /** @prop {ModifierFn} */
2279 |     fn: computeStyle,
2280 |     /**
2281 |      * @prop {Boolean} gpuAcceleration=true
2282 |      * If true, it uses the CSS 3D transformation to position the popper.
2283 |      * Otherwise, it will use the `top` and `left` properties
2284 |      */
2285 |     gpuAcceleration: true,
2286 |     /**
2287 |      * @prop {string} [x='bottom']
2288 |      * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.
2289 |      * Change this if your popper should grow in a direction different from `bottom`
2290 |      */
2291 |     x: 'bottom',
2292 |     /**
2293 |      * @prop {string} [x='left']
2294 |      * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.
2295 |      * Change this if your popper should grow in a direction different from `right`
2296 |      */
2297 |     y: 'right'
2298 |   },
2299 | 
2300 |   /**
2301 |    * Applies the computed styles to the popper element.
2302 |    *
2303 |    * All the DOM manipulations are limited to this modifier. This is useful in case
2304 |    * you want to integrate Popper.js inside a framework or view library and you
2305 |    * want to delegate all the DOM manipulations to it.
2306 |    *
2307 |    * Note that if you disable this modifier, you must make sure the popper element
2308 |    * has its position set to `absolute` before Popper.js can do its work!
2309 |    *
2310 |    * Just disable this modifier and define your own to achieve the desired effect.
2311 |    *
2312 |    * @memberof modifiers
2313 |    * @inner
2314 |    */
2315 |   applyStyle: {
2316 |     /** @prop {number} order=900 - Index used to define the order of execution */
2317 |     order: 900,
2318 |     /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
2319 |     enabled: true,
2320 |     /** @prop {ModifierFn} */
2321 |     fn: applyStyle,
2322 |     /** @prop {Function} */
2323 |     onLoad: applyStyleOnLoad,
2324 |     /**
2325 |      * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
2326 |      * @prop {Boolean} gpuAcceleration=true
2327 |      * If true, it uses the CSS 3D transformation to position the popper.
2328 |      * Otherwise, it will use the `top` and `left` properties
2329 |      */
2330 |     gpuAcceleration: undefined
2331 |   }
2332 | };
2333 | 
2334 | /**
2335 |  * The `dataObject` is an object containing all the information used by Popper.js.
2336 |  * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.
2337 |  * @name dataObject
2338 |  * @property {Object} data.instance The Popper.js instance
2339 |  * @property {String} data.placement Placement applied to popper
2340 |  * @property {String} data.originalPlacement Placement originally defined on init
2341 |  * @property {Boolean} data.flipped True if popper has been flipped by flip modifier
2342 |  * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper
2343 |  * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier
2344 |  * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)
2345 |  * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)
2346 |  * @property {Object} data.boundaries Offsets of the popper boundaries
2347 |  * @property {Object} data.offsets The measurements of popper, reference and arrow elements
2348 |  * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values
2349 |  * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values
2350 |  * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0
2351 |  */
2352 | 
2353 | /**
2354 |  * Default options provided to Popper.js constructor.<br />
2355 |  * These can be overridden using the `options` argument of Popper.js.<br />
2356 |  * To override an option, simply pass an object with the same
2357 |  * structure of the `options` object, as the 3rd argument. For example:
2358 |  * ```
2359 |  * new Popper(ref, pop, {
2360 |  *   modifiers: {
2361 |  *     preventOverflow: { enabled: false }
2362 |  *   }
2363 |  * })
2364 |  * ```
2365 |  * @type {Object}
2366 |  * @static
2367 |  * @memberof Popper
2368 |  */
2369 | var Defaults = {
2370 |   /**
2371 |    * Popper's placement.
2372 |    * @prop {Popper.placements} placement='bottom'
2373 |    */
2374 |   placement: 'bottom',
2375 | 
2376 |   /**
2377 |    * Set this to true if you want popper to position it self in 'fixed' mode
2378 |    * @prop {Boolean} positionFixed=false
2379 |    */
2380 |   positionFixed: false,
2381 | 
2382 |   /**
2383 |    * Whether events (resize, scroll) are initially enabled.
2384 |    * @prop {Boolean} eventsEnabled=true
2385 |    */
2386 |   eventsEnabled: true,
2387 | 
2388 |   /**
2389 |    * Set to true if you want to automatically remove the popper when
2390 |    * you call the `destroy` method.
2391 |    * @prop {Boolean} removeOnDestroy=false
2392 |    */
2393 |   removeOnDestroy: false,
2394 | 
2395 |   /**
2396 |    * Callback called when the popper is created.<br />
2397 |    * By default, it is set to no-op.<br />
2398 |    * Access Popper.js instance with `data.instance`.
2399 |    * @prop {onCreate}
2400 |    */
2401 |   onCreate: function onCreate() {},
2402 | 
2403 |   /**
2404 |    * Callback called when the popper is updated. This callback is not called
2405 |    * on the initialization/creation of the popper, but only on subsequent
2406 |    * updates.<br />
2407 |    * By default, it is set to no-op.<br />
2408 |    * Access Popper.js instance with `data.instance`.
2409 |    * @prop {onUpdate}
2410 |    */
2411 |   onUpdate: function onUpdate() {},
2412 | 
2413 |   /**
2414 |    * List of modifiers used to modify the offsets before they are applied to the popper.
2415 |    * They provide most of the functionalities of Popper.js.
2416 |    * @prop {modifiers}
2417 |    */
2418 |   modifiers: modifiers
2419 | };
2420 | 
2421 | /**
2422 |  * @callback onCreate
2423 |  * @param {dataObject} data
2424 |  */
2425 | 
2426 | /**
2427 |  * @callback onUpdate
2428 |  * @param {dataObject} data
2429 |  */
2430 | 
2431 | // Utils
2432 | // Methods
2433 | var Popper = function () {
2434 |   /**
2435 |    * Creates a new Popper.js instance.
2436 |    * @class Popper
2437 |    * @param {HTMLElement|referenceObject} reference - The reference element used to position the popper
2438 |    * @param {HTMLElement} popper - The HTML element used as the popper
2439 |    * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)
2440 |    * @return {Object} instance - The generated Popper.js instance
2441 |    */
2442 |   function Popper(reference, popper) {
2443 |     var _this = this;
2444 | 
2445 |     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
2446 |     classCallCheck(this, Popper);
2447 | 
2448 |     this.scheduleUpdate = function () {
2449 |       return requestAnimationFrame(_this.update);
2450 |     };
2451 | 
2452 |     // make update() debounced, so that it only runs at most once-per-tick
2453 |     this.update = debounce(this.update.bind(this));
2454 | 
2455 |     // with {} we create a new object with the options inside it
2456 |     this.options = _extends({}, Popper.Defaults, options);
2457 | 
2458 |     // init state
2459 |     this.state = {
2460 |       isDestroyed: false,
2461 |       isCreated: false,
2462 |       scrollParents: []
2463 |     };
2464 | 
2465 |     // get reference and popper elements (allow jQuery wrappers)
2466 |     this.reference = reference && reference.jquery ? reference[0] : reference;
2467 |     this.popper = popper && popper.jquery ? popper[0] : popper;
2468 | 
2469 |     // Deep merge modifiers options
2470 |     this.options.modifiers = {};
2471 |     Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {
2472 |       _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
2473 |     });
2474 | 
2475 |     // Refactoring modifiers' list (Object => Array)
2476 |     this.modifiers = Object.keys(this.options.modifiers).map(function (name) {
2477 |       return _extends({
2478 |         name: name
2479 |       }, _this.options.modifiers[name]);
2480 |     })
2481 |     // sort the modifiers by order
2482 |     .sort(function (a, b) {
2483 |       return a.order - b.order;
2484 |     });
2485 | 
2486 |     // modifiers have the ability to execute arbitrary code when Popper.js get inited
2487 |     // such code is executed in the same order of its modifier
2488 |     // they could add new properties to their options configuration
2489 |     // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!
2490 |     this.modifiers.forEach(function (modifierOptions) {
2491 |       if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
2492 |         modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
2493 |       }
2494 |     });
2495 | 
2496 |     // fire the first update to position the popper in the right place
2497 |     this.update();
2498 | 
2499 |     var eventsEnabled = this.options.eventsEnabled;
2500 |     if (eventsEnabled) {
2501 |       // setup event listeners, they will take care of update the position in specific situations
2502 |       this.enableEventListeners();
2503 |     }
2504 | 
2505 |     this.state.eventsEnabled = eventsEnabled;
2506 |   }
2507 | 
2508 |   // We can't use class properties because they don't get listed in the
2509 |   // class prototype and break stuff like Sinon stubs
2510 | 
2511 | 
2512 |   createClass(Popper, [{
2513 |     key: 'update',
2514 |     value: function update$$1() {
2515 |       return update.call(this);
2516 |     }
2517 |   }, {
2518 |     key: 'destroy',
2519 |     value: function destroy$$1() {
2520 |       return destroy.call(this);
2521 |     }
2522 |   }, {
2523 |     key: 'enableEventListeners',
2524 |     value: function enableEventListeners$$1() {
2525 |       return enableEventListeners.call(this);
2526 |     }
2527 |   }, {
2528 |     key: 'disableEventListeners',
2529 |     value: function disableEventListeners$$1() {
2530 |       return disableEventListeners.call(this);
2531 |     }
2532 | 
2533 |     /**
2534 |      * Schedules an update. It will run on the next UI update available.
2535 |      * @method scheduleUpdate
2536 |      * @memberof Popper
2537 |      */
2538 | 
2539 | 
2540 |     /**
2541 |      * Collection of utilities useful when writing custom modifiers.
2542 |      * Starting from version 1.7, this method is available only if you
2543 |      * include `popper-utils.js` before `popper.js`.
2544 |      *
2545 |      * **DEPRECATION**: This way to access PopperUtils is deprecated
2546 |      * and will be removed in v2! Use the PopperUtils module directly instead.
2547 |      * Due to the high instability of the methods contained in Utils, we can't
2548 |      * guarantee them to follow semver. Use them at your own risk!
2549 |      * @static
2550 |      * @private
2551 |      * @type {Object}
2552 |      * @deprecated since version 1.8
2553 |      * @member Utils
2554 |      * @memberof Popper
2555 |      */
2556 | 
2557 |   }]);
2558 |   return Popper;
2559 | }();
2560 | 
2561 | /**
2562 |  * The `referenceObject` is an object that provides an interface compatible with Popper.js
2563 |  * and lets you use it as replacement of a real DOM node.<br />
2564 |  * You can use this method to position a popper relatively to a set of coordinates
2565 |  * in case you don't have a DOM node to use as reference.
2566 |  *
2567 |  * ```
2568 |  * new Popper(referenceObject, popperNode);
2569 |  * ```
2570 |  *
2571 |  * NB: This feature isn't supported in Internet Explorer 10.
2572 |  * @name referenceObject
2573 |  * @property {Function} data.getBoundingClientRect
2574 |  * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.
2575 |  * @property {number} data.clientWidth
2576 |  * An ES6 getter that will return the width of the virtual reference element.
2577 |  * @property {number} data.clientHeight
2578 |  * An ES6 getter that will return the height of the virtual reference element.
2579 |  */
2580 | 
2581 | 
2582 | Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;
2583 | Popper.placements = placements;
2584 | Popper.Defaults = Defaults;
2585 | 
2586 | return Popper;
2587 | 
2588 | })));
2589 | //# sourceMappingURL=popper.js.map
2590 | 


--------------------------------------------------------------------------------
/vendor/assets/stylesheets/jquery_with_bootstrap.scss:
--------------------------------------------------------------------------------
1 | @import "bootstrap";


--------------------------------------------------------------------------------