From 1e5e925d427f2dd981fab2181a099759fe74e53b Mon Sep 17 00:00:00 2001 From: Paul Stanton Date: Thu, 22 Aug 2024 12:02:05 +0100 Subject: [PATCH] Fix pulsar css and js inclides --- Gruntfile.js | 1 - docs/docs/components/button.mdx | 14 +- docs/docs/guides/getting-started.mdx | 46 +- docs/docusaurus.config.js | 7 +- docs/src/css/custom.scss | 104 +- docs/src/theme/Layout/index.js | 11 + docs/src/theme/prism-include-languages.js | 23 + .../examples/dropdown-button-basic.html | 7 + docs/static/js/bundle.js | 104020 +++++++++++++++ docs/static/js/main.js | 37 + docs/yarn.lock | 42 +- package.json | 2 +- stylesheets/_component.cards.scss | 1 + stylesheets/_function.color-luminance.scss | 34 +- stylesheets/_function.color.scss | 53 +- stylesheets/_function.pick-best-color.scss | 19 +- stylesheets/pulsar.scss | 5 +- 17 files changed, 104232 insertions(+), 194 deletions(-) create mode 100644 docs/src/theme/Layout/index.js create mode 100644 docs/src/theme/prism-include-languages.js create mode 100644 docs/static/examples/dropdown-button-basic.html create mode 100644 docs/static/js/bundle.js create mode 100644 docs/static/js/main.js diff --git a/Gruntfile.js b/Gruntfile.js index 08681cce70..5bf7cadfc9 100644 --- a/Gruntfile.js +++ b/Gruntfile.js @@ -511,7 +511,6 @@ module.exports = function(grunt) { 'autoprefixer', 'browserify:dev', 'browserify:lexicon', - 'browserSync', 'watch' ]); diff --git a/docs/docs/components/button.mdx b/docs/docs/components/button.mdx index 11aab8e16a..6a8ca339fe 100644 --- a/docs/docs/components/button.mdx +++ b/docs/docs/components/button.mdx @@ -83,7 +83,7 @@ The text label you use for a button should be clear enough for any user to under If the button relates to an action, the label should ideally be a verb, use the common state classes to reinforce dangerous or destructive actions with colour, but don't rely on colour alone to communicate a button’s intention.
- +       
Other recommendations for labelling your buttons include: @@ -94,12 +94,12 @@ Other recommendations for labelling your buttons include:
Do use title case
-
-
- -
-
Don’t use sentence case or all caps
+
+
+
+  
+
Don’t use sentence case or all caps
@@ -127,7 +127,7 @@ If an action relates to creating new items of content, use 'New', Do not use 'Cr If a button triggers more than one action you should communicate the chain of events to the user, ideally in the order in which they will happen. This helps users to build a mental model of what is happening when they push a button.
- +  
## Using icons diff --git a/docs/docs/guides/getting-started.mdx b/docs/docs/guides/getting-started.mdx index 3e3bd1bf35..c4d045c133 100644 --- a/docs/docs/guides/getting-started.mdx +++ b/docs/docs/guides/getting-started.mdx @@ -10,46 +10,46 @@ As a Jadu designer or developer, you’re probably working on one or more of the ## Team -
-
-
-
-
- -
-

Paul Stanton

+
+
+
+
+
+ +
+

Paul Stanton

-
+
Head of User Experience @jadu
-
-
- GitHub +
+
+ GitHub
-
-
-
-
+
+
+
+
-
-

James Jacobs

+
+

James Jacobs

-
+
Accessibility Lead
-
-
- GitHub +
+
+ GitHub
diff --git a/docs/docusaurus.config.js b/docs/docusaurus.config.js index b4b7f09fa8..f45374d9d6 100644 --- a/docs/docusaurus.config.js +++ b/docs/docusaurus.config.js @@ -52,6 +52,11 @@ const config = { ], ], + scripts: [ + 'js/bundle.js', + 'js/main.js', + ], + themeConfig: /** @type {import('@docusaurus/preset-classic').ThemeConfig} */ ({ @@ -93,7 +98,7 @@ const config = { copyright: `Copyright © ${new Date().getFullYear()} Jadu Ltd. Built with Docusaurus.`, }, prism: { - theme: prismThemes.github, + theme: prismThemes.dracula, darkTheme: prismThemes.dracula, }, }), diff --git a/docs/src/css/custom.scss b/docs/src/css/custom.scss index 576567f6a3..3514c14400 100644 --- a/docs/src/css/custom.scss +++ b/docs/src/css/custom.scss @@ -21,6 +21,8 @@ $font-family-brands: 'Font Awesome 6 Brands'; $fa-font-path: '/static/fonts/fontawesome-free-6.0.0-web/webfonts'; $fa-css-prefix: 'icon'; +@use '../../../stylesheets/function.color' as colorFunctions; + @import '/static/fonts/fontawesome-free-6.0.0-web/scss/fontawesome'; @import '/static/fonts/fontawesome-free-6.0.0-web/scss/regular'; @import '/static/fonts/fontawesome-free-6.0.0-web/scss/solid'; @@ -33,9 +35,6 @@ $fa-css-prefix: 'icon'; // Functions @import '../../../stylesheets/function.math'; -@import '../../../stylesheets/function.color-luminance'; -@import '../../../stylesheets/function.pick-best-color'; -@import '../../../stylesheets/function.color'; // $font-path: '/static/fonts/'; @font-face { @@ -227,7 +226,9 @@ $fa-css-prefix: 'icon'; --ifm-color-primary-light: #dd3b40; --ifm-color-primary-lighter: #de464b; --ifm-color-primary-lightest: #e4666a; - + + --docusaurus-highlighted-code-line-bg: #f19d9e; + .theme-doc-sidebar-container { background-color: var(--ifm-navbar-background-color); } @@ -238,58 +239,29 @@ $fa-css-prefix: 'icon'; --ifm-menu-color: #000; } -// // --ifm-global-shadow-lw: none; - -// // --jadu-purple: #3e4994; - -// // --ifm-background-surface-color: var(--jadu-purple); -// // --ifm-navbar-link-color: #fff; -// // --ifm-navbar-link-hover-color: #fff; - -// // --ifm-menu-color-active: var(--jadu-purple); - -// // --ifm-heading-color: var(--jadu-purple); - -// // --ifm-card-background-color: #fff; -// // --ifm-container-width: 1300px; - -// // --ifm-table-border-width: 0; - -// // --ifm-alert-color: #000; -// } - -// body { -// font-size: 16px; -// } +main { + --ifm-tabs-padding-vertical: 5px; + --ifm-tabs-padding-horizontal: 10px; +} table { display: table; width: 100%; } -// .hero--primary { -// --ifm-hero-background-color: #fff; -// --ifm-hero-text-color: var(--ifm-font-color-base); - -// padding: 2rem 0 1rem; -// } - -// .hero__title { -// margin-bottom: 0; -// } - -// .admonition h5 { -// color: var(--ifm-alert-color); -// } - .d-example { - border: 1px solid #ccc; + border: 1px dashed #ccc; margin-bottom: 1em; padding: 1em; width: 100%; + * { + all: revert; + } + h1, h2, h3, h4, h5, h6 { color: unset; + font-weight: normal; } ul, ol { @@ -314,10 +286,13 @@ table { } .d-guidelines-preview { - // background-color: #f5f5f5; border: 1px solid #ccc; margin-bottom: .75em; padding: 1em; + + > p { + margin: 0; + } } .d-guidelines-label__title { @@ -344,47 +319,6 @@ table { } } -// .u-float-left { -// float: left; -// } - -// .docusaurus-highlight-code-line { -// background-color: rgb(72, 77, 91); -// display: block; -// margin: 0 calc(-1 * var(--ifm-pre-padding)); -// padding: 0 var(--ifm-pre-padding); -// } - -// table { -// display: table; -// } - -// table:not(.table) { -// display: table; - -// th { -// background-color: var(--jadu-purple); -// border: 1px solid var(--jadu-purple); -// color: #fff; -// } - -// td { -// border: 1px solid #ccc; -// } -// } - -// html[data-theme='dark'] { -// --ifm-heading-color: white; - -// .d-example .control__label { -// color: white; -// } - -// table:not(.table) th { -// background-color: black; -// } -// } - .product-support { ul { list-style-type: none; diff --git a/docs/src/theme/Layout/index.js b/docs/src/theme/Layout/index.js new file mode 100644 index 0000000000..316a715fd5 --- /dev/null +++ b/docs/src/theme/Layout/index.js @@ -0,0 +1,11 @@ +import React from 'react'; +import Layout from '@theme-original/Layout'; + +export default function LayoutWrapper(props) { + return ( + <> +
+ + + ); +} diff --git a/docs/src/theme/prism-include-languages.js b/docs/src/theme/prism-include-languages.js new file mode 100644 index 0000000000..0f888307fa --- /dev/null +++ b/docs/src/theme/prism-include-languages.js @@ -0,0 +1,23 @@ +import siteConfig from '@generated/docusaurus.config'; +export default function prismIncludeLanguages(PrismObject) { + const { + themeConfig: {prism}, + } = siteConfig; + const {additionalLanguages} = prism; + // Prism components work on the Prism instance on the window, while prism- + // react-renderer uses its own Prism instance. We temporarily mount the + // instance onto window, import components to enhance it, then remove it to + // avoid polluting global namespace. + // You can mutate PrismObject: registering plugins, deleting languages... As + // long as you don't re-assign it + globalThis.Prism = PrismObject; + additionalLanguages.forEach((lang) => { + if (lang === 'php') { + // eslint-disable-next-line global-require + require('prismjs/components/prism-markup-templating.js'); + } + // eslint-disable-next-line global-require, import/no-dynamic-require + require(`prismjs/components/prism-${lang}`); + }); + delete globalThis.Prism; +} diff --git a/docs/static/examples/dropdown-button-basic.html b/docs/static/examples/dropdown-button-basic.html new file mode 100644 index 0000000000..1882767441 --- /dev/null +++ b/docs/static/examples/dropdown-button-basic.html @@ -0,0 +1,7 @@ +
+ + +
\ No newline at end of file diff --git a/docs/static/js/bundle.js b/docs/static/js/bundle.js new file mode 100644 index 0000000000..00d518b307 --- /dev/null +++ b/docs/static/js/bundle.js @@ -0,0 +1,104020 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.pulsar = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i 1); + + // Make pagination links appear as buttons to AT + pagination.find('.paginate_button').attr('role', 'button'); + + // Add aria-current to current page number + pagination.find('.paginate_button.current').attr('aria-current', 'true'); + + // Remove disable links + pagination.find('.paginate_button.disabled').addClass('u-display-none'); + + // Add aria-labels to numbered links + paginationNumbers = pagination.find('.paginate_button:not(.first, .previous, .next, .last)'); + paginationNumbers.each(function () { + var $numberLink = $(this); + $numberLink.attr('aria-label', 'Page ' + $numberLink.text()); + }); + }; + + },{}],3:[function(require,module,exports){ + 'use strict'; + + module.exports.initComplete = function () { + var pagination = $(this).closest('.dataTables_wrapper').find('.dataTables_paginate'); + + if (this.api().page.info().pages > 1) { + pagination.wrap(''); + } + }; + + },{}],4:[function(require,module,exports){ + 'use strict'; + + var $ = require('jquery'); + + function DisableUiComponent(html) { + this.$html = html; + } + + function preventDefaultAndStopPropagation(e) { + e.preventDefault(); + e.stopPropagation(); + } + + DisableUiComponent.prototype.init = function () { + var component = this; + + component.disable(component.$html.find('[data-disable-ui="true"]')); + }; + + DisableUiComponent.prototype.disable = function (target) { + var FORM_ELEMENTS = 'button:not(.disabled), input:not(.disabled), select:not(.disabled)', + LINK_ELEMENTS = 'a:not(.disabled)', + LABEL_ELEMENTS = 'label'; + + target.each(function () { + var $this = $(this); + + // Disable form elements + $this.find(FORM_ELEMENTS).on('click', preventDefaultAndStopPropagation).addClass('disabled').prop('disabled', true); + + // Disable labels + $this.find(LABEL_ELEMENTS).addClass('u-cursor-not-allowed'); + + // Disable links (uses .js-disable as any existing disabled) + $this.find(LINK_ELEMENTS).on('click', preventDefaultAndStopPropagation).addClass('js-disabled u-cursor-not-allowed').attr('aria-disabled', 'true').attr('tabindex', '-1'); + + // Wrap with disabled wrapper to visually disable + $this.wrap('
'); + }); + }; + + DisableUiComponent.prototype.enable = function (target) { + var FORM_ELEMENTS = 'button.disabled, input.disabled, select.disabled', + LINK_ELEMENTS = 'a.js-disabled', + LABEL_ELEMENTS = 'label'; + + target.each(function () { + var $this = $(this); + + // Remove attribute used to disable a UI on load + $this.removeAttr('data-disable-ui aria-disabled'); + + // Enable form elements + $this.find(FORM_ELEMENTS).off('click', preventDefaultAndStopPropagation).removeClass('disabled').prop('disabled', false); + + // Enable labels + $this.find(LABEL_ELEMENTS).removeClass('u-cursor-not-allowed'); + + // Enable links + $this.find(LINK_ELEMENTS).off('click', preventDefaultAndStopPropagation).removeClass('js-disabled u-cursor-not-allowed').removeAttr('aria-disabled').removeAttr('tabindex'); + + // Remove wrapper which provides visually disabled styling + if ($this.parent().hasClass('u-ui-disabled')) { + $this.unwrap(); + } + }); + }; + + module.exports = DisableUiComponent; + + },{"jquery":416}],5:[function(require,module,exports){ + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZone = function () { + /** + * DropZone + * @param {Element} node + * @param {Object} options + * @param {DropZoneValidatorDispatcher} validator + * @param {DropZoneEventManager} eventManager + * @param {DropZoneIdleTimer} idleTimer + * @param {DropZoneFileManager} fileManager + * @param {DropZoneCallbackManager} callbackManager + */ + function DropZone(node, options, validator, eventManager, idleTimer, fileManager, callbackManager) { + _classCallCheck(this, DropZone); + + this.validator = validator; + this.eventManager = eventManager; + this.idleTimer = idleTimer; + this.fileManager = fileManager; + this.callbackManager = callbackManager; + this.node = window.$ && node instanceof window.$ ? node[0] : node; + this.options = options; + this.id = this.options.dropZoneId; + // cache methods with context + this.handleDropWithContext = this.handleDrop.bind(this); + this.handleWindowEnterWithContext = this.handleWindowEnter.bind(this); + this.handleWindowLeaveWithContext = this.handleWindowLeave.bind(this); + // a flag for determining support + this.supportsDataTransfer = true; + // setup files and size storage + this.files = []; + this.size = 0; + this.enabled = true; + } + + /** + * Initialise plugin + */ + + + _createClass(DropZone, [{ + key: 'init', + value: function init() { + // prevent this for all environments as the default behaviour can be frustrating + this.eventManager.add(window, 'drop', this.eventManager.preventer); + // add events for environments that support data transfer items + if (this.options.supported) { + this.windowActive = false; + this.dropZoneActive = false; + // prevent + this.eventManager.add(window, 'drag', this.eventManager.preventer); + this.eventManager.add(window, 'dragstart', this.eventManager.preventer); + this.eventManager.add(window, 'dragend', this.eventManager.preventer); + this.eventManager.add(window, 'dragover', this.eventManager.preventer); + this.eventManager.add(window, 'dragenter', this.eventManager.preventer); + this.eventManager.add(window, 'dragleave', this.eventManager.preventer); + // interactions + this.eventManager.add(window, 'dragenter', this.handleWindowEnterWithContext); + this.eventManager.add(window, 'dragleave', this.handleWindowLeaveWithContext); + this.eventManager.add(window, 'drop', this.handleDropWithContext); + + // attempt to handle missed callbacks + // mouseout has proven to be more reliable than dragleave + this.eventManager.add(document, 'mouseout', this.idleTimer.start.bind(this, this.forceWindowLeave.bind(this))); + } + } + + /** + * Handle drop event + * @param {Event} event + */ + + }, { + key: 'handleDrop', + value: function handleDrop(event) { + var files = event.dataTransfer.items || event.dataTransfer.files; + + if (this.enabled) { + // determine where the drop has taken place + // dropped on the DropZone + if (this.windowActive && this.dropZoneActive) { + this.addFiles(files); + // dropped on the window + } else if (this.windowActive && !this.dropZoneActive) { + this.callbackManager.create(this.options.windowDrop, this, { files: this.files }); + } + + // reset DropZone state + this.windowActive = false; + this.dropZoneActive = false; + } + } + + /** + * Validate and add files to the DropZone + * @param {Array} files + * @param {Object} meta + */ + + }, { + key: 'addFiles', + value: function addFiles(files) { + var meta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var _validator$validate = this.validator.validate(files, this.files.length, this.size), + valid = _validator$validate.valid, + text = _validator$validate.text; + + var processedFiles = []; + + for (var i = 0; i < files.length; i++) { + var file = files[i].getAsFile ? files[i].getAsFile() : files[i]; + var id = this.files.length + i; + + // increment size store + this.size += file.size; + // process file + processedFiles.push(this.fileManager.createFileObject(file, id, meta)); + } + + if (valid) { + // add processed files to file store + this.files = [].concat(_toConsumableArray(this.files), processedFiles); + } + + // fire dropped callback + this.callbackManager.create(this.options.dropZoneDrop, this, { files: processedFiles, valid: valid, text: text }); + } + + /** + * Determine if file is on window + * @param {number} x + * @param {number} y + * @returns {boolean|Element} + */ + + }, { + key: 'fileOnWindow', + value: function fileOnWindow(x, y) { + var offWindow = x === 0 && y === 0; + return !offWindow && document.elementFromPoint(x, y); + } + + /** + * Force window leave + * @param {Event} event + */ + + }, { + key: 'forceWindowLeave', + value: function forceWindowLeave(event) { + var active = this.windowActive || this.dropZoneActive; + + if (active && !this.fileOnWindow(event.clientX, event.clientY)) { + this.handleWindowLeave(event, true); + } + } + + /** + * Handle a file dragged into the window + * @param {Event} event + */ + + }, { + key: 'handleWindowEnter', + value: function handleWindowEnter(event) { + var onWindow = this.fileOnWindow(event.clientX, event.clientY); + var onDropZone = this.node.contains(onWindow); + var files = event.dataTransfer.items || event.dataTransfer.files; + + // clear idle timer + this.idleTimer.clear(); + + // if we are unable to get a length from the files we know data transfer + // isn't supported, so we'll set this flag to use later + if (!files.length) { + this.supportsDataTransfer = false; + } + + if (onWindow && !this.windowActive && this.enabled) { + // handle files on window + var _validator$validate2 = this.validator.validate(files, this.files.length, this.size), + valid = _validator$validate2.valid, + text = _validator$validate2.text; + + this.windowActive = true; + this.callbackManager.create(this.options.windowEnter, this, { valid: valid, text: text }); + } + + if (onDropZone && !this.dropZoneActive && this.enabled) { + // handle files on DropZone + this.handleDropZoneEnter(files); + } + } + + /** + * Handle a file being dragged off of the window + * @param {Event} event + * @param {Boolean} force + */ + + }, { + key: 'handleWindowLeave', + value: function handleWindowLeave(event) { + var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + var onDropZone = this.node.contains(document.elementFromPoint(event.clientX, event.clientY)); + var onWindow = this.fileOnWindow(event.clientX, event.clientY); + var files = null; + + // if we are forcing this method, there is a good chance we do not have dataTransfer items + if (!force) { + files = event.dataTransfer.items || event.dataTransfer.files; + } + + if (force || !onWindow) { + this.windowActive = false; + this.dropZoneActive = false; + this.idleTimer.clear(); + this.callbackManager.create(this.options.windowLeave, this); + } else if (!onDropZone && this.dropZoneActive) { + this.handleDropZoneLeave(files); + } + } + + /** + * Handle drag entering the DropZone + * @param {Array} files + */ + + }, { + key: 'handleDropZoneEnter', + value: function handleDropZoneEnter(files) { + var _validator$validate3 = this.validator.validate(files, this.files.length, this.size), + valid = _validator$validate3.valid, + text = _validator$validate3.text; + + this.idleTimer.clear(); + this.dropZoneActive = true; + this.callbackManager.create(this.options.dropZoneEnter, this, { valid: valid, text: text }); + } + + /** + * Handle drag leaving the DropZone + * @param {Array} files + */ + + }, { + key: 'handleDropZoneLeave', + value: function handleDropZoneLeave(files) { + var _validator$validate4 = this.validator.validate(files, this.files.length, this.size), + valid = _validator$validate4.valid, + text = _validator$validate4.text; + + this.idleTimer.clear(); + this.dropZoneActive = false; + this.callbackManager.create(this.options.dropZoneLeave, this, { valid: valid, text: text }); + } + + /** + * Return all files in the store or a file at a specified index + * @return {Array} files + */ + + }, { + key: 'getFiles', + value: function getFiles() { + return this.files; + } + + /** + * Return a file at an index + * @param {number} index + * @returns {Object} file + */ + + }, { + key: 'getFile', + value: function getFile(index) { + return this.files[index]; + } + + /** + * Return total size of files on the DropZone + * @return {Number} + */ + + }, { + key: 'getSize', + value: function getSize() { + return this.size; + } + + /** + * Remove a file from the store using it's ID + * @param {number} id + */ + + }, { + key: 'removeFile', + value: function removeFile(id) { + var _this = this; + + this.files = this.files.filter(function (file) { + if (file.id === id) { + _this.size -= file.raw.size; + } else { + return file; + } + }); + + this.callbackManager.create(this.options.fileRemoved, this); + } + + /** + * Reset + * - Remove any events attached by DropZone + * - re-initialise default values, and event handlers + */ + + }, { + key: 'reset', + value: function reset() { + this.files = []; + this.size = 0; + this.eventManager.removeAll(); + this.init(); + } + + /** + * Get DropZone ID + * @returns {number} + */ + + }, { + key: 'getDropZoneId', + value: function getDropZoneId() { + return this.id; + } + + /** + * Get dataTransfer support + * @returns {boolean} + */ + + }, { + key: 'getSupportsDataTransfer', + value: function getSupportsDataTransfer() { + return this.supportsDataTransfer; + } + + /** + * Enable DropZoneComponent + */ + + }, { + key: 'enable', + value: function enable() { + this.enabled = true; + } + + /** + * Disable DropZoneComponent + */ + + }, { + key: 'disable', + value: function disable() { + this.enabled = false; + } + }]); + + return DropZone; + }(); + + exports.default = DropZone; + + },{}],6:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneBodyClassManager = function () { + function DropZoneBodyClassManager() { + _classCallCheck(this, DropZoneBodyClassManager); + } + + _createClass(DropZoneBodyClassManager, [{ + key: 'update', + + /** + * Update body dropZone class state + * @param {Element} body + * @param {Array} classNames + */ + value: function update(body) { + var classNames = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + + var cleanBodyClass = body.className.replace(/dropzone-[a-zA-Z0-9\-]+/g, '').trim(); + + body.className = classNames.length ? cleanBodyClass + ' ' + classNames.join(' ') : cleanBodyClass; + } + }]); + + return DropZoneBodyClassManager; + }(); + + module.exports = DropZoneBodyClassManager; + + },{}],7:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _DropZoneBrowseNodeManager = require('./DropZoneBrowseNodeManager'); + + var _DropZoneBrowseNodeManager2 = _interopRequireDefault(_DropZoneBrowseNodeManager); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneBrowseNodeFactory = function () { + function DropZoneBrowseNodeFactory() { + _classCallCheck(this, DropZoneBrowseNodeFactory); + } + + _createClass(DropZoneBrowseNodeFactory, null, [{ + key: 'create', + + /** + * Create a Browse Node manager instance + * @param {Element} node + * @returns {DropZoneBrowseNodeManager} + */ + value: function create(node) { + return new _DropZoneBrowseNodeManager2.default(node); + } + }]); + + return DropZoneBrowseNodeFactory; + }(); + + module.exports = DropZoneBrowseNodeFactory; + + },{"./DropZoneBrowseNodeManager":8}],8:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneBrowseNodeManager = function () { + function DropZoneBrowseNodeManager(node) { + _classCallCheck(this, DropZoneBrowseNodeManager); + + this.node = node; + this.events = []; + // We always want to prevent default whether the node is enabled or not + if (node) { + this.node.addEventListener('click', function (event) { + event.preventDefault(); + }); + } + } + + /** + * Update node reference + * @param {Element} node + */ + + + _createClass(DropZoneBrowseNodeManager, [{ + key: 'update', + value: function update(node) { + this.node = node; + this.node.addEventListener('click', function (event) { + event.preventDefault(); + }); + } + + /** + * Return node + * @returns {Element} + */ + + }, { + key: 'getNode', + value: function getNode() { + return this.node; + } + + /** + * Add an event listener to node + * @param {String} event + * @param {Function} handler + */ + + }, { + key: 'addEvent', + value: function addEvent(event, handler) { + this.events.push({ event: event, handler: handler, active: true }); + this.node.addEventListener(event, handler); + } + + /** + * Remove attached events + */ + + }, { + key: 'disableEvents', + value: function disableEvents() { + var _this = this; + + this.events = this.events.map(function (event) { + _this.node.removeEventListener(event.event, event.handler); + return { event: event.event, handler: event.handler, active: false }; + }); + } + + /** + * Re-attach events + */ + + }, { + key: 'enableEvents', + value: function enableEvents() { + var _this2 = this; + + this.events = this.events.map(function (event) { + _this2.node.addEventListener(event.event, event.handler); + return { event: event.event, handler: event.handler, active: true }; + }); + } + }]); + + return DropZoneBrowseNodeManager; + }(); + + module.exports = DropZoneBrowseNodeManager; + + },{}],9:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _lodash = require('lodash'); + + var _lodash2 = _interopRequireDefault(_lodash); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneCallbackManager = function () { + function DropZoneCallbackManager() { + _classCallCheck(this, DropZoneCallbackManager); + } + + _createClass(DropZoneCallbackManager, [{ + key: 'create', + + /** + * Check for a callback, if it exists, call it + * @param {Function} callback + * @param {Object} instance + * @param {Object} data + */ + value: function create(callback, instance) { + var data = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + data = _lodash2.default.extend({}, data, { instance: instance }); + + if (typeof callback === 'function') { + callback(data); + } + } + }]); + + return DropZoneCallbackManager; + }(); + + module.exports = DropZoneCallbackManager; + + },{"lodash":418}],10:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _lodash = require('lodash'); + + var _lodash2 = _interopRequireDefault(_lodash); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneComponent = function () { + /** + * DropZoneComponent + * @param {Element} body + * @param {string} selector + * @param {DropZoneInstanceManager} instanceManager + * @param {DropZoneOptionsManager} optionsManager + * @param {DropZoneComponentUtils} utils + * @param {DropZoneComponentValidationManager} validationManager + * @param {DropZoneBodyClassManager} classManager + */ + function DropZoneComponent(body, selector, instanceManager, optionsManager, utils, validationManager, classManager) { + _classCallCheck(this, DropZoneComponent); + + this.body = body; + this.selector = selector; + this.instanceManager = instanceManager; + this.optionsManager = optionsManager; + this.utils = utils; + this.validationManager = validationManager; + this.classManager = classManager; + } + + /** + * Initiate DropZone component, this wraps and defines options for + * multiple instances of DropZone + */ + + + _createClass(DropZoneComponent, [{ + key: 'init', + value: function init() { + var _this = this; + + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var defaults = { + // values + maxFiles: 5, + maxSize: 3e+8, // 300mb + idleTimerDuration: 1000, + // helper html + idleHtml: 'your files here or ', + windowEnterHtml: 'Drag your files here', + dropZoneEnterHtml: 'Drop your files here', + fileRemoveLabel: 'Remove', + // passive + passive: false, + // support + supported: true, + // input + inputNodeId: null, + showInputNode: false, + // file node config + fileNodeDesc: true, + fileNodeName: true, + fileNodeSize: true, + fileNodeType: true, + // node classes + nodeClasses: { + info: 'dropzone__info', + wrapper: 'dropzone__file-wrapper', + validation: 'dropzone__validation', + help: 'dropzone__help', + browse: 'dropzone__browse', + inner: 'dropzone__file-inner', + close: 'dropzone__close', + error: 'dropzone__error', + file: 'dropzone__file', + meta: 'dropzone__meta', + name: 'dropzone__name', + description: 'dropzone__description', + type: 'dropzone__type', + size: 'dropzone__size', + thumbnail: 'dropzone__thumbnail' + }, + // interaction classes + interactionClasses: { + windowEnter: 'dropzone-window-active', + dropZoneEnter: 'dropzone-dropzone-active', + dropZoneSuccess: 'dropzone-success', + dropZoneError: 'dropzone-error' + } + }; + + var callbacks = { + windowEnter: this.handleWindowEnter.bind(this), + windowLeave: this.handleWindowLeave.bind(this), + dropZoneEnter: this.handleDropZoneEnter.bind(this), + dropZoneLeave: this.handleDropzoneLeave.bind(this), + dropZoneDrop: this.handleDropZoneDrop.bind(this), + windowDrop: this.handleWindowDrop.bind(this), + fileRemoved: this.handleFileRemoved.bind(this) + }; + + // get all DropZone elements + this.dropZoneInstances = [].slice.call(this.body.querySelectorAll(this.selector)); + + // build options from options passed to the constructor and the defaults + this.optionsManager.buildComponentOptions(defaults, options, callbacks); + + // add DropZone(s) to instance manager + this.dropZoneInstances.forEach(function (node) { + // create and store DropZone instance + _this.instanceManager.addInstance(node, _this.optionsManager); + }); + + // iterate over our DropZoneInstanceManagerInstances to process any input nodes & update help state + this.instanceManager.getInstance().forEach(function (instance) { + if (instance.input && _this.instanceManager.getSupported(instance.id)) { + _this.processInputNode(instance.input, instance.id, instance.options.showInputNode); + + if (instance.browse) { + instance.browse.addEvent('click', _this.handleBrowseNodeClick.bind(_this, instance.input)); + } + } + }); + + // bind this here, so we have a ref + this.removeFile = this.removeFile.bind(this); + } + + /** + * If an input node ID has been passed in, we'll take care of linking the DropZone + * instance to this node + * @param {Element} input + * @param {number} id + * @param {boolean} show + */ + + }, { + key: 'processInputNode', + value: function processInputNode(input, id, show) { + var _this2 = this; + + // for now these handlers can stay anonymous, the likely hood of wanting to disable a DropZone + // at some point in a session seems unlikely. famous. last. words. + input.addEventListener('change', function () { + var files = input.files; + + // we'll add a persist property to our file objects, this can be used to + // persist the front-end validation, which is essential when using an + // associated file input + if (input.value) { + _this2.instanceManager.addFiles(files, id, { persist: true }); + } + + // reset input node value, this will ensure our change event + // fires each time we use the browse files functionality - even + // if we try to add an identical value + input.value = ''; + input.type = ''; + input.type = 'file'; + }); + + // visually hide input - this should ideally be done in the CSS also to prevent a + // flash on load (with some consideration for non javascript users) + if (!show) { + input.style.display = 'none'; + } + } + + /** + * Handle browse node click + * @param {Element} input + */ + + }, { + key: 'handleBrowseNodeClick', + value: function handleBrowseNodeClick(input) { + // trigger a synthetic click on the input node which will activate the + // native Browse Files interaction + input.click(); + } + + /** + * Update DropZone info node innerHTML + * @param {number} id + * @param {String} string + */ + + }, { + key: 'updateInfoState', + value: function updateInfoState(id, string) { + var _instanceManager$getI = this.instanceManager.getInstance(id), + info = _instanceManager$getI.info, + node = _instanceManager$getI.node; + + var options = this.optionsManager.getInstanceOptions(id); + + if (info) { + info.innerHTML = string; + + var browse = node.querySelector('.' + options.nodeClasses.browse); + + if (browse) { + this.instanceManager.updateBrowseNode(id, browse); + } + } + } + + /** + * Update DropZone Html + * - remove validation node if we have one + * - add / remove files Html + * - remove wrapper if we have no files + * @param {number} id + */ + + }, { + key: 'updateDropZoneFiles', + value: function updateDropZoneFiles(id) { + var _this3 = this; + + var _instanceManager$getI2 = this.instanceManager.getInstance(id), + node = _instanceManager$getI2.node; + + var options = this.optionsManager.getInstanceOptions(id); + var files = this.instanceManager.getFiles(id); + var wrapper = node.querySelector('.' + options.nodeClasses.wrapper); + var fileNodeString = ''; + + // if we've got a drop we know we don't have any errors + // clear any previous validation messages + this.validationManager.clear(node, options.nodeClasses.validation); + + // if there are no files we'll remove the wrapper + if (!files.length) { + if (wrapper) { + wrapper.parentNode.removeChild(wrapper); + } + + return; + } + + // if we do not already have a wrapper, create one + if (!wrapper) { + wrapper = document.createElement('div'); + wrapper.className = options.nodeClasses.wrapper; + node.appendChild(wrapper); + } + + // create file html string + files.forEach(function (file) { + fileNodeString += _this3.utils.createFileNode(file, options); + }); + + // update wrapper html + wrapper.innerHTML = fileNodeString; + [].slice.call(wrapper.querySelectorAll('.' + options.nodeClasses.close)).forEach(function (closeButton) { + closeButton.addEventListener('click', _this3.removeFile); + }); + } + + /** + * Throw a DropZone error, useful as a public method for manually triggering DropZone errors + * example: throwing an error returned as a response from a server + * @param {String} error + * @param {number} id + */ + + }, { + key: 'throwValidationError', + value: function throwValidationError(error, id) { + var _instanceManager$getI3 = this.instanceManager.getInstance(parseInt(id)), + node = _instanceManager$getI3.node, + info = _instanceManager$getI3.info; + + var options = this.optionsManager.getInstanceOptions(id); + + this.validationManager.update(error, node, info, options.nodeClasses.validation, options.nodeClasses.error, options.passive); + + this.updateInfoState(id, options.idleHtml); + } + + /** + * Remove files from DropZone instances + * @param {Event} event + */ + + }, { + key: 'removeFile', + value: function removeFile(event) { + var file = null; + var dropZone = null; + var path = this.utils.getEventPath(event.target); + + event.preventDefault(); + + // grab the file id and DropZone id, this is necessary in the + // albeit unlikely event we have multiple DropZone instances + path.forEach(function (node) { + if (file === null) { + var attr = node.getAttribute('data-dropzone-file'); + + file = attr ? parseInt(attr) : null; + } + + if (dropZone === null) { + var _attr = node.getAttribute('data-dropzone-id'); + + dropZone = _attr ? parseInt(_attr) : null; + } + }); + + if (dropZone !== null && file !== null) { + this.instanceManager.removeFile(dropZone, file); + this.updateDropZoneFiles(dropZone); + } + } + + /** + * Handle DropZone windowEnter callback + * @param {Boolean} valid + * @param {String} text + * @param {DropZone} instance + */ + + }, { + key: 'handleWindowEnter', + value: function handleWindowEnter(_ref) { + var valid = _ref.valid, + text = _ref.text, + instance = _ref.instance; + + var id = instance.getDropZoneId(); + + if (valid) { + this.updateInfoState(id, instance.options.windowEnterHtml); + this.classManager.update(this.body, [instance.options.interactionClasses.windowEnter]); + } else { + this.throwValidationError(text, id); + this.classManager.update(this.body, [instance.options.interactionClasses.windowEnter, instance.options.interactionClasses.dropZoneError]); + } + + if (instance.options.customWindowEnter && typeof instance.options.customWindowEnter === 'function') { + instance.options.customWindowEnter.apply(this, [].slice.call(arguments)); + } + } + + /** + * Handle DropZone windowLeave callback + * @param {DropZone} instance + */ + + }, { + key: 'handleWindowLeave', + value: function handleWindowLeave(_ref2) { + var instance = _ref2.instance; + + var id = instance.getDropZoneId(); + + // update helper text + this.updateInfoState(id, instance.options.idleHtml); + + // reset body class + this.classManager.update(this.body); + + // update validation if there was any + this.validationManager.clear(instance.node, instance.options.nodeClasses.validation); + + // call any additional callbacks passed in via options + if (instance.options.customWindowLeave && typeof instance.options.customWindowLeave === 'function') { + instance.options.customWindowLeave.apply(this, [].slice.call(arguments)); + } + } + + /** + * Handle DropZone dropZoneEnter callback + * @param {Boolean} valid + * @param {String} text + * @param {DropZone} instance + */ + + }, { + key: 'handleDropZoneEnter', + value: function handleDropZoneEnter(_ref3) { + var valid = _ref3.valid, + text = _ref3.text, + instance = _ref3.instance; + + var id = instance.getDropZoneId(); + + // update helper text + if (valid) { + this.updateInfoState(id, instance.options.dropZoneEnterHtml); + this.classManager.update(this.body, [instance.options.interactionClasses.windowEnter, instance.options.interactionClasses.dropZoneEnter]); + } else { + this.throwValidationError(text, id); + this.classManager.update(this.body, [instance.options.interactionClasses.windowEnter, instance.options.interactionClasses.dropZoneEnter, instance.options.interactionClasses.dropZoneError]); + } + + // call any additional callbacks passed in via options + if (instance.options.customDropZoneEnter && typeof instance.options.customDropZoneEnter === 'function') { + instance.options.customDropZoneEnter.apply(this, [].slice.call(arguments)); + } + } + + /** + * Handle DropZone dropZoneLeave callback + * @param {Boolean} valid + * @param {String} text + * @param {DropZone} instance + */ + + }, { + key: 'handleDropzoneLeave', + value: function handleDropzoneLeave(_ref4) { + var valid = _ref4.valid, + text = _ref4.text, + instance = _ref4.instance; + + var id = instance.getDropZoneId(); + + // update helper text + if (valid) { + this.updateInfoState(id, instance.options.windowEnterHtml); + this.classManager.update(this.body, [instance.options.interactionClasses.windowEnter]); + } else { + this.throwValidationError(text, id); + this.classManager.update(this.body, [instance.options.interactionClasses.windowEnter, instance.options.interactionClasses.dropZoneError]); + } + + // call any additional callbacks passed in via options + if (instance.options.customDropZoneLeave && typeof instance.options.customDropZoneLeave === 'function') { + instance.options.customDropZoneLeave.apply(this, [].slice.call(arguments)); + } + } + + /** + * Handle DropZone dropZoneEnter callback + * @param {Array} files + * @param {Boolean} valid + * @param {String} text + * @param {DropZone} instance + */ + + }, { + key: 'handleDropZoneDrop', + value: function handleDropZoneDrop(_ref5) { + var files = _ref5.files, + valid = _ref5.valid, + text = _ref5.text, + instance = _ref5.instance; + + var id = instance.getDropZoneId(); + + if (valid) { + this.updateDropZoneFiles(id); + this.classManager.update(this.body, [instance.options.interactionClasses.dropZoneSuccess]); + } else { + // If a persist property has been set on the file, we will throw a + // validation error which will persist once the file is dropped, this + // helps us out when we need to throw an error when a user uses an associated + // native file input's "browse files" + var persist = _lodash2.default.find(files, function (file) { + return file.meta.persist; + }); + + if (!instance.getSupportsDataTransfer() || persist) { + this.throwValidationError(text, id); + } else { + // if we are not persisting validation messages, clear any that are present + this.validationManager.clear(instance.node, instance.options.nodeClasses.validation); + } + + this.classManager.update(this.body); + } + + // update helper text + this.updateInfoState(id, instance.options.idleHtml); + + // call any additional callbacks passed in via options + if (instance.options.customDropZoneDrop && typeof instance.options.customDropZoneDrop === 'function') { + instance.options.customDropZoneDrop.apply(this, [].slice.call(arguments)); + } + } + + /** + * Handle DropZone windowDrop callback + * @param {Array} files + * @param {DropZone} instance + */ + + }, { + key: 'handleWindowDrop', + value: function handleWindowDrop(_ref6) { + var files = _ref6.files, + instance = _ref6.instance; + + var id = instance.getDropZoneId(); + + // reset body class + this.classManager.update(this.body); + + // handle dropped files + this.updateDropZoneFiles(id); + + // update helper text + this.updateInfoState(id, instance.options.idleHtml); + + if (instance.getSupportsDataTransfer()) { + // clear validation + this.validationManager.clear(instance.node, instance.options.nodeClasses.validation); + } + + if (instance.options.customWindowDrop && typeof instance.options.customWindowDrop === 'function') { + instance.options.customWindowDrop.apply(this, [].slice.call(arguments)); + } + } + + /** + * Handle DropZone fileRemoved callback + * @param {DropZone} instance + */ + + }, { + key: 'handleFileRemoved', + value: function handleFileRemoved(_ref7) { + var instance = _ref7.instance; + + // reset body class + this.classManager.update(this.body); + + // call any additional callbacks passed in via options + if (instance.options.customFileRemoved && typeof instance.options.customFileRemoved === 'function') { + instance.options.customFileRemoved.apply(this, [].slice.call(arguments)); + } + } + + /** + * Validate files against a DropZone instance + * @param {FileList} files + * @param {number} id + * @returns {Object} validation object + */ + + }, { + key: 'validateFiles', + value: function validateFiles(files, id) { + return this.instanceManager.validateFiles(files, id); + } + + /** + * Reset all / selected DropZones + * @param {number} id + */ + + }, { + key: 'reset', + value: function reset() { + var _this4 = this; + + var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : -1; + + if (id < 0) { + this.instanceManager.getInstance().forEach(function (instance) { + _this4.instanceManager.resetInstance(instance.id); + _this4.updateDropZoneFiles(instance.id); + _this4.updateInfoState(instance.id, _this4.optionsManager.getInstanceOption(instance.id, 'idleHtml')); + }); + } else { + this.instanceManager.resetInstance(id); + this.updateDropZoneFiles(id); + this.updateInfoState(id, this.optionsManager.getInstanceOption(id, 'idleHtml')); + } + + this.classManager.update(this.body); + } + + /** + * Add files to DropZone instance + * @param {FileList|Array} files + * @param {number} id + * @param {Object} meta + */ + + }, { + key: 'addFilesToDropZone', + value: function addFilesToDropZone(files, id) { + var meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + this.instanceManager.addFiles(files, id, meta); + } + + /** + * Get all files from DropZone instances + * @param {number} id + * @returns {{valid: Boolean, text: String, files: Array}} + */ + + }, { + key: 'getFilesFromDropZone', + value: function getFilesFromDropZone(id) { + var files = this.instanceManager.getFiles(id); + + var _instanceManager$vali = this.instanceManager.validateFiles(files.map(function (file) { + return file.raw; + }), id, true), + valid = _instanceManager$vali.valid, + text = _instanceManager$vali.text; + + // throw an internal validation error + + + if (!valid) { + this.throwValidationError(text, id); + } + + // return a files collection object + return { valid: valid, text: text, files: files }; + } + + /** + * Get instance idleHtml + * @param {number} id + * @returns {string} + */ + + }, { + key: 'getInstanceIdleHtml', + value: function getInstanceIdleHtml(id) { + return this.optionsManager.getInstanceOption(id, 'idleHtml'); + } + + /** + * Get instance windowEnterHtml + * @param {number} id + * @returns {string} + */ + + }, { + key: 'getInstanceWindowEnterHtml', + value: function getInstanceWindowEnterHtml(id) { + return this.optionsManager.getInstanceOption(id, 'windowEnterHtml'); + } + + /** + * Get instance dropZoneEnterHtml + * @param {number} id + * @returns {string} + */ + + }, { + key: 'getInstanceDropZoneEnterHtml', + value: function getInstanceDropZoneEnterHtml(id) { + return this.optionsManager.getInstanceOption(id, 'dropZoneEnterHtml'); + } + + /** + * Get instance support + * @param {number} id + * @returns {boolean} + */ + + }, { + key: 'getSupportsDataTransferItems', + value: function getSupportsDataTransferItems(id) { + return this.instanceManager.getSupportsDataTransfer(id); + } + + /** + * Enable DropZoneComponent + * @param {Number} id + */ + + }, { + key: 'enable', + value: function enable(id) { + this.instanceManager.enableInstance(id); + } + + /** + * Disable DropZoneComponent + * @param {Number} id + */ + + }, { + key: 'disable', + value: function disable(id) { + this.instanceManager.disableInstance(id); + } + + /** + * Get instance Browse Files node + * @param {Number} id + */ + + }, { + key: 'getBrowseNode', + value: function getBrowseNode(id) { + var _instanceManager$getI4 = this.instanceManager.getInstance(id), + browse = _instanceManager$getI4.browse; + + return browse.getNode(); + } + + /** + * Disable browse node functionality + * @param {Number} id + */ + + }, { + key: 'disableBrowseNode', + value: function disableBrowseNode(id) { + this.instanceManager.disableBrowseNode(id); + } + + /** + * Enable browse node functionality + * @param {Number} id + */ + + }, { + key: 'enableBrowseNode', + value: function enableBrowseNode(id) { + this.instanceManager.enableBrowseNode(id); + } + }]); + + return DropZoneComponent; + }(); + + module.exports = DropZoneComponent; + + },{"lodash":418}],11:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _DropZoneComponent = require('./DropZoneComponent'); + + var _DropZoneComponent2 = _interopRequireDefault(_DropZoneComponent); + + var _DropZoneInstanceManager = require('./DropZoneInstanceManager'); + + var _DropZoneInstanceManager2 = _interopRequireDefault(_DropZoneInstanceManager); + + var _DropZoneFactory = require('./DropZoneFactory'); + + var _DropZoneFactory2 = _interopRequireDefault(_DropZoneFactory); + + var _DropZoneOptionsManager = require('./DropZoneOptionsManager'); + + var _DropZoneOptionsManager2 = _interopRequireDefault(_DropZoneOptionsManager); + + var _DropZoneComponentUtils = require('./DropZoneComponentUtils'); + + var _DropZoneComponentUtils2 = _interopRequireDefault(_DropZoneComponentUtils); + + var _DropZoneComponentValidationManager = require('./DropZoneComponentValidationManager'); + + var _DropZoneComponentValidationManager2 = _interopRequireDefault(_DropZoneComponentValidationManager); + + var _DropZoneBodyClassManager = require('./DropZoneBodyClassManager'); + + var _DropZoneBodyClassManager2 = _interopRequireDefault(_DropZoneBodyClassManager); + + var _MimeTyper = require('../libs/MimeTyper'); + + var _MimeTyper2 = _interopRequireDefault(_MimeTyper); + + var _DropZoneBrowseNodeFactory = require('./DropZoneBrowseNodeFactory'); + + var _DropZoneBrowseNodeFactory2 = _interopRequireDefault(_DropZoneBrowseNodeFactory); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneComponentFactory = function () { + function DropZoneComponentFactory() { + _classCallCheck(this, DropZoneComponentFactory); + } + + _createClass(DropZoneComponentFactory, null, [{ + key: 'create', + + /** + * Create an instance of the DropZoneComponent with it's dependencies + * @param {Element} html + * @param {String} selector + * @returns {DropZoneComponent} + */ + value: function create(html, selector) { + var mimeTyper = new _MimeTyper2.default(), + utilsManager = new _DropZoneComponentUtils2.default(mimeTyper); + + return new _DropZoneComponent2.default(html, selector, new _DropZoneInstanceManager2.default(html, _DropZoneFactory2.default, _DropZoneBrowseNodeFactory2.default), new _DropZoneOptionsManager2.default(utilsManager), utilsManager, new _DropZoneComponentValidationManager2.default(), new _DropZoneBodyClassManager2.default()); + } + }]); + + return DropZoneComponentFactory; + }(); + + module.exports = DropZoneComponentFactory; + + },{"../libs/MimeTyper":58,"./DropZoneBodyClassManager":6,"./DropZoneBrowseNodeFactory":7,"./DropZoneComponent":10,"./DropZoneComponentUtils":12,"./DropZoneComponentValidationManager":13,"./DropZoneFactory":16,"./DropZoneInstanceManager":20,"./DropZoneOptionsManager":21}],12:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneComponentUtils = function () { + function DropZoneComponentUtils(mimeTyper) { + _classCallCheck(this, DropZoneComponentUtils); + + this.mimeTyper = mimeTyper; + } + + /** + * Build an options object from a node's attributes + * @param {Element} node + */ + + + _createClass(DropZoneComponentUtils, [{ + key: 'getOptionsFromAttrs', + value: function getOptionsFromAttrs(node) { + var _this = this; + + return [].slice.call(node.attributes).reduce(function (attrs, attr) { + var name = attr.name; + var value = attr.value; + // grab value from attributes matching data-dropzone-{option}={value} + + if (name.match(/dropzone/)) { + // transform hyphen separated attr to DropZone camelCase option + var option = name.replace(/data-dropzone-/, ''); + + // split the space separated whitelist into an array + if (option === 'whitelist') { + value = value.split(' '); + } + + // parse bools + if (value === 'false') { + value = false; + } else if (value === 'true') { + value = true; + } + + // parse numbers + switch (option) { + case 'max-files': + case 'max-size': + value = parseInt(value); + break; + } + + attrs[_this.camelCaseIfy(option)] = value; + } + + return attrs; + }, {}); + } + + /** + * Transform a hyphen separated string to camel case + * @param {String} string + * @return {String} + */ + + }, { + key: 'camelCaseIfy', + value: function camelCaseIfy(string) { + return string.split('-').map(function (word, index) { + return index ? word[0].toUpperCase() + word.slice(1) : word; + }).join(''); + } + + /** + * Create DropZone file Html string + * @param {Object} file + * @param {Object} options + * @return {String} + */ + + }, { + key: 'createFileNode', + value: function createFileNode(file, options) { + var desc = file.meta.description ? '

' + file.meta.description + '

' : '', + name = file.name ? '

' + file.name + '

' : '', + size = file.size ? '

' + file.size + '

' : '', + type = file.type ? '

' + file.type + '

' : ''; + + var thumb = '
\n
\n \n ' + thumb + '\n
\n ' + (options.fileNodeName ? name : '') + '\n ' + (options.fileNodeDesc ? desc : '') + '\n ' + (options.fileNodeSize ? size : '') + '\n ' + (options.fileNodeType ? type : '') + '\n
\n
\n
').replace(/>\s+<'); + } + + /** + * Polyfill the lack of an event.path for some browsers + * @param {Element} target + * @return {Array} + */ + + }, { + key: 'getEventPath', + value: function getEventPath(target) { + var eventPath = [target]; + var node = target; + // ensure we have an element we can query an attribute on + while (node.parentNode && node.parentNode.getAttribute) { + eventPath.push(node.parentNode); + node = node.parentNode; + } + + return eventPath; + } + }]); + + return DropZoneComponentUtils; + }(); + + module.exports = DropZoneComponentUtils; + + },{}],13:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneComponentValidation = function () { + function DropZoneComponentValidation() { + _classCallCheck(this, DropZoneComponentValidation); + } + + _createClass(DropZoneComponentValidation, [{ + key: 'clear', + + /** + * Remove validation node + * @param {Element} node + * @param {String} selector + */ + value: function clear(node, selector) { + var validation = node.querySelector('.' + selector); + + if (validation) { + validation.parentNode.removeChild(validation); + } + } + + /** + * Update validation node + * @param {String} error + * @param {Element} node + * @param {Element} info + * @param {String} validationClass + * @param {String} errorClass + * @param {boolean} passive + */ + + }, { + key: 'update', + value: function update(error, node, info, validationClass, errorClass, passive) { + var validation = node.querySelector('.' + validationClass); + + // if we are in passive mode we're handing this over to the developer installing the plugin + // they can access validation data by using the filesRejected callback + if (passive) { + return; + } + + var errorNode = '

' + error + '

'; + + // if a validation element doesn't exist, create one + if (!validation) { + validation = document.createElement('div'); + validation.className = validationClass; + info.parentNode.insertBefore(validation, info); + } + + // create error message and update validation + validation.innerHTML = errorNode; + } + }]); + + return DropZoneComponentValidation; + }(); + + module.exports = DropZoneComponentValidation; + + },{}],14:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneErrors = function () { + /** + * DropZoneErrors + * @param {String} whitelist + * @param {String} maxFiles + * @param {String} maxSize + * @param {String} unknown + * @param {String} empty + */ + function DropZoneErrors() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + _ref$whitelist = _ref.whitelist, + whitelist = _ref$whitelist === undefined ? 'Unsupported file type' : _ref$whitelist, + _ref$maxFiles = _ref.maxFiles, + maxFiles = _ref$maxFiles === undefined ? 'Maximum number files exceeded' : _ref$maxFiles, + _ref$maxSize = _ref.maxSize, + maxSize = _ref$maxSize === undefined ? 'Maximum file size exceeded' : _ref$maxSize, + _ref$unknown = _ref.unknown, + unknown = _ref$unknown === undefined ? 'A file type is not recognized' : _ref$unknown, + _ref$empty = _ref.empty, + empty = _ref$empty === undefined ? 'A file attached has no size, this could mean it has been removed, please check the file still exists' : _ref$empty; + + _classCallCheck(this, DropZoneErrors); + + this.whitelistText = whitelist; + this.maxFilesText = maxFiles; + this.maxSizeText = maxSize; + this.unknownText = unknown; + this.emptyText = empty; + } + + /** + * Get a file validation error object + * @param {String} error + * @returns {Object} error + */ + + + _createClass(DropZoneErrors, [{ + key: 'getFileValidationError', + value: function getFileValidationError(error) { + switch (error) { + case 'WHITELIST': + return { + valid: false, + code: 'WHITELIST', + text: this.whitelistText + }; + case 'MAX_FILES': + return { + valid: false, + code: 'MAX_FILES', + text: this.maxFilesText + }; + case 'MAX_SIZE': + return { + valid: false, + code: 'MAX_SIZE', + text: this.maxSizeText + }; + case 'UNKNOWN': + return { + valid: false, + code: 'UNKNOWN', + text: this.unknownText + }; + case 'EMPTY': + return { + valid: false, + code: 'EMPTY', + text: this.emptyText + }; + } + } + }]); + + return DropZoneErrors; + }(); + + module.exports = DropZoneErrors; + + },{}],15:[function(require,module,exports){ + "use strict"; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneEventManager = function () { + function DropZoneEventManager() { + _classCallCheck(this, DropZoneEventManager); + + this.pool = []; + } + + /** + * Attach an event listener to a node and store in eventPool + * @param {Element} node + * @param {String} event + * @param {Function} handler + */ + + + _createClass(DropZoneEventManager, [{ + key: "add", + value: function add(node, event, handler) { + this.pool.push({ node: node, event: event, handler: handler }); + node.addEventListener(event, handler); + } + + /** + * Remove all event listeners and return an empty pool + */ + + }, { + key: "removeAll", + value: function removeAll() { + this.pool.forEach(function (item) { + var node = item.node, + event = item.event, + handler = item.handler; + + + node.removeEventListener(event, handler); + }); + + this.pool.length = 0; + } + + /** + * Prevent default event behaviour & propagation + * @param {Event} event + */ + + }, { + key: "preventer", + value: function preventer(event) { + event.preventDefault(); + } + }]); + + return DropZoneEventManager; + }(); + + module.exports = DropZoneEventManager; + + },{}],16:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _DropZoneValidationUtils = require('./DropZoneValidationUtils'); + + var _DropZoneValidationUtils2 = _interopRequireDefault(_DropZoneValidationUtils); + + var _DropZoneErrors = require('./DropZoneErrors'); + + var _DropZoneErrors2 = _interopRequireDefault(_DropZoneErrors); + + var _DropZoneValidatorDispatcher = require('./DropZoneValidatorDispatcher'); + + var _DropZoneValidatorDispatcher2 = _interopRequireDefault(_DropZoneValidatorDispatcher); + + var _DropZoneEventManager = require('./DropZoneEventManager'); + + var _DropZoneEventManager2 = _interopRequireDefault(_DropZoneEventManager); + + var _DropZoneIdleTimer = require('./DropZoneIdleTimer'); + + var _DropZoneIdleTimer2 = _interopRequireDefault(_DropZoneIdleTimer); + + var _DropZoneFileManager = require('./DropZoneFileManager'); + + var _DropZoneFileManager2 = _interopRequireDefault(_DropZoneFileManager); + + var _DropZoneFileUtils = require('./DropZoneFileUtils'); + + var _DropZoneFileUtils2 = _interopRequireDefault(_DropZoneFileUtils); + + var _DropZoneCallbackManager = require('./DropZoneCallbackManager'); + + var _DropZoneCallbackManager2 = _interopRequireDefault(_DropZoneCallbackManager); + + var _DropZone = require('./DropZone'); + + var _DropZone2 = _interopRequireDefault(_DropZone); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneFactory = function () { + function DropZoneFactory() { + _classCallCheck(this, DropZoneFactory); + } + + _createClass(DropZoneFactory, null, [{ + key: 'create', + + /** + * Create an instance of a DropZone with it's options and dependencies + * @param {Element} node + * @param {Object} options + * @param {Object} errorOptions + * @returns {DropZone} + */ + value: function create(node, options, errorOptions) { + return new _DropZone2.default(node, options, new _DropZoneValidatorDispatcher2.default(new _DropZoneValidationUtils2.default(), new _DropZoneErrors2.default(errorOptions.validationText), errorOptions.whitelist, errorOptions.maxFiles, errorOptions.maxSize), new _DropZoneEventManager2.default(), new _DropZoneIdleTimer2.default(options.idleTimerDuration), new _DropZoneFileManager2.default(new _DropZoneFileUtils2.default()), new _DropZoneCallbackManager2.default()); + } + }]); + + return DropZoneFactory; + }(); + + module.exports = DropZoneFactory; + + },{"./DropZone":5,"./DropZoneCallbackManager":9,"./DropZoneErrors":14,"./DropZoneEventManager":15,"./DropZoneFileManager":17,"./DropZoneFileUtils":18,"./DropZoneIdleTimer":19,"./DropZoneValidationUtils":22,"./DropZoneValidatorDispatcher":23}],17:[function(require,module,exports){ + "use strict"; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneFileManager = function () { + /** + * DropZoneFileManager + * @param {DropZoneFileUtils} utils + */ + function DropZoneFileManager(utils) { + _classCallCheck(this, DropZoneFileManager); + + this.utils = utils; + } + + /** + * A place we can do something with a file before we add it to the store. + * @param {Object} file + * @param {number} id + * @param {Object} meta + * @return {Object} file object + */ + + + _createClass(DropZoneFileManager, [{ + key: "createFileObject", + value: function createFileObject(file, id) { + var meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + return { + raw: file, + id: id, + meta: meta, + thumbnail: !file.mock ? this.utils.getFileThumbnail(file) : null, + name: !file.mock ? this.utils.getFileName(file.name) : file.name, + type: !file.mock ? this.utils.getFileType(file.type) : null, + size: !file.mock ? this.utils.getFileSize(file.size) : null + }; + } + }]); + + return DropZoneFileManager; + }(); + + module.exports = DropZoneFileManager; + + },{}],18:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneFileUtils = function () { + function DropZoneFileUtils() { + _classCallCheck(this, DropZoneFileUtils); + } + + _createClass(DropZoneFileUtils, [{ + key: 'getFileName', + + /** + * Format filename for printing + * @param {String} filename + * @return {String} + */ + value: function getFileName(filename) { + return filename.replace(/.*[\\\/]/, ''); + } + + /** + * Format type for printing + * @param {String} type + * @return {String} + */ + + }, { + key: 'getFileType', + value: function getFileType(type) { + if (type.length) { + return type; + } else { + return ''; + } + } + + /** + * Format size for printing + * @param {number} size + * @param {number} decimal + * @return {String} + */ + + }, { + key: 'getFileSize', + value: function getFileSize(size) { + var decimal = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + + var kb = 1000, + sizes = ['Bytes', 'KB', 'MB', 'GB'], + i = Math.floor(Math.log(size) / Math.log(kb)); + + if (!size) { + return '0 Byte'; + } else { + return parseFloat((size / Math.pow(kb, i)).toFixed(decimal)) + ' ' + sizes[i]; + } + } + + /** + * Create url for image preview + * @param {Object} file + * @return {String|Boolean} + */ + + }, { + key: 'getFileThumbnail', + value: function getFileThumbnail(file) { + if (file.type.match(/\/(gif|jpeg|png|svg+xml|svg)/) && window.URL.createObjectURL) { + return window.URL.createObjectURL(file); + } else { + return false; + } + } + }]); + + return DropZoneFileUtils; + }(); + + module.exports = DropZoneFileUtils; + + },{}],19:[function(require,module,exports){ + "use strict"; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneIdleTimer = function () { + /** + * DropZoneIdleTimer + * @param {number} duration + */ + function DropZoneIdleTimer(duration) { + _classCallCheck(this, DropZoneIdleTimer); + + this.timer = null; + this.duration = duration; + } + + /** + * Start timer + * @param {Function} callback + */ + + + _createClass(DropZoneIdleTimer, [{ + key: "start", + value: function start(callback) { + var _this = this; + + // remove callback from args + var args = [].slice.call(arguments); + this.timer = setTimeout(function () { + // clear reference to timeout + _this.timer = null; + // invoke callback + callback.apply(_this, args.slice(1)); + }, this.duration); + } + + /** + * Clear current timeout + */ + + }, { + key: "clear", + value: function clear() { + if (this.timer !== null) { + clearTimeout(this.timer); + } + } + }]); + + return DropZoneIdleTimer; + }(); + + module.exports = DropZoneIdleTimer; + + },{}],20:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _lodash = require('lodash'); + + var _lodash2 = _interopRequireDefault(_lodash); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneInstanceManager = function () { + function DropZoneInstanceManager(html, DropZoneFactory, BrowseNodeFactory) { + _classCallCheck(this, DropZoneInstanceManager); + + this.html = html; + this.instances = []; + this.DropZoneFactory = DropZoneFactory; + this.BrowseNodeFactory = BrowseNodeFactory; + } + + /** + * Add DropZone instance to the manager + * @param {Element} node + * @param {DropZoneOptionsManager} optionsManager + */ + + + _createClass(DropZoneInstanceManager, [{ + key: 'addInstance', + value: function addInstance(node, optionsManager) { + var id = this.instances.length; + var options = optionsManager.buildInstanceOptions(node, id); + var errorOptions = optionsManager.buildValidatorOptions(options); + var input = options.inputNodeId ? this.html.querySelector('#' + options.inputNodeId) : null; + var browse = this.BrowseNodeFactory.create(node.querySelector('.' + options.nodeClasses.browse)); + var info = node.querySelector('.' + options.nodeClasses.info); + var dropZone = this.DropZoneFactory.create(node, options, errorOptions); + + // initiate dropZone + dropZone.init(); + + // set DropZone ID on node + node.setAttribute('data-dropzone-id', id); + + // store instance object + this.instances.push({ options: options, node: node, dropZone: dropZone, input: input, browse: browse, info: info, id: id }); + } + + /** + * Update ref to browse node and re-attach events + * @param {Number} id + * @param {Element} node + */ + + }, { + key: 'updateBrowseNode', + value: function updateBrowseNode(id, node) { + var instance = _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }); + + instance.browse.update(node); + instance.browse.enableEvents(); + } + + /** + * Enable browse node events + * @param {Number} id + */ + + }, { + key: 'enableBrowseNode', + value: function enableBrowseNode(id) { + var instance = _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }); + + instance.browse.enableEvents(); + } + + /** + * Disable browse node events + * @param {Number} id + */ + + }, { + key: 'disableBrowseNode', + value: function disableBrowseNode(id) { + var instance = _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }); + + instance.browse.disableEvents(); + } + + /** + * Get a DropZone instance object, will return all instances if no id arg supplied + * @param {number} id + * @returns {Object|Array} + */ + + }, { + key: 'getInstance', + value: function getInstance() { + var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : -1; + + var result = void 0; + + if (id < 0) { + result = this.instances; + } else { + result = _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }); + } + + return result; + } + + /** + * Add files to an instance + * @param {FileList} files + * @param {number} id + * @param {Object} meta + */ + + }, { + key: 'addFiles', + value: function addFiles(files, id) { + var meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }).dropZone.addFiles(files, meta); + } + + /** + * Remove file from an instance + * @param {number} id + * @param {number} fileId + */ + + }, { + key: 'removeFile', + value: function removeFile(id, fileId) { + _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }).dropZone.removeFile(fileId); + } + + /** + * Get all files from an instance + * @param {number} id + * @returns {Array} files + */ + + }, { + key: 'getFiles', + value: function getFiles(id) { + return _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }).dropZone.getFiles(); + } + + /** + * Get a specific file from an instance + * @param {number} id + * @param {number} index + * @returns {Object} file + */ + + }, { + key: 'getFile', + value: function getFile(id, index) { + return _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }).dropZone.getFile(index); + } + + /** + * Get data transfer support from an instance + * @param {number} id + * @returns {boolean} + */ + + }, { + key: 'getSupportsDataTransfer', + value: function getSupportsDataTransfer(id) { + return _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }).dropZone.getSupportsDataTransfer(); + } + + /** + * Get supported option + * @param {number} id + * @returns {boolean} + */ + + }, { + key: 'getSupported', + value: function getSupported(id) { + return _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }).options.supported; + } + + /** + * Validate files against an instance + * @param {FileList} files + * @param {number} id + * @param {Boolean} retry + */ + + }, { + key: 'validateFiles', + value: function validateFiles(files, id) { + var retry = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + var instance = _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }); + + return instance.dropZone.validator.validate(files, instance.dropZone.getFiles().length, instance.dropZone.getSize(), retry); + } + + /** + * Reset an instance + * @param {number} id + */ + + }, { + key: 'resetInstance', + value: function resetInstance() { + var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : -1; + + if (id < 0) { + this.instances.forEach(function (instance) { + return instance.dropZone.reset(); + }); + } else { + _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }).dropZone.reset(); + } + } + + /** + * Disable DropZone instance + * @param {Number} id + */ + + }, { + key: 'disableInstance', + value: function disableInstance(id) { + var instance = _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }); + + instance.dropZone.disable(); + } + + /** + * Enable DropZone instance + * @param {Number} id + */ + + }, { + key: 'enableInstance', + value: function enableInstance(id) { + var instance = _lodash2.default.find(this.instances, function (i) { + return i.id === id; + }); + + instance.dropZone.enable(); + } + }]); + + return DropZoneInstanceManager; + }(); + + module.exports = DropZoneInstanceManager; + + },{"lodash":418}],21:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _lodash = require('lodash'); + + var _lodash2 = _interopRequireDefault(_lodash); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneOptionsManager = function () { + function DropZoneOptionsManager(utils) { + _classCallCheck(this, DropZoneOptionsManager); + + this.componentOptions = {}; + this.instanceOptions = []; + this.utils = utils; + } + + /** + * Build and store base component options + * @param {Object} defaults + * @param {Object} options + * @param {Object} callbacks + */ + + + _createClass(DropZoneOptionsManager, [{ + key: 'buildComponentOptions', + value: function buildComponentOptions(defaults, options, callbacks) { + this.componentOptions = _lodash2.default.extend({}, defaults, options, callbacks); + } + + /** + * Build Instance options + * @param {Element} node + * @param {number} id + */ + + }, { + key: 'buildInstanceOptions', + value: function buildInstanceOptions(node, id) { + var attrOptions = this.utils.getOptionsFromAttrs(node); + var options = _lodash2.default.extend({}, this.componentOptions, attrOptions); + + options.dropZoneId = id; + this.instanceOptions[id] = options; + + return options; + } + + /** + * Get instance options + * @param {number} id + * @returns {Object} + */ + + }, { + key: 'getInstanceOptions', + value: function getInstanceOptions(id) { + return this.instanceOptions[id]; + } + + /** + * Get a property from an instance options + * @param {number} id + * @param {string} prop + * @returns {*} + */ + + }, { + key: 'getInstanceOption', + value: function getInstanceOption(id, prop) { + return this.instanceOptions[id][prop]; + } + + /** + * Build options object for the DropZoneValidator + * This allows us to define the validator options in the HTML + * @param {Object} options + * @returns {Object} validator options + */ + + }, { + key: 'buildValidatorOptions', + value: function buildValidatorOptions(options) { + var validatorOptions = { validationText: {} }; + + return Object.keys(options).reduce(function (validatorOptions, option) { + switch (option) { + case 'validationMaxFiles': + case 'validationWhitelist': + case 'validationMaxSize': + case 'validationUnknown': + // this is converting 'validationMaxFiles' -> 'maxFiles' so the validator options can be + // set in the html e.g. 'data-validation-max-files="Too many files"' + var newOption = option.replace('validation', ''); + + newOption = newOption[0].toLowerCase() + newOption.slice(1); + validatorOptions.validationText[newOption] = options[option]; + break; + case 'maxFiles': + case 'maxSize': + case 'whitelist': + validatorOptions[option] = options[option]; + break; + } + + return validatorOptions; + }, validatorOptions); + } + }]); + + return DropZoneOptionsManager; + }(); + + module.exports = DropZoneOptionsManager; + + },{"lodash":418}],22:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneValidationUtils = function () { + function DropZoneValidationUtils() { + _classCallCheck(this, DropZoneValidationUtils); + } + + _createClass(DropZoneValidationUtils, [{ + key: 'validateType', + + /** + * Validate a file type against a whitelist + * @param {String} type + * @param {Array} whitelist + * @returns {boolean} valid + */ + value: function validateType(type, whitelist) { + var valid = void 0; + + // in the absence of a whitelist, everything is valid + if (!whitelist.length) { + valid = true; + } + + whitelist.forEach(function (mime) { + if (!valid) { + if (mime.search('/') >= 0) { + if (mime === type) { + // if the user has specified a full mime e.g. 'image/png' + // we will check that against the type + valid = true; + } else if (mime.indexOf('*') >= 0) { + // if the user has specified a wildcard mime e.g. 'image/*' + // we will create a wildcard expression and test against it + var re = new RegExp(mime.replace('/*/g', '[\\W\\w]*')); + + valid = !!re.exec(type); + } else { + valid = false; + } + } else { + // if the user has specified a part mime e.g. 'png' + // we'll split the type and check against the right hand side + // the equivalent of '*/png' + valid = type.split('/')[1] === mime; + } + } + }); + + return valid; + } + + /** + * Validate against max file count + * @param {number} count + * @param {number} max + * @returns {boolean} valid + */ + + }, { + key: 'validateCount', + value: function validateCount(count, max) { + return count <= max; + } + + /** + * Validate against max file size + * @param {number} count + * @param {number} max + * @returns {boolean} valid + */ + + }, { + key: 'validateSize', + value: function validateSize(count, max) { + return count <= max; + } + }]); + + return DropZoneValidationUtils; + }(); + + module.exports = DropZoneValidationUtils; + + },{}],23:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var DropZoneValidatorDispatcher = function () { + /** + * DropZoneValidator + * @param {DropZoneValidationUtils} utils + * @param {DropZoneErrors} errors + * @param {Array} whitelist + * @param {number} maxFiles + * @param {number} maxSize + */ + function DropZoneValidatorDispatcher(utils, errors, whitelist, maxFiles, maxSize) { + _classCallCheck(this, DropZoneValidatorDispatcher); + + this.utils = utils; + this.errors = errors; + this.whitelist = whitelist; + this.maxFiles = maxFiles; + this.maxSize = maxSize; + } + + /** + * Dispatch validation methods + * @param {Array} files + * @param {Number} totalFiles + * @param {Number} totalSize + * @param {Boolean} retry + * @returns {Object} error + */ + + + _createClass(DropZoneValidatorDispatcher, [{ + key: 'validate', + value: function validate(files, totalFiles, totalSize) { + var retry = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + + var result = { valid: true, text: '' }; + var fileCount = totalFiles; + var sizeCount = totalSize; + + // if we have files but we do not have a length we're dealing + // with a browser with limited support, so we'll return them as valid + // now and let them be caught later + if (!files.length) { + return result; + } + + for (var i = 0; i < files.length; i++) { + var file = files[i]; + var fileObject = file.getAsFile ? file.getAsFile() : file; + + // if we are in retry mode we don't need to increment this count + // as the file will already be on the DropZone instance + if (!retry) { + fileCount++; + } + + // reject items that do not hav a size + if (result.valid && file.size === 0) { + result = this.errors.getFileValidationError('EMPTY'); + } + + // whitelist + // - check we have a whitelist + // - ensure our file is on the whitelist + // - skip files that have a mock property + if (result.valid && file.type && this.whitelist && this.whitelist.length && !file.mock && !this.utils.validateType(file.type, this.whitelist)) { + result = this.errors.getFileValidationError('WHITELIST'); + } + + // max files + // - ensure we haven't exceeded our max files + if (result.valid && !this.utils.validateCount(fileCount, this.maxFiles)) { + result = this.errors.getFileValidationError('MAX_FILES'); + } + + // max size + // - ensure we haven't exceeded our maximum size, if we can get size + // + // check to see if we can get a file, if we can't we know we cannot + // determine the size, so we'll pass this and handle it when we can get + // the size + if (result.valid && fileObject && !file.mock) { + // if we are in retry mode we don't want tp add the size of each file + // as they will already be on the DropZone instance + if (!retry) { + sizeCount += fileObject.size; + } + + if (!this.utils.validateSize(sizeCount, this.maxSize)) { + result = this.errors.getFileValidationError('MAX_SIZE'); + } + } + } + + return result; + } + }]); + + return DropZoneValidatorDispatcher; + }(); + + module.exports = DropZoneValidatorDispatcher; + + },{}],24:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require('jquery'); + var Selectors = { + 'DATA_TOGGLE': '[data-toggle=dropdown]', + 'DROP_MENU': '.dropdown__menu', + 'VISIBLE_ITEMS': '.dropdown__menu li a:not(.is-disabled):not(.disabled), .dropdown__menu li button:not(.is-disabled):not(.disabled):not(:disabled)', + 'DISABLED': '.disabled, .is-disabled, :disabled', + 'DROPDOWN': '.dropdown', + 'BTN_GROUP': '.btn__group', + 'BTN_GROUP_OPEN': '.btn__group.open', + 'BTN_GROUP_DROP': '.btn__group.dropdown, .btn__group.dropup', + 'DROPUP': 'dropup', + 'OPEN': 'open' + }; + var Keycodes = { + 'ESC': 27, + 'UP': 38, + 'DOWN': 40 + }; + + var DropdownButtonComponent = function () { + /** + * DropdownButton + * @param {jQuery} $html - jQuery wrapper of the html node + */ + function DropdownButtonComponent($html) { + _classCallCheck(this, DropdownButtonComponent); + + this.$html = $html; + } + + /** + * Initialise component + */ + + + _createClass(DropdownButtonComponent, [{ + key: 'init', + value: function init() { + var _this = this; + + if (typeof this.$html === 'undefined' || !this.$html.length) { + throw new Error('$html must be passed to DropdownButtonComponent'); + } + + this.$html.on('click', Selectors.DATA_TOGGLE, function (event) { + return _this.toggle(event); + }).on('click', function (event) { + return _this.handleBodyClick(event); + }).on('keydown', function (event) { + return _this.handleEscKeydown(event); + }).on('focusout', Selectors.BTN_GROUP_OPEN, function (event) { + return _this.handleDropParentFocusout(event); + }); + + this.$html.find(Selectors.DATA_TOGGLE).on('keydown', function (event) { + return _this.handleDropButtonKeydown(event); + }); + this.$html.find(Selectors.DROP_MENU).on('keydown', function (event) { + return _this.handleDropMenuKeydown(event); + }); + } + + /** + * Handle toggle + * @param {Event} event + */ + + }, { + key: 'toggle', + value: function toggle(event) { + var $button = $(event.target).closest(Selectors.DATA_TOGGLE), + $parent = $button.parent(), + dropdownOpen = $parent.hasClass(Selectors.OPEN); + + if ($button.is(Selectors.DISABLED)) { + return; + } + + this.closeAllDropdowns(); + + if (!dropdownOpen) { + if (event.isDefaultPrevented()) { + return; + } + + $parent.toggleClass(Selectors.OPEN); + $button.attr('aria-expanded', 'true'); + } + } + + /** + * Close all dropdowns + */ + + }, { + key: 'closeAllDropdowns', + value: function closeAllDropdowns() { + var dropdownButtons = this.$html.find(Selectors.DATA_TOGGLE); + + dropdownButtons.each(function (index, button) { + var $button = $(button), + $parent = $button.parent(); + + if (!$parent.hasClass(Selectors.OPEN)) { + return; + } + + $parent.removeClass(Selectors.OPEN).trigger('hidden.bs.dropdown'); + + $button.attr('aria-expanded', 'false'); + }); + } + + /** + * Close all dropdowns on body click + * @param {Event} event + */ + + }, { + key: 'handleBodyClick', + value: function handleBodyClick(event) { + var $clickedElement = $(event.target); + + if ($clickedElement.attr('data-toggle') === 'dropdown' || $clickedElement.closest(Selectors.BTN_GROUP).hasClass(Selectors.OPEN) || $clickedElement.closest(Selectors.DROPDOWN).hasClass(Selectors.OPEN)) { + return; + } + this.closeAllDropdowns(); + } + + /** + * Close all dropdowns on body click + * @param {Event} event + */ + + }, { + key: 'handleEscKeydown', + value: function handleEscKeydown(event) { + var $elementWithFocus = $(':focus'); + + if (event.keyCode === Keycodes.ESC) { + if ($elementWithFocus.closest(Selectors.BTN_GROUP_DROP)) { + $elementWithFocus.closest(Selectors.BTN_GROUP_DROP).find(Selectors.DATA_TOGGLE).trigger('focus'); + } + + this.closeAllDropdowns(); + } + } + + /** + * Open dropdown menu on arrow up or down, depending on dropdown or dropup + * @param {Event} event + */ + + }, { + key: 'handleDropButtonKeydown', + value: function handleDropButtonKeydown(event) { + var $keydownElement = $(event.target), + $parentButtonGroup = $keydownElement.closest(Selectors.BTN_GROUP), + direction = $parentButtonGroup.hasClass(Selectors.DROPUP) ? 'up' : 'down', + $dropdownItems = $parentButtonGroup.find(Selectors.VISIBLE_ITEMS); + + if ($keydownElement.is(Selectors.DISABLED)) { + return; + } + + if (event.keyCode === Keycodes.DOWN && direction === 'down') { + event.preventDefault(); + + if (!$dropdownItems.length) { + return; + } + + if (!$parentButtonGroup.hasClass(Selectors.OPEN)) { + $keydownElement.trigger('click'); + } + + $dropdownItems.first().trigger('focus'); + } + + if (event.keyCode === Keycodes.UP && direction === 'up') { + event.preventDefault(); + + if (!$dropdownItems.length) { + return; + } + + if (!$parentButtonGroup.hasClass(Selectors.OPEN)) { + $keydownElement.trigger('click'); + } + + $dropdownItems.last().trigger('focus'); + } + } + + /** + * Allow arrow key menu navigation + * @param {Event} event + */ + + }, { + key: 'handleDropMenuKeydown', + value: function handleDropMenuKeydown(event) { + var codes = [Keycodes.ESC, Keycodes.UP, Keycodes.DOWN], + $keydownElement = $(event.target), + $dropdownItems = $keydownElement.closest(Selectors.BTN_GROUP).find(Selectors.VISIBLE_ITEMS); + var isKey = function isKey(key, codes) { + return codes.filter(function (code) { + return code === key; + }).length; + }; + var index = void 0; + + if (!isKey(event.keyCode, codes)) { + return; + } + + if (!$dropdownItems.length) { + return; + } + + event.preventDefault(); + + index = $dropdownItems.index($dropdownItems.filter(':focus')); + + if (event.keyCode === Keycodes.UP && index > 0) { + index--; + } + + if (event.keyCode === Keycodes.DOWN && index < $dropdownItems.length) { + index++; + } + + if (index < 0) { + index = 0; + } + + $dropdownItems.eq(index).trigger('focus'); + } + + /** + * Close drop menu when focus leaves parent btn__group + */ + + }, { + key: 'handleDropParentFocusout', + value: function handleDropParentFocusout() { + var _this2 = this; + + // Using timeout due to :focus return body when an element loses focus before new element gains focus + setTimeout(function () { + var $elementWithFocus = $(':focus'); + if (!$elementWithFocus.closest(Selectors.BTN_GROUP_OPEN).length) { + _this2.closeAllDropdowns(); + } + }, 1); + } + }]); + + return DropdownButtonComponent; + }(); + + module.exports = DropdownButtonComponent; + + },{"jquery":416}],25:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var ErrorSummaryComponent = function () { + function ErrorSummaryComponent() { + _classCallCheck(this, ErrorSummaryComponent); + } + + _createClass(ErrorSummaryComponent, [{ + key: 'init', + + + /** + * Initialise + * @param {jQuery} $html - jQuery wrapper of the html node + */ + value: function init($html) { + var $errorSummary = void 0; + + if (typeof $html === 'undefined' || !$html.length) { + throw new Error('$html must be passed to ErrorSummaryComponent init()'); + } + + $errorSummary = $html.find('[data-error-summary]'); + + if (!$errorSummary.length) { + return; + } + + if ($errorSummary.length > 1) { + throw new Error('Only one error summary may be present on a page'); + } + + $errorSummary.focus(); + } + }]); + + return ErrorSummaryComponent; + }(); + + module.exports = ErrorSummaryComponent; + + },{}],26:[function(require,module,exports){ + 'use strict'; + + var $ = require('jquery'), + _ = require('lodash'); + + function FilterBarComponent(html) { + this.$html = html; + } + + FilterBarComponent.prototype.init = function () { + var component = this; + + this.$container = this.$html.find('.filter-bar'); + + this.$container.each(function () { + var $filterbar = $(this); + + // Create the filter add button + createFilterListButton($filterbar); + + // Hide the form elements + hideFormControls($filterbar); + + // Move save button + moveFormActions($filterbar); + + // Handlers + showFilterBar(component, $filterbar); + populateFilterList($filterbar); + showAddFilterPopover($filterbar); + addFilter($filterbar); + removeFilter($filterbar); + clearAllFilters($filterbar); + }); + }; + + function showFilterBar(component, $filterbar) { + + component.$html.on('click', '[data-ui="show-filter-bar"]', function (e) { + var $addFilterButton = $filterbar.find('[data-ui="show-filter-list"]'); + + e.preventDefault(); + + // Show add button if hidden by clear + $addFilterButton.removeClass('u-display-none'); + + // Show filter bar + $filterbar.removeClass('u-display-none'); + + // Focus add button + $addFilterButton.trigger('focus'); + }); + } + + function createFilterListButton($filterbar) { + var $formGroups = $filterbar.find('.form__group'), + $addFilterButton, + $filterList = $('
    '), + $filterLabelsWrapper = $('
    '); + + // Loop through form groups + $formGroups.each(function () { + $filterList.append('
  • ' + _.escape($(this).find('.control__label').text()) + '
    • '); + }); + + // Build up list and mark up for Add filter button + $addFilterButton = $(''); + $addFilterButton.attr('data-content', $filterList[0].outerHTML); + + // Append button and label wrapper + $filterLabelsWrapper.appendTo($filterbar.find('fieldset')); + $addFilterButton.appendTo($filterLabelsWrapper); + + // Initialize popover + $addFilterButton.popover(); + + $filterbar.on('click', '[data-ui="show-filter-list"]', function (e) { + e.preventDefault(); + + var $addFilterButton = $(this); + + if ($addFilterButton.attr('aria-expanded') == 'false') { + $addFilterButton.attr('aria-expanded', 'true'); + } else { + $addFilterButton.attr('aria-expanded', 'false'); + } + }); + } + + function hideFormControls($filterbar) { + $filterbar.find('.form__group').addClass('u-display-none'); + $filterbar.find('.form__actions').addClass('u-display-none'); + } + + function moveFormActions($filterbar) { + var $formActions = $filterbar.find('.form__actions'), + $fieldset = $filterbar.find('fieldset'); + + $formActions.appendTo($fieldset); + $formActions.addClass('u-display-none'); + } + + function showAddFilterPopover($filterbar) { + var filterTitle, + filterId, + select2Placeholder, + $formGroup, + $filterLabel, + $popoverControls, + $popoverContent, + $field, + $select2, + $addFilterButton = $filterbar.find('[data-ui="show-filter-list"]'); + + $filterbar.on('click', '[data-ui="filter-item"]', function (e) { + e.preventDefault(); + + filterTitle = $(this).attr('data-filter-title'); + filterId = $(this).attr('data-filter-id'); + $field = $filterbar.find('#' + filterId); + + $addFilterButton.attr('aria-expanded', 'false'); + + // Hide the filter item in the list + updateFilterList($addFilterButton, filterId, 'hide'); + + // Add new filter label + $filterLabel = $('' + _.escape(filterTitle) + ' '); + $filterLabel.insertBefore($addFilterButton); + + // If checkbox, check it but no need to display it or move to popover + if ($field[0].type === 'checkbox') { + + // Hide the filter list popover + $addFilterButton.popover('hide'); + + // Check the checkbox + $field.prop('checked', true); + + // Add the remove button to the label + filterId = $filterLabel.attr('data-filter-id'); + $filterLabel.append(''); + + // Add the label + $filterLabel.removeClass('label--primary').addClass('label--inverse'); + + // Hide the filter list button if no links remaining + filterListButtonVisibility($filterbar); + + // Check if save button should be visible + formActionsVisibility($filterbar); + + // Focus the add button or, if that's not visible, focus the save button + if (!$addFilterButton.hasClass('u-display-none')) { + $addFilterButton.trigger('focus'); + } else { + $filterbar.find('.form__actions .btn--primary').trigger('focus'); + } + } else { + + // Create content for the popover + $popoverContent = $('
    '); + + // Move the field into the popover content + $formGroup = $filterbar.find('#' + filterId).closest('.form__group'); + $formGroup.appendTo($popoverContent); + $formGroup.addClass('form__group--flush'); + + // Hide the control label + $formGroup.removeClass('u-display-none').find('.control__label').addClass('hide'); + + // Add popover controls + $popoverControls = $('
    '); + $popoverControls.insertAfter($formGroup); + + // Refresh the select2 + $select2 = $popoverContent.find('.js-select2:not([data-init="false"])'); + select2Placeholder = $select2.attr('data-placeholder'); + $select2.select2({ placeholder: select2Placeholder }); + + // Trigger popover with form field on added label + /* istanbul ignore next: difficult to test generated popover content */ + $filterLabel.popover({ + html: true, + title: function title() { + return filterTitle; + }, + content: function content() { + return $popoverContent; + }, + placement: 'bottom', + trigger: 'manual' + }); + + // Hide the filter list popover + $addFilterButton.popover('hide'); + + // Show the popover + $filterLabel.popover('show'); + + // Disable the add filter button + $addFilterButton.addClass('is-disabled').attr('disabled', true); + + // Hide the filter list button if no links remaining + filterListButtonVisibility($filterbar); + + // Focus on field to avoid unnecessary extra click + if ($field.hasClass('js-select2') && $field.data('init') !== false) { + $field.select2('focus'); + } else { + /* istanbul ignore next: difficult to test due to generated popover content */ + $field.focus(); + } + + // Enable button when field has value + /* istanbul ignore next: difficult to test due to field being inside generated popover content */ + $field.on('change keyup', function () { + if ($field.val()) { + $popoverControls.find('[data-ui="add-filter"]').removeClass('is-disabled').attr('disabled', false).attr('aria-disabled', false); + } else { + $popoverControls.find('[data-ui="add-filter"]').addClass('is-disabled').attr('disabled', true); + } + }); + } + }); + } + + /* istanbul ignore next: difficult to test due to field and form controls being inside generated popover content */ + function addFilter($filterbar) { + $filterbar.on('click', '[data-ui="add-filter"]', function (e) { + var $field = $(this).closest('.added-popover-content').find('.form__control'), + $popover = $(this).closest('.popover'), + $formGroup = $popover.find('.form__group'), + $label = $popover.prev('.label'), + $addFilterButton = $filterbar.find('[data-ui="show-filter-list"]'), + $legend = $filterbar.find('form fieldset legend'), + values, + valueForLabel = null, + filterId, + initalLabelText = _.escape($label.text()); + + e.preventDefault(); + + // Check if field is a select2 + if ($field.hasClass('js-select2')) { + + values = $field.select2('data'); + + $.each(values, function (index, value) { + if (valueForLabel === null) { + valueForLabel = value.text; + } else { + valueForLabel = valueForLabel + ', ' + value.text; + } + }); + } else { + valueForLabel = $field.val(); + } + + // Add it to the label + $label.find('.chosen-filter').text(': ' + valueForLabel); + + // Add the remove button to the label + filterId = $label.attr('data-filter-id'); + $label.append(''); + + // Swap classes + $label.removeClass('label--primary').addClass('label--inverse'); + + // Hide the field + $formGroup.addClass('u-display-none'); + + // Move the form group out of the popover and back into the filterbar form + $formGroup.insertAfter($legend); + + // Close popover and destroy to prevent an empty popover showing on label click + $label.popover('destroy'); + + // Enable add filter button + $addFilterButton.removeClass('is-disabled').attr('disabled', false).attr('aria-disabled', false); + + // Check if save button should be visible + formActionsVisibility($filterbar); + + // Focus the add button or, if that's not visible, focus the save button + if (!$addFilterButton.hasClass('u-display-none')) { + $addFilterButton.trigger('focus'); + } else { + $filterbar.find('.form__actions .btn--primary').trigger('focus'); + } + }); + } + + function removeFilter($filterbar) { + var $addFilterButton = $filterbar.find('[data-ui="show-filter-list"]'); + + $filterbar.on('click', '[data-ui="filter-cancel"]', function (e) { + var filterId = $(this).attr('data-filter-id'), + $legend = $filterbar.find('form fieldset legend'), + $field = $filterbar.find('#' + filterId), + $formGroup = $field.closest('.form__group'), + $label; + + e.preventDefault(); + + if ($(this).parents('.popover').length) { + $label = $(this).closest('.popover').prev('.label'); + } else { + $label = $(this).closest('.label'); + } + + // Add option back to list + updateFilterList($addFilterButton, filterId, 'show'); + + // Empty values from field + if ($field[0].type === 'select-one' || $field[0].type === 'select-multiple') { + $field.find('option:selected').prop('selected', false); + } else if ($field[0].type === 'checkbox') { + $field.prop('checked', false); + } else { + $field.val(''); + } + + // Destroy select2 + if ($field.hasClass('select2-hidden-accessible')) { + $field.select2('destroy'); + } + + // Hide the field + $formGroup.addClass('u-display-none'); + + // Move the form group out of the popover and back into the form + $formGroup.insertAfter($legend); + + // Remove the popover and label + $label.popover('hide'); + $label.remove(); + + // Enable add filter button + $addFilterButton.removeClass('is-disabled').attr('disabled', false).attr('aria-disabled', false); + + // Find any open add filter button popover + $addFilterButton.popover('hide'); + + // Check if button should be visible + filterListButtonVisibility($filterbar); + + // Check if save button should be visible + formActionsVisibility($filterbar); + + // Shift focus to add button + $addFilterButton.trigger('focus'); + }); + } + + function filterListButtonVisibility($filterbar) { + var $addFilterButton = $filterbar.find('[data-ui="show-filter-list"]'), + addFilterList, + $addFilterList; + + addFilterList = $addFilterButton.attr('data-content'); + $addFilterList = $(_.unescape(addFilterList)); + + if ($addFilterList.find('li:not(.u-display-none)').length) { + $addFilterButton.removeClass('u-display-none'); + } else { + $addFilterButton.addClass('u-display-none'); + } + } + + function formActionsVisibility($filterbar) { + var $formActions = $filterbar.find('.form__actions'); + + // Ensure form actions are visible after all filters remove when filters present on load + if ($filterbar.data('had-filters-on-load') === true) { + $formActions.removeClass('u-display-none'); + $formActions.find('.btn--primary').removeClass('u-display-none'); + + return; + } + + if ($filterbar.find('.label').length) { + $formActions.removeClass('u-display-none'); + } else { + $formActions.addClass('u-display-none'); + } + } + + function clearAllFilters($filterbar) { + var $addFilterButton = $filterbar.find('[data-ui="show-filter-list"]'); + + $filterbar.on('click', '[data-ui="clear-all-filters"]', function (e) { + + e.preventDefault(); + + // Close filter bar + $filterbar.addClass('u-display-none'); + + // Remove all labels + $filterbar.find('.label').remove(); + + // Reset filter list + updateFilterList($addFilterButton, null, 'reset'); + + // Hide form actions + formActionsVisibility($filterbar); + + // Reset form + $filterbar.find('form').trigger('reset'); + }); + } + + function updateFilterList($addFilterButton, filterId, visibility) { + var addFilterList = $addFilterButton.attr('data-content'), + $addFilterList = $(_.unescape(addFilterList)), + $filterItem, + $filterItemParent; + + if (filterId !== null) { + $filterItem = $addFilterList.find('[data-filter-id="' + filterId + '"]'); + $filterItemParent = $filterItem.parent(); + } + + if (visibility === 'show') { + $filterItemParent.removeClass('u-display-none'); + } else if (visibility === 'hide') { + $filterItemParent.addClass('u-display-none'); + } else if (visibility === 'reset') { + $addFilterList.find('li.u-display-none').removeClass('u-display-none'); + } + + $addFilterButton.attr('data-content', $addFilterList[0].outerHTML); + } + + /** + * Fired on load, this reads the values of the hidden filters form and + * populates the filterbar with the required labels. + **/ + function populateFilterList($filterbar) { + + var $formGroups = $filterbar.find('.form__group'), + $labelContainer = $filterbar.find('.filter-bar__labels'), + $addFilterButton = $filterbar.find('[data-ui="show-filter-list"]'), + hiddenFormGroups = 0; + + $formGroups.each(function () { + var $this = $(this), + $filterField = $this.find('.form__control'), + filterId = $filterField.attr('id'), + filterLabel = $this.find('.control__label').text().trim(), + filterValue = $filterField.val(), + initalLabelText = filterLabel; + + if ($filterField.hasClass('select')) { + if ($filterField.prop('multiple')) { + filterValue = $filterField.find('option:selected').toArray().map(function (item) { + return item.text; + }).join(', '); + } else if ($filterField.find('option:selected').val()) { + filterValue = $filterField.find('option:selected').text(); + } + } + + if ($filterField[0].type === 'checkbox') { + if ($filterField.prop('checked') === true) { + filterValue = ' '; + } else { + filterValue = ''; + } + } else { + filterLabel = filterLabel + ': '; + } + + if (filterValue !== '' && filterValue !== null && filterValue.length !== 0) { + $labelContainer.prepend('' + _.escape(filterLabel) + _.escape(filterValue) + ''); + + // Keep track of how many filters have already been applied + hiddenFormGroups++; + + // Hide the filter item in the list + updateFilterList($addFilterButton, filterId, 'hide'); + + // Show the filterbar + $filterbar.removeClass('u-display-none'); + + // Track if there were filters on load for form action visibility + $filterbar.data('had-filters-on-load', true); + + // Show the clear button + $filterbar.find('.form__actions').removeClass('u-display-none'); + $filterbar.find('.form__actions .btn--primary').addClass('u-display-none'); + } + + // Don't show add filter button if all filters have been loaded + if ($formGroups.length === hiddenFormGroups) { + $addFilterButton.addClass('u-display-none'); + } + }); + } + + module.exports = FilterBarComponent; + + },{"jquery":416,"lodash":418}],27:[function(require,module,exports){ + 'use strict'; + + var $ = require('jquery'); + require('jquery-sticky'); + + function FlashMessageComponent(html) { + + this.$html = html; + }; + + FlashMessageComponent.prototype.init = function () { + + var component = this, + prototype = '
    '; + + component.$container = this.$html.find('.js-flash-container'); + component.$flashes = this.$html.find('.flash'); + + if (!component.$container.length) { + throw new Error('Missing container with class .js-flash-container'); + } + + component.$prototype = $(prototype); + + component.$flashes.on('click', '[data-dismiss=flash]', function (e) { + component.dismiss($(this).closest('.flash')); + }); + + return true; + }; + + FlashMessageComponent.prototype.success = function (message) { + + var component = this, + $flash; + + if (!message) { + message = 'Success!'; + } + + $flash = component.render(message, 'success', 'icon-ok'); + + return true; + }; + + FlashMessageComponent.prototype.error = function (message) { + + var component = this, + $flash; + + if (!message) { + message = 'There was an error, but no error message was supplied.'; + } + + $flash = component.render(message, 'error', 'icon-warning-sign'); + + return true; + }; + + FlashMessageComponent.prototype.warning = function (message) { + + var component = this, + $flash; + + if (!message) { + message = 'Something kinda bad happened, but no warning message was supplied.'; + } + + $flash = component.render(message, 'warning', 'icon-warning-sign'); + + return true; + }; + + FlashMessageComponent.prototype.info = function (message) { + + var component = this, + $flash; + + if (!message) { + message = 'Something happened that you should know about, but we forgot to say what it was...'; + } + + $flash = component.render(message, 'info', 'icon-info-sign'); + + return true; + }; + + FlashMessageComponent.prototype.render = function (message, type, icon) { + + var component = this, + $prototype = $(component.$prototype.clone()); + + if (!type) { + type = 'success'; + } + + if (!icon) { + icon = 'icon-info-sign'; + } + + $prototype.append($(' ' + message + '')).removeClass('flash--default').addClass('flash--' + type); + + component.$container.append($prototype).on('click', '[data-dismiss=flash]', function (e) { + component.dismiss($(this).closest('.flash')); + }); + + return true; + }; + + FlashMessageComponent.prototype.dismiss = function (target) { + $(target).slideUp('100', function () { + $(this).remove(); + }); + }; + + module.exports = FlashMessageComponent; + + },{"jquery":416,"jquery-sticky":408}],28:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var FocusManagementService = function () { + /** + * Focus Management Service + */ + function FocusManagementService() { + _classCallCheck(this, FocusManagementService); + + this.$element = null; + this.focusableElementList = 'a[href], input, select, textarea, button'; + } + + /** + * Store element that focus will be returned to + * @param {jQuery} $element - jQuery wrapper of the element + */ + + + _createClass(FocusManagementService, [{ + key: 'storeElement', + value: function storeElement($element) { + this.$element = $element; + } + + /** + * Return focus to original element + */ + + }, { + key: 'returnFocusToElement', + value: function returnFocusToElement() { + this.$element.focus(); + } + + /** + * Check if an element is stored + */ + + }, { + key: 'hasStoredElement', + value: function hasStoredElement() { + return this.$element !== null; + } + + /** + * Move focus to first focuable element in a collection + * @param {jQuery} $collection - jQuery collection of elements + */ + + }, { + key: 'focusFirstFocusableElement', + value: function focusFirstFocusableElement($collection) { + var $focusableElements = $collection.find(this.focusableElementList).not('[tabindex=-1], [disabled], :hidden, [aria-hidden]'); + + if ($focusableElements.length) { + $focusableElements.first().focus(); + } + } + + /** + * Trap focus within a container + * @param {jQuery} $container + */ + + }, { + key: 'trapFocus', + value: function trapFocus($container) { + var $focusableElements = $container.find(this.focusableElementList).not('[tabindex=-1], [disabled], :hidden, [aria-hidden]'); + + $container.on('keydown', this.trapFocusKeydownListener.bind(this, $focusableElements)); + } + + /** + * Manage focus on keydown + * @param {jQuery} $container + * @param {Event} event + */ + + }, { + key: 'trapFocusKeydownListener', + value: function trapFocusKeydownListener($focusableElements, event) { + var keyCode = event.keyCode || event.which; + + // If tab key is pressed + if (keyCode === 9) { + // Check for shift tab + if (event.shiftKey) { + // Focus previous, check if first element is is currently in focus, if so focus last element + if ($focusableElements.first().is(':focus')) { + event.preventDefault(); + $focusableElements.last().trigger('focus'); + } + } else { + // Focus next, check if last element is is currently in focus, if so focus first element + if ($focusableElements.last().is(':focus')) { + event.preventDefault(); + $focusableElements.first().trigger('focus'); + } + } + } + } + }]); + + return FocusManagementService; + }(); + + module.exports = FocusManagementService; + + },{}],29:[function(require,module,exports){ + 'use strict'; + + var $ = require('jquery'); + + function HelpTextComponent(html, window, document) { + this.$html = html; + this.window = window; + this.$document = $(document); + } + + HelpTextComponent.prototype.init = function () { + var component = this, + $tabHelpContainer = component.$html.find('.tab-help-container'); + + // Visually hide sidebar so you can't tab to it with keyboard/screenreaders + $tabHelpContainer.addClass('hide').attr('aria-hidden', 'true'); + + // Help toggle click bind + component.$html.on('click', '.js-show-page-help', function (e) { + e.preventDefault(); + e.stopPropagation(); + component.toggleHelpSidebar(); + }).on('focusout', '.tab-help-container', function (event) { + return component.handleFocusOut(event); + }); + + // Close help button + $tabHelpContainer.on('click', '.js-close-page-help', function (e) { + e.preventDefault(); + e.stopPropagation(); + component.toggleHelpSidebar(); + }); + + // Make mobile help container child element non-interactive + component.toggleChildElementInteractivity($tabHelpContainer, false); + + // Bind to tab.js event to update help text in sidebar on tab change + component.$html.find('a[data-toggle="tab"]').on('shown.bs.tab', function (e) { + component.updateHelpSidebar(); + }); + }; + + HelpTextComponent.prototype.toggleHelpSidebar = function () { + var component = this, + $mobileToggleHelpButton = component.$html.find('.js-show-page-help'), + $tabHelpContainer = component.$html.find('.tab-help-container'); + + if ($mobileToggleHelpButton.hasClass('is-open')) { + $mobileToggleHelpButton.removeClass('is-open'); + component.toggleChildElementInteractivity($tabHelpContainer, false); + } else { + $mobileToggleHelpButton.addClass('is-open'); + component.toggleChildElementInteractivity($tabHelpContainer, true); + } + + if (component.$html.hasClass('open-help')) { + component.$html.removeClass('open-help'); + if (component.$html.hasClass('lt-ie10')) { + $tabHelpContainer.addClass('hide').attr('aria-hidden', 'true'); + } else { + $tabHelpContainer.one('webkitTransitionEnd otransitionend oTransitionEnd msTransitionEnd transitionend', function (e) { + component.$html.find('.js-show-page-help').trigger('focus'); + + $tabHelpContainer.addClass('hide').attr('aria-hidden', 'true'); + }); + } + } else { + $tabHelpContainer.removeClass('hide').removeAttr('aria-hidden'); + component.$html.addClass('open-help'); + + // Jump focus to the help container + $tabHelpContainer.one('webkitTransitionEnd otransitionend oTransitionEnd msTransitionEnd transitionend', function (e) { + $tabHelpContainer.find('.js-close-page-help').trigger('focus'); + }); + } + }; + + HelpTextComponent.prototype.updateHelpSidebar = function () { + var component = this, + $activeTabContainer = component.$html.find('.tab__pane.is-active .tab__container'), + activeTabSideBarContentHtml = component.$html.find('.tab__pane.is-active .tab__sidebar').html(), + $mobileToggleHelpButton = $(''), + $mobileToggleContainer = component.$html.find('.tab__pane.is-active .tab__content'), + $tabHelp = component.$html.find('.tab-help'), + isMobile, + mobileCloseHelpButton = ''; + + // Check if active tab has help text + if (activeTabSideBarContentHtml && activeTabSideBarContentHtml.length > 0) { + + // If clicked outside of sidebar, close sidebar + this.$document.on('click', function (e) { + + // side bar help is open + if (component.$html.hasClass('open-help')) { + + // check if inside of sidebar + if (!$(e.target).closest('.tab-help-container').length) { + component.toggleHelpSidebar(); + } + } + }); + + // If mobile help button doesn't already exist add it if help text exists + if (!$mobileToggleContainer.find('.js-show-page-help').length) { + $mobileToggleHelpButton.prependTo($mobileToggleContainer); + } + + // Add class used for setting desktop column widths + $activeTabContainer.addClass('has-sidebar'); + + // Check if mobile + isMobile = !component.window.matchMedia('(min-width: 992px)').matches; + + // Populate mobile sidebar help content + if (isMobile) { + $tabHelp.html(activeTabSideBarContentHtml); + + // Add mobile help close button + $(mobileCloseHelpButton).prependTo($tabHelp); + + // Hide mobile sidebar interactive elements from a11y tree while closed + component.toggleChildElementInteractivity($tabHelp, false); + } + + // Watch for window resizes + $(component.window).on('resize', function () { + isMobile = !component.window.matchMedia('(min-width: 992px)').matches; + if (isMobile) { + $tabHelp.html(activeTabSideBarContentHtml); + + // Add mobile help close button + $(mobileCloseHelpButton).prependTo($tabHelp); + + // Hide mobile sidebar interactive elements from a11y tree while closed + component.toggleChildElementInteractivity($tabHelp, false); + } + }); + } else { + $activeTabContainer.removeClass('has-sidebar'); + } + }; + + /** + * Return focus to the open help control when focus leaves the help container + */ + HelpTextComponent.prototype.handleFocusOut = function (e) { + var component = this; + + if (component.$html.hasClass('open-help')) { + // Using timeout due to :focus return body when an element loses focus before new element gains focus + setTimeout(function () { + var $elementWithFocus = $(':focus'); + if (!$elementWithFocus.closest('.tab-help').length) { + component.toggleHelpSidebar(); + } + }, 1); + } + }; + + /** + * Toggle focusability of elements + */ + HelpTextComponent.prototype.toggleChildElementInteractivity = function ($container, interactive) { + var focusableElements = 'a[href], button'; + + if (interactive === true) { + $container.find(focusableElements).removeAttr('tabindex'); + } else { + $container.find(focusableElements).attr('tabindex', '-1'); + } + }; + + module.exports = HelpTextComponent; + + },{"jquery":416}],30:[function(require,module,exports){ + 'use strict'; + + var $ = require('jquery'); + + function MasterSwitchComponent(html, disableUi) { + this.$html = html; + this.disableUi = disableUi; + } + + MasterSwitchComponent.prototype.init = function () { + var component = this; + + component.$container = this.$html.find('.masterswitch'); + + component.$container.each(function () { + var $this = $(this); + + this.$control = $this.find('.masterswitch-control input'); + this.$content = $this.find('.masterswitch-content'); + + if (!this.$control.prop('checked')) { + component.switchOff(this.$control); + } else { + component.switchOn(this.$control); + } + + this.$control.on('change', function (e) { + if ($(this).prop('checked')) { + component.switchOn(e.target); + } else { + component.switchOff(e.target); + } + }); + }); + }; + + MasterSwitchComponent.prototype.switchOn = function (target) { + var component = this; + + component.$target = $(target).closest('.masterswitch').find('.masterswitch-content'); + + component.$target.removeClass('is-disabled'); + component.disableUi.enable(component.$target); + }; + + MasterSwitchComponent.prototype.switchOff = function (target) { + var component = this; + + component.$target = $(target).closest('.masterswitch').find('.masterswitch-content'); + + component.$target.addClass('is-disabled'); + component.disableUi.disable(component.$target); + }; + + module.exports = MasterSwitchComponent; + + },{"jquery":416}],31:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var ModalFocusService = function () { + function ModalFocusService() { + _classCallCheck(this, ModalFocusService); + } + + _createClass(ModalFocusService, [{ + key: 'trapFocus', + + /** + * Trap focus within modals + * @param {jQuery} $modal - jquery wrapper of the modal markup + * @param {jQuery} $container - jquery wrapper of the container, typically body + */ + value: function trapFocus($modal, $container) { + var $modalFocusableElements = $modal.find('.modal__content').find('a[href], area[href], input, select, textarea, button, iframe, object, embed, [tabindex], *[contenteditable]').not('[tabindex=-1], [disabled], :hidden, [aria-hidden]'); + var $modalBodyFocusableElements = $modal.find('.modal__body').find('a[href], area[href], input, select, textarea, button, iframe, object, embed, [tabindex], *[contenteditable]').not('[tabindex=-1], [disabled], :hidden, [aria-hidden]'); + var $modalCloseButton = $modal.find('.close[data-dismiss="modal"]').first(); + var $modalFooterCancelButton = $modal.find('.modal__footer [data-dismiss="modal"]').first(); + + /** + * Manage focus + * If modal has focusable elements in body, focus the first + * If not, focus the X close button + * If for some reason it doesn't have that, focus the cancel button in footer + * As a last resort, search for anything to focus + */ + if ($modalBodyFocusableElements.length) { + $modalBodyFocusableElements.first().trigger('focus'); + } else if ($modalCloseButton.length) { + $modalCloseButton.trigger('focus'); + } else if ($modalFooterCancelButton.length) { + $modalFooterCancelButton.trigger('focus'); + } else { + $modalFocusableElements.first().trigger('focus'); + } + + /** + * Trap focus within modal + */ + $container.on('keydown', this.keydownListener.bind(this, $modalFocusableElements)); + } + + /** + * Manage focus when tab / shift + tab are pressed + * @param {jQuery} $modalFocusableelements - jquery wrapper of elements that can gain focus + * @param {event} event + */ + + }, { + key: 'keydownListener', + value: function keydownListener($modalFocusableelements, event) { + var keyCode = event.keyCode || event.which; + + // If tab key is pressed + if (keyCode === 9) { + // Check for shift tab + if (event.shiftKey) { + // Focus previous, check if first element is is currently in focus, if so focus last element + if ($modalFocusableelements.first().is(':focus')) { + event.preventDefault(); + $modalFocusableelements.last().trigger('focus'); + } + } else { + // Focus next, check if last element is is currently in focus, if so focus first element + if ($modalFocusableelements.last().is(':focus')) { + event.preventDefault(); + $modalFocusableelements.first().trigger('focus'); + } + } + } + } + + /** + * Release focus back to original triggering element + * @param {$triggeringElement} $triggeringElement - jquery wrapper of the element that triggered the modal + */ + + }, { + key: 'releaseFocus', + value: function releaseFocus($triggeringElement) { + if ($triggeringElement.closest('.dropdown__menu').length) { + // If triggering link is in a button group / dropdown, return focus to the surrounding button + $triggeringElement.closest('.btn__group').find('.btn.dropdown__toggle').trigger('focus'); + } else { + // Else return it to the triggering link + $triggeringElement.trigger('focus'); + } + } + }]); + + return ModalFocusService; + }(); + + module.exports = ModalFocusService; + + },{}],32:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require('jquery'); + + var ModalListener = function () { + + /** + * ModalListener + * @constructor + * @param {jQuery} $html - jQuery wrapper of the html node + */ + function ModalListener(modalFocusService) { + _classCallCheck(this, ModalListener); + + this.modalFocusService = modalFocusService; + } + + /** + * Listen for modals being shown or hidden + * @param {jQuery} $container + */ + + + _createClass(ModalListener, [{ + key: 'listen', + value: function listen($container) { + var _this = this; + + var $triggeringElement = void 0; + + // Hook modal-triggering elements + $container.find('[data-toggle="modal"]').on('click', function (event) { + var $modalTrigger = $(event.target); + + if (!$modalTrigger.hasClass('disabled')) { + $triggeringElement = $modalTrigger; + event.preventDefault(); + } + }); + + $container.on('shown.bs.modal', function (data) { + var $modal = $(data.target); + _this.modalFocusService.trapFocus($modal, $container); + }); + + $container.on('hidden.bs.modal', function () { + // Check if click came from a [data-modal] link + if (typeof $triggeringElement !== 'undefined') { + _this.modalFocusService.releaseFocus($triggeringElement); + } + }); + } + }]); + + return ModalListener; + }(); + + module.exports = ModalListener; + + },{"jquery":416}],33:[function(require,module,exports){ + 'use strict'; + + var $ = require('jquery'); + + function ModulePermissionsComponent(html) { + this.$html = html; + }; + + ModulePermissionsComponent.prototype.init = function () { + + var component = this; + + component.$html.on('click', '.js-module-toggle', component.toggleModuleVisibility); + component.$html.on('click', '.js-refine-toggle', component.toggleModulePagesVisibility); + + // // Module-master + component.$html.find('.module').on('click', '[data-toggle="module-master"]', function () { + component.toggleModuleMasterState(this); + }); + + component.$html.find('.module').on('click', '[data-toggle="module-row"]', function () { + component.toggleModuleRowState(this); + }); + + component.$html.find('.module').on('click', '[data-crud]', function () { + component.toggleCrudState(this); + }); + + component.$html.find('.module').on('click', '[data-toggle="module-crud"]', function () { + component.toggleModuleState(this); + }); + + component.$html.find('.module').on('click', '[data-toggle="page"]', function () { + component.togglePageState(this); + }); + + // Set up indeterminate checkboxes on page load + component.$html.find('.checkbox[indeterminate]').prop('indeterminate', true); + }; + + ModulePermissionsComponent.prototype.toggleModuleVisibility = function () { + + var $toggle = $(this), + $target = $toggle.closest('.module'); + + if ($target.hasClass('is-open')) { + $target.removeClass('is-open'); + $toggle.html(''); + } else { + $target.addClass('is-open'); + $toggle.html(''); + } + }; + + ModulePermissionsComponent.prototype.toggleModulePagesVisibility = function () { + + var $toggle = $(this), + $target = $toggle.closest('.module-page'); + + if ($target.hasClass('is-open')) { + $target.removeClass('is-open'); + $toggle.text('refine'); + } else { + $target.addClass('is-open'); + $toggle.text('close'); + } + }; + + ModulePermissionsComponent.prototype.toggleModuleMasterState = function (target) { + + var component = this, + $this = $(target), + $scope = $this.closest('.module'), + $rowToggles = $('[data-toggle="module-row"]', $scope), + $crud = $('[data-crud]', $scope), + $r = $('[data-crud="view"]', $scope), + $cud = $('[data-crud="create"], [data-crud="update"], [data-crud="delete"]', $scope); + + if ($this.is(':checked')) { + component.setChecked($.merge($rowToggles, $crud)); + } else if ($this.is(':not(:checked)')) { + component.setUnchecked($.merge($rowToggles, $r)); + component.setDisabled($cud); + } + }; + + ModulePermissionsComponent.prototype.toggleModuleRowState = function (target) { + + var component = this, + $this = $(target), + $scope = $this.closest('.module-row'), + $moduleScope = $this.closest('.module'), + $rowToggles = $('[data-toggle="module-row"]', $scope), + $crud = $('[data-crud]', $scope), + $r = $('[data-crud="view"]', $scope), + $cud = $('[data-crud="create"], [data-crud="update"], [data-crud="delete"]', $scope); + + if ($this.is(':checked')) { + if ($scope.has('.module-subpage').length) { + component.setChecked($.merge($rowToggles, $crud)); + } else { + component.setChecked($crud); + } + } else if ($this.is(':not(:checked)')) { + if ($scope.has('.module-subpage').length) { + component.setUnchecked($.merge($rowToggles, $r)); + } else { + component.setUnchecked($r); + } + component.setDisabled($cud); + } + + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="view"]', $this.closest('.module'))); + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="create"]', $this.closest('.module'))); + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="update"]', $this.closest('.module'))); + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="delete"]', $this.closest('.module'))); + }; + + ModulePermissionsComponent.prototype.toggleCrudState = function (target) { + + var component = this, + $this = $(target), + $scope = $this.closest('.module-row'), + $pageScope = $this.closest('.module-page'), + $moduleScope = $this.closest('.module'), + $moduleCrudToggle = $('[data-toggle="module-crud"][data-crud="' + $this.data('crud') + '"]', $moduleScope), + $cud = $('[data-crud]:not([data-crud="view"])', $scope); + + if ($this.data('crud') == 'view') { + if ($this.prop('checked')) { + component.setEnabled($cud); + } else { + component.setDisabled($cud); + } + } + + if ($this.prop('checked')) { + component.setChecked($this); + } else { + component.setUnchecked($this); + } + + if ($this.data('toggle') == 'subpage') { + + var subpageCrudSelector = '[data-toggle="subpage"][data-crud="' + $this.data('crud') + '"]', + $pageCrudToggle = $('[data-toggle="page"][data-crud="' + $this.data('crud') + '"]', $pageScope); + + if ($(subpageCrudSelector + ':checked', $pageScope).length == 0) { + component.setUnchecked($pageCrudToggle); + } else if ($(subpageCrudSelector + ':checked', $pageScope).length == $(subpageCrudSelector, $pageScope).length) { + component.setChecked($pageCrudToggle); + } else { + component.setIndeterminate($pageCrudToggle); + } + + component.toggleModuleCrud($moduleCrudToggle); + } + + setTimeout(function () { + component.updateRowToggles($moduleScope); + }, 0); + }; + + ModulePermissionsComponent.prototype.updateRowToggles = function (scope) { + + var component = this, + $rows = $('.module-row', scope); + + $rows.each(function () { + var $this = $(this), + $rowToggle = $('> .control__label > .checkbox', $this), + numCheckboxes = $('[data-crud]', $this).length, + numChecked = $('[data-crud]:checked', $this).length; + + if (numChecked == 0) { + component.setUnchecked($rowToggle); + } else if (numChecked === numCheckboxes) { + component.setChecked($rowToggle); + } else { + component.setIndeterminate($rowToggle); + } + + if ($this.has('.module-subpage').length && !$this.hasClass('module-subpage')) { + component.toggleModulePageCrud($('[data-toggle="page"][data-crud="view"]', $this.closest('.module-page'))); + component.toggleModulePageCrud($('[data-toggle="page"][data-crud="create"]', $this.closest('.module-page'))); + component.toggleModulePageCrud($('[data-toggle="page"][data-crud="update"]', $this.closest('.module-page'))); + component.toggleModulePageCrud($('[data-toggle="page"][data-crud="delete"]', $this.closest('.module-page'))); + } + + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="view"]', $this.closest('.module'))); + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="create"]', $this.closest('.module'))); + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="update"]', $this.closest('.module'))); + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="delete"]', $this.closest('.module'))); + }); + }; + + ModulePermissionsComponent.prototype.toggleModuleCrud = function (target) { + + var component = this, + $this = $(target), + $scope = $this.closest('.module'), + crudSelector = '[data-crud="' + $this.data('crud') + '"]:not([data-toggle="module-crud"])', + $moduleMasterToggle = $('[data-toggle="module-master"]', $scope), + moduleCrudSelector = '[data-toggle="module-crud"]', + $moduleCrudToggle = $('[data-toggle="module-crud"][data-crud="' + $this.data('crud') + '"]', $scope); + + if ($(crudSelector + ':checked', $scope).length == 0) { + component.setUnchecked($moduleCrudToggle); + } else if ($(crudSelector, $scope).length == $(crudSelector + ':checked', $scope).length) { + component.setChecked($moduleCrudToggle); + } else { + component.setIndeterminate($moduleCrudToggle); + } + + if ($(moduleCrudSelector + ':checked', $scope).length === 0 && $(moduleCrudSelector + ':indeterminate', $scope).length === 0) { + component.setUnchecked($moduleMasterToggle); + } else if ($(moduleCrudSelector, $scope).length === $(moduleCrudSelector + ':checked', $scope).length) { + component.setChecked($moduleMasterToggle); + } else if ($(moduleCrudSelector, $scope).length > $(moduleCrudSelector + ':checked', $scope).length) { + component.setIndeterminate($moduleMasterToggle); + } + }; + + ModulePermissionsComponent.prototype.toggleModulePageCrud = function (target) { + + var component = this, + $this = $(target), + $scope = $this.closest('.module-page'), + crudSelector = '[data-crud="' + $this.data('crud') + '"]:not([data-toggle="page"])', + $modulePageCrudToggle = $('[data-toggle="page"][data-crud="' + $this.data('crud') + '"]', $scope); + + if ($(crudSelector + ':checked', $scope).length == 0) { + if (!$modulePageCrudToggle.prop('disabled')) { + component.setUnchecked($modulePageCrudToggle); + } + } else if ($(crudSelector, $scope).length == $(crudSelector + ':checked', $scope).length) { + component.setChecked($modulePageCrudToggle); + } else { + component.setIndeterminate($modulePageCrudToggle); + } + }; + + ModulePermissionsComponent.prototype.togglePageState = function (target) { + + var component = this, + $this = $(target), + $scope = $this.closest('.module-page'), + $moduleScope = $this.closest('.module'), + crudSelector = '[data-crud="' + $this.data('crud') + '"]:not([data-toggle="page"])', + $crudEnabledToggles = $(crudSelector + ':not(:disabled)', $scope), + $crudCheckedToggles = $(crudSelector + ':checked', $scope), + $crudDisabledToggles = $(crudSelector + ':disabled', $scope), + $moduleCrudToggle = $('[data-toggle="module-crud"][data-crud="' + $this.data('crud') + '"]', $moduleScope); + + if ($crudEnabledToggles.length) { + if ($this.prop('checked')) { + component.setChecked($crudEnabledToggles); + } else { + component.setUnchecked($crudEnabledToggles); + } + } + + // if ($($crudDisabledToggles.selector, $scope).length > 0) { + // console.log('1'); + // component.setIndeterminate($this); + // } else + if ($($crudEnabledToggles.selector, $scope).length === $($crudCheckedToggles.selector, $scope).length) { + //console.log('2'); + // if ($this.data('toggle') != 'page') { + // console.log('2a'); + // component.setChecked($this); + // } + } else { + //console.log('3'); + component.setUnchecked($this); + } + + component.toggleModuleCrud($moduleCrudToggle); + }; + + ModulePermissionsComponent.prototype.toggleModuleState = function (target) { + + var component = this, + $this = $(target), + $scope = $this.closest('.module'), + crudSelector = '[data-crud="' + $this.data('crud') + '"]:not([data-toggle="module-crud"])', + $crudEnabledToggles = $(crudSelector + ':not(:disabled)', $scope), + $crudCheckedToggles = $(crudSelector + ':checked', $scope), + $crudDisabledToggles = $(crudSelector + ':disabled', $scope); + + if ($this.prop('checked')) { + component.setChecked($crudEnabledToggles); + } else { + component.setUnchecked($crudEnabledToggles); + } + + if ($($crudDisabledToggles.selector, $scope).length > 0) { + component.setIndeterminate($this); + } else if ($($crudEnabledToggles.selector, $scope).length === $($crudCheckedToggles.selector, $scope).length) { + component.setChecked($this); + } else { + component.setUnchecked($this); + + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="view"]', $this.closest('.module'))); + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="create"]', $this.closest('.module'))); + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="update"]', $this.closest('.module'))); + component.toggleModuleCrud($('[data-toggle="module-crud"][data-crud="delete"]', $this.closest('.module'))); + } + }; + + ModulePermissionsComponent.prototype.setChecked = function (target) { + target.prop('indeterminate', false).prop('disabled', false).prop('checked', true).parent().removeClass('is-disabled is-indeterminate').addClass('is-checked'); + }; + + ModulePermissionsComponent.prototype.setUnchecked = function (target) { + target.prop('checked', false).prop('indeterminate', false).prop('disabled', false).parent().removeClass('is-checked is-disabled is-indeterminate'); + }; + + ModulePermissionsComponent.prototype.setIndeterminate = function (target) { + target.prop('checked', false).prop('disabled', false).prop('indeterminate', true).parent().removeClass('is-checked is-disabled').addClass('is-indeterminate'); + }; + + ModulePermissionsComponent.prototype.setDisabled = function (target) { + target.prop('checked', false).prop('indeterminate', false).prop('disabled', true).parent().removeClass('is-checked is-indeterminate').addClass('is-disabled'); + }; + + ModulePermissionsComponent.prototype.setEnabled = function (target) { + target.prop('disabled', false).parent().removeClass('is-disabled'); + }; + + module.exports = ModulePermissionsComponent; + + },{"jquery":416}],34:[function(require,module,exports){ + 'use strict'; + + var $ = require('jquery'); + + function NavMainComponent($html, rootWindow, focusManagementService) { + this.$html = $html; + this.window = rootWindow; + this.$window = $(rootWindow); + this.focusManagementService = focusManagementService; + }; + + NavMainComponent.MISSING_ATTR_ERROR = 'A nav link must have a href or data-target attribute'; + NavMainComponent.CLOSE_WITH_ESCAPE = "CLOSE_WITH_ESCAPE"; + NavMainComponent.CLOSE_WITH_CLICK = "CLOSE_WITH_CLICK"; + + /** + * Initialise + */ + NavMainComponent.prototype.init = function () { + var component = this; + + if (!component.$html.length) { + throw new Error('html must be passed to NavMainComponent'); + } + + if (!component.$window.length) { + throw new Error('window must be passed to NavMainComponent'); + } + + component.$body = this.$html.find('body'); + component.$navMain = this.$html.find('.nav-main'); + component.$brandingLink = this.$html.find('.jadu-branding'); + component.$navPrimary = this.$html.find('.nav-primary'); + component.$navSecondary = this.$html.find('.nav-secondary'); + component.$navTertiary = component.$navMain.find('.nav-tertiary'); + component.$navQuaternary = component.$navMain.find('.nav-quaternary'); + component.$primaryNavLinks = component.$navPrimary.find('.nav-link'); + component.$tertiaryNavLinks = component.$navTertiary.find('.nav-link'); + component.$closeLink = component.$navMain.find('[data-nav-action=close]'); + component.$mobileMenuButton = this.$html.find('.mobile-menu-button'); + + // Calculate what primary nav items can be shown and which need to be hidden in more menu + component.adjustNavItems(); + + // Check which tabindexes should be applied to navigation links to ensure WCAG compliance + component.manageTabIndexes(); + + // Hide nav from SR on mobile + var isMobile = !component.window.matchMedia('(min-width: 992px)').matches; + if (isMobile) { + component.$navMain.attr('aria-hidden', 'true'); + } + + // Open navigation on mobile + component.$mobileMenuButton.on('click', function (event) { + var $self = $(this); + event.stopImmediatePropagation(); + + if ($self.text() === 'Menu') { + component.showMobileNav(true); + } else { + component.showMobileNav(false); + } + }); + + // More button is shown when window is too short to display all primary nav items + component.$navMain.on('click', '.more-icon > .nav-link', function (event) { + var $self = $(this); + event.preventDefault(); + component.moreIconClickHandler($self); + }); + + // Re-adjust nav items on window resize to calc if more button is needed + component.$window.on('resize', function () { + var isMobile = !component.window.matchMedia('(min-width: 992px)').matches; + + component.adjustNavItems(); + component.manageTabIndexes(); + + if (!isMobile) { + component.showMobileNav(false); + component.$navMain.removeAttr('aria-hidden'); + } + }); + + // Close navs when element outside of nav is clicked + component.$body.find('.toolbar, .content-main, .footer').on('click', function () { + if (component.isNavOpen()) { + component.closeNavs($(this)); + } + }); + + // Open secondary nav on primary nav item click + component.$primaryNavLinks.on('click', function (event) { + component.openSecondaryNav($(this), event); + }); + + // Open quaternary nav on tertiary nav item click + component.$tertiaryNavLinks.on('click', function (event) { + var $self = $(this), + target; + + if ($self.attr('href')) { + target = $self.attr('href'); + } else if ($self.attr('data-target')) { + target = $self.attr('data-target'); + } else { + throw new Error(NavMainComponent.MISSING_ATTR_ERROR); + } + + if (target.indexOf('#') !== -1) { + event.preventDefault(); + + // Change aria expanded to true + $self.attr('aria-expanded', 'true'); + } + + component.openQuaternaryNav(target, $self); + }); + + // Close respective navs on close link click + component.$closeLink.on('click', function (event) { + event.preventDefault(); + component.closeNavs($(this)); + }); + + // Close respective navs on ESC + this.$html.on('keydown', function (event) { + if (event.keyCode === 27) { + if (component.$navQuaternary.hasClass('is-open')) { + component.closeQuaternaryNav({ type: NavMainComponent.CLOSE_WITH_ESCAPE }); + } else if (component.$navTertiary.hasClass('is-open')) { + component.closeTertiaryNav(); + } else if (component.$navSecondary.hasClass('is-open')) { + component.closeSecondaryNav({ type: NavMainComponent.CLOSE_WITH_ESCAPE }); + } else if (isMobile && component.$body.hasClass('open-nav')) { + component.showMobileNav(false); + } + } + }); + }; + + /** + * Check if any navs are open + * @returns {boolean} + */ + NavMainComponent.prototype.isNavOpen = function () { + var component = this, + isMobile = !component.window.matchMedia('(min-width: 992px)').matches; + + if (isMobile && component.$body.hasClass('open-nav')) { + return true; + } else if (component.$navSecondary.hasClass('is-open')) { + return true; + } else if (component.$navTertiary.hasClass('is-open')) { + return true; + } else if (component.$navQuaternary.hasClass('is-open')) { + return true; + } else { + return false; + } + }; + + /** + * Unto the tabindex if the main nav is in responsive mode + * This maintains the tab order to ensure WCAG compliance + */ + NavMainComponent.prototype.manageTabIndexes = function () { + var component = this, + isMobile = !component.window.matchMedia('(min-width: 992px)').matches; + + if (isMobile) { + component.$brandingLink.attr('tabindex', '-1'); + component.$primaryNavLinks.attr('tabindex', '-1'); + } else { + component.$brandingLink.attr('tabindex', '1'); + component.$primaryNavLinks.attr('tabindex', '1'); + } + }; + + /** + * Open secondary navigation, close all other navs and highlight primary nav item parent + * @param {jQuery} $triggeringElement - the element clicked to open secondary nav + * @param {Event} event - click event for the primary nav link + */ + NavMainComponent.prototype.openSecondaryNav = function ($triggeringElement, event) { + var component = this, + target; + + if ($triggeringElement.attr('href')) { + target = $triggeringElement.attr('href'); + } else if ($triggeringElement.attr('data-target')) { + target = $triggeringElement.attr('data-target'); + } else { + throw new Error(NavMainComponent.MISSING_ATTR_ERROR); + } + + // Close any previously open navs + component.closeSecondaryNav(); + component.closeTertiaryNav(); + component.closeQuaternaryNav(); + + // Close any open popovers which would appear over the navigation + component.$html.find('[data-toggle="popover"]').popover('hide'); + + // If href is a fragment (therefore opens a sub nav), don't add it to the URL because it breaks the back button + if (target.indexOf('#') !== -1) { + event.preventDefault(); + $triggeringElement.attr('aria-expanded', 'true'); + component.$navSecondary.addClass('is-open'); + component.$navSecondary.find('.nav-list.is-active').removeClass('is-active'); + component.$navSecondary.find('[data-nav="' + target + '"]').addClass('is-active'); + } + + if (component.$html.find('[data-nav="' + target + '"]').length >= 1) { + component.$navMain.addClass('is-open'); + } else { + component.closeNavs($triggeringElement); + } + + component.$navPrimary.find('.is-active').removeClass('is-active'); + component.$navPrimary.find('[href="' + target + '"], [data-target="' + target + '"]').addClass('is-active'); + + // Manage focus + component.focusManagementService.storeElement($triggeringElement); + component.focusManagementService.focusFirstFocusableElement(component.$navSecondary); + component.focusManagementService.trapFocus(component.$navSecondary); + }; + + /** + * Open quaternary navigation + * @param {string} target - href of target nav list + */ + NavMainComponent.prototype.openQuaternaryNav = function (target, $trigger) { + var component = this; + + // If menu item has child menu options and therefore is same-page link then open $navQuaternary + if (target.indexOf('#') !== -1) { + component.$navQuaternary.addClass('is-open'); + } + + // Show the target nav-list in the opened nav + component.$navQuaternary.find('[data-nav="' + target + '"]').addClass('is-active'); + + // Manage focus + component.focusManagementService.storeElement($trigger); + component.focusManagementService.focusFirstFocusableElement(component.$navQuaternary); + component.focusManagementService.trapFocus(component.$navQuaternary); + }; + + /** + * Close respective nav(s) depending on which close link was clicked + * @param {jQuery} $linkClicked - jQuery object of the close link clicked + */ + NavMainComponent.prototype.closeNavs = function ($linkClicked) { + var component = this, + $linkParent = $linkClicked.closest('.nav-flyout'); + + if ($linkParent.hasClass('nav-secondary')) { + component.closeSecondaryNav({ type: NavMainComponent.CLOSE_WITH_CLICK, trigger: $linkClicked }); + } else if ($linkParent.hasClass('nav-tertiary')) { + component.closeTertiaryNav(); + } else if ($linkParent.hasClass('nav-quaternary')) { + component.closeQuaternaryNav({ type: NavMainComponent.CLOSE_WITH_CLICK, trigger: $linkClicked }); + } + + // like a body click or something outside of navs + else { + component.closeSecondaryNav({ type: NavMainComponent.CLOSE_WITH_CLICK, trigger: $linkClicked }); + component.closeTertiaryNav(); + component.closeQuaternaryNav({ type: NavMainComponent.CLOSE_WITH_CLICK, trigger: $linkClicked }); + } + }; + + /** + * Close secondary navigation + * @param {Object} [action] + */ + NavMainComponent.prototype.closeSecondaryNav = function (action) { + var component = this; + + component.$navMain.removeClass('is-open'); + component.$navMain.find('[aria-expanded=true]').attr('aria-expanded', 'false'); + component.$navSecondary.removeClass('is-open'); + component.$primaryNavLinks.removeClass('is-active'); + component.$navMain.find('.nav-item.is-active').removeClass('is-active'); + component.$navSecondary.find('.nav-list').removeClass('is-active'); + + if (action === undefined) { + return; + } + + switch (action.type) { + case NavMainComponent.CLOSE_WITH_ESCAPE: + if (component.focusManagementService.hasStoredElement()) { + component.focusManagementService.returnFocusToElement(); + } + break; + case NavMainComponent.CLOSE_WITH_CLICK: + if (action.trigger.parents('.nav-secondary').length > 0) { + if (component.focusManagementService.hasStoredElement()) { + component.focusManagementService.returnFocusToElement(); + } + } + break; + } + }; + + /** + * Close tertiary navigation + */ + NavMainComponent.prototype.closeTertiaryNav = function () { + var component = this; + + component.$navTertiary.removeClass('is-open'); + component.$navTertiary.find('.nav-list').removeClass('is-active'); + + component.$navMain.find('[aria-expanded=true]').removeClass('is-active').attr('aria-expanded', 'false').trigger('focus'); + }; + + /** + * Close quaternary navigation + * @param {Object} [action] + */ + NavMainComponent.prototype.closeQuaternaryNav = function (action) { + var component = this; + + component.$navQuaternary.removeClass('is-open'); + component.$navQuaternary.find('.nav-list.is-active').removeClass('is-active'); + component.$navTertiary.find('[aria-expanded=true]').attr('aria-expanded', 'false'); + + if (action === undefined) { + return; + } + + switch (action.type) { + case NavMainComponent.CLOSE_WITH_ESCAPE: + if (component.focusManagementService.hasStoredElement()) { + component.focusManagementService.returnFocusToElement(); + } + break; + case NavMainComponent.CLOSE_WITH_CLICK: + if (action.trigger.parents('.nav-quaternary').length > 0) { + if (component.focusManagementService.hasStoredElement()) { + component.focusManagementService.returnFocusToElement(); + } + } + break; + } + }; + + /** + * Toggle mobile navigation + */ + NavMainComponent.prototype.showMobileNav = function (show) { + var component = this; + + if (show === false) { + component.$body.removeClass('open-nav'); + component.$mobileMenuButton.removeClass('open').text('Menu').attr('aria-expanded', 'false'); + component.$brandingLink.attr('tabindex', '-1'); + component.$primaryNavLinks.attr('tabindex', '-1'); + component.$navMain.attr('aria-hidden', 'true'); + component.$body.find('.skip-link').removeAttr('aria-hidden'); + component.$body.find('.toolbar > :not(.mobile-menu-button)').removeAttr('aria-hidden'); + component.$body.find('.content-main').removeAttr('aria-hidden'); + component.$body.find('.footer').removeAttr('aria-hidden'); + + return; + } + + component.$body.addClass('open-nav'); + component.$mobileMenuButton.addClass('open').text('Close').attr('aria-expanded', 'true'); + component.$brandingLink.attr('tabindex', '3'); + component.$primaryNavLinks.attr('tabindex', '3'); + component.$navMain.attr('aria-hidden', 'false'); + + // Hide rest of page from SR while nav open + component.$body.find('.skip-link').attr('aria-hidden', 'true'); + component.$body.find('.toolbar > :not(.mobile-menu-button)').attr('aria-hidden', 'true'); + component.$body.find('.content-main').attr('aria-hidden', 'true'); + component.$body.find('.footer').attr('aria-hidden', 'true'); + }; + + /** + * Detect window height, adjust the number of items in the primary nav and check when to add "More" option + */ + NavMainComponent.prototype.adjustNavItems = function () { + var component = this, + availableHeight = component.$window.height(), + navItemsHeight = component.$html.find('.nav-primary .nav-items').outerHeight(true) + component.$html.find('.jadu-branding').outerHeight(true), + moreIconHeight = 72, + // Pre calculated height of the "More" nav item + navItemsCountTotal = component.$html.find('.nav-primary .nav-items li').length, + numberOfHiddenNavItems = component.$html.find('.nav-primary .nav-item:hidden').length; + + // When nav items + more icon height is greater than available window height + if (navItemsHeight > availableHeight) { + // Prevent infinite loop when all nav items are already hidden + if (numberOfHiddenNavItems === navItemsCountTotal - 1) { + return; + } + + // If there is not enough space hide the last primary nav items + component.hidePrimaryNavItems(navItemsHeight, moreIconHeight, availableHeight); + // Get the number of hidden items to make only them visible in the tertiary menu + numberOfHiddenNavItems = component.$html.find('.nav-primary .nav-item:hidden').length; + // Add "More" nav item and check its visibility if already exists + component.addMoreNavItem(numberOfHiddenNavItems); + // Hide the primary nav items duplicate in tertiary menu + component.hideMoreCategoriesTopItems(navItemsCountTotal, numberOfHiddenNavItems); + } else if (navItemsHeight + moreIconHeight < availableHeight) { + // Unhide items if they were hidden and there is space in the primary nav + component.unhidePrimaryNavItems(); + numberOfHiddenNavItems = component.$html.find('.nav-primary .nav-item:hidden').length; + component.lastItemSubstitution(numberOfHiddenNavItems); + } + }; + + /** + * Hide primary nav items that don't fit in window + * @param {number} navItemsHeight - PX height of primary nav items + * @param {number} moreIconHeight - PX height of more link + * @param {number} availableHeight - PX height of window + */ + NavMainComponent.prototype.hidePrimaryNavItems = function (navItemsHeight, moreIconHeight, availableHeight) { + var component = this, + navItems = component.$html.find('.nav-primary .nav-items'), + lastPrimaryNavItem = navItems.find('li:last-child'), + nthChild = 2; // This number represents the item before the last in the nth-last-child; + + while (navItemsHeight + moreIconHeight > availableHeight) { + // If last nav item is visible hide it + if (lastPrimaryNavItem.is(':visible')) { + lastPrimaryNavItem.hide(); + } else { + // If last nav item is hidden hide the next one up + navItems.find('li:nth-last-child(' + nthChild + ')').hide(); + nthChild++; + } + + // Recalculate nav items height based on items just hidden + navItemsHeight = navItems.outerHeight(true) + component.$html.find('.jadu-branding').outerHeight(true); + } + }; + + /** + * Unhide primary nav items + */ + NavMainComponent.prototype.unhidePrimaryNavItems = function () { + var component = this, + navItems = component.$html.find('.nav-primary .nav-items'), + navItemMore = navItems.find('.more-icon'), + firstHiddenPrimaryNavItem = navItems.find('li:hidden').first(); + + if (firstHiddenPrimaryNavItem.length > 0 && navItemMore.is(':visible')) { + + // Reset display type to list-item rather than show() to make sure they don't get recreated as inline-block + firstHiddenPrimaryNavItem.css({ display: 'list-item' }); + } + }; + + /** + * Add the more link to the primary nav + * @param {number} numberOfHiddenNavItems - Number of hidden nav items + */ + NavMainComponent.prototype.addMoreNavItem = function (numberOfHiddenNavItems) { + var component = this, + navItems = component.$html.find('.nav-primary .nav-items'), + navItemMore = navItems.find('.more-icon'); + + // Add the "More" nav item + if (numberOfHiddenNavItems > 0 && !component.$html.find('.more-icon').length) { + navItems.append('
    • '); + } + + // Check if "More" nav item is visible + if (navItemMore.is(':hidden') && numberOfHiddenNavItems > 0) { + navItemMore.show(); + } else { + component.$html.find('.nav-tertiary').removeClass('is-open'); + component.$html.find('.nav-quaternary').removeClass('is-open'); + } + }; + + /** + * Hide the nav items in nav tertiary that are already displayed in the primary nav + * @param {number} navItemsCountTotal - Total number of nav items + * @param {number} numberOfHiddenNavItems - Number of hidden nav items + */ + NavMainComponent.prototype.hideMoreCategoriesTopItems = function (navItemsCountTotal, numberOfHiddenNavItems) { + var component = this, + nthChild = 1, + // Number used to iterate nth-child + itemsToHideCount; + + // Reset hidden nav items + component.$html.find('.nav-tertiary .nav-items li').show(); + + // Calculate the number of visible nav items in primary nav + itemsToHideCount = navItemsCountTotal - numberOfHiddenNavItems - 1; // 1 is for the "More" nav item + + // Hide top items in "More Categories" equal to the number of visible items of primary nav + while (itemsToHideCount >= 0) { + component.$html.find('.nav-tertiary .nav-items li:nth-child(' + nthChild + ')').hide(); + nthChild++; + itemsToHideCount--; + } + }; + + /** + * Hide more link if there are no hidden nav items + * @param {number} numberOfHiddenNavItems - Number of hidden nav items + */ + NavMainComponent.prototype.lastItemSubstitution = function (numberOfHiddenNavItems) { + var component = this, + navItems = component.$html.find('.nav-primary .nav-items'), + navItemMore = navItems.find('.more-icon'); + + if (numberOfHiddenNavItems === 0) { + navItemMore.hide(); + component.$html.find('.nav-tertiary').removeClass('is-open'); + component.$html.find('.nav-quaternary').removeClass('is-open'); + } + }; + + /** + * Hide more link if there are no hidden nav items + * @param {jQuery} $moreLink - jQuery object of the more link + */ + NavMainComponent.prototype.moreIconClickHandler = function ($moreLink) { + var component = this; + + $moreLink.addClass('is-active'); + + // Close secondary nav if already open + component.closeSecondaryNav(); + + // If tertiary nav is already open + if (component.$navTertiary.find('.nav-list').hasClass('is-active')) { + $moreLink.attr('aria-expanded', 'false'); + component.$navTertiary.removeClass('is-open'); + component.$navQuaternary.removeClass('is-open'); + component.$navTertiary.find('.nav-list').removeClass('is-active'); + component.$navQuaternary.find('.nav-list').removeClass('is-active'); + } else { + $moreLink.attr('aria-expanded', 'true'); + + // Open $navTertiary + component.$navTertiary.find('.nav-list').addClass('is-active'); + component.$navTertiary.addClass('is-open'); + + // Manage focus + component.focusManagementService.storeElement($moreLink); + component.focusManagementService.focusFirstFocusableElement(component.$navTertiary); + component.focusManagementService.trapFocus(component.$navTertiary); + } + }; + + module.exports = NavMainComponent; + + },{"jquery":416}],35:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var _require = require('../utilities/fileUtilities'), + filterFileExtension = _require.filterFileExtension, + getFileExtension = _require.getFileExtension; + + var FaviconEditor = function () { + /** + * @param root {HTMLElement} + */ + function FaviconEditor(root) { + _classCallCheck(this, FaviconEditor); + + /** + * references + * @type {Array<{ node: HTMLLinkElement, cachedHref: string }>} + */ + this.favicons = []; + + /** + * Root element for favicon queries + * @type {HTMLElement} + */ + this.root = root; + + /** + * A serializer function that can be overwritten using + * the public API, this is for altering the return data type + * from the update methods + * @param canvas {HTMLCanvasElement} + * @param ctx {CanvasRenderingContext2D} + * @param originalImage {HTMLImageElement} + */ + this.serializer = function (canvas, ctx, originalImage) { + return canvas.toDataURL('image/' + getFileExtension(originalImage.src)); + }; + } + + /** + * Override the canvas serializer function + * @param serializer {function} + */ + + + _createClass(FaviconEditor, [{ + key: 'setSerializer', + value: function setSerializer(serializer) { + this.serializer = serializer; + } + + /** + * Initiate service + */ + + }, { + key: 'init', + value: function init() { + // Get favicon nodes from DOM + this.favicons = [].slice.call(this.root.querySelectorAll('[rel*="icon"]')).map(function (node) { + return { node: node, cachedHref: node.href }; + }); + } + + /** + * Update the favicon href, takes a custom graphics function + * that exposes the canvas context for adding favicon details + * @param customGraphics {function} + */ + + }, { + key: 'update', + value: function () { + var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(customGraphics) { + var _this = this; + + var setupPromises, favicons, data, index, _favicons$index, node, canvas, image, uri; + + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + setupPromises = []; + favicons = void 0; + data = void 0; + + + this.favicons.forEach(function (_ref2) { + var node = _ref2.node; + + if (filterFileExtension(node.href, 'ico png')) { + setupPromises.push(_this.setup(node)); + } + }); + + _context.prev = 4; + _context.next = 7; + return Promise.all(setupPromises); + + case 7: + favicons = _context.sent; + _context.next = 13; + break; + + case 10: + _context.prev = 10; + _context.t0 = _context['catch'](4); + + favicons = []; + + case 13: + + for (index = 0; index < favicons.length; index++) { + _favicons$index = favicons[index], node = _favicons$index.node, canvas = _favicons$index.canvas, image = _favicons$index.image; + uri = this.draw(canvas, image, customGraphics); + + // assign the uri to data so we can return the new + // favicon data uri + + if (!index) { + data = uri; + } + + node.href = uri; + } + + return _context.abrupt('return', data); + + case 15: + case 'end': + return _context.stop(); + } + } + }, _callee, this, [[4, 10]]); + })); + + function update(_x) { + return _ref.apply(this, arguments); + } + + return update; + }() + + /** + * Add a circle to the top right of the favicon + * @param color {string} + * @param size {number} + * @returns {Promise} + */ + + }, { + key: 'addCircleNotification', + value: function () { + var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(color) { + var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5; + return regeneratorRuntime.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + _context2.next = 2; + return this.update(function (canvas, ctx) { + ctx.fillStyle = color; + ctx.beginPath(); + ctx.arc(canvas.width - size, size, size, 0, 2 * Math.PI); + ctx.fill(); + }); + + case 2: + return _context2.abrupt('return', _context2.sent); + + case 3: + case 'end': + return _context2.stop(); + } + } + }, _callee2, this); + })); + + function addCircleNotification(_x3) { + return _ref3.apply(this, arguments); + } + + return addCircleNotification; + }() + + /** + * Add a notification with a custom graphics function, + * the callback will receive the canvas and context as + * arguments + * @param customGraphics {function} + * @returns {Promise} + */ + + }, { + key: 'addCustomNotification', + value: function () { + var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(customGraphics) { + return regeneratorRuntime.wrap(function _callee3$(_context3) { + while (1) { + switch (_context3.prev = _context3.next) { + case 0: + _context3.next = 2; + return this.update(customGraphics); + + case 2: + return _context3.abrupt('return', _context3.sent); + + case 3: + case 'end': + return _context3.stop(); + } + } + }, _callee3, this); + })); + + function addCustomNotification(_x4) { + return _ref4.apply(this, arguments); + } + + return addCustomNotification; + }() + + /** + * Setup an in-memory canvas + * @param faviconNode {HTMLLinkElement} + */ + + }, { + key: 'setup', + value: function setup(faviconNode) { + // Create an image from our favicon + var favicon = document.createElement('img'); + + // Create canvas + var canvas = document.createElement('canvas'); + + // Side step issues with CORs and "tainted" canvases + favicon.crossOrigin = ''; + + return new Promise(function (resolve, reject) { + favicon.src = faviconNode.href; + + // Wait for our favicon to load + favicon.addEventListener('load', function (event) { + resolve({ canvas: canvas, image: event.target, node: faviconNode }); + }); + + favicon.addEventListener('error', reject); + }); + } + + /** + * Draw favicon on a canvas + * @param canvas {HTMLCanvasElement} + * @param favicon {HTMLImageElement} + * @param customGraphics {function} + */ + + }, { + key: 'draw', + value: function draw(canvas, favicon, customGraphics) { + var ctx = canvas.getContext('2d'); + + // Setup dimensions + canvas.width = favicon.width; + canvas.height = favicon.height; + + // Draw favicon + ctx.drawImage(favicon, 0, 0); + + // Add graphics + customGraphics(canvas, ctx); + + // pass canvas, ctx & favicon image node to our + // serializer function + return this.serializer(canvas, ctx, favicon); + } + + /** + * Restore favicons to cached state + */ + + }, { + key: 'restore', + value: function restore() { + this.favicons.forEach(function (_ref5) { + var node = _ref5.node, + cachedHref = _ref5.cachedHref; + + node.href = cachedHref; + }); + } + }]); + + return FaviconEditor; + }(); + + module.exports = FaviconEditor; + + },{"../utilities/fileUtilities":69}],36:[function(require,module,exports){ + 'use strict'; + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + + var $ = require('jquery'), + TimePickerComponent = require('./TimePickerComponent'), + InputLength = require('input-length'); + + require('pikaday'), require('pikaday/plugins/pikaday.jquery'); + require('spectrum-colorpicker'); + require('select2')(); + + function PulsarFormComponent(html) { + this.$html = html; + this.timePickerComponent = new TimePickerComponent(); + this.inputLength = new InputLength(this.$html); + } + + PulsarFormComponent.prototype.init = function () { + var component = this; + + // Colour picker + component.initColourpickers(); + + // Date picker + component.initDatePickers(); + + // Choice block + component.initSelectionButtons(); + + // Select2 + component.initSelect2(component.$html.find('.js-select2:not([data-init="false"])')); + + // Time picker + component.initTimePickers(); + + // Toggle switches + component.initToggleSwitches(); + + // Maxlength counters + component.initMaxlengthCounters(); + }; + + /** + * Re-initialise the Form Component Services + * I've intentionally left out Select2 here, as programmatic + * control often requires more custom behaviour than simply re-init'ing + */ + PulsarFormComponent.prototype.refresh = function () { + // Colour picker + this.initColourpickers(); + + // Date picker + this.initDatePickers(); + + // Choice block + this.initSelectionButtons(); + + // Time picker + this.initTimePickers(); + }; + + /** + * Initiate a visual counter on inputs with a maxlength + */ + PulsarFormComponent.prototype.initMaxlengthCounters = function () { + this.inputLength.init({ + targetSelector: '[data-maxlength]', + baseClass: 'help-block' + }); + }; + + /** + * Initiate a time picker on data-timepicker fields + */ + PulsarFormComponent.prototype.initTimePickers = function () { + this.timePickerComponent.init(this.$html.find('[data-timepicker=true]')); + }; + + /** + * Initiate a date picker on data-datepicker fields using pickaday + */ + PulsarFormComponent.prototype.initDatePickers = function () { + var datepickers = this.$html.find('[data-datepicker="true"]'); + var defaultDateFormat = 'DD/MM/YYYY'; + + datepickers.each(function (index, element) { + var dateFormat = element.getAttribute('data-format'); + + // Check if data-format attribute exists and lowercase it + // to eliminate different styles of writing issues + if (dateFormat !== null) { + dateFormat = dateFormat.toLowerCase(); + } + + switch (dateFormat) { + case 'us': + defaultDateFormat = 'MM/DD/YYYY'; + break; + case 'reverse': + defaultDateFormat = 'YYYY/MM/DD'; + break; + default: + defaultDateFormat = 'DD/MM/YYYY'; + } + + // Initialize pikaday with the correct date format + $(element).pikaday({ + format: defaultDateFormat + }); + + // Initialize placeholder attribute based on the date format + $(element).attr('placeholder', defaultDateFormat.toLowerCase()); + + // Switch off autocomplete to avoid it overlapping the date picker + $(element).attr('autocomplete', 'off'); + }); + }; + + /** + * Initiate colour pickers + */ + PulsarFormComponent.prototype.initColourpickers = function () { + var component = this, + pickers = component.$html.find('.js-colorpicker'); + + pickers.each(function () { + + var $this = $(this), + $input = $this.find('.form__control'), + $pickerInput = $(''), + disabledAttr = $input.attr('disabled'), + isDisabled = false, + existingPicker = $input.next('[data-colour-picker-input]'); + + if ((typeof disabledAttr === 'undefined' ? 'undefined' : _typeof(disabledAttr)) !== (typeof undefined === 'undefined' ? 'undefined' : _typeof(undefined)) && disabledAttr !== false) { + isDisabled = true; + } + + if (existingPicker.length) { + // Remove existing colour picker elements, + // frustratingly invoking the spectrum 'destroy' + // method does not remove the sp-replacer + $pickerInput.spectrum('destroy'); + existingPicker.remove(); + $input.siblings('.sp-replacer').remove(); + } + + $pickerInput.insertAfter($input); + + // changing the picker should update the input + /* istanbul ignore next: won't test spectrum internals */ + $pickerInput.spectrum({ + color: '#' + $input.val(), + disabled: isDisabled, + showInput: false, + preferredFormat: 'hex', + replacerClassName: 'btn', + change: function change(color) { + if (!$input.attr('disabled')) { + $input.val(('' + color).substring(1)); + $input.trigger('change'); + } + } + }); + + // Remove the text input inside the picker, which we don't use and + // causes a11y issues if left in the markup + component.$html.find('.sp-input-container').remove(); + + // changing the input should update the picker + $input.on('change', function () { + $pickerInput.spectrum('set', '#' + $input.val()); + }); + }); + }; + + /** + * Update colour pickers within a scope + * @param $root + */ + PulsarFormComponent.prototype.updateColourPicker = function ($root) { + var $input = $root.find('.js-colorpicker .form__control'); + + $input.each(function (index, element) { + var $input = $(element); + var $picker = $input.next(); + + $picker.spectrum('set', '#' + $input.val()); + }); + }; + + /** + * Initiate Selection Buttons + */ + PulsarFormComponent.prototype.initSelectionButtons = function () { + var choiceblock = this.$html.find('.choice--block'); + + choiceblock.find('input[type="checkbox"]:checked, input[type="radio"]:checked').closest('.control__label').addClass('is-selected'); + + choiceblock.on('change', '.controls input[type="checkbox"], .controls input[type="radio"]', this.selectionButtons); + }; + + /** + * Selection Button className logic + */ + PulsarFormComponent.prototype.selectionButtons = function () { + var $target = $(this), + $controls = $target.closest('.controls'); + + $controls.find('input[type="checkbox"]:not(:checked), input[type="radio"]:not(:checked)').closest('.control__label').removeClass('is-selected'); + + if ($target.is(':checked')) { + $target.closest('.control__label').addClass('is-selected'); + } else { + $target.closest('.control__label').removeClass('is-selected'); + } + }; + + /** + * Initiate Select2 + * @param target + */ + PulsarFormComponent.prototype.initSelect2 = function (target) { + var $target = target; + + $target.each(function () { + var $this = $(this), + config = {}; + + function formatOption(data) { + return $('' + data.text + ''); + } + + if ($this.data('html')) { + config.templateResult = formatOption; + config.templateSelection = formatOption; + } + + $this.select2(config); + $this.parent().find('.select2-container').removeAttr('style'); + }); + }; + + /** + * Initiate Toggle Switches + * + * This only allows click events on the main label, or the actual toggle control + */ + PulsarFormComponent.prototype.initToggleSwitches = function () { + var component = this; + + component.$html.on('click', '.toggle-switch-wrapper-label', function (e) { + var $target = $(e.target), + $toggle = $(this).find('.toggle-switch'); + + if ($target.hasClass('toggle-switch-label') || $target.hasClass('toggle-switch') || $target.hasClass('control__label')) { + $toggle.trigger('focus'); + } else { + e.preventDefault(); + } + }); + }; + + module.exports = PulsarFormComponent; + + },{"./TimePickerComponent":53,"input-length":405,"jquery":416,"pikaday":420,"pikaday/plugins/pikaday.jquery":421,"select2":431,"spectrum-colorpicker":432}],37:[function(require,module,exports){ + 'use strict'; + + /* jshint: global e, ui */ + + var $ = require('jquery'), + _ = require('lodash'); + + $.ui = require('jquery-ui/ui/widget.js'); + + require('jquery-ui/ui/data'); + require('jquery-ui/ui/disable-selection'); + require('jquery-ui/ui/scroll-parent'); + require('jquery-ui/ui/widgets/mouse'); + require('jquery-ui/ui/widgets/sortable'); + + function PulsarSortableComponent(html, window) { + this.$html = html; + this.window = window; + } + + PulsarSortableComponent.prototype.init = function () { + var component = this; + + component.initTables(); + }; + + PulsarSortableComponent.prototype.initTables = function () { + /* istanbul ignore next: difficult to test jQueryUI sortable behaviour */ + var component = this, + fakeUi = {}, + currentRow, + linkContainer, + moveLinks, + update = function update(e, ui, $sortableElement) { + var $item = $(ui.item); + + $item.removeClass('is-dragging').addClass('has-success fade', function () { + setTimeout(function () { + $item.removeClass('has-success fade'); + }, 2500); + }); + + component.updateOrder(); + }; + + /* istanbul ignore next: difficult to test jQueryUI sortable behaviour */ + this.$html.find('.table.is-sortable tbody').sortable({ + placeholder: 'is-sorting', + helper: component.fixHelper, + opacity: 0.9, + create: function create(e, ui) { + component.addOrder(); + }, + start: function start(e, ui) { + $(ui.helper).addClass('is-dragging'); + } + }).disableSelection(); + + // Trigger update() on sortupdate event + /* istanbul ignore next: difficult to test jQueryUI sortable behaviour */ + this.$html.find('.table.is-sortable tbody').on('sortupdate', function (e, ui) { + var $sortableElement = $(this); + + update(e, ui, $sortableElement); + }); + + // Show arrows when row is tabbed to focus + this.$html.find('[data-move]').on('focus', function () { + + // Using keydown instead of keyup as it means that the up/down controls + // are displayed if the tab key is being held down until the right + // element comes into focus + $(component.window).keydown(function (e) { + var code = e.keyCode ? e.keyCode : e.which, + $parentElement = $(e.target.parentElement); + + // If tab key has been pressed + if (code === 9) { + if ($(e.target).hasClass('hide')) { + $parentElement.width($parentElement.width() + 40); + + $parentElement.closest('.table.is-sortable').find('[data-move]').removeClass('hide'); + } + } + }); + }); + + // Reorder via arrows + this.$html.find('[data-move]').on('click keypress', function () { + var $this = $(this), + currentRow = $this.closest('tr'), + linkContainer = $this.closest('td'), + moveLinks = linkContainer.find('a'); + + moveLinks.addClass('hide'); + linkContainer.addClass('u-text-align-center').append(''); + + if ($this.attr('data-move') === 'up') { + currentRow.prev().before(currentRow); + } + if ($this.attr('data-move') === 'down') { + currentRow.next().after(currentRow); + } + + setTimeout(function () { + linkContainer.removeClass('u-text-align-center').find('.js-sortable-moved').remove(); + + moveLinks.removeClass('hide'); + }, 1500); + + // Fake the UI object created by sortable drag and drop + fakeUi.item = currentRow; + + // Trigger sortupdate and pass the updated row + component.$html.find('.table.is-sortable tbody').trigger('sortupdate', [fakeUi]); + }); + + // Update "Actions" badge when table row is clicked + this.$html.find('.has-badges table tr').on('click', function (event) { + var $this = $(this), + $target = $(event.target), + $checkbox = $this.find('.checkbox').first(), + selected = $checkbox.prop('checked'); + + // toggle checkbox state if the checkbox was not the target of the event + if (!$target.is($checkbox)) { + $checkbox.prop('checked', !selected); + } + + // toggle row selected class + $this.toggleClass('is-selected'); + + component.actionsBadge(); + }); + }; + + /* istanbul ignore next: difficult to test jQueryUI sortable behaviour */ + PulsarSortableComponent.prototype.fixHelper = function (e, ui) { + ui.children().each(function () { + $(this).width($(this).width()); + }); + + return ui; + }; + + PulsarSortableComponent.prototype.addOrder = function () { + var component = this; + + component.$html.find('.table.is-sortable tr > td:first-of-type').each(function (i) { + var $this = $(this), + label = _.escape($this.text()), + count = i + 1; + + $this.html('' + count + ' ' + label); + }); + }; + + PulsarSortableComponent.prototype.updateOrder = function () { + var component = this; + + component.$html.find('.table.is-sortable .js-sortable-count').each(function (i) { + $(this).text(i + 1); + }); + }; + + // Create or update "Actions" badge when a table row is selected + PulsarSortableComponent.prototype.actionsBadge = function () { + var component = this, + checkedBoxesCount = component.$html.find('.has-badges table tr input.checkbox:checked').length, + badge = component.$html.find('.has-badges .btn__group.dropdown span.badge'), + itemWording = component.$html.find('.has-badges .btn__group.dropdown .item-wording'), + deleteOption = component.$html.find('.has-badges .dropdown__menu li .delete'); + + if (checkedBoxesCount > 0) { + // Remove previous badge + badge.remove(); + // Add badge next to "Actions" dropdown text + $('' + checkedBoxesCount + '').insertBefore('.has-badges .btn__group.dropdown span.caret'); + + if (deleteOption) { + // Add badge to "Delete" option of the dropdown + $('' + checkedBoxesCount + '').appendTo(deleteOption); + + // Add the words item/items depending on the number of items + if (checkedBoxesCount === 1) { + itemWording.remove(); + $('item').appendTo(deleteOption); + } else { + itemWording.remove(); + $('items').appendTo(deleteOption); + } + } + } else if (checkedBoxesCount === 0) { + // Remove previous badges if there are no selected items + badge.remove(); + itemWording.remove(); + } + }; + + module.exports = PulsarSortableComponent; + + },{"jquery":416,"jquery-ui/ui/data":409,"jquery-ui/ui/disable-selection":410,"jquery-ui/ui/scroll-parent":411,"jquery-ui/ui/widget.js":412,"jquery-ui/ui/widgets/mouse":414,"jquery-ui/ui/widgets/sortable":415,"lodash":418}],38:[function(require,module,exports){ + 'use strict'; + + var $ = require('jquery'), + StickyScrollBarComponent = require('./StickyScrollBarComponent'); + + var _require = require('./DataTables/dataTablesInitComplete'), + initComplete = _require.initComplete; + + var _require2 = require('./DataTables/dataTablesDrawCallback'), + drawCallback = _require2.drawCallback; + + require('datatables.net')(window, $); + require('datatables.net-buttons')(window, $); + require('datatables.net-responsive')(window, $); + require('datatables.net-select')(window, $); + require('jquery-countdown'); + + function PulsarUIComponent(html, history) { + this.history = history; + this.$html = html; + this.$window = $(window); + this.stickyScrollBarComponent = new StickyScrollBarComponent(this.$window, this.$html); + } + + PulsarUIComponent.prototype.init = function () { + var component = this; + + this.initDisabledLinks(); + this.initTables(); + this.initDataTables(); + this.initCountdown(); + }; + + PulsarUIComponent.prototype.initDisabledLinks = function () { + var $links = this.$html.find('a.is-disabled'); + + $links.each(function () { + var $this = $(this); + + $this.attr('aria-disabled', 'true').attr('role', 'button').attr('data-href', $this.attr('href')).removeAttr('href').on('click', function (e) { + e.preventDefault(); + }); + }); + }; + + PulsarUIComponent.getDatatableOptions = function ($table) { + var dom = '<"dataTables_top"Birf><"dataTables_actions"T>t<"dataTables_bottom"pl>', + langEmptyTable = 'There are currently no items to display', + pageLength = 25, + lengthChange = false, + select = { + className: 'dt-row-selected', + style: 'multi', + selector: 'td.table-selection' + }, + columnDefs = [{ + searchable: false, + orderable: false, + targets: 0 + }]; + + if ($table.length && $table.data('empty-table')) { + langEmptyTable = $table.data('empty-table'); + } + + if ($table.length && $table.data('page-length')) { + pageLength = $table.data('page-length'); + } + + if ($table.length && $table.data('length-change')) { + lengthChange = $table.data('length-change'); + } + + if ($table.length && $table.data('select') === false) { + select = false; + columnDefs = []; + } + + if ($table.length && $table.data('overflow') === 'collapse') { + columnDefs = [{ + className: 'control', + orderable: false, + searchable: false, + targets: 0 + }]; + } + + if ($table.length && $table.data('overflow') === 'collapse' && $table.data('select') === true) { + columnDefs = [{ + className: 'control', + targets: 0 + }, { + orderable: false, + searchable: false, + targets: [0, 1] + }]; + } + + var options = { + aaSorting: [], + autoWidth: false, + buttons: [], + className: 'dt-row-selected', + columnDefs: columnDefs, + initComplete: initComplete, + drawCallback: drawCallback, + dom: dom, + language: { + emptyTable: langEmptyTable, + info: "Showing _START_ to _END_ of _TOTAL_ items", + infoEmpty: 'No items', + infoFiltered: " (filtered from _MAX_ items)", + zeroRecords: "No items matched your filter, please clear it and try again", + search: "Filter records", + aria: { + paginate: { + first: 'First page', + previous: 'Previous page', + next: 'Next page', + last: 'Last page' + } + } + }, + lengthChange: lengthChange, + pageLength: pageLength, + pagingType: 'full_numbers', + responsive: { + details: { + type: 'column', + target: '.table-child-toggle' + } + }, + select: select, + selector: 'td.table-selection', + stateSave: false, + style: 'multi' + }; + + return options; + }; + + PulsarUIComponent.prototype.initTables = function () { + + // Wrap non datatable tables in responsive container so they can scroll when required + var $tables = this.$html.find('.table:not(.datatable), .table--datagrid:not(.datatable)'); + + $tables.each(function (i, v) { + var $table = $(v); + + if (!$table.parent().hasClass('table-container')) { + $table.wrap('
    '); + } + }); + }; + + PulsarUIComponent.prototype.initDataTables = function () { + var component = this, + datatables = component.$html.find('.datatable:not([data-init="false"]):not(.table--horizontal)'), + datatablesHorizontal = component.$html.find('.datatable.table--horizontal:not([data-init="false"])'); + + datatables.each(function () { + var $this = $(this); + + var datatableOptions = PulsarUIComponent.getDatatableOptions($this); + + var table = $this.DataTable(datatableOptions); + + $this.on('click', '.js-select-all', function (e) { + var $checkbox = $(e.target), + $allCheckboxes = $this.find('.js-select'); + + if ($checkbox.hasClass('selected')) { + table.rows().deselect(); + $checkbox.removeClass('selected'); + $allCheckboxes.removeClass('selected').prop('checked', false); + } else { + table.rows().select(); + $checkbox.addClass('selected'); + $allCheckboxes.addClass('selected').prop('checked', true); + } + }); + }); + + datatablesHorizontal.each(function () { + var $this = $(this), + dom = '<"dataTables_top"Birf><"dataTables_actions"T><"table-container"t><"dataTables_bottom"lp>', + select = { + className: 'dt-row-selected', + style: 'multi', + selector: '.js-select', + info: true + }; + + if ($this.data('select') === false) { + dom = '<"dataTables_top"irf><"dataTables_actions"T><"dt-disable-selection"<"table-container"t>><"dataTables_bottom"lp>'; + select = false; + } + + var datatableOptions = PulsarUIComponent.getDatatableOptions($this); + + var horizontalOptions = $.extend({}, datatableOptions, { + dom: dom, + responsive: null, + select: select + }); + + var table = $this.DataTable(horizontalOptions); + + // Add sticky scroll bar + component.stickyScrollBarComponent.init($this.parent()); + + // Init bulk actions menu + component.toggleBulkActions($this); + + // Rerun bulk actions on row select + table.on('select deselect', function (e, dt, type, indexes) { + if (type === 'row') { + component.toggleBulkActions($this); + } + }); + + $this.on('click', '.js-select-all', function (e) { + var $checkbox = $(e.target), + $allCheckboxes = $this.find('.js-select'); + + if ($checkbox.hasClass('selected')) { + table.rows({ search: 'applied' }).deselect(); + + $checkbox.removeClass('selected'); + $allCheckboxes.removeClass('selected').prop('checked', false); + } else { + table.rows({ search: 'applied' }).select(); + $checkbox.addClass('selected'); + $allCheckboxes.addClass('selected').prop('checked', true); + } + }); + }); + + // Refresh datatables when tabs are switched, this fixes some layout issues + this.$html.find('a[data-toggle="tab"]').on('shown.bs.tab', function (e) { + $($.fn.dataTable.tables(true)).DataTable().columns.adjust().responsive.recalc(); + }); + + this.$html.find('.table--horizontal').each(function () { + var $table = $(this).parent(); + + $table.on('scroll', function () { + component.styleTableOverflows($table); + }); + + $(window).on('load resize', function () { + component.styleTableOverflows($table); + + // reset column widths so headers match the body + $($.fn.dataTable.tables(true)).DataTable().columns.adjust(); + }); + + // Add sticky scroll bar + component.stickyScrollBarComponent.init($table); + }); + + // Remove invalid attribute after tables are loaded + // https://datatables.net/forums/discussion/comment/145251/#Comment_145251 + component.$html.find('.dataTables_empty').removeAttr('valign'); + }; + + PulsarUIComponent.prototype.styleTableOverflows = function ($container) { + var $table = $container.find('.table'), + tableFullWidth = $table[0].scrollWidth, + tableVisibleWidth = $container.width(); + + // Toggle right hand shadow, if overflowing to the right + if (Math.floor(tableFullWidth) === Math.floor(tableVisibleWidth)) { + $container.removeClass('table--overflow-right'); + } else { + $container.addClass('table--overflow-right'); + } + + // Toggle left hand shadow, if overflowing to the left + if ($table.offsetParent().offset().left - $table.offset().left > 0) { + $container.addClass('table--overflow-left'); + } else { + $container.removeClass('table--overflow-left'); + } + + // Remove right hand shadow if table scrolled to right hand edge + if (-Math.abs(tableFullWidth - tableVisibleWidth - $table.offsetParent().offset().left) >= $table.offset().left) { + $container.removeClass('table--overflow-right'); + } + }; + + PulsarUIComponent.prototype.initCountdown = function () { + + // Initial basic implementation of https://github.com/hilios/jQuery.countdown + this.$html.find('.js-countdown').each(function () { + + var $this = $(this), + format = '%ww %dd %Hh %Mm %S'; + + if (typeof $this.data('format') !== 'undefined') { + format = $this.data('format'); + } + + $this.countdown($this.data('final-date'), function (event) { + $this.html(event.strftime(format)); + }); + }); + }; + + PulsarUIComponent.prototype.toggleBulkActions = function (table) { + var table = table.DataTable(), + count = table.rows({ selected: true }).count(), + $bulkActionsButton = this.$html.find('.bulk-actions'), + $bulkActionsBadge = $bulkActionsButton.find('.js-bulk-actions-badge'), + $bulkActions = this.$html.find('[data-bulk-action]'); + + if (count === 0) { + $bulkActionsBadge.hide(); + + $bulkActions.addClass('disabled').prop('aria-disabled', 'true').prop('aria-label', 'no rows selected').parent().attr({ + 'data-toggle': 'tooltips', + 'data-placement': 'right', + 'data-container': 'body', + 'title': 'Select one or more items to perform this bulk action' + }).tooltips(); + } else { + $bulkActionsBadge.attr('aria-label', count + ' row' + (count > 1 ? 's' : '') + ' selected').text(count).show(); + + $bulkActions.removeClass('disabled').prop('aria-disabled', 'false').parent().tooltips('destroy'); + } + }; + + module.exports = PulsarUIComponent; + + },{"./DataTables/dataTablesDrawCallback":2,"./DataTables/dataTablesInitComplete":3,"./StickyScrollBarComponent":49,"datatables.net":404,"datatables.net-buttons":401,"datatables.net-responsive":402,"datatables.net-select":403,"jquery":416,"jquery-countdown":406}],39:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require("jquery"); + + var InputCloneService = function () { + function InputCloneService() { + _classCallCheck(this, InputCloneService); + } + + _createClass(InputCloneService, [{ + key: 'clone', + + /** + * Dispatch input clone methods + * returns a clone node (deep) by default + * @param element + * @returns {*|Node} + */ + value: function clone(element) { + var type = { + 'select-one': this.cloneSelect.bind(this), + 'select-multiple': this.cloneSelect.bind(this) + }; + + // If the input type is not defined in our type list we'll just return a deep clone + return type[element.type] === undefined ? element.cloneNode(true) : type[element.type](element); + } + + /** + * Clone select element and maintain selected state + * @param select + */ + + }, { + key: 'cloneSelect', + value: function cloneSelect(select) { + var $select = $(select); + var selectClone = select.cloneNode(true); + + if ($select.hasClass('js-select2') && $select.data('select2')) { + var select2Data = $select.select2('data'); + var dataAttr = JSON.stringify(select2Data.map(function (state) { + return { + disabled: state.disabled, + id: state.id, + selected: state.selected, + text: state.text, + title: state.title + }; + })); + + select.setAttribute('data-repeater-select2-data', dataAttr); + $select.select2('destroy'); + } + + // Empty out options + selectClone.innerHTML = ''; + + // Re-create each option with the state from the cloned select + [].slice.call(select.children).forEach(function (option) { + selectClone.appendChild(new Option(option.innerText, option.value, option.selected, option.selected)); + }); + + return selectClone; + } + }]); + + return InputCloneService; + }(); + + module.exports = InputCloneService; + + },{"jquery":416}],40:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var _ = require('lodash'); + var $ = require('jquery'); + + var InputReplacementService = function () { + /** + * Input replacement service + * @param {PulsarFormComponent} pulsarFormComponent + */ + function InputReplacementService(pulsarFormComponent) { + _classCallCheck(this, InputReplacementService); + + this.pulsarFormComponent = pulsarFormComponent; + } + + /** + * Replace an input element with another of the same type (usually a clone) + * @param elements + * @param replacement + * @returns {*|jQuery} + */ + + + _createClass(InputReplacementService, [{ + key: 'replace', + value: function replace(elements, replacement) { + var type = { + 'radio': this.replaceRadioInput.bind(this), + 'select-one': this.replaceSelect.bind(this), + 'select-multiple': this.replaceSelect.bind(this) + }; + + // If the type is not defined we will use jQuery's replaceWith(...) method + // We are expecting an element list here, as with radio Inputs we'll have + // a chance of receiving multiple inputs with the same name + [].slice.call(elements).forEach(function (element) { + type[element.type] === undefined ? $(element).replaceWith(replacement) : type[element.type](element, replacement); + }); + } + + /** + * Replace radio inputs + * @param radio + * @param replacement + */ + + }, { + key: 'replaceRadioInput', + value: function replaceRadioInput(radio, replacement) { + var originalId = radio.getAttribute('data-pseudo-radio-id'); + var replacementId = replacement.getAttribute('data-pseudo-radio-id'); + + if (originalId === replacementId) { + $(radio).replaceWith(replacement); + } + } + + /** + * We don't need to replace the select2s here, we can update the original clone + * we'll replace regular selects with their state-full clones + * @param select + * @param replacement + */ + + }, { + key: 'replaceSelect', + value: function replaceSelect(select, replacement) { + var $select = $(select); + + if ($select.hasClass('js-select2')) { + // Parse our dumped select2 data + var select2Data = JSON.parse(select.getAttribute('data-repeater-select2-data')); + + if (select2Data) { + // Set each options's selected value based on the parsed select2 data + [].slice.call(select.children).forEach(function (option) { + var previousState = _.find(select2Data, function (s2) { + return s2.id === option.value; + }); + + option.selected = previousState ? previousState.selected : false; + }); + } + + this.pulsarFormComponent.initSelect2($select); + } else { + $select.replaceWith(replacement); + } + } + }]); + + return InputReplacementService; + }(); + + module.exports = InputReplacementService; + + },{"jquery":416,"lodash":418}],41:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var _ = require('lodash'); + + var InputValueService = function () { + function InputValueService() { + _classCallCheck(this, InputValueService); + } + + _createClass(InputValueService, [{ + key: 'getValue', + + /** + * Dispatch input value get methods + * returns the value prop by default + * @param element + * @returns {*} + */ + value: function getValue(element) { + var type = { + 'checkbox': this.getCheckboxValue.bind(this), + 'select-multiple': this.getMultiSelectValue.bind(this), + 'radio': this.getRadioValue.bind(this) + }; + + return type[element.type] === undefined ? { value: element.value, selected: this.getSelected(element) } : type[element.type](element); + } + + /** + * Dispatch input value set methods + * will set the value prop by default + * accepts a "state" object for inputs we control the state of + * @param element + * @param value + * @param state + * @returns {*} + */ + + }, { + key: 'setValue', + value: function setValue(element, value, state) { + var type = { + 'checkbox': this.setCheckboxValue.bind(this), + 'radio': this.setRadioValue.bind(this), + 'select-multiple': this.setMultiSelectValue.bind(this) + }; + + return type[element.type] === undefined ? element.value = value : type[element.type](element, value, state); + } + + /** + * Dispatch print methods for values, by default + * we will simply return the input's value + * @param element + * @param value + * @param state + * @returns {*} + */ + + }, { + key: 'printValue', + value: function printValue(element, value, state) { + var type = { + 'password': this.printPassword.bind(this), + 'select-one': this.printSelect.bind(this), + 'select-multiple': this.printSelect.bind(this) + }; + + return type[element.type] === undefined ? element.value : type[element.type](element, value, state); + } + + /** + * Print passwords in a hidden state + * @param element + */ + + }, { + key: 'printPassword', + value: function printPassword(element) { + return element.value.replace(new RegExp(/./g), '*'); + } + + /** + * Get the text content of selected options when printing select values + * @param element + * @param value + */ + + }, { + key: 'printSelect', + value: function printSelect(element, value) { + return _.find([].slice.call(element.children), function (option) { + return option.value === value; + }).textContent; + } + + /** + * Get the selected attribute from a for input + * if an input does not have a checked property we'll assume it is active + * @param element + * @returns {*} + */ + + }, { + key: 'getSelected', + value: function getSelected(element) { + var type = { + 'checkbox': this.isSelected.bind(this), + 'radio': this.isSelected.bind(this) + }; + + return type[element.type] === undefined ? true : type[element.type](element); + } + + /** + * Check if an element is selected + * @param element + */ + + }, { + key: 'isSelected', + value: function isSelected(element) { + return element.checked; + } + + /** + * Get a checkbox value + * @param checkbox + * @returns {*} + */ + + }, { + key: 'getCheckboxValue', + value: function getCheckboxValue(checkbox) { + return { value: checkbox.value, selected: checkbox.checked }; + } + + /** + * Get a radio value + * @param radio + * @returns {{value: *, selected: boolean}} + */ + + }, { + key: 'getRadioValue', + value: function getRadioValue(radio) { + return { value: radio.value, selected: radio.checked }; + } + + /** + * Get multi select values + * @param select + */ + + }, { + key: 'getMultiSelectValue', + value: function getMultiSelectValue(select) { + return [].slice.call(select.children).map(function (option) { + return { value: option.value, selected: option.selected }; + }); + } + + /** + * Set a checkbox checked state if we have a value + * @param checkbox + * @param value + */ + + }, { + key: 'setCheckboxValue', + value: function setCheckboxValue(checkbox, value) { + checkbox.checked = !!value; + } + + /** + * Set radio input value based on internally managed state (PseudoRadioService) + * @param radio + * @param value + * @param state + */ + + }, { + key: 'setRadioValue', + value: function setRadioValue(radio, value, state) { + // We only need to make this fairly destructive change if the input has a name + // attr. Once this value is set, the input values in a set of radios will be set + // to the selected value – which will render them useless (apart from our use case) + // which is to simply submit the correct value + if (state.selected && radio.hasAttribute('name')) { + radio.value = value; + radio.checked = true; + } + } + + /** + * Set the value of a multi select input + * @param select + * @param value + * @param state + */ + + }, { + key: 'setMultiSelectValue', + value: function setMultiSelectValue(select, value, state) { + _.find([].slice.call(select.children), function (option) { + return option.value === value; + }).selected = state.selected; + } + }]); + + return InputValueService; + }(); + + module.exports = InputValueService; + + },{"lodash":418}],42:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var _ = require('lodash'); + + var PseudoRadioInputService = function () { + /** + * Create pseudo radio input behaviour in the + * absence of a name attribute + * @param root {HTMLElement} + * @param pseudoNameAttr + */ + function PseudoRadioInputService(root, pseudoNameAttr) { + _classCallCheck(this, PseudoRadioInputService); + + this.root = root; + this.name = { + init: 'name', + pseudo: pseudoNameAttr + }; + } + + /** + * Create initial radio state for each matching input + */ + + + _createClass(PseudoRadioInputService, [{ + key: 'init', + value: function init() { + var _this = this; + + var id = 1; + + this.state = [].slice.call(this.root.querySelectorAll('[type="radio"]')).reduce(function (state, input) { + var key = input.getAttribute(_this.name.init); + + if (state[key] === undefined) { + id = 1; + state[key] = []; + } + + input.setAttribute('data-pseudo-radio-id', id); + state[key].push({ value: input.value, checked: input.checked }); + id++; + + return state; + }, {}); + + this.root.addEventListener('change', this.handleChange.bind(this)); + } + + /** + * Listen for input changes and update state + */ + + }, { + key: 'handleChange', + value: function handleChange(event) { + var target = event.target; + + + if (target.type === 'radio') { + this.updateState(target.getAttribute(this.name.pseudo), target.value); + } + } + + /** + * Update state as a result of an input + * @param name + * @param value + */ + + }, { + key: 'updateState', + value: function updateState(name, value) { + var _this2 = this; + + this.state[name] = this.state[name].map(function (radio) { + var checked = value === undefined ? radio.checked : radio.value === value; + var input = _this2.root.querySelectorAll('[' + _this2.name.pseudo + '="' + name + '"][value="' + radio.value + '"]'); + + // update state object + radio.checked = checked; + // update DOM + [].slice.call(input).forEach(function (i) { + return i.checked = checked; + }); + + return radio; + }); + } + + /** + * Set the state of the radio inputs based on an external state + * @param state {Object.} + */ + + }, { + key: 'setState', + value: function setState(state) { + var _this3 = this; + + Object.keys(state).forEach(function (input) { + if (_this3.state[input] !== undefined) { + var selected = _.find(state[input].value, function (i) { + return i.selected; + }); + // Set state using the selected input in the state argument + if (selected) { + _this3.updateState(input, selected.value); + } + } + }); + } + + /** + * Refresh a radio group based on the internal state + */ + + }, { + key: 'refresh', + value: function refresh() { + var _this4 = this; + + Object.keys(this.state).forEach(function (group) { + _this4.updateState(group); + }); + } + }]); + + return PseudoRadioInputService; + }(); + + module.exports = PseudoRadioInputService; + + },{"lodash":418}],43:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require('jquery'); + + var Repeater = function () { + /** + * Repeater + * @param repeater {HTMLElement} + * @param pulsarFormComponent {PulsarFormComponent} + * @param activeFunctionService {ActiveFunctionService} + * @param inputCloneService {InputCloneService} + * @param inputValueService {InputValueService} + * @param inputReplacementService {InputReplacementService} + * @param uniqueIdService {UniqueIdService} + * @param repeaterPreviewService {RepeaterPreviewService} + * @param pseudoRadioInputService {PseudoRadioInputService} + * @param repeaterDataService {RepeaterDataService} + * @param repeaterPlaceholderService {RepeaterPlaceholderService} + * @param formFieldResetService {FormFieldResetService} + * @param focusManagementService {FocusManagementService} + */ + function Repeater(repeater, pulsarFormComponent, activeFunctionService, inputCloneService, inputValueService, inputReplacementService, uniqueIdService, repeaterPreviewService, pseudoRadioInputService, repeaterDataService, repeaterPlaceholderService, formFieldResetService, focusManagementService) { + _classCallCheck(this, Repeater); + + this.pulsarFormComponent = pulsarFormComponent; + this.activeFunctionService = activeFunctionService; + this.inputCloneService = inputCloneService; + this.inputValueService = inputValueService; + this.inputReplacementService = inputReplacementService; + this.uniqueIdService = uniqueIdService; + this.repeaterPreviewService = repeaterPreviewService; + this.pseudoRadioInputService = pseudoRadioInputService; + this.repeaterDataService = repeaterDataService; + this.repeaterPlaceholderService = repeaterPlaceholderService; + this.formFieldResetService = formFieldResetService; + this.focusManagementService = focusManagementService; + + this.repeater = repeater; + this.repeaterEntries = 0; + this.savedEntries = 0; + this.state = []; + } + + /** + * Initialise + * @param {array} initialState + */ + + + _createClass(Repeater, [{ + key: 'init', + value: function init() { + var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + + // Preview UI HTML that is dynamically added to preview rows + this.previewUiHTML = '\n \n \n '; + + var maxItemsAttr = this.repeater.getAttribute('data-repeater-max-entries'); + + // Store max repeater groups as an integer + this.maxSavedGroups = maxItemsAttr === null ? Infinity : parseInt(maxItemsAttr, 10); + + // Initiate pseudo radio service to polyfill radio inputs without name attrs + this.pseudoRadioInputService.init(); + + var $repeater = $(this.repeater); + + // Remove repeater group input names to prevent their values being submitted + this.removeGroupInputNames($repeater.find('[data-repeater-new-group]')[0]); + + // Attach the "add new group" handler + var $addGroupButton = $repeater.find('[data-repeater-add-group]'); + + $addGroupButton.on('click', this.activeFunctionService.wrap.bind(this.activeFunctionService, $addGroupButton[0], this.handleAddGroup.bind(this))); + + var $saveGroup = $repeater.find('[data-repeater-save-group]'); + + // Attach the "save new group" handler + $saveGroup.on('click', this.handleSaveGroup.bind(this)); + + var $cancelGroup = $repeater.find('[data-repeater-cancel-save]'); + + // Attach the "cancel new group" handler + $cancelGroup.on('click', this.handleCancelGroup.bind(this)); + + if (initialState.length > 0) { + this.parseInitialState(initialState); + } + } + + /** + * @param initialState + */ + + }, { + key: 'parseInitialState', + value: function parseInitialState(initialState) { + var _this = this; + + initialState.forEach(function (state, index) { + state.forEach(function (_ref) { + var name = _ref.name, + value = _ref.value; + + // Grab the input from the "add new group" form + var $input = $(_this.repeater).find('[data-repeater-name="' + name + '"]'); + + // If we get multiple inputs we are parsing multiple state + // entries, therefore we need to ensure we're getting the + // input at the correct index as there will be multiple inputs + // with the same data-repeater-name at this point + if ($input.length > 1) { + $input = $input.eq(index); + } + + $input.val(value); + }); + + _this.handleSaveGroup(); + }); + } + + /** + * Handle the add group action + * @param event + */ + + }, { + key: 'handleAddGroup', + value: function handleAddGroup(event) { + var $repeater = $(this.repeater); + var $addGroupForm = $repeater.find('[data-repeater-new-group]'); + + event.preventDefault(); + $addGroupForm.show(); + $repeater.find('[data-repeater-add-group]').addClass('disabled').attr('disabled', true); + + // Shift focus to the first focusable element in the form + this.focusManagementService.focusFirstFocusableElement($addGroupForm); + + // Capture triggering element so we can return focus when closed + this.focusManagementService.storeElement($(event.target)); + } + + /** + * Handle the save group action + * @param event + * @param state + */ + + }, { + key: 'handleSaveGroup', + value: function handleSaveGroup() { + var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + + var $repeater = $(this.repeater); + var colspan = parseInt(this.repeater.getAttribute('data-repeater-preview-colspan'), 10); + var previewUi = document.createElement('td'); + + if (event !== null) { + event.preventDefault(); + } + + var $addGroupForm = $repeater.find('[data-repeater-new-group]'); + + // Create state object from the current form + this.state[this.repeaterEntries] = state !== null ? state : this.createState($addGroupForm[0]); + + // Create preview HTML + var preview = this.repeaterPreviewService.create(this.state[this.repeaterEntries], $repeater.find('[data-repeater-for-name]').toArray(), this.repeaterEntries); + + // Set preview attributes and append to the DOM + preview.setAttribute('colspan', colspan); + preview.setAttribute('data-repeater-preview-id', this.repeaterEntries); + + // Attach preview element to the DOM + $repeater.find('[data-repeater-preview-root]').append(preview); + + // Attach preview UI to preview row + previewUi.innerHTML = this.previewUiHTML; + preview.appendChild(previewUi); + + var editGroup = preview.querySelector('[data-repeater-edit-group]'); + // Attach preview "edit group" handler + editGroup.addEventListener('click', this.activeFunctionService.wrap.bind(this.activeFunctionService, editGroup, this.handleEditGroup.bind(this, this.repeaterEntries))); + + var deleteGroup = preview.querySelector('[data-repeater-delete-group]'); + // Attach preview "edit group" handler + deleteGroup.addEventListener('click', this.activeFunctionService.wrap.bind(this.activeFunctionService, deleteGroup, this.handleDeleteGroup.bind(this, this.repeaterEntries))); + + // Create saved data if this is not the initial parse + if (state === null) { + this.saveData($addGroupForm[0]); + } + + // Create the edit form + this.addGroupToRepeater(this.createEditEntryGroup()); + + // Remove "empty" placeholder + this.repeaterPlaceholderService.remove(); + + // Reset new repeater group form + this.formFieldResetService.reset($addGroupForm[0]); + + // Reset Pulsar colour pickers + this.pulsarFormComponent.updateColourPicker($addGroupForm); + + // Update internal state + this.repeaterEntries++; + this.savedEntries++; + + var $addGroupButton = $repeater.find('[data-repeater-add-group]'); + + if (this.savedEntries < this.maxSavedGroups) { + $addGroupButton.removeClass('disabled').removeAttr('disabled'); + + // Update add new group text + $addGroupButton.text(this.repeater.getAttribute('data-repeater-add-another-group-text')); + + // Return focus to triggering element, if one exists + if (this.focusManagementService.hasStoredElement()) { + this.focusManagementService.returnFocusToElement(); + } + } else { + $addGroupButton.addClass('disabled').attr('disabled', true); + + // If at max entries, focus the edit button of the new row + $(preview).find('[data-repeater-edit-group]').focus(); + } + + // Re-initialise select2 instances in the "edit" and "new group" form + this.pulsarFormComponent.initSelect2($addGroupForm.find('.js-select2')); + + // Hide new repeater group form + $addGroupForm.hide(); + } + + /** + * Save repeater state to the DOM + * @param group + */ + + }, { + key: 'saveData', + value: function saveData(group) { + this.repeaterDataService.create(group, this.repeaterEntries); + } + + /** + * Convert the "create new repeater group" to a state object + * @param group {HTMLElement} + * @returns {Object.} + */ + + }, { + key: 'createState', + value: function createState(group) { + var _this2 = this; + + var name = 'data-repeater-name'; + var $inputs = $(group).find('[' + name + ']'); + + return $inputs.toArray().reduce(function (state, input) { + var value = _this2.inputValueService.getValue(input); + var valueArray = Array.isArray(value) ? value : [value]; + + // Add a reference to the element + valueArray.forEach(function (value) { + return value.ref = input; + }); + + if (state[input.getAttribute(name)] === undefined) { + state[input.getAttribute(name)] = {}; + } + + if (!Array.isArray(state[input.getAttribute(name)].value)) { + state[input.getAttribute(name)].value = valueArray; + } else { + valueArray.forEach(function (value) { + return state[input.getAttribute(name)].value.push(value); + }); + } + + return state; + }, {}); + } + + /** + * Create an inline edit form beneath each preview row + */ + + }, { + key: 'createEditEntryGroup', + value: function createEditEntryGroup() { + var clone = $(this.repeater).find('[data-repeater-new-group]')[0].cloneNode(true); + + // Add repeater ID to the group + clone.setAttribute('data-repeater-edit-id', this.repeaterEntries); + + // Remove the new group attr + clone.removeAttribute('data-repeater-new-group'); + + // Remove group input name attrs + this.removeGroupInputNames(clone); + + return clone; + } + }, { + key: 'addGroupToRepeater', + value: function addGroupToRepeater(group) { + var _this3 = this; + + var clonedControls = group.querySelector('[data-repeater-new-group-controls]'); + var preview = this.repeater.querySelector('[data-repeater-preview-id="' + this.repeaterEntries + '"]'); + var inputsWithState = $(group).find('[data-repeater-name]').toArray().map(function (input) { + return _this3.inputCloneService.clone(input); + }); + + // Add cloned group after preview, this will act as the edit group + $(preview).after(group); + + // Append our "deep" cloned inputs + inputsWithState.forEach(function (input) { + var name = input.getAttribute('data-repeater-name'); + // Replace inputs in clone with "deep" cloned inputs + _this3.inputReplacementService.replace([].slice.call(clonedControls.querySelectorAll('[data-repeater-name="' + name + '"]')), input); + }); + + // Create unique for/id + this.uniqueIdService.uniquifyFors(preview.nextElementSibling); + + // Create unique IDs for selectWoo elements + this.uniqueIdService.uniquifySelectWoo(group); + + // Refresh radio state + this.pseudoRadioInputService.refresh(); + + // Refresh the PulsarFormComponent services + this.pulsarFormComponent.refresh(); + + // Hide edit form + $(group).hide(); + + // Add events to the save / cancel UI within the group + group.querySelector('[data-repeater-save-group]').addEventListener('click', this.handleUpdateGroup.bind(this, group, this.repeaterEntries)); + group.querySelector('[data-repeater-cancel-save]').addEventListener('click', this.handleCancelGroupUpdate.bind(this, group, this.repeaterEntries)); + } + + /** + * Handle edit group action + * @param repeaterId {number} + * @param event + */ + + }, { + key: 'handleEditGroup', + value: function handleEditGroup(repeaterId, event) { + var $repeater = $(this.repeater); + var $edit = $repeater.find('[data-repeater-preview-root]').find('[data-repeater-edit-id=' + repeaterId + ']'); + + event.preventDefault(); + this.repeaterPreviewService.toggleUi(); + $repeater.find('[data-repeater-add-group]').addClass('disabled').attr('disabled', true); + $edit.show(); + + // Shift focus to the first focusable element in the form + this.focusManagementService.focusFirstFocusableElement($edit); + + // Capture triggering element so we can return focus when closed + this.focusManagementService.storeElement($(event.target)); + } + + /** + * Handle delete group action + * @param repeaterId {number} + * @param event + */ + + }, { + key: 'handleDeleteGroup', + value: function handleDeleteGroup(repeaterId, event) { + var $repeater = $(this.repeater); + var $previewRoot = $repeater.find('[data-repeater-preview-root]'); + var $preview = $previewRoot.find('[data-repeater-preview-id="' + repeaterId + '"]'); + var $edit = $repeater.find('[data-repeater-edit-id="' + repeaterId + '"]'); + var $saved = $repeater.find('[data-repeater-saved-data-id="' + repeaterId + '"]'); + var $previousRow = $previewRoot.find('[data-repeater-preview-id="' + (repeaterId - 1) + '"]'); + + event.preventDefault(); + + // Remove DOM + $preview.remove(); + $edit.remove(); + $saved.remove(); + + // Update state + this.savedEntries--; + + var $addGroupButton = $repeater.find('[data-repeater-add-group]'); + + // Enable "add group" button if we have not exceeded max saved entries + if (this.savedEntries < this.maxSavedGroups) { + $addGroupButton.removeClass('disabled').removeAttr('disabled'); + } + + // Update "add group" button text and add placeholder if we have removed all entries + if (this.savedEntries <= 0) { + $addGroupButton.text(this.repeater.getAttribute('data-repeater-add-new-group-text')); + + // Add "empty" placeholder + this.repeaterPlaceholderService.add(); + } + + // Focus either previous row delete button of add button if no previous + if ($previousRow.length) { + $previousRow.find('[data-repeater-delete-group]').focus(); + } else { + $addGroupButton.focus(); + } + } + + /** + * Handle the cancel interaction when adding a new group + * @param event + */ + + }, { + key: 'handleCancelGroup', + value: function handleCancelGroup(event) { + var $repeater = $(this.repeater); + + if (this.savedEntries < this.maxSavedGroups) { + $repeater.find('[data-repeater-add-group]').removeClass('disabled').removeAttr('disabled'); + + // Return focus to triggering element + this.focusManagementService.returnFocusToElement(); + } + + event.preventDefault(); + + var $addGroupForm = $repeater.find('[data-repeater-new-group]'); + + // Reset new repeater group form + this.formFieldResetService.reset($addGroupForm[0]); + + // Reset Pulsar colour pickers + this.pulsarFormComponent.updateColourPicker($addGroupForm); + + // Hide the "add group" form + $addGroupForm.hide(); + } + + /** + * Handle an edit / update save + * @param group {HTMLElement} + * @param repeaterId {number} + * @param event + */ + + }, { + key: 'handleUpdateGroup', + value: function handleUpdateGroup(group, repeaterId, event) { + event.preventDefault(); + + var $repeater = $(this.repeater); + + // Update state + this.state[repeaterId] = this.createState(group); + + // Update preview elements + this.repeaterPreviewService.update(this.state[repeaterId], $repeater.find('[data-repeater-for-name]').toArray(), $repeater.find('[data-repeater-preview-root]')[0], repeaterId); + + // Update saved data + this.repeaterDataService.update(this.state[repeaterId], repeaterId); + + // Enable preview UI + this.repeaterPreviewService.toggleUi(); + + // Enable "add group" button if we have not exceeded max saved entries + if (this.savedEntries < this.maxSavedGroups) { + $repeater.find('[data-repeater-add-group]').removeClass('disabled').removeAttr('disabled'); + } + + // Return focus to triggering element + this.focusManagementService.returnFocusToElement(); + + // Hide edit group form + $(group).hide(); + } + + /** + * Handle an update cancel, inputs will be restored to their un-edited state + * @param group {HTMLElement|Node} + * @param repeaterId {number} + * @param event + */ + + }, { + key: 'handleCancelGroupUpdate', + value: function handleCancelGroupUpdate(group, repeaterId, event) { + var _this4 = this; + + event.preventDefault(); + + var $group = $(group); + var $repeater = $(this.repeater); + + // Reset input values to pre-edited state + $group.find('[data-repeater-name]').each(function (index, element) { + _this4.state[repeaterId][element.getAttribute('data-repeater-name')].value.forEach(function (input) { + // Update the value for selected inputs + _this4.inputValueService.setValue(element, input.value, { selected: input.selected }); + }); + }); + + // Revert radio inputs to pre-edited values + this.pseudoRadioInputService.setState(this.state[repeaterId]); + + // Enable preview UI + this.repeaterPreviewService.toggleUi(); + + // Enable "add group" button if we have not exceeded max saved entries + if (this.savedEntries < this.maxSavedGroups) { + $repeater.find('[data-repeater-add-group]').removeClass('disabled').removeAttr('disabled'); + } + + // Update any colour pickers that might exist + this.pulsarFormComponent.updateColourPicker($(group)); + + // Hide edit group + $group.hide(); + + // Return focus to triggering element + this.focusManagementService.returnFocusToElement(); + } + + /** + * Remove name attribute and add custom name attribute, this will + * omit the input's data from requests + * @param group {HTMLElement|Node} + */ + + }, { + key: 'removeGroupInputNames', + value: function removeGroupInputNames(group) { + var $inputs = $(group).find('[name]'); + + $inputs.each(function (index, input) { + var name = input.getAttribute('name'); + // set name attr on cloned group + input.setAttribute('data-repeater-name', name); + // remove custom name attr on group + input.removeAttribute('name'); + }); + } + }]); + + return Repeater; + }(); + + module.exports = Repeater; + + },{"jquery":416}],44:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require('jquery'); + + var RepeaterDataService = function () { + /** + * @param {HTMLElement} root + * @param {InputCloneService} inputCloneService + * @param {InputValueService} inputValueService + * @param {UniqueIdService} uniqueIdService + */ + function RepeaterDataService(root, inputCloneService, inputValueService, uniqueIdService) { + _classCallCheck(this, RepeaterDataService); + + this.root = root; + this.inputCloneService = inputCloneService; + this.inputValueService = inputValueService; + this.uniqueIdService = uniqueIdService; + } + + /** + * Create repeater data group + * @param group + * @param savedEntryId + */ + + + _createClass(RepeaterDataService, [{ + key: 'create', + value: function create(group, savedEntryId) { + var _this = this; + + var $formGroups = $(group).find('.form__group'); + var $dataRoot = $(this.root).find('[data-repeater-saved-entries-root]'); + var savedData = document.createElement('div'); + + // Add an identifier to an entry in the saved data + savedData.setAttribute('data-repeater-saved-data-id', savedEntryId); + + $formGroups.each(function (index, group) { + // Get the label + var labelText = $(group).find('.control__label:first-child').text(); + + // Clone the input + var $input = $(group).find('[data-repeater-name]'); + var name = $input.attr('data-repeater-name'); + var clone = _this.inputCloneService.clone($input[0]); + + // Add name attr to clone + clone.setAttribute('name', name); + + // Remove the new group attr + clone.removeAttribute('data-repeater-name'); + + // Hide clone from SRs + clone.classList.add('u-display-none'); + + // Add hidden label to cloned input to stop a11y tools complaining + clone.setAttribute('aria-label', labelText); + + // Add cloned input to entry + savedData.appendChild(clone); + }); + + this.uniqueIdService.uniquifyIds(savedData); + + // Append saved entry to the DOM + $dataRoot.append(savedData); + } + + /** + * Update repeater data group + */ + + }, { + key: 'update', + value: function update(state, savedEntryId) { + var _this2 = this; + + var $dataRoot = $(this.root).find('[data-repeater-saved-entries-root]'); + var $savedData = $dataRoot.find('[data-repeater-saved-data-id="' + savedEntryId + '"]'); + + // Iterate each input in the saved data + $savedData.find('[name]').each(function (index, element) { + state[element.getAttribute('name')].value.forEach(function (input) { + // Update the value for selected inputs + _this2.inputValueService.setValue(element, input.value, { selected: input.selected }); + }); + }); + } + }]); + + return RepeaterDataService; + }(); + + module.exports = RepeaterDataService; + + },{"jquery":416}],45:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var RepeaterManagerComponent = function () { + /** + * Repeater Manager + * @param pulsarFormComponent {PulsarFormComponent} + * @param repeaterComponentFactory {repeaterComponentFactory} + * @param $html {$} + */ + function RepeaterManagerComponent(pulsarFormComponent, repeaterComponentFactory, $html) { + _classCallCheck(this, RepeaterManagerComponent); + + this.pulsarFormComponent = pulsarFormComponent; + this.repeaterComponentFactory = repeaterComponentFactory; + this.$html = $html; + } + + /** + * Initiate repeaters on the page + */ + + + _createClass(RepeaterManagerComponent, [{ + key: 'init', + value: function init() { + var _this = this; + + this.$html.find('[data-repeater]').each(function (index, element) { + var repeater = _this.repeaterComponentFactory(_this.pulsarFormComponent, element); + var initialData = element.getAttribute('data-repeater-initial-state'); + + repeater.init(JSON.parse(initialData)); + }); + } + }]); + + return RepeaterManagerComponent; + }(); + + module.exports = RepeaterManagerComponent; + + },{}],46:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require("jquery"); + + var RepeaterPlaceholderService = function () { + /** + * Repeater placeholder service + * @param {HTMLElement} root + */ + function RepeaterPlaceholderService(root) { + _classCallCheck(this, RepeaterPlaceholderService); + + this.$root = $(root); + this.$placeholder = this.$root.find('[data-repeater-preview-placeholder]'); + } + + /** + * Prepend the preview empty placeholder + */ + + + _createClass(RepeaterPlaceholderService, [{ + key: 'add', + value: function add() { + this.$root.find('[data-repeater-preview-root]').prepend(this.$placeholder); + } + + /** + * Remove preview placeholder and update reference + */ + + }, { + key: 'remove', + value: function remove() { + var $placeholder = this.$root.find('[data-repeater-preview-placeholder]'); + + // If there is no placeholder, move along + if ($placeholder.length === 0) { + return; + } + + this.$placeholder = $placeholder.clone(); + $placeholder.remove(); + } + }]); + + return RepeaterPlaceholderService; + }(); + + module.exports = RepeaterPlaceholderService; + + },{"jquery":416}],47:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require("jquery"); + + var RepeaterPreviewService = function () { + /** + * Create / Update Repeater preview elements + * @param {HTMLElement} root + * @param {InputValueService} inputValueService + * @param options + */ + function RepeaterPreviewService(root, inputValueService) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + _classCallCheck(this, RepeaterPreviewService); + + this.root = root; + this.inputValueService = inputValueService; + this.emptyHTML = options.empty || 'empty'; + } + + /** + * Create a repeater preview + * @param state + * @param headings + * @param id + * @returns {HTMLElement} + */ + + + _createClass(RepeaterPreviewService, [{ + key: 'create', + value: function create(state, headings, id) { + var _this = this; + + var previewRow = document.createElement('tr'); + + // For each heading, create a repeater preview + headings.forEach(function (heading) { + var name = heading.getAttribute('data-repeater-for-name'); + var data = state[name]; + var value = _this.emptyHTML; + + if (data === undefined) { + throw new Error('The input "' + name + '" was not found in the Repeater.'); + } + + var preview = document.createElement('td'); + + preview.setAttribute('data-repeater-preview-update-id', name + '_' + id); + + data.value.filter(function (input) { + return input.selected && input.value; + }).forEach(function (input) { + value = _this.print(input.ref, value, input.value); + }); + + preview.textContent = value; + previewRow.appendChild(preview); + }); + + return previewRow; + } + + /** + * Update a repeater preview + * @param state + * @param headings + * @param root + * @param id + */ + + }, { + key: 'update', + value: function update(state, headings, root, id) { + var _this2 = this; + + headings.forEach(function (heading) { + var name = heading.getAttribute('data-repeater-for-name'); + var data = state[name]; + var value = _this2.emptyHTML; + + // If our heading exists inside the state object + if (state[name]) { + var preview = root.querySelector('[data-repeater-preview-update-id="' + name + '_' + id + '"]'); + + // Set the value for each input in the state + data.value.filter(function (input) { + return input.selected && input.value; + }).forEach(function (input) { + value = _this2.print(input.ref, value, input.value); + }); + + preview.innerText = value; + } + }); + } + + /** + * Toggle the disabled state of preview UI buttons + */ + + }, { + key: 'toggleUi', + value: function toggleUi() { + var $preview = $(this.root).find('[data-repeater-preview-id]'); + + $preview.toArray().forEach(function (preview) { + var $previewUi = $(preview).find('[data-repeater-preview-ui]'); + $previewUi.toggleClass('disabled'); + + if ($previewUi.prop('disabled') !== false) { + $previewUi.prop('disabled', false); + } else { + $previewUi.prop('disabled', true); + } + }); + } + + /** + * Print a preview value, this handles sanitizing values via + * the InputValueService as well as concatenating multiple values + * @param input + * @param value + * @param newValue + * @returns {*} + */ + + }, { + key: 'print', + value: function print(input, value, newValue) { + var printedValue = this.inputValueService.printValue(input, newValue); + + if (value === this.emptyHTML) { + return printedValue; + } else { + return value + ', ' + printedValue; + } + } + }]); + + return RepeaterPreviewService; + }(); + + module.exports = RepeaterPreviewService; + + },{"jquery":416}],48:[function(require,module,exports){ + 'use strict'; + + var InputCloneService = require('./InputCloneService'); + var InputValueService = require('./InputValueService'); + var PseudoRadioInputService = require('./PseudoRadioInputService'); + var InputReplacementService = require('./InputReplacementService'); + var RepeaterPreviewService = require('./RepeaterPreviewService'); + var ActiveFunctionService = require('../utilities/ActiveFunctionService'); + var RepeaterDataService = require('./RepeaterDataService'); + var UniqueIdService = require('../utilities/UniqueIdService'); + var HashService = require('../utilities/HashService'); + var Repeater = require('./RepeaterComponent'); + var RepeaterPlaceholderService = require('./RepeaterPlaceholderService'); + var FormFieldResetService = require('../utilities/FormFieldResetService'); + var FocusManagementService = require('../FocusManagementService'); + + /** + * Create a repeater component instance + * @param pulsarFormComponent {PulsarFormComponent} + * @param repeater {HTMLElement} + * @returns {Repeater} + */ + function repeaterComponentFactory(pulsarFormComponent, repeater) { + var activeFunctionService = new ActiveFunctionService(); + var inputCloneService = new InputCloneService(); + var inputValueService = new InputValueService(); + var inputReplacementService = new InputReplacementService(pulsarFormComponent); + var uniqueIdService = new UniqueIdService(new HashService(Date)); + var repeaterDataService = new RepeaterDataService(repeater, inputCloneService, inputValueService, uniqueIdService); + var repeaterPreviewService = new RepeaterPreviewService(repeater, inputValueService); + var pseudoRadioInputService = new PseudoRadioInputService(repeater, 'data-repeater-name'); + var repeaterPlaceholderService = new RepeaterPlaceholderService(repeater); + var formFieldResetService = new FormFieldResetService(); + var focusManagementService = new FocusManagementService(); + + return new Repeater(repeater, pulsarFormComponent, activeFunctionService, inputCloneService, inputValueService, inputReplacementService, uniqueIdService, repeaterPreviewService, pseudoRadioInputService, repeaterDataService, repeaterPlaceholderService, formFieldResetService, focusManagementService); + } + + module.exports = repeaterComponentFactory; + + },{"../FocusManagementService":28,"../utilities/ActiveFunctionService":65,"../utilities/FormFieldResetService":66,"../utilities/HashService":67,"../utilities/UniqueIdService":68,"./InputCloneService":39,"./InputReplacementService":40,"./InputValueService":41,"./PseudoRadioInputService":42,"./RepeaterComponent":43,"./RepeaterDataService":44,"./RepeaterPlaceholderService":46,"./RepeaterPreviewService":47}],49:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require('jquery'); + + var StickyScrollBarComponent = function () { + + /** + * StickyScrollBarComponent + * @constructor + * @param {jQuery} $rootWindow - jQuery wrapper of the window object + * @param {jQuery} $html - jQuery wrapper of the html node + */ + function StickyScrollBarComponent($rootWindow, $html) { + _classCallCheck(this, StickyScrollBarComponent); + + this.$window = $rootWindow; + this.$html = $html; + this.$stickyScrollBar = $('
    '); + this.$stickyScrollBarInner = this.$stickyScrollBar.children(); + // cache methods with context + this.scrollStickyScrollBarWithContext = this.scrollStickyScrollBar.bind(this); + this.scrollElementWithStickyScrollBarByScrollBarWithContext = this.scrollElementWithStickyScrollBarByScrollBar.bind(this); + this.updateStickyScrollBarWithContext = this.updateStickyScrollBar.bind(this); + } + + /** + * Initialise + * @param {jQuery} $element - jQuery object of the element that requires a sticky scroll bar + */ + + + _createClass(StickyScrollBarComponent, [{ + key: 'init', + value: function init($element) { + if (typeof $element === 'undefined' || !$element) { + throw new Error('an element to add the scroller to must be passed to StickyScrollBarComponent'); + } + + if (typeof this.$window === 'undefined' || !this.$window) { + throw new Error('window must be passed to StickyScrollBarComponent'); + } + + if (typeof this.$html === 'undefined' || !this.$html) { + throw new Error('$html must be passed to StickyScrollBarComponent'); + } + + // Set $elementWithStickyScrollBar + this.$elementWithStickyScrollBar = $element; + + // Add the sticky scroll bar + this.$stickyScrollBar.appendTo(this.$elementWithStickyScrollBar); + + // Init the sticky scroll bar + this.$stickyScrollBar.addClass('u-display-none').on('scroll', this.scrollElementWithStickyScrollBarByScrollBarWithContext); + + // Call on load + this.updateStickyScrollBar(); + + // Call on scroll and window resize + this.$window.on('scroll resize', this.updateStickyScrollBarWithContext); + } + + /** + * Set $elementWithStickyScrollBar scroll when scrolled by sticky scroll bar + */ + + }, { + key: 'scrollElementWithStickyScrollBarByScrollBar', + value: function scrollElementWithStickyScrollBarByScrollBar() { + this.$elementWithStickyScrollBar.scrollLeft(this.$stickyScrollBar.scrollLeft()); + } + + /** + * Set $stickyScrollBar scroll when $elementWithStickyScrollBar is scrolled + */ + + }, { + key: 'scrollStickyScrollBar', + value: function scrollStickyScrollBar() { + this.$stickyScrollBar.scrollLeft(this.$elementWithStickyScrollBar.scrollLeft()); + } + + /** + * Toggle visiblity of sticky scroll bar + */ + + }, { + key: 'showStickyScrollBar', + value: function showStickyScrollBar(option) { + if (option) { + this.$stickyScrollBar.removeClass('u-display-none'); + } else { + this.$stickyScrollBar.addClass('u-display-none'); + } + } + + /** + * Update sticky scroll bar visibility, thumb position and width + */ + + }, { + key: 'updateStickyScrollBar', + value: function updateStickyScrollBar() { + var _$elementWithStickySc = this.$elementWithStickyScrollBar.offset(), + top = _$elementWithStickySc.top; + + var bottom = top + this.$elementWithStickyScrollBar.height(); + var topOffset = 30; + var viewportBottom = void 0; + + // Allow for footer + if (this.$html.find('.footer').css('position') === 'fixed') { + viewportBottom = this.$window.scrollTop() + this.$window.height() - this.$html.find('.footer').outerHeight(); + } else { + viewportBottom = this.$window.scrollTop() + this.$window.height(); + } + + // Check if the $elementWithStickyScrollBar is visible but bottom is outside of viewport + if (top + topOffset < viewportBottom && bottom > viewportBottom) { + + // Check if the $elementWithStickyScrollBar has a scrollbar + var scroll = this.$elementWithStickyScrollBar.scrollLeft(); + var scrollMax = this.$elementWithStickyScrollBar[0].scrollWidth - this.$elementWithStickyScrollBar[0].clientWidth; + var widthOuter = this.$elementWithStickyScrollBar.innerWidth(); + var widthInner = widthOuter + scrollMax; + + this.$elementWithStickyScrollBar.scrollLeft(scroll); + + // Abort if the $elementWithStickyScrollBar doesn't have a scrollbar + if (widthInner <= widthOuter) { + return; + } + + // Show sticky scroll bar + this.showStickyScrollBar(true); + + // Sync sticky scroll bar if $elementWithStickyScrollBar content is scrolled + this.$elementWithStickyScrollBar.off('scroll', this.scrollStickyScrollBarWithContext); + this.$elementWithStickyScrollBar.on('scroll', this.scrollStickyScrollBarWithContext); + + // Adjust the sticky scroll bar scrollbar + this.$stickyScrollBar.css({ + left: this.$elementWithStickyScrollBar.offset().left - this.$window.scrollLeft(), + width: widthOuter + }).scrollLeft(scroll); + + // Set sticky scroll bar width + this.$stickyScrollBarInner.width(widthInner); + } else { + // Hide when not needed + this.showStickyScrollBar(false); + } + } + }]); + + return StickyScrollBarComponent; + }(); + + module.exports = StickyScrollBarComponent; + + },{"jquery":416}],50:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require('jquery'); + + var StickySidebarComponent = function () { + + /** + * StickySidebarComponent + * @constructor + * @param {object} window - window object + * @param {jQuery} $html - jQuery wrapper of the html node + */ + function StickySidebarComponent($html, window) { + _classCallCheck(this, StickySidebarComponent); + + this.$html = $html; + this.window = window; + } + + /** + * Initialise component + * + * Should be fired on page load, checks for required options, performs an + * initial sticky calculation and binds to resize & scroll events + */ + + + _createClass(StickySidebarComponent, [{ + key: 'init', + value: function init() { + var _this = this; + + if (typeof this.$html === 'undefined') { + throw new Error('$html must be passed to StickySidebarComponent'); + } + + if (typeof this.window === 'undefined') { + throw new Error('window must be passed to StickySidebarComponent'); + } + + this.sticky(); + $(this.window).on('scroll resize', function (event) { + return _this.sticky(event); + }); + } + + /** + * Sticky calculation + * + * Add the required sticky class to the container, and remove it if scrolled up + */ + + }, { + key: 'sticky', + value: function sticky() { + var $container = this.$html.find('.tab__container.has-settings .tab__inner'); + var $header = $container.children('.tab__header'); + var $settings = $container.find('.tab__settings'); + var hasClass = $container.hasClass('is-sticky'); + + if (!$settings.length) { + return; + } + + var scrollTop = $(this.window).scrollTop(); + var sidebarOffset = Math.floor($container.offset().top + ($header.length > 0 ? $header.outerHeight() : 0)); + + var hasScrolledPastContainer = scrollTop >= sidebarOffset; + + if (hasScrolledPastContainer) { + if (!hasClass) { + $container.addClass('is-sticky'); + } + } else { + if (hasClass) { + // Ensure when re-stickying that the content is scrolled to the top + $settings.scrollTop(0); + + $container.removeClass('is-sticky'); + } + } + } + }]); + + return StickySidebarComponent; + }(); + + module.exports = StickySidebarComponent; + + },{"jquery":416}],51:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require('jquery'); + + /** + * Enhance tab.js behaviour + */ + + var TabEnhancements = function () { + function TabEnhancements() { + _classCallCheck(this, TabEnhancements); + } + + _createClass(TabEnhancements, [{ + key: 'init', + + /** + * Initialise + * @param {jQuery} $html - a jQuery wrapper of the html node + */ + value: function init($html) { + var _this = this; + + this.$html = $html; + + if (typeof $.fn.tab === 'undefined') { + console.warn('PULSAR: tab.js must be loaded in order to use TabEnhacements.js'); + } + + // Make sure tab panes are at least as high as the tab list (cms legacy tabs list) + this.$html.find('.tabs > .tabs__content > .tab__pane').css('min-height', this.$html.find('.tabs__list').height()); + + // Remove skip target IDs set in markup + this.$html.find('div.tab__content').removeAttr('id'); + + // Add the skip-target ID to the active main + this.$html.find('.tab__pane.is-active div.tab__content').attr('id', 'skip-target'); + + // On tab change + this.$html.find('.nav-inline [data-toggle="tab"]').on('show.bs.tab', function (event) { + var $activeTab = _this.$html.find($(event.target).attr('href')); + + // Remove previously set skip target IDs on other tabs + _this.$html.find('div.tab__content').removeAttr('id'); + + // Add skip target ID to new active tab main + $activeTab.find('div.tab__content').attr('id', 'skip-target'); + }); + } + }]); + + return TabEnhancements; + }(); + + module.exports = TabEnhancements; + + },{"jquery":416}],52:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var TableDetailComponent = function () { + + /** + * TableDetailComponent + * @constructor + * @param {jQuery} $html - jQuery wrapper of the html node + */ + function TableDetailComponent($html) { + _classCallCheck(this, TableDetailComponent); + + this.$html = $html; + this.focusableElementList = 'a[href], area[href], input, select, textarea, button, iframe, object, embed, [tabindex], *[contenteditable]'; + this.panelIsOpen = false; + } + + /** + * Initialise + */ + + + _createClass(TableDetailComponent, [{ + key: 'init', + value: function init() { + var _this = this; + + if (typeof this.$html === 'undefined' || !this.$html.length) { + throw new Error('$html must be passed to TableDetailComponent'); + } + + var $panelHtml = $(''), + $panelAlreadyExists = this.$html.find('[data-table-detail-panel]'), + $main = this.$html.find('main'), + $roleMain = this.$html.find('[role="main"]'), + $elementToAppendTo = void 0, + $triggeringElement = void 0; + + this.$table = this.$html.find('[data-table-detail-table]'); + + if (!this.$table.length) { + return; + } + + // Check panel hasn't already been added, in case of a datatable re-initting this component on paginated page draw + if ($panelAlreadyExists.length === 0) { + // If main or role="main" is present append alerts to that (to satify WCAG 1.3.1 Info and Relationships) + if ($main.length > 0) { + $elementToAppendTo = $main; + } else if ($roleMain.length > 0) { + $elementToAppendTo = $roleMain; + } else { + $elementToAppendTo = this.$html.find('body'); + } + + // Add backdrop and detail panel if UI contains a table detail pattern + if (this.$table.length) { + $elementToAppendTo.append('
    ').append($panelHtml); + } + } + + // Grab detail panel bits we need + this.$detailPanel = this.$html.find('[data-table-detail-panel]'); + this.$detailPanelBody = this.$html.find('[data-table-detail-panel-body]'); + this.$detailPanelTitle = this.$html.find('[data-table-detail-panel-title]'); + this.$tableDetailBackdrop = this.$html.find('.table-detail-backdrop'); + + // Open click listener + this.$table.on('click', '[data-table-detail-view-detail]', function (event) { + event.preventDefault(); + + var $parentRow = $(event.currentTarget).closest('tr'); + + // If the table is in DT collapse mode, and the detail trigger is in the child row + // then fetch the detail content from the appropriate parent row + if ($parentRow.hasClass('child')) { + $parentRow = $parentRow.prev(); + } + + var detailContent = $parentRow.data('table-detail-content'); + var customDetailPanelTitle = $parentRow.data('table-detail-panel-custom-title'); + + $triggeringElement = $(event.target); + + _this.viewDetail(detailContent, customDetailPanelTitle); + }); + + // Close click listener + this.$detailPanel.find('[data-table-detail-close-panel]').on('click', function (event) { + event.preventDefault(); + _this.closeDetail(); + $triggeringElement.trigger('focus'); + }); + + // Close with backdrop click + this.$tableDetailBackdrop.on('click', function (event) { + event.preventDefault(); + if (_this.panelIsOpen) { + _this.closeDetail(); + $triggeringElement.trigger('focus'); + } + }); + + // Close ESC button + this.$html.on('keydown', function (event) { + if (event.keyCode === 27 && _this.panelIsOpen) { + _this.closeDetail(); + $triggeringElement.trigger('focus'); + } + }); + } + /** + * Show detail panel and populate with content and optional custom title + * @param {String} content - string of html content to populate the detail panel body with + * @param {String} customDetailPanelTitle - optinal custom detail panel title specific to the row clicked + */ + + }, { + key: 'viewDetail', + value: function viewDetail(content, customDetailPanelTitle) { + // Set the title if present + if (customDetailPanelTitle) { + this.$detailPanelTitle.html(customDetailPanelTitle); + } + + // Remove aria-hidden so SR can read + this.$detailPanel.removeAttr('aria-hidden'); + + // Remove any previously added contents + this.$detailPanelBody.empty(); + + // Add attached data to detail panel body + this.$detailPanelBody.html(content); + + // Apply backdrop + this.$tableDetailBackdrop.addClass('in'); + + // Mark panel as open + this.panelIsOpen = true; + + // Open panel + this.$detailPanel.addClass('table-detail--open'); + + // Make elements focusable again + this.$detailPanel.find(this.focusableElementList).not('[disabled], :hidden, [aria-hidden]').removeAttr('tabindex'); + + // Trap focus within the panel + this.trapFocus(); + } + + /** + * Hide detail panel and remove backdrop + */ + + }, { + key: 'closeDetail', + value: function closeDetail() { + // Remove backdrop + this.$tableDetailBackdrop.removeClass('in'); + + // Close panel + this.$detailPanel.removeClass('table-detail--open'); + + // Mark panel as closed + this.panelIsOpen = false; + + // Hide panel contents from screen readers + this.$detailPanel.attr('aria-hidden', 'true'); + + // Make sure focusable elemnts cannot gain focus whilst panel is closed + this.$detailPanel.find(this.focusableElementList).not('[tabindex=-1], [disabled], :hidden, [aria-hidden]').attr('tabindex', '-1'); + + // Remove previously bound listener + this.$html.off('keydown', this.boundKeydownListener); + } + + /** + * Listen for keyboard navigation, trap tabbing within the panels focusable elements + * @param {jQuery} $focusableElements - Collection of focusable elements in the details panel + */ + + }, { + key: 'keydownListener', + value: function keydownListener($focusableElements, event) { + var keyCode = event.keyCode || event.which; + + // If tab key is pressed + if (keyCode === 9) { + // Check for shift tab + if (event.shiftKey) { + // Focus previous, check if first element is is currently in focus, if so focus last element + if ($focusableElements.first().is(':focus')) { + event.preventDefault(); + $focusableElements.last().trigger('focus'); + } + } else { + // Focus next, check if last element is is currently in focus, if so focus first element + if ($focusableElements.last().is(':focus')) { + event.preventDefault(); + $focusableElements.first().trigger('focus'); + } + } + } + } + + /** + * Trap keyboard focus in the panel + */ + + }, { + key: 'trapFocus', + value: function trapFocus() { + var $focusablePanelBodyElements = this.$detailPanelBody.find('a[href], area[href], input, select, textarea, button, iframe, object, embed, [tabindex], *[contenteditable]').not('[tabindex=-1], [disabled], :hidden, [aria-hidden]'), + $focusableElements = this.$detailPanel.find('a[href], area[href], input, select, textarea, button, iframe, object, embed, [tabindex], *[contenteditable]').not('[tabindex=-1], [disabled], :hidden, [aria-hidden]'); + + // If the panel body contains a focusable element we should focus that rather than the close button + if ($focusablePanelBodyElements.length > 0) { + $focusablePanelBodyElements.first().trigger('focus'); + } else { + this.$detailPanel.find('[data-table-detail-close-panel]').trigger('focus'); + } + + this.boundKeydownListener = this.keydownListener.bind(this, $focusableElements); + this.$html.on('keydown', this.boundKeydownListener); + } + }]); + + return TableDetailComponent; + }(); + + module.exports = TableDetailComponent; + + },{}],53:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + require('timepicker'); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var TimePickerComponent = function () { + function TimePickerComponent() { + _classCallCheck(this, TimePickerComponent); + } + + _createClass(TimePickerComponent, [{ + key: 'init', + + + /** + * Bind timepicker to element + * @param {jQuery} $element - jQuery object of the element that requires a time picker + * @param {Object?} options - Options for the date picker, see https://github.com/jonthornton/jquery-timepicker + */ + value: function init($element, options) { + if (typeof $element === 'undefined' || !$element) { + throw new Error('$element must be passed to TimePickerComponent'); + } + + if ($element.length) { + $element.timepicker(options); + } + } + }]); + + return TimePickerComponent; + }(); + + module.exports = TimePickerComponent; + + },{"timepicker":433}],54:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require('jquery'); + + /** + * Accessible tooltips using the tippyjs library with some custom behaviour to meet WCAG 2.1 1.4.13 + */ + + var TooltipListener = function () { + + /** + * Tooltip listener + * @constructor + * @param {jQuery} $html - jQuery wrapper of the container node + * @param {tippy} TippyJS lib + * @param {hideAll} Tippy hideAll method + */ + function TooltipListener($html, tippy, hideAll) { + _classCallCheck(this, TooltipListener); + + this.$html = $html; + this.tippy = tippy; + this.hideAll = hideAll; + this.tippys = []; + this.tippyConfig = { + // Default to not allowing html inside of tooltip + allowHTML: false, + + // Remove the default fade animation + animation: 'none', + + // To prevent overflow issues, always append to body + appendTo: this.$html.find('body')[0], + + // Remove the animation duration + duration: 0, + + // Interactive allows us the hover over the tooltip contents, needed for WCAG 1.4.13: Content on Hover or Focus + // unfortunately, adding aria: 'describedby' here doesn't work as the interactive option removes it and replaces + // with aria-expanded see https://github.com/atomiks/tippyjs/issues/709 + // therefore we manually handle the tooltip aria-describedby attribute in the onMount and onHide lifecycle hooks + interactive: true, + + // Custom methods, also required for WCAG compliance + onCreate: this.onCreate, + onMount: this.onMount, + onHide: this.onHide, + onHidden: this.onHidden + }; + } + + /** + * Initialise + */ + + + _createClass(TooltipListener, [{ + key: 'init', + value: function init() { + var _this = this; + + this.tippys = this.tippy('[data-tippy-content]', this.tippyConfig); + + // Close ESC button + this.$html.on('keydown', function (event) { + if (event.keyCode === 27) { + _this.hideAll(); + } + }); + } + + /** + * Listen for new elements with tippys, ignore if already instantiated, create tooltip if not + * @param {jQuery} $html - jQuery wrapper of the container node + */ + + }, { + key: 'listen', + value: function listen($html) { + var _this2 = this; + + // Only create new tippys + $html.find('[data-tippy-content]').each(function (index, element) { + if (_this2.isInstantiated(element)) { + return; + } + + _this2.tippys.push(_this2.tippy(element, _this2.tippyConfig)); + }); + } + + /** + * Check if element is instantiated + * @param {Element} element - element to check for tippy instance + */ + + }, { + key: 'isInstantiated', + value: function isInstantiated(element) { + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = this.tippys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var tippy = _step.value; + + if (tippy.reference === element) { + return true; + } + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + + return false; + } + + /** + * Get tippy instance of element + * @returns {(object|null)} tippy object relating to an element or null + */ + + }, { + key: 'getInstance', + value: function getInstance(element) { + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + + try { + for (var _iterator2 = this.tippys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var tippy = _step2.value; + + if (tippy.reference === element) { + return tippy; + } + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + + return null; + } + }, { + key: 'onCreate', + value: function onCreate(instance) { + // Remove unnecessary aria-expanded attribute (added by the interactive option - needed for content hover) + $(instance.reference).removeAttr('aria-expanded'); + } + }, { + key: 'onMount', + value: function onMount(instance) { + var existingValue = void 0; + + // If the element already has aria-describedby text, keep it and add the tippy reference ID + if ($(instance.reference).attr('aria-describedby')) { + existingValue = $(instance.reference).attr('aria-describedby'); + $(instance.reference).attr('aria-describedby', 'tippy-' + instance.id + ' ' + existingValue); + } else { + $(instance.reference).attr('aria-describedby', 'tippy-' + instance.id); + } + + // Remove unnecessary re-added aria-expanded attribute + $(instance.reference).removeAttr('aria-expanded'); + } + }, { + key: 'onHide', + value: function onHide(instance) { + var existingValue = $(instance.reference).attr('aria-describedby'); + + // Remove tippy aria-describedby reference + existingValue = existingValue.replace('tippy-' + instance.id, '').trim(); + + // If no existing aria-describedby, remove the attribute + if (existingValue.length < 1) { + $(instance.reference).removeAttr('aria-describedby'); + } else { + $(instance.reference).attr('aria-describedby', existingValue); + } + } + }, { + key: 'onHidden', + value: function onHidden(instance) { + // Remove unnecessary aria-expanded attribute + $(instance.reference).removeAttr('aria-expanded'); + } + }]); + + return TooltipListener; + }(); + + module.exports = TooltipListener; + + },{"jquery":416}],55:[function(require,module,exports){ + 'use strict'; + + var $ = require('jquery'); + + var tippy = require('tippy.js').default; + + var _require = require('tippy.js'), + hideAll = _require.hideAll; + + var TooltipListener = require('./TooltipListener'); + + /** + * Create a Tooltip listener instance + * @param {jQuery} $html - jQuery wrapper of the html node + */ + function tooltipFactory($html) { + return new TooltipListener($html, tippy, hideAll); + } + + module.exports = tooltipFactory; + + },{"./TooltipListener":54,"jquery":416,"tippy.js":435}],56:[function(require,module,exports){ + 'use strict'; + + var $ = require('jquery'); + + require('jquery-placeholder'); + function SignInComponent(html) { + this.$html = html; + } + + SignInComponent.prototype.init = function () { + + var component = this; + + component.$container = this.$html.find('.signin'), component.$signinInner = this.$html.find('.signin__inner'), component.$errorPane = this.$html.find('.signin-error'), component.$signInPane = this.$html.find('.signin-form'), component.$resetPane = this.$html.find('.signin-reset'), component.$twoStepPane = this.$html.find('.signin-twostep'), component.$usernameField = this.$html.find('[name="username"]'), component.$passwordField = this.$html.find('[name="password"]'), component.$signInButton = this.$html.find('[name="signin-submit"]'), component.$signInTwoStep = this.$html.find('[name="signin-twostep"]'), component.$resetEmailField = this.$html.find('[name="reset-email"]'), component.$resetSubmit = this.$html.find('[name="reset-submit"]'), component.$twoStepOne = this.$html.find('[name="twoStepOne"]'), component.$twoStepTwo = this.$html.find('[name="twoStepTwo"]'), component.$info = this.$html.find('.signin-form .signin__info'), component.$twoStepInfo = this.$html.find('.signin-twostep .signin__info'), component.$alert = $('.alert'); + component.successMessage = 'Signed in successfully'; + component.signInFailMessage = ' Your username and/or password was incorrect'; + + component.hint = '', component.infoText = component.$info.text(), component.signInButtonValue = component.$signInButton.html(), component.animationEnd = 'webkitAnimationEnd oanimationend oAnimationEnd msAnimationEnd animationend'; + component.transitionEnd = 'webkitTransitionEnd otransitionend oTransitionEnd msTransitionEnd transitionend', component.twoStepAttempt = 0; + + // Polyfill placeholder behaviour in oldIE + this.$html.find('input').placeholder(); + + // Forgotten password + this.$html.find('[href="#forgot-password"]').on('click', function (e) { + e.preventDefault(); + + component.switchPanel('.signin-reset'); + + component.$container.removeClass('signin--error'); + + component.$container.addClass('active-reset').one(component.transitionEnd, function () { + component.$resetEmailField.focus(); + }); + + $('.signin__input, .signin__submit, .signin__link', $('.signin-reset')).prop('tabindex', ''); + }); + + // Cancel forgotten password + this.$html.find('[href="#signin"]').on('click', function (e) { + e.preventDefault(); + e.stopPropagation(); + component.reset(); + }); + + // Forgotten username + this.$html.find('[href="#forgot-username"]').on('click', function (e) { + e.preventDefault(); + + component.switchPanel('.signin-forgot'); + + component.$container.removeClass('signin--error'); + + component.$container.addClass('active-forgot').one(component.transitionEnd, function () { + component.$resetEmailField.focus(); + }); + + $('.signin__input, .signin__submit, .signin__link', $('.signin-reset')).prop('tabindex', ''); + }); + + // Escape key resets the UI back to the login pane + $(document).on('keyup', function (e) { + if (e.keyCode == 27) { + component.reset(); + }; + }); + + this.$html.find('[name="signin-submit"]').on('click', function (e) { + e.preventDefault(); + + var infoText = ' Enter your username and password'; + + if (!component.$usernameField.val() || !component.$passwordField.val()) { + component.$container.addClass('shake').one(component.animationEnd, function () { + $(this).removeClass('shake'); + }); + + if (component.$usernameField.val() && !component.$passwordField.val()) { + infoText = ' Enter your password'; + + component.$passwordField.focus(); + + if (!component.$passwordField.prev('.signin__hint').length) { + + component.$passwordField.before(component.hint).on('keyup', function () { + if ($(this).val().length > 0) { + $(this).prev('.signin__hint').fadeOut(150); + } else { + $(this).prev('.signin__hint').fadeIn(150); + } + }); + }; + } else if (!component.$usernameField.val() && component.$passwordField.val()) { + infoText = ' Enter your username'; + component.$usernameField.focus(); + + if (!component.$usernameField.prev('.signin__hint').length) { + component.$usernameField.before(component.hint).on('keyup', function () { + if ($(this).val().length > 0) { + $(this).prev('.signin__hint').fadeOut(150); + } else { + $(this).prev('.signin__hint').fadeIn(150); + } + }); + }; + } else { + component.$usernameField.focus(); + + if (!component.$usernameField.prev('.signin__hint').length) { + component.$usernameField.before(component.hint).on('keyup', function () { + if ($(this).val().length > 0) { + $(this).prev('.signin__hint').fadeOut(150); + } else { + $(this).prev('.signin__hint').fadeIn(150); + } + }); + }; + } + + component.$info.animate({ + opacity: 0 + }, 150, function () { + $(this).html(infoText).animate({ + opacity: 1 + }, 150); + }); + } else { + + // PRETEND WE'VE AUTHED AND GO TO 2FA SCREEN + component.twoStep(); + } + }); + + this.$html.find('[name="reset-submit"]').on('click', function (e) { + e.preventDefault(); + + if (!component.$resetEmailField.val()) { + + component.$container.addClass('shake').one(component.animationEnd, function () { + $(this).removeClass('shake'); + }); + + component.$resetEmailField.focus().before(component.hint).on('keyup', function () { + if ($(this).val().length > 0) { + $(this).prev('.signin__hint').fadeOut(150); + } else { + $(this).prev('.signin__hint').fadeIn(150); + } + }); + } + }); + }; + + SignInComponent.prototype.reset = function () { + + var component = this; + + component.switchPanel('.signin-form'); + + component.$container.removeClass('signin--error').find('.signin__hint').remove(); + + if (this.$html.find('.signin-container input:not([name="username"])').length) { + this.$html.find('.signin-container input:not([name="username"])').trigger('blur'); + } + + $('.signin__input, .signin__submit, .signin__link', $('.signin-reset')).prop('tabindex', '-1'); + + if (component.$info.text() != component.infoText) { + component.$info.animate({ + opacity: 0 + }, 150, function () { + $(this).text(component.infoText).animate({ + opacity: 1 + }, 150); + }); + } + + if (component.$signInButton.html() != component.signInButtonValue) { + component.$signInButton.animate({ + opacity: 0 + }, 150, function () { + $(this).text(component.signInButtonValue).animate({ + opacity: 1 + }, 150); + }); + }; + + component.$container.removeClass('active-reset active-forgot active-twostep').one(component.transitionEnd, function () { + component.$usernameField.focus(); + }); + }; + + SignInComponent.prototype.signinFail = function () { + + var component = this; + + component.$container.find('.signin__hint').remove(); + + component.$info.animate({ + opacity: 0 + }, 150, function () { + $(this).html('').append(component.signInFailMessage).animate({ + opacity: 1 + }, 150); + }); + + if (component.$container.hasClass('signin--error')) { + return false; + } + + component.$container.addClass('signin--error'); + component.$usernameField.focus(); + + component.$signInButton.animate({ + opacity: 0 + }, 150, function () { + $(this).html('Try Again').animate({ + opacity: 1 + }, 150); + }); + + // return false here so that focus() can be correctly assigned + return false; + }; + + SignInComponent.prototype.switchPanel = function (panelClass) { + + var component = this, + newPanel = component.$container.find(panelClass), + oldPanel = component.$container.find('.signin__panel:not(' + panelClass + ')'); + + component.$container.removeClass('signin--error'); + + // This panel + newPanel.attr('aria-hidden', 'false').find('[tabindex]').prop('disabled', false).each(function () { + $(this).attr('tabindex', '0'); + }); + + // Other panels + oldPanel.attr('aria-hidden', 'true').find('[tabindex]').prop('disabled', true).each(function () { + $(this).attr('tabindex', '-1'); + }); + }; + + SignInComponent.prototype.twoStep = function () { + + var component = this; + + component.switchPanel('.signin-twostep'); + + component.$container.addClass('active-twostep').one(component.transitionEnd, function () { + component.$twoStepOne.focus(); + }); + + component.$twoStepOne.on('keyup', function () { + var $stepOneField = $(this); + + if ($stepOneField.val().length === parseInt($stepOneField.attr('maxlength'))) { + component.$twoStepTwo.focus(); + } + }); + + component.$twoStepTwo.on('keyup', function () { + if ($(this).val().length === 0) { + component.$twoStepOne.focus(); + } + }); + + this.$html.find('[name="signin-twostep"]').on('click', function (e) { + e.preventDefault(); + + if (!component.$twoStepOne.val() || !component.$twoStepTwo.val()) { + + component.$container.addClass('shake').one(component.animationEnd, function () { + $(this).removeClass('shake'); + }); + + // replace contents of info element so screenreader announces it + var twoStepInfo = component.$twoStepPane.find('.signin__info').html(); + component.$twoStepInfo.html('').append(twoStepInfo); + } + + if (component.$twoStepOne.val().length < 3) { + + component.$twoStepOne.focus(); + + if (!component.$twoStepOne.prev('.signin__hint').length) { + component.$twoStepOne.before(component.hint).on('keyup', function () { + if ($(this).val().length > 0) { + $(this).prev('.signin__hint').fadeOut(150); + } else { + $(this).prev('.signin__hint').fadeIn(150); + } + }); + }; + } else if (component.$twoStepOne.val().length == 3 && component.$twoStepTwo.val().length < 3) { + + component.$twoStepTwo.focus(); + + if (!component.$twoStepTwo.next('.signin__hint').length) { + + component.$twoStepTwo.after(component.hint).on('keyup', function () { + if ($(this).val().length > 0) { + $(this).prev('.signin__hint').fadeOut(150); + } else { + $(this).prev('.signin__hint').fadeIn(150); + } + }); + }; + } else { + component.success(); + } + }); + }; + + SignInComponent.prototype.twoStepFail = function () { + + var component = this; + + if (component.twoStepAttempt >= 1) { + component.$twoStepInfo.animate({ + opacity: 0 + }, 150, function () { + $(this).html(' Having trouble?
    check our two-step help page').animate({ + opacity: 1 + }, 150); + }); + }; + + if (!component.$container.hasClass('signin--error')) { + component.$container.addClass('signin--error'); + component.$twoStepOne.focus(); + + component.$signInTwoStep.animate({ + opacity: 0 + }, 150, function () { + $(this).html('Try Again').animate({ + opacity: 1 + }, 150); + }); + } + + component.twoStepAttempt++; + }; + + SignInComponent.prototype.success = function () { + + var component = this, + successPanel = component.$container.find('.signin-success'), + oldPanel = component.$container.find('.signin__panel:not(.signin-success)'); + + component.$alert.append(document.createTextNode(component.successMessage)); + component.$container.addClass('active-success'); + + successPanel.attr('aria-hidden', 'false'); + oldPanel.attr('aria-hidden', 'true'); + }; + + module.exports = SignInComponent; + + },{"jquery":416,"jquery-placeholder":407}],57:[function(require,module,exports){ + 'use strict'; + + /** + * Pulsar + * + * Core UI components that should always be present. + * + * Jadu Ltd. + */ + + // Fixes issue with dependencies that expect both $ and jQuery to be set + window.jQuery = window.$ = require('jquery'); + + require('babel-polyfill'); + + // Global UI components + var $ = require('jquery'), + modal = require('./libs/modal'), + tab = require('./libs/tab'), + popover = require('./libs/popover'), + tooltip = require('./libs/tooltip'), + matchMedia = require('./polyfills/matchMedia'), + matchMediaAddListener = require('./polyfills/matchMedia.addListener'), + dt = require('datatables.net')(window, $), + dt_buttons = require('datatables.net-buttons')(window, $), + dt_responsive = require('datatables.net-responsive')(window, $), + dt_select = require('datatables.net-select')(window, $), + ButtonComponent = require('./ButtonComponent'), + DropdownButtonComponent = require('./DropdownButtonComponent'), + DisableUiComponent = require('./DisableUiComponent'), + ErrorSummaryComponent = require('./ErrorSummaryComponent'), + HelpTextComponent = require('./HelpTextComponent'), + FilterBarComponent = require('./FilterBarComponent'), + FlashMessageComponent = require('./FlashMessageComponent'), + MasterSwitchComponent = require('./MasterSwitchComponent'), + ModulePermissionsComponent = require('./ModulePermissionsComponent'), + NavMainComponent = require('./NavMainComponent'), + PulsarFormComponent = require('./PulsarFormComponent'), + PulsarUIComponent = require('./PulsarUIComponent'), + PulsarSortableComponent = require('./PulsarSortableComponent'), + SignInComponent = require('./area/signin/signin'), + StickySidebarComponent = require('./StickySidebarComponent'), + TableDetailComponent = require('./TableDetailComponent'), + DropZoneComponentFactory = require('./DropZone/DropZoneComponentFactory'), + RepeaterManagerComponent = require('./Repeater/RepeaterManagerComponent'), + repeaterComponentFactory = require('./Repeater/repeaterComponentFactory'), + FaviconEditor = require('./Notifications/FaviconEditor'), + tooltipFactory = require('./Tooltips/tooltipsFactory'), + ModalFocusService = require('./Modals/ModalFocusService'), + ModalListener = require('./Modals/ModalListener'), + datePicker = require('pulsar-date-picker'), + FocusManagementService = require('./FocusManagementService'), + TabEnhancements = require('./TabEnhancements/TabEnhancements'); + + require('jstree'); + + module.exports = { + ButtonComponent: ButtonComponent, + DropdownButtonComponent: DropdownButtonComponent, + DropZoneComponentFactory: DropZoneComponentFactory, + DisableUiComponent: DisableUiComponent, + ErrorSummaryComponent: ErrorSummaryComponent, + HelpTextComponent: HelpTextComponent, + FilterBarComponent: FilterBarComponent, + FlashMessageComponent: FlashMessageComponent, + MasterSwitchComponent: MasterSwitchComponent, + ModulePermissionsComponent: ModulePermissionsComponent, + NavMainComponent: NavMainComponent, + PulsarFormComponent: PulsarFormComponent, + PulsarUIComponent: PulsarUIComponent, + PulsarSortableComponent: PulsarSortableComponent, + SignInComponent: SignInComponent, + StickySidebarComponent: StickySidebarComponent, + TableDetailComponent: TableDetailComponent, + RepeaterManagerComponent: RepeaterManagerComponent, + repeaterComponentFactory: repeaterComponentFactory, + FaviconEditor: FaviconEditor, + tooltipFactory: tooltipFactory, + ModalFocusService: ModalFocusService, + ModalListener: ModalListener, + datePicker: datePicker, + FocusManagementService: FocusManagementService, + TabEnhancements: TabEnhancements + }; + + },{"./ButtonComponent":1,"./DisableUiComponent":4,"./DropZone/DropZoneComponentFactory":11,"./DropdownButtonComponent":24,"./ErrorSummaryComponent":25,"./FilterBarComponent":26,"./FlashMessageComponent":27,"./FocusManagementService":28,"./HelpTextComponent":29,"./MasterSwitchComponent":30,"./Modals/ModalFocusService":31,"./Modals/ModalListener":32,"./ModulePermissionsComponent":33,"./NavMainComponent":34,"./Notifications/FaviconEditor":35,"./PulsarFormComponent":36,"./PulsarSortableComponent":37,"./PulsarUIComponent":38,"./Repeater/RepeaterManagerComponent":45,"./Repeater/repeaterComponentFactory":48,"./StickySidebarComponent":50,"./TabEnhancements/TabEnhancements":51,"./TableDetailComponent":52,"./Tooltips/tooltipsFactory":55,"./area/signin/signin":56,"./libs/modal":59,"./libs/popover":60,"./libs/tab":61,"./libs/tooltip":62,"./polyfills/matchMedia":64,"./polyfills/matchMedia.addListener":63,"babel-polyfill":70,"datatables.net":404,"datatables.net-buttons":401,"datatables.net-responsive":402,"datatables.net-select":403,"jquery":416,"jstree":417,"pulsar-date-picker":424}],58:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _lodash = require('lodash'); + + var _lodash2 = _interopRequireDefault(_lodash); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var MimeTyper = function () { + function MimeTyper() { + _classCallCheck(this, MimeTyper); + + // this will be returned in the event we cannot match the MIME type + this.default = 'file-o'; + this.classes = { + code: 'file-code-o', + text: 'file-text-o', + doc: 'file-word-o', + powerpoint: 'file-powerpoint-o', + excel: 'file-excel-o', + pdf: 'file-pdf-o', + image: 'file-image-o', + zip: 'file-zip-o', + video: 'file-movie-o', + audio: 'file-audio-os' + }; + // MIME type map {MIME type}: {class name} + this.mimes = { + // code + 'text/css': this.classes.code, + 'text/html': this.classes.code, + 'application/javascript': this.classes.code, + 'text/javascript': this.classes.code, + 'application/ecmascript': this.classes.code, + 'text/xml': this.classes.code, + // text + 'text/plain': this.classes.text, + 'application/plain': this.classes.text, + 'text/richtext': this.classes.text, + 'application/rtf': this.classes.text, + // document + 'application/msword': this.classes.doc, + 'application/vnd.openxmlformats-officedocument.wordprocessingml.document': this.classes.doc, + // powerpoint + 'application/vnd.ms-powerpoint': this.classes.powerpoint, + 'application/mspowerpoint': this.classes.powerpoint, + 'application/powerpoint': this.classes.powerpoint, + // spreadsheet + 'application/excel': this.classes.excel, + 'application/vnd.ms-excel': this.classes.excel, + 'application/x-excel': this.classes.excel, + 'application/x-msexcel': this.classes.excel, + 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': this.classes.excel, + // pdf + 'application/pdf': this.classes.pdf, + // image + 'image/jpeg': this.classes.image, + 'image/png': this.classes.image, + 'image/svg': this.classes.image, + 'image/svg+xml': this.classes.image, + 'image/gif': this.classes.image, + // zip + 'application/x-compressed': this.classes.zip, + 'application/x-gzip': this.classes.zip, + 'application/zip': this.classes.zip, + 'application/x-zip': this.classes.zip, + // video + 'video/mpeg': this.classes.video, + 'video/quicktime': this.classes.video, + 'video/mp4': this.classes.video, + // audio + 'audio/mpeg': this.classes.audio, + 'audio/midi': this.classes.audio, + 'audio/wav': this.classes.audio, + 'audio/x-wav': this.classes.audio + }; + } + + /** + * Search MIME keys and return corresponding class name. + * If we can't find the type, return the default class name. + * @param {String} userMime + * @return {String} + */ + + + _createClass(MimeTyper, [{ + key: 'getIconClass', + value: function getIconClass(userMime) { + var match = _lodash2.default.find(Object.keys(this.mimes), function (mime) { + return mime === userMime; + }); + + return match ? this.mimes[match] : this.default; + } + }]); + + return MimeTyper; + }(); + + module.exports = MimeTyper; + + },{"lodash":418}],59:[function(require,module,exports){ + /* ======================================================================== + * Bootstrap: modal.js v3.0.3 + * http://twbs.github.com/bootstrap/javascript.html#modals + * ======================================================================== + * Copyright 2012 Twitter, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ======================================================================== */ + + 'use strict'; + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + + var $ = require('jquery'), + _ = require('lodash'); + + // MODAL CLASS DEFINITION + // ====================== + + var Modal = function Modal(element, options) { + this.options = options; + this.$element = $(element); + this.$backdrop = this.isShown = null; + + if (this.options.remote) this.$element.load(this.options.remote); + }; + + Modal.DEFAULTS = { + backdrop: 'static', + keyboard: true, + show: true + }; + + Modal.prototype.toggle = function (_relatedTarget) { + return this[!this.isShown ? 'show' : 'hide'](_relatedTarget); + }; + + Modal.prototype.show = function (_relatedTarget) { + var that = this; + var e = $.Event('show.bs.modal', { relatedTarget: _relatedTarget }); + + this.$element.trigger(e); + + if (this.isShown || e.isDefaultPrevented()) return; + + this.isShown = true; + + this.escape(); + + this.$element.on('click.dismiss.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this)); + + this.backdrop(function () { + var transition = $.support.transition && that.$element.hasClass('fade'); + + if (!that.$element.parent().length) { + that.$element.appendTo(document.body); // don't move modals dom position + } + + that.$element.show(); + + if (transition) { + that.$element[0].offsetWidth; // force reflow + } + + that.$element.addClass('in').attr('aria-hidden', false); + + that.enforceFocus(); + + var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget }); + + transition ? that.$element.find('.modal-dialog') // wait for modal to slide in + .one($.support.transition.end, function () { + that.$element.trigger('focus').trigger(e); + }).emulateTransitionEnd(300) : that.$element.trigger('focus').trigger(e); + }); + }; + + Modal.prototype.hide = function (e) { + if (e) e.preventDefault(); + + e = $.Event('hide.bs.modal'); + + this.$element.trigger(e); + + if (!this.isShown || e.isDefaultPrevented()) return; + + this.isShown = false; + + this.escape(); + + $(document).off('focusin.bs.modal'); + + this.$element.removeClass('in').attr('aria-hidden', true).off('click.dismiss.modal'); + + var $modalContent = this.$element.find('.modal__content').detach(); + this.$element.find('.modal__dialog').append($modalContent); + + $.support.transition && this.$element.hasClass('fade') ? this.$element.one($.support.transition.end, $.proxy(this.hideModal, this)).emulateTransitionEnd(300) : this.hideModal(); + }; + + Modal.prototype.enforceFocus = function () { + $(document).off('focusin.bs.modal') // guard against infinite focus loop + .on('focusin.bs.modal', $.proxy(function (e) { + if (this.$element[0] !== e.target && !this.$element.has(e.target).length) { + this.$element.trigger('focus'); + } + }, this)); + }; + + Modal.prototype.escape = function () { + if (this.isShown && this.options.keyboard) { + this.$element.on('keyup.dismiss.bs.modal', $.proxy(function (e) { + e.which == 27 && this.hide(); + }, this)); + } else if (!this.isShown) { + this.$element.off('keyup.dismiss.bs.modal'); + } + }; + + Modal.prototype.hideModal = function () { + var that = this; + this.$element.hide(); + this.backdrop(function () { + that.removeBackdrop(); + that.$element.trigger('hidden.bs.modal'); + }); + }; + + Modal.prototype.removeBackdrop = function () { + this.$backdrop && this.$backdrop.remove(); + this.$backdrop = null; + }; + + Modal.prototype.backdrop = function (callback) { + var that = this; + var animate = this.$element.hasClass('fade') ? 'fade' : ''; + + if (this.isShown && this.options.backdrop) { + var doAnimate = $.support.transition && animate; + + this.$backdrop = $('
    ').appendTo(document.body); + + this.$element.on('click.dismiss.modal', $.proxy(function (e) { + if (e.target !== e.currentTarget) return; + this.options.backdrop == 'static' ? this.$element[0].focus.call(this.$element[0]) : this.hide.call(this); + }, this)); + + if (doAnimate) this.$backdrop[0].offsetWidth; // force reflow + + this.$backdrop.addClass('in'); + + if (!callback) return; + + doAnimate ? this.$backdrop.one($.support.transition.end, callback).emulateTransitionEnd(150) : callback(); + } else if (!this.isShown && this.$backdrop) { + this.$backdrop.removeClass('in'); + + $.support.transition && this.$element.hasClass('fade') ? this.$backdrop.one($.support.transition.end, callback).emulateTransitionEnd(150) : callback(); + } else if (callback) { + callback(); + } + }; + + // MODAL PLUGIN DEFINITION + // ======================= + + var old = $.fn.modal; + + $.fn.modal = function (option, _relatedTarget) { + return this.each(function () { + var $this = $(this); + var data = $this.data('bs.modal'); + var options = $.extend({}, Modal.DEFAULTS, $this.data(), (typeof option === 'undefined' ? 'undefined' : _typeof(option)) == 'object' && option); + + if (!data) $this.data('bs.modal', data = new Modal(this, options)); + if (typeof option == 'string') data[option](_relatedTarget);else if (options.show) data.show(_relatedTarget); + }); + }; + + $.fn.modal.Constructor = Modal; + + // MODAL NO CONFLICT + // ================= + + $.fn.modal.noConflict = function () { + $.fn.modal = old; + return this; + }; + + // MODAL DATA-API + // ============== + + $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) { + var $this = $(this); + var href = $this.attr('href'); + var $target = $(_.escape($this.attr('data-target') || href && href.replace(/.*(?=#[^\s]+$)/, ''))); //strip for ie7 + var option = $target.data('modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data()); + + e.preventDefault(); + + $target.modal(option, this).one('hide', function () { + $this.is(':visible') && $this.trigger('focus'); + }); + }); + + $(document).on('show.bs.modal', '.modal', function () { + $(document.body).addClass('modal-open'); + }).on('hidden.bs.modal', '.modal', function () { + $(document.body).removeClass('modal-open'); + }); + + module.exports = Modal; + + },{"jquery":416,"lodash":418}],60:[function(require,module,exports){ + /* ======================================================================== + * Bootstrap: popover.js v3.0.0 + * http://twbs.github.com/bootstrap/javascript.html#popovers + * ======================================================================== + * Copyright 2012 Twitter, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ======================================================================== */ + + 'use strict'; + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + + var $ = require('jquery'), + tooltips = require('./tooltip'); + + // POPOVER PUBLIC CLASS DEFINITION + // =============================== + + var Popover = function Popover(element, options) { + this.init('popover', element, options); + }; + + if (!$.fn.tooltips) throw new Error('Popover requires tooltips.js'); + + Popover.DEFAULTS = $.extend({}, $.fn.tooltips.Constructor.DEFAULTS, { + placement: 'right', + trigger: 'click', + content: '', + template: '

    ' + }); + + // NOTE: POPOVER EXTENDS tooltip.js + // ================================ + + Popover.prototype = $.extend({}, $.fn.tooltips.Constructor.prototype); + + Popover.prototype.constructor = Popover; + + Popover.prototype.getDefaults = function () { + return Popover.DEFAULTS; + }; + + Popover.prototype.setContent = function () { + var $tip = this.tip(); + var title = this.getTitle(); + var content = this.getContent(); + + $tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title); + $tip.find('.popover-content')[this.options.html ? 'html' : 'text'](content); + + $tip.removeClass('fade top bottom left right in'); + + $tip.find('.popover-title:empty').hide(); + }; + + Popover.prototype.hasContent = function () { + return this.getTitle() || this.getContent(); + }; + + Popover.prototype.getContent = function () { + var $e = this.$element; + var o = this.options; + + return $e.attr('data-content') || (typeof o.content == 'function' ? o.content.call($e[0]) : o.content); + }; + + Popover.prototype.arrow = function () { + return this.$arrow = this.$arrow || this.tip().find('.arrow'); + }; + + Popover.prototype.tip = function () { + if (!this.$tip) this.$tip = $(this.options.template); + return this.$tip; + }; + + // POPOVER PLUGIN DEFINITION + // ========================= + + var old = $.fn.popover; + + $.fn.popover = function (option) { + return this.each(function () { + var $this = $(this); + var data = $this.data('bs.popover'); + var options = (typeof option === 'undefined' ? 'undefined' : _typeof(option)) == 'object' && option; + + if (!data) $this.data('bs.popover', data = new Popover(this, options)); + if (typeof option == 'string') data[option](); + }); + }; + + $.fn.popover.Constructor = Popover; + + // POPOVER NO CONFLICT + // =================== + + $.fn.popover.noConflict = function () { + $.fn.popover = old; + return this; + }; + + $(document).ready(function () { + $('[data-toggle="popover"], [rel="clickover"]').on('click', function (e) { + e.preventDefault(); + }).popover(); + }); + + $(document).on('click', function (e) { + var $target = $(e.target); + + // Ignore popover and clickover triggers and children + if ($target.attr('data-toggle') === 'popover' || $target.parent().attr('data-toggle') === 'popover' || $target.attr('rel') === 'clickover') { + return; + } + + $('[data-toggle="popover"][data-autoclose="true"], [rel="clickover"]').each(function () { + var $this = $(this), + $bsPopover = $this.popover('hide').data('bs.popover'); + + if ($bsPopover !== undefined && $bsPopover.inState) { + $bsPopover.click = false; + } + }); + }); + + module.exports = Popover; + + },{"./tooltip":62,"jquery":416}],61:[function(require,module,exports){ + /* ======================================================================== + * Bootstrap: tab.js v3.0.0 + * http://twbs.github.com/bootstrap/javascript.html#tabs + * ======================================================================== + * Copyright 2012 Twitter, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ======================================================================== */ + + "use strict"; + + var $ = require('jquery'), + _ = require('lodash'); + + // TAB CLASS DEFINITION + // ==================== + + var Tab = function Tab(element) { + this.element = $(element); + }; + + Tab.prototype.show = function () { + var $this = this.element; + var $ul = $this.closest('ul:not(.dropdown-menu)'); + var selector = $this.attr('data-target'); + + if (!selector) { + selector = $this.attr('href'); + selector = selector && selector.replace(/.*(?=#[^\s]*$)/, ''); //strip for ie7 + } + + if ($this.parent('li').hasClass('is-active')) return; + + var previous = $ul.find('.is-active:last a')[0]; + var e = $.Event('show.bs.tab', { + relatedTarget: previous + }); + + $this.trigger(e); + + if (e.isDefaultPrevented()) return; + + var $target = $(_.escape(selector)); + + // If we have sub-tabs, selecting the parent should activate and highlight the first one + if (!$target.length) { + var firstTab = $('li > a', $this.parent()); + if ($(firstTab).attr('href').substring(0, 1) === "#") { + firstTab.parent().removeClass('is-active').first().addClass('is-active'); + $target = $($(firstTab).attr('href')); + } + } + + this.activate($this.parent('li'), $ul); + this.activate($target, $target.parent(), function () { + $this.trigger({ + type: 'shown.bs.tab', + relatedTarget: previous + }); + }); + + $('.tab__pane').css('min-height', $('.tabs__list').height()); + }; + + Tab.prototype.activate = function (element, container, callback) { + var $active = container.find('> .is-active'); + var transition = callback && $.support.transition && $active.hasClass('fade'); + + function next() { + $active.removeClass('is-active').find('> .dropdown-menu > .is-active').removeClass('is-active'); + + element.addClass('is-active'); + + if (transition) { + element[0].offsetWidth; // reflow for transition + element.addClass('in'); + } else { + element.removeClass('fade'); + } + + if (element.parent('.dropdown-menu')) { + element.closest('li.dropdown').addClass('is-active'); + } + + callback && callback(); + } + + transition ? $active.one($.support.transition.end, next).emulateTransitionEnd(150) : next(); + + $active.removeClass('in'); + }; + + // TAB PLUGIN DEFINITION + // ===================== + + var old = $.fn.tab; + + $.fn.tab = function (option) { + return this.each(function () { + var $this = $(this); + var data = $this.data('bs.tab'); + + if (!data) $this.data('bs.tab', data = new Tab(this)); + if (typeof option == 'string') data[option](); + }); + }; + + $.fn.tab.Constructor = Tab; + + // TAB NO CONFLICT + // =============== + + $.fn.tab.noConflict = function () { + $.fn.tab = old; + return this; + }; + + // TAB DATA-API + // ============ + + $(document).on('click.bs.tab.data-api', '[data-toggle="tab"]:not(.disabled), [data-toggle="pill"]', function (e) { + e.preventDefault(); + + var $this = $(this), + target = $this.attr('href'); + + $this.tab('show'); + + $('.tabs__list a:not([href="' + target + '"])').parent().removeClass('is-active'); + + if ($(this).closest('.tabs__list').length) { + $this.parent().addClass('is-active'); + } else { + $('.tabs__list a[href="' + target + '"]').parent().addClass('is-active'); + } + }); + + module.exports = Tab; + + },{"jquery":416,"lodash":418}],62:[function(require,module,exports){ + /* ======================================================================== + * Bootstrap: tooltip.js v3.1.1 + * http://getbootstrap.com/javascript/#tooltips + * Inspired by the original jQuery.tipsy by Jason Frame + * ======================================================================== + * Copyright 2011-2014 Twitter, Inc. + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) + * + * NOTE: tooltip namespace has been changed to 'tooltips' to resolve a conflict + * with jQueryUI + * ======================================================================== */ + + "use strict"; + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + + var $ = require('jquery'), + _ = require('lodash'); + + // TOOLTIPS PUBLIC CLASS DEFINITION + // =============================== + + var Tooltips = function Tooltips(element, options) { + this.type = this.options = this.enabled = this.timeout = this.hoverState = this.$element = null; + + this.init('tooltips', element, options); + }; + + Tooltips.DEFAULTS = { + animation: true, + placement: 'top', + selector: false, + template: '', + trigger: 'hover focus', + title: '', + delay: 0, + html: false, + container: false, + viewport: { + selector: 'body', + padding: 0 + } + }; + + Tooltips.prototype.init = function (type, element, options) { + this.enabled = true; + this.type = type; + this.$element = $(element); + this.options = this.getOptions(options); + this.$viewport = this.options.viewport && $.find(this.options.viewport.selector || this.options.viewport); + + var triggers = this.options.trigger.split(' '); + + for (var i = triggers.length; i--;) { + var trigger = triggers[i]; + + if (trigger == 'click') { + this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this)); + } else if (trigger != 'manual') { + var eventIn = trigger == 'hover' ? 'mouseenter' : 'focusin'; + var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'; + + this.$element.on(eventIn + '.' + this.type, this.options.selector, $.proxy(this.enter, this)); + this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this)); + } + } + + this.options.selector ? this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' }) : this.fixTitle(); + }; + + Tooltips.prototype.getDefaults = function () { + return Tooltips.DEFAULTS; + }; + + Tooltips.prototype.getOptions = function (options) { + options = $.extend({}, this.getDefaults(), this.$element.data(), options); + + if (options.delay && typeof options.delay == 'number') { + options.delay = { + show: options.delay, + hide: options.delay + }; + } + + return options; + }; + + Tooltips.prototype.getDelegateOptions = function () { + var options = {}; + var defaults = this.getDefaults(); + + this._options && $.each(this._options, function (key, value) { + if (defaults[key] != value) options[key] = value; + }); + + return options; + }; + + Tooltips.prototype.enter = function (obj) { + var self = obj instanceof this.constructor ? obj : $(obj.currentTarget)[this.type](this.getDelegateOptions()).data('bs.' + this.type); + + clearTimeout(self.timeout); + + self.hoverState = 'in'; + + if (!self.options.delay || !self.options.delay.show) return self.show(); + + self.timeout = setTimeout(function () { + if (self.hoverState == 'in') self.show(); + }, self.options.delay.show); + }; + + Tooltips.prototype.leave = function (obj) { + var self = obj instanceof this.constructor ? obj : $(obj.currentTarget)[this.type](this.getDelegateOptions()).data('bs.' + this.type); + + clearTimeout(self.timeout); + + self.hoverState = 'out'; + + if (!self.options.delay || !self.options.delay.hide) return self.hide(); + + self.timeout = setTimeout(function () { + if (self.hoverState == 'out') self.hide(); + }, self.options.delay.hide); + }; + + Tooltips.prototype.show = function () { + var e = $.Event('show.bs.' + this.type); + + if (this.hasContent() && this.enabled) { + this.$element.trigger(e); + + if (e.isDefaultPrevented()) return; + var that = this; + + var $tip = this.tip(); + + this.setContent(); + + if (this.options.animation) $tip.addClass('fade'); + + var placement = typeof this.options.placement == 'function' ? this.options.placement.call(this, $tip[0], this.$element[0]) : this.options.placement; + + var autoToken = /\s?auto?\s?/i; + var autoPlace = autoToken.test(placement); + if (autoPlace) placement = placement.replace(autoToken, '') || 'top'; + + $tip.detach().css({ top: 0, left: 0, display: 'block' }).addClass(placement); + + this.options.container ? $tip.appendTo($.find(this.options.container)) : $tip.insertAfter(this.$element); + + var pos = this.getPosition(); + var actualWidth = $tip[0].offsetWidth; + var actualHeight = $tip[0].offsetHeight; + + if (autoPlace) { + var orgPlacement = placement; + var $parent = this.$element.parent(); + var parentDim = this.getPosition($parent); + + placement = placement == 'bottom' && pos.top + pos.height + actualHeight - parentDim.scroll > parentDim.height ? 'top' : placement == 'top' && pos.top - parentDim.scroll - actualHeight < 0 ? 'bottom' : placement == 'right' && pos.right + actualWidth > parentDim.width ? 'left' : placement == 'left' && pos.left - actualWidth < parentDim.left ? 'right' : placement; + + $tip.removeClass(orgPlacement).addClass(placement); + } + + var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight); + + this.applyPlacement(calculatedOffset, placement); + this.hoverState = null; + + var complete = function complete() { + that.$element.trigger('shown.bs.' + that.type); + }; + + $.support.transition && this.$tip.hasClass('fade') ? $tip.one($.support.transition.end, complete).emulateTransitionEnd(150) : complete(); + } + }; + + Tooltips.prototype.applyPlacement = function (offset, placement) { + var $tip = this.tip(); + var width = $tip[0].offsetWidth; + var height = $tip[0].offsetHeight; + + // manually read margins because getBoundingClientRect includes difference + var marginTop = parseInt($tip.css('margin-top'), 10); + var marginLeft = parseInt($tip.css('margin-left'), 10); + + // we must check for NaN for ie 8/9 + if (isNaN(marginTop)) marginTop = 0; + if (isNaN(marginLeft)) marginLeft = 0; + + offset.top = offset.top + marginTop; + offset.left = offset.left + marginLeft; + + // $.fn.offset doesn't round pixel values + // so we use setOffset directly with our own function B-0 + $.offset.setOffset($tip[0], $.extend({ + using: function using(props) { + $tip.css({ + top: Math.round(props.top), + left: Math.round(props.left) + }); + } + }, offset), 0); + + $tip.addClass('in'); + + // check to see if placing tip in new offset caused the tip to resize itself + var actualWidth = $tip[0].offsetWidth; + var actualHeight = $tip[0].offsetHeight; + + if (placement == 'top' && actualHeight != height) { + offset.top = offset.top + height - actualHeight; + } + + var delta = this.getViewportAdjustedDelta(placement, offset, actualWidth, actualHeight); + + if (delta.left) offset.left += delta.left;else offset.top += delta.top; + + var arrowDelta = delta.left ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight; + var arrowPosition = delta.left ? 'left' : 'top'; + var arrowOffsetPosition = delta.left ? 'offsetWidth' : 'offsetHeight'; + + $tip.offset(offset); + this.replaceArrow(arrowDelta, $tip[0][arrowOffsetPosition], arrowPosition); + }; + + Tooltips.prototype.replaceArrow = function (delta, dimension, position) { + this.arrow().css(position, delta ? 50 * (1 - delta / dimension) + '%' : ''); + }; + + Tooltips.prototype.setContent = function () { + var $tip = this.tip(); + var title = this.getTitle(); + + $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title); + $tip.removeClass('fade in top bottom left right'); + }; + + Tooltips.prototype.hide = function () { + var that = this; + var $tip = this.tip(); + var e = $.Event('hide.bs.' + this.type); + + function complete() { + if (that.hoverState != 'in') $tip.detach(); + that.$element.trigger('hidden.bs.' + that.type); + } + + this.$element.trigger(e); + + if (e.isDefaultPrevented()) return; + + $tip.removeClass('in'); + + $.support.transition && this.$tip.hasClass('fade') ? $tip.one($.support.transition.end, complete).emulateTransitionEnd(150) : complete(); + + this.hoverState = null; + + return this; + }; + + Tooltips.prototype.fixTitle = function () { + var $e = this.$element; + if ($e.attr('title') || typeof $e.attr('data-original-title') != 'string') { + $e.attr('data-original-title', $e.attr('title') || '').attr('title', ''); + } + }; + + Tooltips.prototype.hasContent = function () { + return this.getTitle(); + }; + + Tooltips.prototype.getPosition = function ($element) { + $element = $element || this.$element; + var el = $element[0]; + var isBody = el.tagName == 'BODY'; + return $.extend({}, typeof el.getBoundingClientRect == 'function' ? el.getBoundingClientRect() : null, { + scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.scrollTop(), + width: isBody ? $(window).width() : $element.outerWidth(), + height: isBody ? $(window).height() : $element.outerHeight() + }, isBody ? { top: 0, left: 0 } : $element.offset()); + }; + + Tooltips.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) { + return placement == 'bottom' ? { top: pos.top + pos.height, left: pos.left + pos.width / 2 - actualWidth / 2 } : placement == 'top' ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2 } : placement == 'left' ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } : + /* placement == 'right' */{ top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width }; + }; + + Tooltips.prototype.getViewportAdjustedDelta = function (placement, pos, actualWidth, actualHeight) { + var delta = { top: 0, left: 0 }; + if (!this.$viewport) return delta; + + var viewportPadding = this.options.viewport && this.options.viewport.padding || 0; + var viewportDimensions = this.getPosition(this.$viewport); + + if (/right|left/.test(placement)) { + var topEdgeOffset = pos.top - viewportPadding - viewportDimensions.scroll; + var bottomEdgeOffset = pos.top + viewportPadding - viewportDimensions.scroll + actualHeight; + if (topEdgeOffset < viewportDimensions.top) { + // top overflow + delta.top = viewportDimensions.top - topEdgeOffset; + } else if (bottomEdgeOffset > viewportDimensions.top + viewportDimensions.height) { + // bottom overflow + delta.top = viewportDimensions.top + viewportDimensions.height - bottomEdgeOffset; + } + } else { + var leftEdgeOffset = pos.left - viewportPadding; + var rightEdgeOffset = pos.left + viewportPadding + actualWidth; + if (leftEdgeOffset < viewportDimensions.left) { + // left overflow + delta.left = viewportDimensions.left - leftEdgeOffset; + } else if (rightEdgeOffset > viewportDimensions.width) { + // right overflow + delta.left = viewportDimensions.left + viewportDimensions.width - rightEdgeOffset; + } + } + + return delta; + }; + + Tooltips.prototype.getTitle = function () { + var title; + var $e = this.$element; + var o = this.options; + + title = $e.attr('data-original-title') || (typeof o.title == 'function' ? o.title.call($e[0]) : o.title); + + return title; + }; + + Tooltips.prototype.tip = function () { + return this.$tip = this.$tip || $(this.options.template); + }; + + Tooltips.prototype.arrow = function () { + return this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow'); + }; + + Tooltips.prototype.validate = function () { + if (!this.$element[0].parentNode) { + this.hide(); + this.$element = null; + this.options = null; + } + }; + + Tooltips.prototype.enable = function () { + this.enabled = true; + }; + + Tooltips.prototype.disable = function () { + this.enabled = false; + }; + + Tooltips.prototype.toggleEnabled = function () { + this.enabled = !this.enabled; + }; + + Tooltips.prototype.toggle = function (e) { + var self = e ? $(e.currentTarget)[this.type](this.getDelegateOptions()).data('bs.' + this.type) : this; + self.tip().hasClass('in') ? self.leave(self) : self.enter(self); + }; + + Tooltips.prototype.destroy = function () { + clearTimeout(this.timeout); + this.hide().$element.off('.' + this.type).removeData('bs.' + this.type); + }; + + // TOOLTIPS PLUGIN DEFINITION + // ========================= + + var old = $.fn.tooltips; + + $.fn.tooltips = function (option) { + return this.each(function () { + var $this = $(this); + var data = $this.data('bs.tooltips'); + var options = (typeof option === 'undefined' ? 'undefined' : _typeof(option)) == 'object' && option; + + if ('ontouchstart' in window) { + return; + } + + if (!data && option == 'destroy') return; + if (!data) $this.data('bs.tooltips', data = new Tooltips(this, options)); + if (typeof option == 'string') data[option](); + }); + }; + + $.fn.tooltips.Constructor = Tooltips; + + // TOOLTIPS NO CONFLICT + // =================== + + $.fn.tooltips.noConflict = function () { + $.fn.tooltips = old; + return this; + }; + + $(document).ready(function () { + $('[data-toggle="tooltips"]').tooltips(); + }); + + module.exports = Tooltips; + + },{"jquery":416,"lodash":418}],63:[function(require,module,exports){ + 'use strict'; + + /*! matchMedia() polyfill addListener/removeListener extension. Author & copyright (c) 2012: Scott Jehl. Dual MIT/BSD license */ + (function () { + // Bail out for browsers that have addListener support + if (window.matchMedia && window.matchMedia('all').addListener) { + return false; + } + + var localMatchMedia = window.matchMedia, + hasMediaQueries = localMatchMedia('only all').matches, + isListening = false, + timeoutID = 0, + // setTimeout for debouncing 'handleChange' + queries = [], + // Contains each 'mql' and associated 'listeners' if 'addListener' is used + handleChange = function handleChange(evt) { + // Debounce + clearTimeout(timeoutID); + + timeoutID = setTimeout(function () { + for (var i = 0, il = queries.length; i < il; i++) { + var mql = queries[i].mql, + listeners = queries[i].listeners || [], + matches = localMatchMedia(mql.media).matches; + + // Update mql.matches value and call listeners + // Fire listeners only if transitioning to or from matched state + if (matches !== mql.matches) { + mql.matches = matches; + + for (var j = 0, jl = listeners.length; j < jl; j++) { + listeners[j].call(window, mql); + } + } + } + }, 30); + }; + + window.matchMedia = function (media) { + var mql = localMatchMedia(media), + listeners = [], + index = 0; + + mql.addListener = function (listener) { + // Changes would not occur to css media type so return now (Affects IE <= 8) + if (!hasMediaQueries) { + return; + } + + // Set up 'resize' listener for browsers that support CSS3 media queries (Not for IE <= 8) + // There should only ever be 1 resize listener running for performance + if (!isListening) { + isListening = true; + window.addEventListener('resize', handleChange, true); + } + + // Push object only if it has not been pushed already + if (index === 0) { + index = queries.push({ + mql: mql, + listeners: listeners + }); + } + + listeners.push(listener); + }; + + mql.removeListener = function (listener) { + for (var i = 0, il = listeners.length; i < il; i++) { + if (listeners[i] === listener) { + listeners.splice(i, 1); + } + } + }; + + return mql; + }; + })(); + + },{}],64:[function(require,module,exports){ + 'use strict'; + + /*! matchMedia() polyfill - Test a CSS media type/query in JS. Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas, David Knight. Dual MIT/BSD license */ + + window.matchMedia || (window.matchMedia = function () { + "use strict"; + + // For browsers that support matchMedium api such as IE 9 and webkit + + var styleMedia = window.styleMedia || window.media; + + // For those that don't support matchMedium + if (!styleMedia) { + var style = document.createElement('style'), + script = document.getElementsByTagName('script')[0], + info = null; + + style.type = 'text/css'; + style.id = 'matchmediajs-test'; + + script.parentNode.insertBefore(style, script); + + // 'style.currentStyle' is used by IE <= 8 and 'window.getComputedStyle' for all other browsers + info = 'getComputedStyle' in window && window.getComputedStyle(style, null) || style.currentStyle; + + styleMedia = { + matchMedium: function matchMedium(media) { + var text = '@media ' + media + '{ #matchmediajs-test { width: 1px; } }'; + + // 'style.styleSheet' is used by IE <= 8 and 'style.textContent' for all other browsers + if (style.styleSheet) { + style.styleSheet.cssText = text; + } else { + style.textContent = text; + } + + // Test if media query is true or false + return info.width === '1px'; + } + }; + } + + return function (media) { + return { + matches: styleMedia.matchMedium(media || 'all'), + media: media || 'all' + }; + }; + }()); + + },{}],65:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require('jquery'); + + var ActiveFunctionService = function () { + function ActiveFunctionService() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + _ref$disabled = _ref.disabled, + disabled = _ref$disabled === undefined ? 'disabled' : _ref$disabled; + + _classCallCheck(this, ActiveFunctionService); + + this.disabled = disabled; + } + + /** + * Conditionally invoke a function if an element is active + * @param element + * @param func + * @param event + */ + + + _createClass(ActiveFunctionService, [{ + key: 'wrap', + value: function wrap(element, func, event) { + if (!$(element).hasClass(this.disabled)) { + func(event); + } + } + }]); + + return ActiveFunctionService; + }(); + + module.exports = ActiveFunctionService; + + },{"jquery":416}],66:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var $ = require('jquery'); + + var FormFieldResetService = function () { + function FormFieldResetService() { + _classCallCheck(this, FormFieldResetService); + } + + _createClass(FormFieldResetService, [{ + key: 'reset', + + /** + * A "catch-all" method for resetting form fields + * wrap the root element in a form and trigger a reset event + * this should catch a lot of inconsistency with IE & file inputs + * @param root + */ + value: function reset(root) { + var $root = $(root); + var $select2 = $root.find('.js-select2'); + var $tempFormWrapper = $root.wrap('
    ').closest('form'); + + $tempFormWrapper.trigger('reset'); + $root.unwrap($tempFormWrapper); + + // Trigger a change for select2 enabled inputs + if ($select2.length) { + $select2.each(function (index, element) { + $(element).change(); + }); + } + } + }]); + + return FormFieldResetService; + }(); + + module.exports = FormFieldResetService; + + },{"jquery":416}],67:[function(require,module,exports){ + "use strict"; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var HashService = function () { + /** + * Hash Service + * @param date {DateConstructor} + */ + function HashService(date) { + _classCallCheck(this, HashService); + + this.hashCache = []; + this.date = date; + } + + /** + * The most basic pseudo random hash generator, by all means + * make this more sophisticated, just ensure the final value is a string + * @param {string} value + * @returns {string} + */ + + + _createClass(HashService, [{ + key: "generate", + value: function generate(value) { + var hash = this.date.now(); + + // Increment our numeric hash if it exists in the hash cache + while (this.hashCache.indexOf(value + "_" + hash) !== -1) { + hash++; + } + + // Add our hash to the cache + this.hashCache.push(value + "_" + hash); + + return value + "_" + hash; + } + }]); + + return HashService; + }(); + + module.exports = HashService; + + },{}],68:[function(require,module,exports){ + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var UniqueIdService = function () { + /** + * UniqueIDService + * @param hashService {HashService} + */ + function UniqueIdService(hashService) { + _classCallCheck(this, UniqueIdService); + + this.hashService = hashService; + } + + /** + * Find elements within a scope that have a "for" attribute, then find corresponding + * element with ID, then replace both attributes with a unique-ish ID + * @param root {HTMLElement} + */ + + + _createClass(UniqueIdService, [{ + key: 'uniquifyFors', + value: function uniquifyFors(root) { + var _this = this; + + [].slice.call(root.querySelectorAll('[for]')).forEach(function (forElement) { + var forAttribute = forElement.getAttribute('for'); + var target = root.querySelector('#' + forAttribute); + var hash = _this.hashService.generate(forAttribute); + + if (target) { + forElement.setAttribute('for', hash); + target.setAttribute('id', hash); + } + }); + } + + /** + * Find elements within a scope and replace their ID attribute + * with a unique-ish representation + * @param root {HTMLElement} + */ + + }, { + key: 'uniquifyIds', + value: function uniquifyIds(root) { + var _this2 = this; + + [].slice.call(root.querySelectorAll('[id]')).forEach(function (element) { + var id = element.getAttribute('id'); + var hash = _this2.hashService.generate(id); + + element.setAttribute('id', hash); + }); + } + + /** + * Update selectWoo child elements with unique IDs + * @param group {HTMLElement} + */ + + }, { + key: 'uniquifySelectWoo', + value: function uniquifySelectWoo(group) { + var originalSelect = group.querySelector('select.js-select2'); + + if (originalSelect === null) { + return; + } + + var originalSelectId = originalSelect.getAttribute('id'); + + [].slice.call(group.querySelectorAll('.select2-container')).forEach(function (select2Container) { + if (select2Container.querySelector('.select2-selection--multiple') !== null) { + var selectWooSummary = select2Container.querySelector('.select2-selections'); + var selectWooSearch = select2Container.querySelector('.select2-search__field'); + var newSelectWooSummaryId = 'select2-' + originalSelectId + '-summary'; + + selectWooSummary.setAttribute('id', newSelectWooSummaryId); + selectWooSearch.setAttribute('aria-describedby', newSelectWooSummaryId); + } + + if (select2Container.querySelector('.select2-selection--single') !== null) { + var selectWooSingleSelection = select2Container.querySelector('.select2-selection--single'); + var selectWooSingleSelectionRendered = select2Container.querySelector('.select2-selection__rendered'); + var newSelectWooSingleSelectionRenderedId = 'select2-' + originalSelectId + '-container'; + + selectWooSingleSelectionRendered.setAttribute('id', newSelectWooSingleSelectionRenderedId); + selectWooSingleSelection.setAttribute('aria-controls', newSelectWooSingleSelectionRenderedId); + selectWooSingleSelection.setAttribute('aria-owns', newSelectWooSingleSelectionRenderedId); + } + }); + } + }]); + + return UniqueIdService; + }(); + + module.exports = UniqueIdService; + + },{}],69:[function(require,module,exports){ + 'use strict'; + + /** + * Get a file extension from a string + * @param file {string} + * @returns {boolean} + */ + function getFileExtension(file) { + var ext = file.split('.'); + + // extensions that are not files, you shall not pass. (unless you are a data encoded URL) + if (ext.length < 2) { + // extract mime from data encoded string + var _re = new RegExp(/^data:image\/([a-z\-]+)/, 'i'); + var _test = _re.exec(file); + + return _test !== null && _test[1] !== undefined ? _test[1] : false; + } + + // strip query strings from our extension + var re = new RegExp(/^[a-z0-9\-]+/, 'i'); + var test = re.exec(ext.pop()); + + // return false for anything we deem not to be a file + return test !== null && test[0] !== undefined ? test[0] : false; + } + + /** + * A higher order function responsible for creating file extension + * filter functions based on inclusion + * @param inclusive {boolean} + * @param getExt {function} + * @returns {function} + */ + function filterByFileExtensionFactory(inclusive, getExt) { + return function (list, file) { + var ext = getExt(file); + + // Return a falsy value if we do not have a file + if (!ext) { + return false; + } + + // return a boolean based on presence in the list + // and the inclusion/exclusion option + return list.indexOf(getExt(file)) !== -1 === inclusive; + }; + } + + /** + * A higher order function to create a filter + * to identify data encoded images + * @param inclusive {boolean} + * @returns {function} + */ + function filterByDataEncodedURIFactory(inclusive) { + return function (str) { + // check for strings starting with 'data:' + var re = new RegExp(/^data:/); + var test = re.exec(str); + + // return a boolean based on inclusion + return (test !== null && test[0] !== undefined) === inclusive; + }; + } + + /** + * Filter a file list by extensions + * @param list {Array} + * @param extension {string} a space separated extension list + * @param inclusive? {boolean} + * @returns {Array} + */ + var filterFileExtensionList = function filterFileExtensionList(list, extension) { + var inclusive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + + // create filter function + var fileFilter = filterByFileExtensionFactory(inclusive, getFileExtension); + // split extension list argument and filter + return list.filter(fileFilter.bind(null, extension.split(' '))); + }; + + /** + * Filter a single file string by extensions + * @param file {string} + * @param extension {string} a space separated extension list + * @param inclusive? {boolean} + * @returns {boolean} + */ + var filterFileExtension = function filterFileExtension(file, extension) { + var inclusive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + + return filterByFileExtensionFactory(inclusive, getFileExtension)(extension.split(' '), file); + }; + + /** + * Filter a list of strings by data URI images + * @param list {Array} + * @param inclusive {boolean} + * @returns {Array} + */ + var filterDataEncodedURIList = function filterDataEncodedURIList(list) { + var inclusive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + + return list.filter(filterByDataEncodedURIFactory(inclusive)); + }; + + /** + * Filter a list of strings by data URI images + * @param str {string} + * @param inclusive {boolean} + * @returns {boolean} + */ + var filterDataEncodedURI = function filterDataEncodedURI(str) { + var inclusive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + + return filterByDataEncodedURIFactory(inclusive)(str); + }; + + module.exports = { + filterFileExtensionList: filterFileExtensionList, + filterFileExtension: filterFileExtension, + filterDataEncodedURIList: filterDataEncodedURIList, + filterDataEncodedURI: filterDataEncodedURI, + getFileExtension: getFileExtension + }; + + },{}],70:[function(require,module,exports){ + (function (global){(function (){ + "use strict"; + + require("core-js/shim"); + + require("regenerator-runtime/runtime"); + + require("core-js/fn/regexp/escape"); + + if (global._babelPolyfill) { + throw new Error("only one instance of babel-polyfill is allowed"); + } + global._babelPolyfill = true; + + var DEFINE_PROPERTY = "defineProperty"; + function define(O, key, value) { + O[key] || Object[DEFINE_PROPERTY](O, key, { + writable: true, + configurable: true, + value: value + }); + } + + define(String.prototype, "padLeft", "".padStart); + define(String.prototype, "padRight", "".padEnd); + + "pop,reverse,shift,keys,values,entries,indexOf,every,some,forEach,map,filter,find,findIndex,includes,join,slice,concat,push,splice,unshift,sort,lastIndexOf,reduce,reduceRight,copyWithin,fill".split(",").forEach(function (key) { + [][key] && define(Array, key, Function.call.bind([][key])); + }); + }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + + },{"core-js/fn/regexp/escape":72,"core-js/shim":400,"regenerator-runtime/runtime":71}],71:[function(require,module,exports){ + (function (global){(function (){ + /** + * Copyright (c) 2014, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * https://raw.github.com/facebook/regenerator/master/LICENSE file. An + * additional grant of patent rights can be found in the PATENTS file in + * the same directory. + */ + + !(function(global) { + "use strict"; + + var Op = Object.prototype; + var hasOwn = Op.hasOwnProperty; + var undefined; // More compressible than void 0. + var $Symbol = typeof Symbol === "function" ? Symbol : {}; + var iteratorSymbol = $Symbol.iterator || "@@iterator"; + var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator"; + var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; + + var inModule = typeof module === "object"; + var runtime = global.regeneratorRuntime; + if (runtime) { + if (inModule) { + // If regeneratorRuntime is defined globally and we're in a module, + // make the exports object identical to regeneratorRuntime. + module.exports = runtime; + } + // Don't bother evaluating the rest of this file if the runtime was + // already defined globally. + return; + } + + // Define the runtime globally (as expected by generated code) as either + // module.exports (if we're in a module) or a new, empty object. + runtime = global.regeneratorRuntime = inModule ? module.exports : {}; + + function wrap(innerFn, outerFn, self, tryLocsList) { + // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator. + var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; + var generator = Object.create(protoGenerator.prototype); + var context = new Context(tryLocsList || []); + + // The ._invoke method unifies the implementations of the .next, + // .throw, and .return methods. + generator._invoke = makeInvokeMethod(innerFn, self, context); + + return generator; + } + runtime.wrap = wrap; + + // Try/catch helper to minimize deoptimizations. Returns a completion + // record like context.tryEntries[i].completion. This interface could + // have been (and was previously) designed to take a closure to be + // invoked without arguments, but in all the cases we care about we + // already have an existing method we want to call, so there's no need + // to create a new function object. We can even get away with assuming + // the method takes exactly one argument, since that happens to be true + // in every case, so we don't have to touch the arguments object. The + // only additional allocation required is the completion record, which + // has a stable shape and so hopefully should be cheap to allocate. + function tryCatch(fn, obj, arg) { + try { + return { type: "normal", arg: fn.call(obj, arg) }; + } catch (err) { + return { type: "throw", arg: err }; + } + } + + var GenStateSuspendedStart = "suspendedStart"; + var GenStateSuspendedYield = "suspendedYield"; + var GenStateExecuting = "executing"; + var GenStateCompleted = "completed"; + + // Returning this object from the innerFn has the same effect as + // breaking out of the dispatch switch statement. + var ContinueSentinel = {}; + + // Dummy constructor functions that we use as the .constructor and + // .constructor.prototype properties for functions that return Generator + // objects. For full spec compliance, you may wish to configure your + // minifier not to mangle the names of these two functions. + function Generator() {} + function GeneratorFunction() {} + function GeneratorFunctionPrototype() {} + + // This is a polyfill for %IteratorPrototype% for environments that + // don't natively support it. + var IteratorPrototype = {}; + IteratorPrototype[iteratorSymbol] = function () { + return this; + }; + + var getProto = Object.getPrototypeOf; + var NativeIteratorPrototype = getProto && getProto(getProto(values([]))); + if (NativeIteratorPrototype && + NativeIteratorPrototype !== Op && + hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) { + // This environment has a native %IteratorPrototype%; use it instead + // of the polyfill. + IteratorPrototype = NativeIteratorPrototype; + } + + var Gp = GeneratorFunctionPrototype.prototype = + Generator.prototype = Object.create(IteratorPrototype); + GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; + GeneratorFunctionPrototype.constructor = GeneratorFunction; + GeneratorFunctionPrototype[toStringTagSymbol] = + GeneratorFunction.displayName = "GeneratorFunction"; + + // Helper for defining the .next, .throw, and .return methods of the + // Iterator interface in terms of a single ._invoke method. + function defineIteratorMethods(prototype) { + ["next", "throw", "return"].forEach(function(method) { + prototype[method] = function(arg) { + return this._invoke(method, arg); + }; + }); + } + + runtime.isGeneratorFunction = function(genFun) { + var ctor = typeof genFun === "function" && genFun.constructor; + return ctor + ? ctor === GeneratorFunction || + // For the native GeneratorFunction constructor, the best we can + // do is to check its .name property. + (ctor.displayName || ctor.name) === "GeneratorFunction" + : false; + }; + + runtime.mark = function(genFun) { + if (Object.setPrototypeOf) { + Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); + } else { + genFun.__proto__ = GeneratorFunctionPrototype; + if (!(toStringTagSymbol in genFun)) { + genFun[toStringTagSymbol] = "GeneratorFunction"; + } + } + genFun.prototype = Object.create(Gp); + return genFun; + }; + + // Within the body of any async function, `await x` is transformed to + // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test + // `hasOwn.call(value, "__await")` to determine if the yielded value is + // meant to be awaited. + runtime.awrap = function(arg) { + return { __await: arg }; + }; + + function AsyncIterator(generator) { + function invoke(method, arg, resolve, reject) { + var record = tryCatch(generator[method], generator, arg); + if (record.type === "throw") { + reject(record.arg); + } else { + var result = record.arg; + var value = result.value; + if (value && + typeof value === "object" && + hasOwn.call(value, "__await")) { + return Promise.resolve(value.__await).then(function(value) { + invoke("next", value, resolve, reject); + }, function(err) { + invoke("throw", err, resolve, reject); + }); + } + + return Promise.resolve(value).then(function(unwrapped) { + // When a yielded Promise is resolved, its final value becomes + // the .value of the Promise<{value,done}> result for the + // current iteration. If the Promise is rejected, however, the + // result for this iteration will be rejected with the same + // reason. Note that rejections of yielded Promises are not + // thrown back into the generator function, as is the case + // when an awaited Promise is rejected. This difference in + // behavior between yield and await is important, because it + // allows the consumer to decide what to do with the yielded + // rejection (swallow it and continue, manually .throw it back + // into the generator, abandon iteration, whatever). With + // await, by contrast, there is no opportunity to examine the + // rejection reason outside the generator function, so the + // only option is to throw it from the await expression, and + // let the generator function handle the exception. + result.value = unwrapped; + resolve(result); + }, reject); + } + } + + if (typeof global.process === "object" && global.process.domain) { + invoke = global.process.domain.bind(invoke); + } + + var previousPromise; + + function enqueue(method, arg) { + function callInvokeWithMethodAndArg() { + return new Promise(function(resolve, reject) { + invoke(method, arg, resolve, reject); + }); + } + + return previousPromise = + // If enqueue has been called before, then we want to wait until + // all previous Promises have been resolved before calling invoke, + // so that results are always delivered in the correct order. If + // enqueue has not been called before, then it is important to + // call invoke immediately, without waiting on a callback to fire, + // so that the async generator function has the opportunity to do + // any necessary setup in a predictable way. This predictability + // is why the Promise constructor synchronously invokes its + // executor callback, and why async functions synchronously + // execute code before the first await. Since we implement simple + // async functions in terms of async generators, it is especially + // important to get this right, even though it requires care. + previousPromise ? previousPromise.then( + callInvokeWithMethodAndArg, + // Avoid propagating failures to Promises returned by later + // invocations of the iterator. + callInvokeWithMethodAndArg + ) : callInvokeWithMethodAndArg(); + } + + // Define the unified helper method that is used to implement .next, + // .throw, and .return (see defineIteratorMethods). + this._invoke = enqueue; + } + + defineIteratorMethods(AsyncIterator.prototype); + AsyncIterator.prototype[asyncIteratorSymbol] = function () { + return this; + }; + runtime.AsyncIterator = AsyncIterator; + + // Note that simple async functions are implemented on top of + // AsyncIterator objects; they just return a Promise for the value of + // the final result produced by the iterator. + runtime.async = function(innerFn, outerFn, self, tryLocsList) { + var iter = new AsyncIterator( + wrap(innerFn, outerFn, self, tryLocsList) + ); + + return runtime.isGeneratorFunction(outerFn) + ? iter // If outerFn is a generator, return the full iterator. + : iter.next().then(function(result) { + return result.done ? result.value : iter.next(); + }); + }; + + function makeInvokeMethod(innerFn, self, context) { + var state = GenStateSuspendedStart; + + return function invoke(method, arg) { + if (state === GenStateExecuting) { + throw new Error("Generator is already running"); + } + + if (state === GenStateCompleted) { + if (method === "throw") { + throw arg; + } + + // Be forgiving, per 25.3.3.3.3 of the spec: + // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume + return doneResult(); + } + + context.method = method; + context.arg = arg; + + while (true) { + var delegate = context.delegate; + if (delegate) { + var delegateResult = maybeInvokeDelegate(delegate, context); + if (delegateResult) { + if (delegateResult === ContinueSentinel) continue; + return delegateResult; + } + } + + if (context.method === "next") { + // Setting context._sent for legacy support of Babel's + // function.sent implementation. + context.sent = context._sent = context.arg; + + } else if (context.method === "throw") { + if (state === GenStateSuspendedStart) { + state = GenStateCompleted; + throw context.arg; + } + + context.dispatchException(context.arg); + + } else if (context.method === "return") { + context.abrupt("return", context.arg); + } + + state = GenStateExecuting; + + var record = tryCatch(innerFn, self, context); + if (record.type === "normal") { + // If an exception is thrown from innerFn, we leave state === + // GenStateExecuting and loop back for another invocation. + state = context.done + ? GenStateCompleted + : GenStateSuspendedYield; + + if (record.arg === ContinueSentinel) { + continue; + } + + return { + value: record.arg, + done: context.done + }; + + } else if (record.type === "throw") { + state = GenStateCompleted; + // Dispatch the exception by looping back around to the + // context.dispatchException(context.arg) call above. + context.method = "throw"; + context.arg = record.arg; + } + } + }; + } + + // Call delegate.iterator[context.method](context.arg) and handle the + // result, either by returning a { value, done } result from the + // delegate iterator, or by modifying context.method and context.arg, + // setting context.delegate to null, and returning the ContinueSentinel. + function maybeInvokeDelegate(delegate, context) { + var method = delegate.iterator[context.method]; + if (method === undefined) { + // A .throw or .return when the delegate iterator has no .throw + // method always terminates the yield* loop. + context.delegate = null; + + if (context.method === "throw") { + if (delegate.iterator.return) { + // If the delegate iterator has a return method, give it a + // chance to clean up. + context.method = "return"; + context.arg = undefined; + maybeInvokeDelegate(delegate, context); + + if (context.method === "throw") { + // If maybeInvokeDelegate(context) changed context.method from + // "return" to "throw", let that override the TypeError below. + return ContinueSentinel; + } + } + + context.method = "throw"; + context.arg = new TypeError( + "The iterator does not provide a 'throw' method"); + } + + return ContinueSentinel; + } + + var record = tryCatch(method, delegate.iterator, context.arg); + + if (record.type === "throw") { + context.method = "throw"; + context.arg = record.arg; + context.delegate = null; + return ContinueSentinel; + } + + var info = record.arg; + + if (! info) { + context.method = "throw"; + context.arg = new TypeError("iterator result is not an object"); + context.delegate = null; + return ContinueSentinel; + } + + if (info.done) { + // Assign the result of the finished delegate to the temporary + // variable specified by delegate.resultName (see delegateYield). + context[delegate.resultName] = info.value; + + // Resume execution at the desired location (see delegateYield). + context.next = delegate.nextLoc; + + // If context.method was "throw" but the delegate handled the + // exception, let the outer generator proceed normally. If + // context.method was "next", forget context.arg since it has been + // "consumed" by the delegate iterator. If context.method was + // "return", allow the original .return call to continue in the + // outer generator. + if (context.method !== "return") { + context.method = "next"; + context.arg = undefined; + } + + } else { + // Re-yield the result returned by the delegate method. + return info; + } + + // The delegate iterator is finished, so forget it and continue with + // the outer generator. + context.delegate = null; + return ContinueSentinel; + } + + // Define Generator.prototype.{next,throw,return} in terms of the + // unified ._invoke helper method. + defineIteratorMethods(Gp); + + Gp[toStringTagSymbol] = "Generator"; + + // A Generator should always return itself as the iterator object when the + // @@iterator function is called on it. Some browsers' implementations of the + // iterator prototype chain incorrectly implement this, causing the Generator + // object to not be returned from this call. This ensures that doesn't happen. + // See https://github.com/facebook/regenerator/issues/274 for more details. + Gp[iteratorSymbol] = function() { + return this; + }; + + Gp.toString = function() { + return "[object Generator]"; + }; + + function pushTryEntry(locs) { + var entry = { tryLoc: locs[0] }; + + if (1 in locs) { + entry.catchLoc = locs[1]; + } + + if (2 in locs) { + entry.finallyLoc = locs[2]; + entry.afterLoc = locs[3]; + } + + this.tryEntries.push(entry); + } + + function resetTryEntry(entry) { + var record = entry.completion || {}; + record.type = "normal"; + delete record.arg; + entry.completion = record; + } + + function Context(tryLocsList) { + // The root entry object (effectively a try statement without a catch + // or a finally block) gives us a place to store values thrown from + // locations where there is no enclosing try statement. + this.tryEntries = [{ tryLoc: "root" }]; + tryLocsList.forEach(pushTryEntry, this); + this.reset(true); + } + + runtime.keys = function(object) { + var keys = []; + for (var key in object) { + keys.push(key); + } + keys.reverse(); + + // Rather than returning an object with a next method, we keep + // things simple and return the next function itself. + return function next() { + while (keys.length) { + var key = keys.pop(); + if (key in object) { + next.value = key; + next.done = false; + return next; + } + } + + // To avoid creating an additional object, we just hang the .value + // and .done properties off the next function object itself. This + // also ensures that the minifier will not anonymize the function. + next.done = true; + return next; + }; + }; + + function values(iterable) { + if (iterable) { + var iteratorMethod = iterable[iteratorSymbol]; + if (iteratorMethod) { + return iteratorMethod.call(iterable); + } + + if (typeof iterable.next === "function") { + return iterable; + } + + if (!isNaN(iterable.length)) { + var i = -1, next = function next() { + while (++i < iterable.length) { + if (hasOwn.call(iterable, i)) { + next.value = iterable[i]; + next.done = false; + return next; + } + } + + next.value = undefined; + next.done = true; + + return next; + }; + + return next.next = next; + } + } + + // Return an iterator with no values. + return { next: doneResult }; + } + runtime.values = values; + + function doneResult() { + return { value: undefined, done: true }; + } + + Context.prototype = { + constructor: Context, + + reset: function(skipTempReset) { + this.prev = 0; + this.next = 0; + // Resetting context._sent for legacy support of Babel's + // function.sent implementation. + this.sent = this._sent = undefined; + this.done = false; + this.delegate = null; + + this.method = "next"; + this.arg = undefined; + + this.tryEntries.forEach(resetTryEntry); + + if (!skipTempReset) { + for (var name in this) { + // Not sure about the optimal order of these conditions: + if (name.charAt(0) === "t" && + hasOwn.call(this, name) && + !isNaN(+name.slice(1))) { + this[name] = undefined; + } + } + } + }, + + stop: function() { + this.done = true; + + var rootEntry = this.tryEntries[0]; + var rootRecord = rootEntry.completion; + if (rootRecord.type === "throw") { + throw rootRecord.arg; + } + + return this.rval; + }, + + dispatchException: function(exception) { + if (this.done) { + throw exception; + } + + var context = this; + function handle(loc, caught) { + record.type = "throw"; + record.arg = exception; + context.next = loc; + + if (caught) { + // If the dispatched exception was caught by a catch block, + // then let that catch block handle the exception normally. + context.method = "next"; + context.arg = undefined; + } + + return !! caught; + } + + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + var record = entry.completion; + + if (entry.tryLoc === "root") { + // Exception thrown outside of any try block that could handle + // it, so set the completion value of the entire function to + // throw the exception. + return handle("end"); + } + + if (entry.tryLoc <= this.prev) { + var hasCatch = hasOwn.call(entry, "catchLoc"); + var hasFinally = hasOwn.call(entry, "finallyLoc"); + + if (hasCatch && hasFinally) { + if (this.prev < entry.catchLoc) { + return handle(entry.catchLoc, true); + } else if (this.prev < entry.finallyLoc) { + return handle(entry.finallyLoc); + } + + } else if (hasCatch) { + if (this.prev < entry.catchLoc) { + return handle(entry.catchLoc, true); + } + + } else if (hasFinally) { + if (this.prev < entry.finallyLoc) { + return handle(entry.finallyLoc); + } + + } else { + throw new Error("try statement without catch or finally"); + } + } + } + }, + + abrupt: function(type, arg) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.tryLoc <= this.prev && + hasOwn.call(entry, "finallyLoc") && + this.prev < entry.finallyLoc) { + var finallyEntry = entry; + break; + } + } + + if (finallyEntry && + (type === "break" || + type === "continue") && + finallyEntry.tryLoc <= arg && + arg <= finallyEntry.finallyLoc) { + // Ignore the finally entry if control is not jumping to a + // location outside the try/catch block. + finallyEntry = null; + } + + var record = finallyEntry ? finallyEntry.completion : {}; + record.type = type; + record.arg = arg; + + if (finallyEntry) { + this.method = "next"; + this.next = finallyEntry.finallyLoc; + return ContinueSentinel; + } + + return this.complete(record); + }, + + complete: function(record, afterLoc) { + if (record.type === "throw") { + throw record.arg; + } + + if (record.type === "break" || + record.type === "continue") { + this.next = record.arg; + } else if (record.type === "return") { + this.rval = this.arg = record.arg; + this.method = "return"; + this.next = "end"; + } else if (record.type === "normal" && afterLoc) { + this.next = afterLoc; + } + + return ContinueSentinel; + }, + + finish: function(finallyLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.finallyLoc === finallyLoc) { + this.complete(entry.completion, entry.afterLoc); + resetTryEntry(entry); + return ContinueSentinel; + } + } + }, + + "catch": function(tryLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.tryLoc === tryLoc) { + var record = entry.completion; + if (record.type === "throw") { + var thrown = record.arg; + resetTryEntry(entry); + } + return thrown; + } + } + + // The context.catch method must only be called with a location + // argument that corresponds to a known catch block. + throw new Error("illegal catch attempt"); + }, + + delegateYield: function(iterable, resultName, nextLoc) { + this.delegate = { + iterator: values(iterable), + resultName: resultName, + nextLoc: nextLoc + }; + + if (this.method === "next") { + // Deliberately forget the last sent value so that we don't + // accidentally pass it on to the delegate. + this.arg = undefined; + } + + return ContinueSentinel; + } + }; + })( + // Among the various tricks for obtaining a reference to the global + // object, this seems to be the most reliable technique that does not + // use indirect eval (which violates Content Security Policy). + typeof global === "object" ? global : + typeof window === "object" ? window : + typeof self === "object" ? self : this + ); + + }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + + },{}],72:[function(require,module,exports){ + require('../../modules/core.regexp.escape'); + module.exports = require('../../modules/_core').RegExp.escape; + + },{"../../modules/_core":94,"../../modules/core.regexp.escape":202}],73:[function(require,module,exports){ + module.exports = function (it) { + if (typeof it != 'function') throw TypeError(it + ' is not a function!'); + return it; + }; + + },{}],74:[function(require,module,exports){ + var cof = require('./_cof'); + module.exports = function (it, msg) { + if (typeof it != 'number' && cof(it) != 'Number') throw TypeError(msg); + return +it; + }; + + },{"./_cof":89}],75:[function(require,module,exports){ + // 22.1.3.31 Array.prototype[@@unscopables] + var UNSCOPABLES = require('./_wks')('unscopables'); + var ArrayProto = Array.prototype; + if (ArrayProto[UNSCOPABLES] == undefined) require('./_hide')(ArrayProto, UNSCOPABLES, {}); + module.exports = function (key) { + ArrayProto[UNSCOPABLES][key] = true; + }; + + },{"./_hide":114,"./_wks":200}],76:[function(require,module,exports){ + 'use strict'; + var at = require('./_string-at')(true); + + // `AdvanceStringIndex` abstract operation + // https://tc39.github.io/ecma262/#sec-advancestringindex + module.exports = function (S, index, unicode) { + return index + (unicode ? at(S, index).length : 1); + }; + + },{"./_string-at":177}],77:[function(require,module,exports){ + module.exports = function (it, Constructor, name, forbiddenField) { + if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) { + throw TypeError(name + ': incorrect invocation!'); + } return it; + }; + + },{}],78:[function(require,module,exports){ + var isObject = require('./_is-object'); + module.exports = function (it) { + if (!isObject(it)) throw TypeError(it + ' is not an object!'); + return it; + }; + + },{"./_is-object":123}],79:[function(require,module,exports){ + // 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length) + 'use strict'; + var toObject = require('./_to-object'); + var toAbsoluteIndex = require('./_to-absolute-index'); + var toLength = require('./_to-length'); + + module.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) { + var O = toObject(this); + var len = toLength(O.length); + var to = toAbsoluteIndex(target, len); + var from = toAbsoluteIndex(start, len); + var end = arguments.length > 2 ? arguments[2] : undefined; + var count = Math.min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to); + var inc = 1; + if (from < to && to < from + count) { + inc = -1; + from += count - 1; + to += count - 1; + } + while (count-- > 0) { + if (from in O) O[to] = O[from]; + else delete O[to]; + to += inc; + from += inc; + } return O; + }; + + },{"./_to-absolute-index":185,"./_to-length":189,"./_to-object":190}],80:[function(require,module,exports){ + // 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length) + 'use strict'; + var toObject = require('./_to-object'); + var toAbsoluteIndex = require('./_to-absolute-index'); + var toLength = require('./_to-length'); + module.exports = function fill(value /* , start = 0, end = @length */) { + var O = toObject(this); + var length = toLength(O.length); + var aLen = arguments.length; + var index = toAbsoluteIndex(aLen > 1 ? arguments[1] : undefined, length); + var end = aLen > 2 ? arguments[2] : undefined; + var endPos = end === undefined ? length : toAbsoluteIndex(end, length); + while (endPos > index) O[index++] = value; + return O; + }; + + },{"./_to-absolute-index":185,"./_to-length":189,"./_to-object":190}],81:[function(require,module,exports){ + var forOf = require('./_for-of'); + + module.exports = function (iter, ITERATOR) { + var result = []; + forOf(iter, false, result.push, result, ITERATOR); + return result; + }; + + },{"./_for-of":110}],82:[function(require,module,exports){ + // false -> Array#indexOf + // true -> Array#includes + var toIObject = require('./_to-iobject'); + var toLength = require('./_to-length'); + var toAbsoluteIndex = require('./_to-absolute-index'); + module.exports = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIObject($this); + var length = toLength(O.length); + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare + if (IS_INCLUDES && el != el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare + if (value != value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) if (IS_INCLUDES || index in O) { + if (O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; + }; + + },{"./_to-absolute-index":185,"./_to-iobject":188,"./_to-length":189}],83:[function(require,module,exports){ + // 0 -> Array#forEach + // 1 -> Array#map + // 2 -> Array#filter + // 3 -> Array#some + // 4 -> Array#every + // 5 -> Array#find + // 6 -> Array#findIndex + var ctx = require('./_ctx'); + var IObject = require('./_iobject'); + var toObject = require('./_to-object'); + var toLength = require('./_to-length'); + var asc = require('./_array-species-create'); + module.exports = function (TYPE, $create) { + var IS_MAP = TYPE == 1; + var IS_FILTER = TYPE == 2; + var IS_SOME = TYPE == 3; + var IS_EVERY = TYPE == 4; + var IS_FIND_INDEX = TYPE == 6; + var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; + var create = $create || asc; + return function ($this, callbackfn, that) { + var O = toObject($this); + var self = IObject(O); + var f = ctx(callbackfn, that, 3); + var length = toLength(self.length); + var index = 0; + var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined; + var val, res; + for (;length > index; index++) if (NO_HOLES || index in self) { + val = self[index]; + res = f(val, index, O); + if (TYPE) { + if (IS_MAP) result[index] = res; // map + else if (res) switch (TYPE) { + case 3: return true; // some + case 5: return val; // find + case 6: return index; // findIndex + case 2: result.push(val); // filter + } else if (IS_EVERY) return false; // every + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result; + }; + }; + + },{"./_array-species-create":86,"./_ctx":96,"./_iobject":119,"./_to-length":189,"./_to-object":190}],84:[function(require,module,exports){ + var aFunction = require('./_a-function'); + var toObject = require('./_to-object'); + var IObject = require('./_iobject'); + var toLength = require('./_to-length'); + + module.exports = function (that, callbackfn, aLen, memo, isRight) { + aFunction(callbackfn); + var O = toObject(that); + var self = IObject(O); + var length = toLength(O.length); + var index = isRight ? length - 1 : 0; + var i = isRight ? -1 : 1; + if (aLen < 2) for (;;) { + if (index in self) { + memo = self[index]; + index += i; + break; + } + index += i; + if (isRight ? index < 0 : length <= index) { + throw TypeError('Reduce of empty array with no initial value'); + } + } + for (;isRight ? index >= 0 : length > index; index += i) if (index in self) { + memo = callbackfn(memo, self[index], index, O); + } + return memo; + }; + + },{"./_a-function":73,"./_iobject":119,"./_to-length":189,"./_to-object":190}],85:[function(require,module,exports){ + var isObject = require('./_is-object'); + var isArray = require('./_is-array'); + var SPECIES = require('./_wks')('species'); + + module.exports = function (original) { + var C; + if (isArray(original)) { + C = original.constructor; + // cross-realm fallback + if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; + if (isObject(C)) { + C = C[SPECIES]; + if (C === null) C = undefined; + } + } return C === undefined ? Array : C; + }; + + },{"./_is-array":121,"./_is-object":123,"./_wks":200}],86:[function(require,module,exports){ + // 9.4.2.3 ArraySpeciesCreate(originalArray, length) + var speciesConstructor = require('./_array-species-constructor'); + + module.exports = function (original, length) { + return new (speciesConstructor(original))(length); + }; + + },{"./_array-species-constructor":85}],87:[function(require,module,exports){ + 'use strict'; + var aFunction = require('./_a-function'); + var isObject = require('./_is-object'); + var invoke = require('./_invoke'); + var arraySlice = [].slice; + var factories = {}; + + var construct = function (F, len, args) { + if (!(len in factories)) { + for (var n = [], i = 0; i < len; i++) n[i] = 'a[' + i + ']'; + // eslint-disable-next-line no-new-func + factories[len] = Function('F,a', 'return new F(' + n.join(',') + ')'); + } return factories[len](F, args); + }; + + module.exports = Function.bind || function bind(that /* , ...args */) { + var fn = aFunction(this); + var partArgs = arraySlice.call(arguments, 1); + var bound = function (/* args... */) { + var args = partArgs.concat(arraySlice.call(arguments)); + return this instanceof bound ? construct(fn, args.length, args) : invoke(fn, args, that); + }; + if (isObject(fn.prototype)) bound.prototype = fn.prototype; + return bound; + }; + + },{"./_a-function":73,"./_invoke":118,"./_is-object":123}],88:[function(require,module,exports){ + // getting tag from 19.1.3.6 Object.prototype.toString() + var cof = require('./_cof'); + var TAG = require('./_wks')('toStringTag'); + // ES3 wrong here + var ARG = cof(function () { return arguments; }()) == 'Arguments'; + + // fallback for IE11 Script Access Denied error + var tryGet = function (it, key) { + try { + return it[key]; + } catch (e) { /* empty */ } + }; + + module.exports = function (it) { + var O, T, B; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T + // builtinTag case + : ARG ? cof(O) + // ES3 arguments fallback + : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B; + }; + + },{"./_cof":89,"./_wks":200}],89:[function(require,module,exports){ + var toString = {}.toString; + + module.exports = function (it) { + return toString.call(it).slice(8, -1); + }; + + },{}],90:[function(require,module,exports){ + 'use strict'; + var dP = require('./_object-dp').f; + var create = require('./_object-create'); + var redefineAll = require('./_redefine-all'); + var ctx = require('./_ctx'); + var anInstance = require('./_an-instance'); + var forOf = require('./_for-of'); + var $iterDefine = require('./_iter-define'); + var step = require('./_iter-step'); + var setSpecies = require('./_set-species'); + var DESCRIPTORS = require('./_descriptors'); + var fastKey = require('./_meta').fastKey; + var validate = require('./_validate-collection'); + var SIZE = DESCRIPTORS ? '_s' : 'size'; + + var getEntry = function (that, key) { + // fast case + var index = fastKey(key); + var entry; + if (index !== 'F') return that._i[index]; + // frozen object case + for (entry = that._f; entry; entry = entry.n) { + if (entry.k == key) return entry; + } + }; + + module.exports = { + getConstructor: function (wrapper, NAME, IS_MAP, ADDER) { + var C = wrapper(function (that, iterable) { + anInstance(that, C, NAME, '_i'); + that._t = NAME; // collection type + that._i = create(null); // index + that._f = undefined; // first entry + that._l = undefined; // last entry + that[SIZE] = 0; // size + if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that); + }); + redefineAll(C.prototype, { + // 23.1.3.1 Map.prototype.clear() + // 23.2.3.2 Set.prototype.clear() + clear: function clear() { + for (var that = validate(this, NAME), data = that._i, entry = that._f; entry; entry = entry.n) { + entry.r = true; + if (entry.p) entry.p = entry.p.n = undefined; + delete data[entry.i]; + } + that._f = that._l = undefined; + that[SIZE] = 0; + }, + // 23.1.3.3 Map.prototype.delete(key) + // 23.2.3.4 Set.prototype.delete(value) + 'delete': function (key) { + var that = validate(this, NAME); + var entry = getEntry(that, key); + if (entry) { + var next = entry.n; + var prev = entry.p; + delete that._i[entry.i]; + entry.r = true; + if (prev) prev.n = next; + if (next) next.p = prev; + if (that._f == entry) that._f = next; + if (that._l == entry) that._l = prev; + that[SIZE]--; + } return !!entry; + }, + // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined) + // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined) + forEach: function forEach(callbackfn /* , that = undefined */) { + validate(this, NAME); + var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var entry; + while (entry = entry ? entry.n : this._f) { + f(entry.v, entry.k, this); + // revert to the last existing entry + while (entry && entry.r) entry = entry.p; + } + }, + // 23.1.3.7 Map.prototype.has(key) + // 23.2.3.7 Set.prototype.has(value) + has: function has(key) { + return !!getEntry(validate(this, NAME), key); + } + }); + if (DESCRIPTORS) dP(C.prototype, 'size', { + get: function () { + return validate(this, NAME)[SIZE]; + } + }); + return C; + }, + def: function (that, key, value) { + var entry = getEntry(that, key); + var prev, index; + // change existing entry + if (entry) { + entry.v = value; + // create new entry + } else { + that._l = entry = { + i: index = fastKey(key, true), // <- index + k: key, // <- key + v: value, // <- value + p: prev = that._l, // <- previous entry + n: undefined, // <- next entry + r: false // <- removed + }; + if (!that._f) that._f = entry; + if (prev) prev.n = entry; + that[SIZE]++; + // add to index + if (index !== 'F') that._i[index] = entry; + } return that; + }, + getEntry: getEntry, + setStrong: function (C, NAME, IS_MAP) { + // add .keys, .values, .entries, [@@iterator] + // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11 + $iterDefine(C, NAME, function (iterated, kind) { + this._t = validate(iterated, NAME); // target + this._k = kind; // kind + this._l = undefined; // previous + }, function () { + var that = this; + var kind = that._k; + var entry = that._l; + // revert to the last existing entry + while (entry && entry.r) entry = entry.p; + // get next entry + if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) { + // or finish the iteration + that._t = undefined; + return step(1); + } + // return step by kind + if (kind == 'keys') return step(0, entry.k); + if (kind == 'values') return step(0, entry.v); + return step(0, [entry.k, entry.v]); + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + + // add [@@species], 23.1.2.2, 23.2.2.2 + setSpecies(NAME); + } + }; + + },{"./_an-instance":77,"./_ctx":96,"./_descriptors":100,"./_for-of":110,"./_iter-define":127,"./_iter-step":129,"./_meta":137,"./_object-create":142,"./_object-dp":143,"./_redefine-all":162,"./_set-species":171,"./_validate-collection":197}],91:[function(require,module,exports){ + // https://github.com/DavidBruant/Map-Set.prototype.toJSON + var classof = require('./_classof'); + var from = require('./_array-from-iterable'); + module.exports = function (NAME) { + return function toJSON() { + if (classof(this) != NAME) throw TypeError(NAME + "#toJSON isn't generic"); + return from(this); + }; + }; + + },{"./_array-from-iterable":81,"./_classof":88}],92:[function(require,module,exports){ + 'use strict'; + var redefineAll = require('./_redefine-all'); + var getWeak = require('./_meta').getWeak; + var anObject = require('./_an-object'); + var isObject = require('./_is-object'); + var anInstance = require('./_an-instance'); + var forOf = require('./_for-of'); + var createArrayMethod = require('./_array-methods'); + var $has = require('./_has'); + var validate = require('./_validate-collection'); + var arrayFind = createArrayMethod(5); + var arrayFindIndex = createArrayMethod(6); + var id = 0; + + // fallback for uncaught frozen keys + var uncaughtFrozenStore = function (that) { + return that._l || (that._l = new UncaughtFrozenStore()); + }; + var UncaughtFrozenStore = function () { + this.a = []; + }; + var findUncaughtFrozen = function (store, key) { + return arrayFind(store.a, function (it) { + return it[0] === key; + }); + }; + UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.a.push([key, value]); + }, + 'delete': function (key) { + var index = arrayFindIndex(this.a, function (it) { + return it[0] === key; + }); + if (~index) this.a.splice(index, 1); + return !!~index; + } + }; + + module.exports = { + getConstructor: function (wrapper, NAME, IS_MAP, ADDER) { + var C = wrapper(function (that, iterable) { + anInstance(that, C, NAME, '_i'); + that._t = NAME; // collection type + that._i = id++; // collection id + that._l = undefined; // leak store for uncaught frozen objects + if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that); + }); + redefineAll(C.prototype, { + // 23.3.3.2 WeakMap.prototype.delete(key) + // 23.4.3.3 WeakSet.prototype.delete(value) + 'delete': function (key) { + if (!isObject(key)) return false; + var data = getWeak(key); + if (data === true) return uncaughtFrozenStore(validate(this, NAME))['delete'](key); + return data && $has(data, this._i) && delete data[this._i]; + }, + // 23.3.3.4 WeakMap.prototype.has(key) + // 23.4.3.4 WeakSet.prototype.has(value) + has: function has(key) { + if (!isObject(key)) return false; + var data = getWeak(key); + if (data === true) return uncaughtFrozenStore(validate(this, NAME)).has(key); + return data && $has(data, this._i); + } + }); + return C; + }, + def: function (that, key, value) { + var data = getWeak(anObject(key), true); + if (data === true) uncaughtFrozenStore(that).set(key, value); + else data[that._i] = value; + return that; + }, + ufstore: uncaughtFrozenStore + }; + + },{"./_an-instance":77,"./_an-object":78,"./_array-methods":83,"./_for-of":110,"./_has":113,"./_is-object":123,"./_meta":137,"./_redefine-all":162,"./_validate-collection":197}],93:[function(require,module,exports){ + 'use strict'; + var global = require('./_global'); + var $export = require('./_export'); + var redefine = require('./_redefine'); + var redefineAll = require('./_redefine-all'); + var meta = require('./_meta'); + var forOf = require('./_for-of'); + var anInstance = require('./_an-instance'); + var isObject = require('./_is-object'); + var fails = require('./_fails'); + var $iterDetect = require('./_iter-detect'); + var setToStringTag = require('./_set-to-string-tag'); + var inheritIfRequired = require('./_inherit-if-required'); + + module.exports = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) { + var Base = global[NAME]; + var C = Base; + var ADDER = IS_MAP ? 'set' : 'add'; + var proto = C && C.prototype; + var O = {}; + var fixMethod = function (KEY) { + var fn = proto[KEY]; + redefine(proto, KEY, + KEY == 'delete' ? function (a) { + return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a); + } : KEY == 'has' ? function has(a) { + return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a); + } : KEY == 'get' ? function get(a) { + return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a); + } : KEY == 'add' ? function add(a) { fn.call(this, a === 0 ? 0 : a); return this; } + : function set(a, b) { fn.call(this, a === 0 ? 0 : a, b); return this; } + ); + }; + if (typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function () { + new C().entries().next(); + }))) { + // create collection constructor + C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER); + redefineAll(C.prototype, methods); + meta.NEED = true; + } else { + var instance = new C(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + var ACCEPT_ITERABLES = $iterDetect(function (iter) { new C(iter); }); // eslint-disable-line no-new + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new C(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + if (!ACCEPT_ITERABLES) { + C = wrapper(function (target, iterable) { + anInstance(target, C, NAME); + var that = inheritIfRequired(new Base(), target, C); + if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that); + return that; + }); + C.prototype = proto; + proto.constructor = C; + } + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + // weak collections should not contains .clear method + if (IS_WEAK && proto.clear) delete proto.clear; + } + + setToStringTag(C, NAME); + + O[NAME] = C; + $export($export.G + $export.W + $export.F * (C != Base), O); + + if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP); + + return C; + }; + + },{"./_an-instance":77,"./_export":104,"./_fails":106,"./_for-of":110,"./_global":112,"./_inherit-if-required":117,"./_is-object":123,"./_iter-detect":128,"./_meta":137,"./_redefine":163,"./_redefine-all":162,"./_set-to-string-tag":172}],94:[function(require,module,exports){ + var core = module.exports = { version: '2.6.12' }; + if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef + + },{}],95:[function(require,module,exports){ + 'use strict'; + var $defineProperty = require('./_object-dp'); + var createDesc = require('./_property-desc'); + + module.exports = function (object, index, value) { + if (index in object) $defineProperty.f(object, index, createDesc(0, value)); + else object[index] = value; + }; + + },{"./_object-dp":143,"./_property-desc":161}],96:[function(require,module,exports){ + // optional / simple context binding + var aFunction = require('./_a-function'); + module.exports = function (fn, that, length) { + aFunction(fn); + if (that === undefined) return fn; + switch (length) { + case 1: return function (a) { + return fn.call(that, a); + }; + case 2: return function (a, b) { + return fn.call(that, a, b); + }; + case 3: return function (a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function (/* ...args */) { + return fn.apply(that, arguments); + }; + }; + + },{"./_a-function":73}],97:[function(require,module,exports){ + 'use strict'; + // 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString() + var fails = require('./_fails'); + var getTime = Date.prototype.getTime; + var $toISOString = Date.prototype.toISOString; + + var lz = function (num) { + return num > 9 ? num : '0' + num; + }; + + // PhantomJS / old WebKit has a broken implementations + module.exports = (fails(function () { + return $toISOString.call(new Date(-5e13 - 1)) != '0385-07-25T07:06:39.999Z'; + }) || !fails(function () { + $toISOString.call(new Date(NaN)); + })) ? function toISOString() { + if (!isFinite(getTime.call(this))) throw RangeError('Invalid time value'); + var d = this; + var y = d.getUTCFullYear(); + var m = d.getUTCMilliseconds(); + var s = y < 0 ? '-' : y > 9999 ? '+' : ''; + return s + ('00000' + Math.abs(y)).slice(s ? -6 : -4) + + '-' + lz(d.getUTCMonth() + 1) + '-' + lz(d.getUTCDate()) + + 'T' + lz(d.getUTCHours()) + ':' + lz(d.getUTCMinutes()) + + ':' + lz(d.getUTCSeconds()) + '.' + (m > 99 ? m : '0' + lz(m)) + 'Z'; + } : $toISOString; + + },{"./_fails":106}],98:[function(require,module,exports){ + 'use strict'; + var anObject = require('./_an-object'); + var toPrimitive = require('./_to-primitive'); + var NUMBER = 'number'; + + module.exports = function (hint) { + if (hint !== 'string' && hint !== NUMBER && hint !== 'default') throw TypeError('Incorrect hint'); + return toPrimitive(anObject(this), hint != NUMBER); + }; + + },{"./_an-object":78,"./_to-primitive":191}],99:[function(require,module,exports){ + // 7.2.1 RequireObjectCoercible(argument) + module.exports = function (it) { + if (it == undefined) throw TypeError("Can't call method on " + it); + return it; + }; + + },{}],100:[function(require,module,exports){ + // Thank's IE8 for his funny defineProperty + module.exports = !require('./_fails')(function () { + return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7; + }); + + },{"./_fails":106}],101:[function(require,module,exports){ + var isObject = require('./_is-object'); + var document = require('./_global').document; + // typeof document.createElement is 'object' in old IE + var is = isObject(document) && isObject(document.createElement); + module.exports = function (it) { + return is ? document.createElement(it) : {}; + }; + + },{"./_global":112,"./_is-object":123}],102:[function(require,module,exports){ + // IE 8- don't enum bug keys + module.exports = ( + 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf' + ).split(','); + + },{}],103:[function(require,module,exports){ + // all enumerable object keys, includes symbols + var getKeys = require('./_object-keys'); + var gOPS = require('./_object-gops'); + var pIE = require('./_object-pie'); + module.exports = function (it) { + var result = getKeys(it); + var getSymbols = gOPS.f; + if (getSymbols) { + var symbols = getSymbols(it); + var isEnum = pIE.f; + var i = 0; + var key; + while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key); + } return result; + }; + + },{"./_object-gops":149,"./_object-keys":152,"./_object-pie":153}],104:[function(require,module,exports){ + var global = require('./_global'); + var core = require('./_core'); + var hide = require('./_hide'); + var redefine = require('./_redefine'); + var ctx = require('./_ctx'); + var PROTOTYPE = 'prototype'; + + var $export = function (type, name, source) { + var IS_FORCED = type & $export.F; + var IS_GLOBAL = type & $export.G; + var IS_STATIC = type & $export.S; + var IS_PROTO = type & $export.P; + var IS_BIND = type & $export.B; + var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]; + var exports = IS_GLOBAL ? core : core[name] || (core[name] = {}); + var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {}); + var key, own, out, exp; + if (IS_GLOBAL) source = name; + for (key in source) { + // contains in native + own = !IS_FORCED && target && target[key] !== undefined; + // export native or passed + out = (own ? target : source)[key]; + // bind timers to global for call from export context + exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; + // extend global + if (target) redefine(target, key, out, type & $export.U); + // export + if (exports[key] != out) hide(exports, key, exp); + if (IS_PROTO && expProto[key] != out) expProto[key] = out; + } + }; + global.core = core; + // type bitmap + $export.F = 1; // forced + $export.G = 2; // global + $export.S = 4; // static + $export.P = 8; // proto + $export.B = 16; // bind + $export.W = 32; // wrap + $export.U = 64; // safe + $export.R = 128; // real proto method for `library` + module.exports = $export; + + },{"./_core":94,"./_ctx":96,"./_global":112,"./_hide":114,"./_redefine":163}],105:[function(require,module,exports){ + var MATCH = require('./_wks')('match'); + module.exports = function (KEY) { + var re = /./; + try { + '/./'[KEY](re); + } catch (e) { + try { + re[MATCH] = false; + return !'/./'[KEY](re); + } catch (f) { /* empty */ } + } return true; + }; + + },{"./_wks":200}],106:[function(require,module,exports){ + module.exports = function (exec) { + try { + return !!exec(); + } catch (e) { + return true; + } + }; + + },{}],107:[function(require,module,exports){ + 'use strict'; + require('./es6.regexp.exec'); + var redefine = require('./_redefine'); + var hide = require('./_hide'); + var fails = require('./_fails'); + var defined = require('./_defined'); + var wks = require('./_wks'); + var regexpExec = require('./_regexp-exec'); + + var SPECIES = wks('species'); + + var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () { + // #replace needs built-in support for named groups. + // #match works fine because it just return the exec results, even if it has + // a "grops" property. + var re = /./; + re.exec = function () { + var result = []; + result.groups = { a: '7' }; + return result; + }; + return ''.replace(re, '$') !== '7'; + }); + + var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = (function () { + // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec + var re = /(?:)/; + var originalExec = re.exec; + re.exec = function () { return originalExec.apply(this, arguments); }; + var result = 'ab'.split(re); + return result.length === 2 && result[0] === 'a' && result[1] === 'b'; + })(); + + module.exports = function (KEY, length, exec) { + var SYMBOL = wks(KEY); + + var DELEGATES_TO_SYMBOL = !fails(function () { + // String methods call symbol-named RegEp methods + var O = {}; + O[SYMBOL] = function () { return 7; }; + return ''[KEY](O) != 7; + }); + + var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL ? !fails(function () { + // Symbol-named RegExp methods call .exec + var execCalled = false; + var re = /a/; + re.exec = function () { execCalled = true; return null; }; + if (KEY === 'split') { + // RegExp[@@split] doesn't call the regex's exec method, but first creates + // a new one. We need to return the patched regex when creating the new one. + re.constructor = {}; + re.constructor[SPECIES] = function () { return re; }; + } + re[SYMBOL](''); + return !execCalled; + }) : undefined; + + if ( + !DELEGATES_TO_SYMBOL || + !DELEGATES_TO_EXEC || + (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) || + (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC) + ) { + var nativeRegExpMethod = /./[SYMBOL]; + var fns = exec( + defined, + SYMBOL, + ''[KEY], + function maybeCallNative(nativeMethod, regexp, str, arg2, forceStringMethod) { + if (regexp.exec === regexpExec) { + if (DELEGATES_TO_SYMBOL && !forceStringMethod) { + // The native String method already delegates to @@method (this + // polyfilled function), leasing to infinite recursion. + // We avoid it by directly calling the native @@method method. + return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) }; + } + return { done: true, value: nativeMethod.call(str, regexp, arg2) }; + } + return { done: false }; + } + ); + var strfn = fns[0]; + var rxfn = fns[1]; + + redefine(String.prototype, KEY, strfn); + hide(RegExp.prototype, SYMBOL, length == 2 + // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue) + // 21.2.5.11 RegExp.prototype[@@split](string, limit) + ? function (string, arg) { return rxfn.call(string, this, arg); } + // 21.2.5.6 RegExp.prototype[@@match](string) + // 21.2.5.9 RegExp.prototype[@@search](string) + : function (string) { return rxfn.call(string, this); } + ); + } + }; + + },{"./_defined":99,"./_fails":106,"./_hide":114,"./_redefine":163,"./_regexp-exec":165,"./_wks":200,"./es6.regexp.exec":297}],108:[function(require,module,exports){ + 'use strict'; + // 21.2.5.3 get RegExp.prototype.flags + var anObject = require('./_an-object'); + module.exports = function () { + var that = anObject(this); + var result = ''; + if (that.global) result += 'g'; + if (that.ignoreCase) result += 'i'; + if (that.multiline) result += 'm'; + if (that.unicode) result += 'u'; + if (that.sticky) result += 'y'; + return result; + }; + + },{"./_an-object":78}],109:[function(require,module,exports){ + 'use strict'; + // https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray + var isArray = require('./_is-array'); + var isObject = require('./_is-object'); + var toLength = require('./_to-length'); + var ctx = require('./_ctx'); + var IS_CONCAT_SPREADABLE = require('./_wks')('isConcatSpreadable'); + + function flattenIntoArray(target, original, source, sourceLen, start, depth, mapper, thisArg) { + var targetIndex = start; + var sourceIndex = 0; + var mapFn = mapper ? ctx(mapper, thisArg, 3) : false; + var element, spreadable; + + while (sourceIndex < sourceLen) { + if (sourceIndex in source) { + element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex]; + + spreadable = false; + if (isObject(element)) { + spreadable = element[IS_CONCAT_SPREADABLE]; + spreadable = spreadable !== undefined ? !!spreadable : isArray(element); + } + + if (spreadable && depth > 0) { + targetIndex = flattenIntoArray(target, original, element, toLength(element.length), targetIndex, depth - 1) - 1; + } else { + if (targetIndex >= 0x1fffffffffffff) throw TypeError(); + target[targetIndex] = element; + } + + targetIndex++; + } + sourceIndex++; + } + return targetIndex; + } + + module.exports = flattenIntoArray; + + },{"./_ctx":96,"./_is-array":121,"./_is-object":123,"./_to-length":189,"./_wks":200}],110:[function(require,module,exports){ + var ctx = require('./_ctx'); + var call = require('./_iter-call'); + var isArrayIter = require('./_is-array-iter'); + var anObject = require('./_an-object'); + var toLength = require('./_to-length'); + var getIterFn = require('./core.get-iterator-method'); + var BREAK = {}; + var RETURN = {}; + var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) { + var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable); + var f = ctx(fn, that, entries ? 2 : 1); + var index = 0; + var length, step, iterator, result; + if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!'); + // fast case for arrays with default iterator + if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) { + result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]); + if (result === BREAK || result === RETURN) return result; + } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) { + result = call(iterator, f, step.value, entries); + if (result === BREAK || result === RETURN) return result; + } + }; + exports.BREAK = BREAK; + exports.RETURN = RETURN; + + },{"./_an-object":78,"./_ctx":96,"./_is-array-iter":120,"./_iter-call":125,"./_to-length":189,"./core.get-iterator-method":201}],111:[function(require,module,exports){ + module.exports = require('./_shared')('native-function-to-string', Function.toString); + + },{"./_shared":174}],112:[function(require,module,exports){ + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global = module.exports = typeof window != 'undefined' && window.Math == Math + ? window : typeof self != 'undefined' && self.Math == Math ? self + // eslint-disable-next-line no-new-func + : Function('return this')(); + if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef + + },{}],113:[function(require,module,exports){ + var hasOwnProperty = {}.hasOwnProperty; + module.exports = function (it, key) { + return hasOwnProperty.call(it, key); + }; + + },{}],114:[function(require,module,exports){ + var dP = require('./_object-dp'); + var createDesc = require('./_property-desc'); + module.exports = require('./_descriptors') ? function (object, key, value) { + return dP.f(object, key, createDesc(1, value)); + } : function (object, key, value) { + object[key] = value; + return object; + }; + + },{"./_descriptors":100,"./_object-dp":143,"./_property-desc":161}],115:[function(require,module,exports){ + var document = require('./_global').document; + module.exports = document && document.documentElement; + + },{"./_global":112}],116:[function(require,module,exports){ + module.exports = !require('./_descriptors') && !require('./_fails')(function () { + return Object.defineProperty(require('./_dom-create')('div'), 'a', { get: function () { return 7; } }).a != 7; + }); + + },{"./_descriptors":100,"./_dom-create":101,"./_fails":106}],117:[function(require,module,exports){ + var isObject = require('./_is-object'); + var setPrototypeOf = require('./_set-proto').set; + module.exports = function (that, target, C) { + var S = target.constructor; + var P; + if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf) { + setPrototypeOf(that, P); + } return that; + }; + + },{"./_is-object":123,"./_set-proto":170}],118:[function(require,module,exports){ + // fast apply, http://jsperf.lnkit.com/fast-apply/5 + module.exports = function (fn, args, that) { + var un = that === undefined; + switch (args.length) { + case 0: return un ? fn() + : fn.call(that); + case 1: return un ? fn(args[0]) + : fn.call(that, args[0]); + case 2: return un ? fn(args[0], args[1]) + : fn.call(that, args[0], args[1]); + case 3: return un ? fn(args[0], args[1], args[2]) + : fn.call(that, args[0], args[1], args[2]); + case 4: return un ? fn(args[0], args[1], args[2], args[3]) + : fn.call(that, args[0], args[1], args[2], args[3]); + } return fn.apply(that, args); + }; + + },{}],119:[function(require,module,exports){ + // fallback for non-array-like ES3 and non-enumerable old V8 strings + var cof = require('./_cof'); + // eslint-disable-next-line no-prototype-builtins + module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) { + return cof(it) == 'String' ? it.split('') : Object(it); + }; + + },{"./_cof":89}],120:[function(require,module,exports){ + // check on default Array iterator + var Iterators = require('./_iterators'); + var ITERATOR = require('./_wks')('iterator'); + var ArrayProto = Array.prototype; + + module.exports = function (it) { + return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it); + }; + + },{"./_iterators":130,"./_wks":200}],121:[function(require,module,exports){ + // 7.2.2 IsArray(argument) + var cof = require('./_cof'); + module.exports = Array.isArray || function isArray(arg) { + return cof(arg) == 'Array'; + }; + + },{"./_cof":89}],122:[function(require,module,exports){ + // 20.1.2.3 Number.isInteger(number) + var isObject = require('./_is-object'); + var floor = Math.floor; + module.exports = function isInteger(it) { + return !isObject(it) && isFinite(it) && floor(it) === it; + }; + + },{"./_is-object":123}],123:[function(require,module,exports){ + module.exports = function (it) { + return typeof it === 'object' ? it !== null : typeof it === 'function'; + }; + + },{}],124:[function(require,module,exports){ + // 7.2.8 IsRegExp(argument) + var isObject = require('./_is-object'); + var cof = require('./_cof'); + var MATCH = require('./_wks')('match'); + module.exports = function (it) { + var isRegExp; + return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp'); + }; + + },{"./_cof":89,"./_is-object":123,"./_wks":200}],125:[function(require,module,exports){ + // call something on iterator step with safe closing on error + var anObject = require('./_an-object'); + module.exports = function (iterator, fn, value, entries) { + try { + return entries ? fn(anObject(value)[0], value[1]) : fn(value); + // 7.4.6 IteratorClose(iterator, completion) + } catch (e) { + var ret = iterator['return']; + if (ret !== undefined) anObject(ret.call(iterator)); + throw e; + } + }; + + },{"./_an-object":78}],126:[function(require,module,exports){ + 'use strict'; + var create = require('./_object-create'); + var descriptor = require('./_property-desc'); + var setToStringTag = require('./_set-to-string-tag'); + var IteratorPrototype = {}; + + // 25.1.2.1.1 %IteratorPrototype%[@@iterator]() + require('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function () { return this; }); + + module.exports = function (Constructor, NAME, next) { + Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) }); + setToStringTag(Constructor, NAME + ' Iterator'); + }; + + },{"./_hide":114,"./_object-create":142,"./_property-desc":161,"./_set-to-string-tag":172,"./_wks":200}],127:[function(require,module,exports){ + 'use strict'; + var LIBRARY = require('./_library'); + var $export = require('./_export'); + var redefine = require('./_redefine'); + var hide = require('./_hide'); + var Iterators = require('./_iterators'); + var $iterCreate = require('./_iter-create'); + var setToStringTag = require('./_set-to-string-tag'); + var getPrototypeOf = require('./_object-gpo'); + var ITERATOR = require('./_wks')('iterator'); + var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next` + var FF_ITERATOR = '@@iterator'; + var KEYS = 'keys'; + var VALUES = 'values'; + + var returnThis = function () { return this; }; + + module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) { + $iterCreate(Constructor, NAME, next); + var getMethod = function (kind) { + if (!BUGGY && kind in proto) return proto[kind]; + switch (kind) { + case KEYS: return function keys() { return new Constructor(this, kind); }; + case VALUES: return function values() { return new Constructor(this, kind); }; + } return function entries() { return new Constructor(this, kind); }; + }; + var TAG = NAME + ' Iterator'; + var DEF_VALUES = DEFAULT == VALUES; + var VALUES_BUG = false; + var proto = Base.prototype; + var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]; + var $default = $native || getMethod(DEFAULT); + var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined; + var $anyNative = NAME == 'Array' ? proto.entries || $native : $native; + var methods, key, IteratorPrototype; + // Fix native + if ($anyNative) { + IteratorPrototype = getPrototypeOf($anyNative.call(new Base())); + if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) { + // Set @@toStringTag to native iterators + setToStringTag(IteratorPrototype, TAG, true); + // fix for some old engines + if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis); + } + } + // fix Array#{values, @@iterator}.name in V8 / FF + if (DEF_VALUES && $native && $native.name !== VALUES) { + VALUES_BUG = true; + $default = function values() { return $native.call(this); }; + } + // Define iterator + if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) { + hide(proto, ITERATOR, $default); + } + // Plug for library + Iterators[NAME] = $default; + Iterators[TAG] = returnThis; + if (DEFAULT) { + methods = { + values: DEF_VALUES ? $default : getMethod(VALUES), + keys: IS_SET ? $default : getMethod(KEYS), + entries: $entries + }; + if (FORCED) for (key in methods) { + if (!(key in proto)) redefine(proto, key, methods[key]); + } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods); + } + return methods; + }; + + },{"./_export":104,"./_hide":114,"./_iter-create":126,"./_iterators":130,"./_library":131,"./_object-gpo":150,"./_redefine":163,"./_set-to-string-tag":172,"./_wks":200}],128:[function(require,module,exports){ + var ITERATOR = require('./_wks')('iterator'); + var SAFE_CLOSING = false; + + try { + var riter = [7][ITERATOR](); + riter['return'] = function () { SAFE_CLOSING = true; }; + // eslint-disable-next-line no-throw-literal + Array.from(riter, function () { throw 2; }); + } catch (e) { /* empty */ } + + module.exports = function (exec, skipClosing) { + if (!skipClosing && !SAFE_CLOSING) return false; + var safe = false; + try { + var arr = [7]; + var iter = arr[ITERATOR](); + iter.next = function () { return { done: safe = true }; }; + arr[ITERATOR] = function () { return iter; }; + exec(arr); + } catch (e) { /* empty */ } + return safe; + }; + + },{"./_wks":200}],129:[function(require,module,exports){ + module.exports = function (done, value) { + return { value: value, done: !!done }; + }; + + },{}],130:[function(require,module,exports){ + module.exports = {}; + + },{}],131:[function(require,module,exports){ + module.exports = false; + + },{}],132:[function(require,module,exports){ + // 20.2.2.14 Math.expm1(x) + var $expm1 = Math.expm1; + module.exports = (!$expm1 + // Old FF bug + || $expm1(10) > 22025.465794806719 || $expm1(10) < 22025.4657948067165168 + // Tor Browser bug + || $expm1(-2e-17) != -2e-17 + ) ? function expm1(x) { + return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1; + } : $expm1; + + },{}],133:[function(require,module,exports){ + // 20.2.2.16 Math.fround(x) + var sign = require('./_math-sign'); + var pow = Math.pow; + var EPSILON = pow(2, -52); + var EPSILON32 = pow(2, -23); + var MAX32 = pow(2, 127) * (2 - EPSILON32); + var MIN32 = pow(2, -126); + + var roundTiesToEven = function (n) { + return n + 1 / EPSILON - 1 / EPSILON; + }; + + module.exports = Math.fround || function fround(x) { + var $abs = Math.abs(x); + var $sign = sign(x); + var a, result; + if ($abs < MIN32) return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32; + a = (1 + EPSILON32 / EPSILON) * $abs; + result = a - (a - $abs); + // eslint-disable-next-line no-self-compare + if (result > MAX32 || result != result) return $sign * Infinity; + return $sign * result; + }; + + },{"./_math-sign":136}],134:[function(require,module,exports){ + // 20.2.2.20 Math.log1p(x) + module.exports = Math.log1p || function log1p(x) { + return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : Math.log(1 + x); + }; + + },{}],135:[function(require,module,exports){ + // https://rwaldron.github.io/proposal-math-extensions/ + module.exports = Math.scale || function scale(x, inLow, inHigh, outLow, outHigh) { + if ( + arguments.length === 0 + // eslint-disable-next-line no-self-compare + || x != x + // eslint-disable-next-line no-self-compare + || inLow != inLow + // eslint-disable-next-line no-self-compare + || inHigh != inHigh + // eslint-disable-next-line no-self-compare + || outLow != outLow + // eslint-disable-next-line no-self-compare + || outHigh != outHigh + ) return NaN; + if (x === Infinity || x === -Infinity) return x; + return (x - inLow) * (outHigh - outLow) / (inHigh - inLow) + outLow; + }; + + },{}],136:[function(require,module,exports){ + // 20.2.2.28 Math.sign(x) + module.exports = Math.sign || function sign(x) { + // eslint-disable-next-line no-self-compare + return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1; + }; + + },{}],137:[function(require,module,exports){ + var META = require('./_uid')('meta'); + var isObject = require('./_is-object'); + var has = require('./_has'); + var setDesc = require('./_object-dp').f; + var id = 0; + var isExtensible = Object.isExtensible || function () { + return true; + }; + var FREEZE = !require('./_fails')(function () { + return isExtensible(Object.preventExtensions({})); + }); + var setMeta = function (it) { + setDesc(it, META, { value: { + i: 'O' + ++id, // object ID + w: {} // weak collections IDs + } }); + }; + var fastKey = function (it, create) { + // return primitive with prefix + if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!has(it, META)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMeta(it); + // return object ID + } return it[META].i; + }; + var getWeak = function (it, create) { + if (!has(it, META)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMeta(it); + // return hash weak collections IDs + } return it[META].w; + }; + // add metadata on freeze-family methods calling + var onFreeze = function (it) { + if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it); + return it; + }; + var meta = module.exports = { + KEY: META, + NEED: false, + fastKey: fastKey, + getWeak: getWeak, + onFreeze: onFreeze + }; + + },{"./_fails":106,"./_has":113,"./_is-object":123,"./_object-dp":143,"./_uid":195}],138:[function(require,module,exports){ + var Map = require('./es6.map'); + var $export = require('./_export'); + var shared = require('./_shared')('metadata'); + var store = shared.store || (shared.store = new (require('./es6.weak-map'))()); + + var getOrCreateMetadataMap = function (target, targetKey, create) { + var targetMetadata = store.get(target); + if (!targetMetadata) { + if (!create) return undefined; + store.set(target, targetMetadata = new Map()); + } + var keyMetadata = targetMetadata.get(targetKey); + if (!keyMetadata) { + if (!create) return undefined; + targetMetadata.set(targetKey, keyMetadata = new Map()); + } return keyMetadata; + }; + var ordinaryHasOwnMetadata = function (MetadataKey, O, P) { + var metadataMap = getOrCreateMetadataMap(O, P, false); + return metadataMap === undefined ? false : metadataMap.has(MetadataKey); + }; + var ordinaryGetOwnMetadata = function (MetadataKey, O, P) { + var metadataMap = getOrCreateMetadataMap(O, P, false); + return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey); + }; + var ordinaryDefineOwnMetadata = function (MetadataKey, MetadataValue, O, P) { + getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue); + }; + var ordinaryOwnMetadataKeys = function (target, targetKey) { + var metadataMap = getOrCreateMetadataMap(target, targetKey, false); + var keys = []; + if (metadataMap) metadataMap.forEach(function (_, key) { keys.push(key); }); + return keys; + }; + var toMetaKey = function (it) { + return it === undefined || typeof it == 'symbol' ? it : String(it); + }; + var exp = function (O) { + $export($export.S, 'Reflect', O); + }; + + module.exports = { + store: store, + map: getOrCreateMetadataMap, + has: ordinaryHasOwnMetadata, + get: ordinaryGetOwnMetadata, + set: ordinaryDefineOwnMetadata, + keys: ordinaryOwnMetadataKeys, + key: toMetaKey, + exp: exp + }; + + },{"./_export":104,"./_shared":174,"./es6.map":232,"./es6.weak-map":339}],139:[function(require,module,exports){ + var global = require('./_global'); + var macrotask = require('./_task').set; + var Observer = global.MutationObserver || global.WebKitMutationObserver; + var process = global.process; + var Promise = global.Promise; + var isNode = require('./_cof')(process) == 'process'; + + module.exports = function () { + var head, last, notify; + + var flush = function () { + var parent, fn; + if (isNode && (parent = process.domain)) parent.exit(); + while (head) { + fn = head.fn; + head = head.next; + try { + fn(); + } catch (e) { + if (head) notify(); + else last = undefined; + throw e; + } + } last = undefined; + if (parent) parent.enter(); + }; + + // Node.js + if (isNode) { + notify = function () { + process.nextTick(flush); + }; + // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339 + } else if (Observer && !(global.navigator && global.navigator.standalone)) { + var toggle = true; + var node = document.createTextNode(''); + new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new + notify = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (Promise && Promise.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + var promise = Promise.resolve(undefined); + notify = function () { + promise.then(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessag + // - onreadystatechange + // - setTimeout + } else { + notify = function () { + // strange IE + webpack dev server bug - use .call(global) + macrotask.call(global, flush); + }; + } + + return function (fn) { + var task = { fn: fn, next: undefined }; + if (last) last.next = task; + if (!head) { + head = task; + notify(); + } last = task; + }; + }; + + },{"./_cof":89,"./_global":112,"./_task":184}],140:[function(require,module,exports){ + 'use strict'; + // 25.4.1.5 NewPromiseCapability(C) + var aFunction = require('./_a-function'); + + function PromiseCapability(C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aFunction(resolve); + this.reject = aFunction(reject); + } + + module.exports.f = function (C) { + return new PromiseCapability(C); + }; + + },{"./_a-function":73}],141:[function(require,module,exports){ + 'use strict'; + // 19.1.2.1 Object.assign(target, source, ...) + var DESCRIPTORS = require('./_descriptors'); + var getKeys = require('./_object-keys'); + var gOPS = require('./_object-gops'); + var pIE = require('./_object-pie'); + var toObject = require('./_to-object'); + var IObject = require('./_iobject'); + var $assign = Object.assign; + + // should work with symbols and should have deterministic property order (V8 bug) + module.exports = !$assign || require('./_fails')(function () { + var A = {}; + var B = {}; + // eslint-disable-next-line no-undef + var S = Symbol(); + var K = 'abcdefghijklmnopqrst'; + A[S] = 7; + K.split('').forEach(function (k) { B[k] = k; }); + return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K; + }) ? function assign(target, source) { // eslint-disable-line no-unused-vars + var T = toObject(target); + var aLen = arguments.length; + var index = 1; + var getSymbols = gOPS.f; + var isEnum = pIE.f; + while (aLen > index) { + var S = IObject(arguments[index++]); + var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS || isEnum.call(S, key)) T[key] = S[key]; + } + } return T; + } : $assign; + + },{"./_descriptors":100,"./_fails":106,"./_iobject":119,"./_object-gops":149,"./_object-keys":152,"./_object-pie":153,"./_to-object":190}],142:[function(require,module,exports){ + // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) + var anObject = require('./_an-object'); + var dPs = require('./_object-dps'); + var enumBugKeys = require('./_enum-bug-keys'); + var IE_PROTO = require('./_shared-key')('IE_PROTO'); + var Empty = function () { /* empty */ }; + var PROTOTYPE = 'prototype'; + + // Create object with fake `null` prototype: use iframe Object with cleared prototype + var createDict = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = require('./_dom-create')('iframe'); + var i = enumBugKeys.length; + var lt = '<'; + var gt = '>'; + var iframeDocument; + iframe.style.display = 'none'; + require('./_html').appendChild(iframe); + iframe.src = 'javascript:'; // eslint-disable-line no-script-url + // createDict = iframe.contentWindow.Object; + // html.removeChild(iframe); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt); + iframeDocument.close(); + createDict = iframeDocument.F; + while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]]; + return createDict(); + }; + + module.exports = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + Empty[PROTOTYPE] = anObject(O); + result = new Empty(); + Empty[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO] = O; + } else result = createDict(); + return Properties === undefined ? result : dPs(result, Properties); + }; + + },{"./_an-object":78,"./_dom-create":101,"./_enum-bug-keys":102,"./_html":115,"./_object-dps":144,"./_shared-key":173}],143:[function(require,module,exports){ + var anObject = require('./_an-object'); + var IE8_DOM_DEFINE = require('./_ie8-dom-define'); + var toPrimitive = require('./_to-primitive'); + var dP = Object.defineProperty; + + exports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if (IE8_DOM_DEFINE) try { + return dP(O, P, Attributes); + } catch (e) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; + }; + + },{"./_an-object":78,"./_descriptors":100,"./_ie8-dom-define":116,"./_to-primitive":191}],144:[function(require,module,exports){ + var dP = require('./_object-dp'); + var anObject = require('./_an-object'); + var getKeys = require('./_object-keys'); + + module.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var keys = getKeys(Properties); + var length = keys.length; + var i = 0; + var P; + while (length > i) dP.f(O, P = keys[i++], Properties[P]); + return O; + }; + + },{"./_an-object":78,"./_descriptors":100,"./_object-dp":143,"./_object-keys":152}],145:[function(require,module,exports){ + 'use strict'; + // Forced replacement prototype accessors methods + module.exports = require('./_library') || !require('./_fails')(function () { + var K = Math.random(); + // In FF throws only define methods + // eslint-disable-next-line no-undef, no-useless-call + __defineSetter__.call(null, K, function () { /* empty */ }); + delete require('./_global')[K]; + }); + + },{"./_fails":106,"./_global":112,"./_library":131}],146:[function(require,module,exports){ + var pIE = require('./_object-pie'); + var createDesc = require('./_property-desc'); + var toIObject = require('./_to-iobject'); + var toPrimitive = require('./_to-primitive'); + var has = require('./_has'); + var IE8_DOM_DEFINE = require('./_ie8-dom-define'); + var gOPD = Object.getOwnPropertyDescriptor; + + exports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P) { + O = toIObject(O); + P = toPrimitive(P, true); + if (IE8_DOM_DEFINE) try { + return gOPD(O, P); + } catch (e) { /* empty */ } + if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]); + }; + + },{"./_descriptors":100,"./_has":113,"./_ie8-dom-define":116,"./_object-pie":153,"./_property-desc":161,"./_to-iobject":188,"./_to-primitive":191}],147:[function(require,module,exports){ + // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window + var toIObject = require('./_to-iobject'); + var gOPN = require('./_object-gopn').f; + var toString = {}.toString; + + var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + + var getWindowNames = function (it) { + try { + return gOPN(it); + } catch (e) { + return windowNames.slice(); + } + }; + + module.exports.f = function getOwnPropertyNames(it) { + return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it)); + }; + + },{"./_object-gopn":148,"./_to-iobject":188}],148:[function(require,module,exports){ + // 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O) + var $keys = require('./_object-keys-internal'); + var hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype'); + + exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return $keys(O, hiddenKeys); + }; + + },{"./_enum-bug-keys":102,"./_object-keys-internal":151}],149:[function(require,module,exports){ + exports.f = Object.getOwnPropertySymbols; + + },{}],150:[function(require,module,exports){ + // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O) + var has = require('./_has'); + var toObject = require('./_to-object'); + var IE_PROTO = require('./_shared-key')('IE_PROTO'); + var ObjectProto = Object.prototype; + + module.exports = Object.getPrototypeOf || function (O) { + O = toObject(O); + if (has(O, IE_PROTO)) return O[IE_PROTO]; + if (typeof O.constructor == 'function' && O instanceof O.constructor) { + return O.constructor.prototype; + } return O instanceof Object ? ObjectProto : null; + }; + + },{"./_has":113,"./_shared-key":173,"./_to-object":190}],151:[function(require,module,exports){ + var has = require('./_has'); + var toIObject = require('./_to-iobject'); + var arrayIndexOf = require('./_array-includes')(false); + var IE_PROTO = require('./_shared-key')('IE_PROTO'); + + module.exports = function (object, names) { + var O = toIObject(object); + var i = 0; + var result = []; + var key; + for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key); + // Don't enum bug & hidden keys + while (names.length > i) if (has(O, key = names[i++])) { + ~arrayIndexOf(result, key) || result.push(key); + } + return result; + }; + + },{"./_array-includes":82,"./_has":113,"./_shared-key":173,"./_to-iobject":188}],152:[function(require,module,exports){ + // 19.1.2.14 / 15.2.3.14 Object.keys(O) + var $keys = require('./_object-keys-internal'); + var enumBugKeys = require('./_enum-bug-keys'); + + module.exports = Object.keys || function keys(O) { + return $keys(O, enumBugKeys); + }; + + },{"./_enum-bug-keys":102,"./_object-keys-internal":151}],153:[function(require,module,exports){ + exports.f = {}.propertyIsEnumerable; + + },{}],154:[function(require,module,exports){ + // most Object methods by ES6 should accept primitives + var $export = require('./_export'); + var core = require('./_core'); + var fails = require('./_fails'); + module.exports = function (KEY, exec) { + var fn = (core.Object || {})[KEY] || Object[KEY]; + var exp = {}; + exp[KEY] = exec(fn); + $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp); + }; + + },{"./_core":94,"./_export":104,"./_fails":106}],155:[function(require,module,exports){ + var DESCRIPTORS = require('./_descriptors'); + var getKeys = require('./_object-keys'); + var toIObject = require('./_to-iobject'); + var isEnum = require('./_object-pie').f; + module.exports = function (isEntries) { + return function (it) { + var O = toIObject(it); + var keys = getKeys(O); + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!DESCRIPTORS || isEnum.call(O, key)) { + result.push(isEntries ? [key, O[key]] : O[key]); + } + } + return result; + }; + }; + + },{"./_descriptors":100,"./_object-keys":152,"./_object-pie":153,"./_to-iobject":188}],156:[function(require,module,exports){ + // all object keys, includes non-enumerable and symbols + var gOPN = require('./_object-gopn'); + var gOPS = require('./_object-gops'); + var anObject = require('./_an-object'); + var Reflect = require('./_global').Reflect; + module.exports = Reflect && Reflect.ownKeys || function ownKeys(it) { + var keys = gOPN.f(anObject(it)); + var getSymbols = gOPS.f; + return getSymbols ? keys.concat(getSymbols(it)) : keys; + }; + + },{"./_an-object":78,"./_global":112,"./_object-gopn":148,"./_object-gops":149}],157:[function(require,module,exports){ + var $parseFloat = require('./_global').parseFloat; + var $trim = require('./_string-trim').trim; + + module.exports = 1 / $parseFloat(require('./_string-ws') + '-0') !== -Infinity ? function parseFloat(str) { + var string = $trim(String(str), 3); + var result = $parseFloat(string); + return result === 0 && string.charAt(0) == '-' ? -0 : result; + } : $parseFloat; + + },{"./_global":112,"./_string-trim":182,"./_string-ws":183}],158:[function(require,module,exports){ + var $parseInt = require('./_global').parseInt; + var $trim = require('./_string-trim').trim; + var ws = require('./_string-ws'); + var hex = /^[-+]?0[xX]/; + + module.exports = $parseInt(ws + '08') !== 8 || $parseInt(ws + '0x16') !== 22 ? function parseInt(str, radix) { + var string = $trim(String(str), 3); + return $parseInt(string, (radix >>> 0) || (hex.test(string) ? 16 : 10)); + } : $parseInt; + + },{"./_global":112,"./_string-trim":182,"./_string-ws":183}],159:[function(require,module,exports){ + module.exports = function (exec) { + try { + return { e: false, v: exec() }; + } catch (e) { + return { e: true, v: e }; + } + }; + + },{}],160:[function(require,module,exports){ + var anObject = require('./_an-object'); + var isObject = require('./_is-object'); + var newPromiseCapability = require('./_new-promise-capability'); + + module.exports = function (C, x) { + anObject(C); + if (isObject(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; + }; + + },{"./_an-object":78,"./_is-object":123,"./_new-promise-capability":140}],161:[function(require,module,exports){ + module.exports = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; + }; + + },{}],162:[function(require,module,exports){ + var redefine = require('./_redefine'); + module.exports = function (target, src, safe) { + for (var key in src) redefine(target, key, src[key], safe); + return target; + }; + + },{"./_redefine":163}],163:[function(require,module,exports){ + var global = require('./_global'); + var hide = require('./_hide'); + var has = require('./_has'); + var SRC = require('./_uid')('src'); + var $toString = require('./_function-to-string'); + var TO_STRING = 'toString'; + var TPL = ('' + $toString).split(TO_STRING); + + require('./_core').inspectSource = function (it) { + return $toString.call(it); + }; + + (module.exports = function (O, key, val, safe) { + var isFunction = typeof val == 'function'; + if (isFunction) has(val, 'name') || hide(val, 'name', key); + if (O[key] === val) return; + if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key))); + if (O === global) { + O[key] = val; + } else if (!safe) { + delete O[key]; + hide(O, key, val); + } else if (O[key]) { + O[key] = val; + } else { + hide(O, key, val); + } + // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative + })(Function.prototype, TO_STRING, function toString() { + return typeof this == 'function' && this[SRC] || $toString.call(this); + }); + + },{"./_core":94,"./_function-to-string":111,"./_global":112,"./_has":113,"./_hide":114,"./_uid":195}],164:[function(require,module,exports){ + 'use strict'; + + var classof = require('./_classof'); + var builtinExec = RegExp.prototype.exec; + + // `RegExpExec` abstract operation + // https://tc39.github.io/ecma262/#sec-regexpexec + module.exports = function (R, S) { + var exec = R.exec; + if (typeof exec === 'function') { + var result = exec.call(R, S); + if (typeof result !== 'object') { + throw new TypeError('RegExp exec method returned something other than an Object or null'); + } + return result; + } + if (classof(R) !== 'RegExp') { + throw new TypeError('RegExp#exec called on incompatible receiver'); + } + return builtinExec.call(R, S); + }; + + },{"./_classof":88}],165:[function(require,module,exports){ + 'use strict'; + + var regexpFlags = require('./_flags'); + + var nativeExec = RegExp.prototype.exec; + // This always refers to the native implementation, because the + // String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js, + // which loads this file before patching the method. + var nativeReplace = String.prototype.replace; + + var patchedExec = nativeExec; + + var LAST_INDEX = 'lastIndex'; + + var UPDATES_LAST_INDEX_WRONG = (function () { + var re1 = /a/, + re2 = /b*/g; + nativeExec.call(re1, 'a'); + nativeExec.call(re2, 'a'); + return re1[LAST_INDEX] !== 0 || re2[LAST_INDEX] !== 0; + })(); + + // nonparticipating capturing group, copied from es5-shim's String#split patch. + var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; + + var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED; + + if (PATCH) { + patchedExec = function exec(str) { + var re = this; + var lastIndex, reCopy, match, i; + + if (NPCG_INCLUDED) { + reCopy = new RegExp('^' + re.source + '$(?!\\s)', regexpFlags.call(re)); + } + if (UPDATES_LAST_INDEX_WRONG) lastIndex = re[LAST_INDEX]; + + match = nativeExec.call(re, str); + + if (UPDATES_LAST_INDEX_WRONG && match) { + re[LAST_INDEX] = re.global ? match.index + match[0].length : lastIndex; + } + if (NPCG_INCLUDED && match && match.length > 1) { + // Fix browsers whose `exec` methods don't consistently return `undefined` + // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/ + // eslint-disable-next-line no-loop-func + nativeReplace.call(match[0], reCopy, function () { + for (i = 1; i < arguments.length - 2; i++) { + if (arguments[i] === undefined) match[i] = undefined; + } + }); + } + + return match; + }; + } + + module.exports = patchedExec; + + },{"./_flags":108}],166:[function(require,module,exports){ + module.exports = function (regExp, replace) { + var replacer = replace === Object(replace) ? function (part) { + return replace[part]; + } : replace; + return function (it) { + return String(it).replace(regExp, replacer); + }; + }; + + },{}],167:[function(require,module,exports){ + // 7.2.9 SameValue(x, y) + module.exports = Object.is || function is(x, y) { + // eslint-disable-next-line no-self-compare + return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y; + }; + + },{}],168:[function(require,module,exports){ + 'use strict'; + // https://tc39.github.io/proposal-setmap-offrom/ + var $export = require('./_export'); + var aFunction = require('./_a-function'); + var ctx = require('./_ctx'); + var forOf = require('./_for-of'); + + module.exports = function (COLLECTION) { + $export($export.S, COLLECTION, { from: function from(source /* , mapFn, thisArg */) { + var mapFn = arguments[1]; + var mapping, A, n, cb; + aFunction(this); + mapping = mapFn !== undefined; + if (mapping) aFunction(mapFn); + if (source == undefined) return new this(); + A = []; + if (mapping) { + n = 0; + cb = ctx(mapFn, arguments[2], 2); + forOf(source, false, function (nextItem) { + A.push(cb(nextItem, n++)); + }); + } else { + forOf(source, false, A.push, A); + } + return new this(A); + } }); + }; + + },{"./_a-function":73,"./_ctx":96,"./_export":104,"./_for-of":110}],169:[function(require,module,exports){ + 'use strict'; + // https://tc39.github.io/proposal-setmap-offrom/ + var $export = require('./_export'); + + module.exports = function (COLLECTION) { + $export($export.S, COLLECTION, { of: function of() { + var length = arguments.length; + var A = new Array(length); + while (length--) A[length] = arguments[length]; + return new this(A); + } }); + }; + + },{"./_export":104}],170:[function(require,module,exports){ + // Works with __proto__ only. Old v8 can't work with null proto objects. + /* eslint-disable no-proto */ + var isObject = require('./_is-object'); + var anObject = require('./_an-object'); + var check = function (O, proto) { + anObject(O); + if (!isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!"); + }; + module.exports = { + set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line + function (test, buggy, set) { + try { + set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2); + set(test, []); + buggy = !(test instanceof Array); + } catch (e) { buggy = true; } + return function setPrototypeOf(O, proto) { + check(O, proto); + if (buggy) O.__proto__ = proto; + else set(O, proto); + return O; + }; + }({}, false) : undefined), + check: check + }; + + },{"./_an-object":78,"./_ctx":96,"./_is-object":123,"./_object-gopd":146}],171:[function(require,module,exports){ + 'use strict'; + var global = require('./_global'); + var dP = require('./_object-dp'); + var DESCRIPTORS = require('./_descriptors'); + var SPECIES = require('./_wks')('species'); + + module.exports = function (KEY) { + var C = global[KEY]; + if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, { + configurable: true, + get: function () { return this; } + }); + }; + + },{"./_descriptors":100,"./_global":112,"./_object-dp":143,"./_wks":200}],172:[function(require,module,exports){ + var def = require('./_object-dp').f; + var has = require('./_has'); + var TAG = require('./_wks')('toStringTag'); + + module.exports = function (it, tag, stat) { + if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag }); + }; + + },{"./_has":113,"./_object-dp":143,"./_wks":200}],173:[function(require,module,exports){ + var shared = require('./_shared')('keys'); + var uid = require('./_uid'); + module.exports = function (key) { + return shared[key] || (shared[key] = uid(key)); + }; + + },{"./_shared":174,"./_uid":195}],174:[function(require,module,exports){ + var core = require('./_core'); + var global = require('./_global'); + var SHARED = '__core-js_shared__'; + var store = global[SHARED] || (global[SHARED] = {}); + + (module.exports = function (key, value) { + return store[key] || (store[key] = value !== undefined ? value : {}); + })('versions', []).push({ + version: core.version, + mode: require('./_library') ? 'pure' : 'global', + copyright: '© 2020 Denis Pushkarev (zloirock.ru)' + }); + + },{"./_core":94,"./_global":112,"./_library":131}],175:[function(require,module,exports){ + // 7.3.20 SpeciesConstructor(O, defaultConstructor) + var anObject = require('./_an-object'); + var aFunction = require('./_a-function'); + var SPECIES = require('./_wks')('species'); + module.exports = function (O, D) { + var C = anObject(O).constructor; + var S; + return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S); + }; + + },{"./_a-function":73,"./_an-object":78,"./_wks":200}],176:[function(require,module,exports){ + 'use strict'; + var fails = require('./_fails'); + + module.exports = function (method, arg) { + return !!method && fails(function () { + // eslint-disable-next-line no-useless-call + arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null); + }); + }; + + },{"./_fails":106}],177:[function(require,module,exports){ + var toInteger = require('./_to-integer'); + var defined = require('./_defined'); + // true -> String#at + // false -> String#codePointAt + module.exports = function (TO_STRING) { + return function (that, pos) { + var s = String(defined(that)); + var i = toInteger(pos); + var l = s.length; + var a, b; + if (i < 0 || i >= l) return TO_STRING ? '' : undefined; + a = s.charCodeAt(i); + return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff + ? TO_STRING ? s.charAt(i) : a + : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000; + }; + }; + + },{"./_defined":99,"./_to-integer":187}],178:[function(require,module,exports){ + // helper for String#{startsWith, endsWith, includes} + var isRegExp = require('./_is-regexp'); + var defined = require('./_defined'); + + module.exports = function (that, searchString, NAME) { + if (isRegExp(searchString)) throw TypeError('String#' + NAME + " doesn't accept regex!"); + return String(defined(that)); + }; + + },{"./_defined":99,"./_is-regexp":124}],179:[function(require,module,exports){ + var $export = require('./_export'); + var fails = require('./_fails'); + var defined = require('./_defined'); + var quot = /"/g; + // B.2.3.2.1 CreateHTML(string, tag, attribute, value) + var createHTML = function (string, tag, attribute, value) { + var S = String(defined(string)); + var p1 = '<' + tag; + if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '"') + '"'; + return p1 + '>' + S + ''; + }; + module.exports = function (NAME, exec) { + var O = {}; + O[NAME] = exec(createHTML); + $export($export.P + $export.F * fails(function () { + var test = ''[NAME]('"'); + return test !== test.toLowerCase() || test.split('"').length > 3; + }), 'String', O); + }; + + },{"./_defined":99,"./_export":104,"./_fails":106}],180:[function(require,module,exports){ + // https://github.com/tc39/proposal-string-pad-start-end + var toLength = require('./_to-length'); + var repeat = require('./_string-repeat'); + var defined = require('./_defined'); + + module.exports = function (that, maxLength, fillString, left) { + var S = String(defined(that)); + var stringLength = S.length; + var fillStr = fillString === undefined ? ' ' : String(fillString); + var intMaxLength = toLength(maxLength); + if (intMaxLength <= stringLength || fillStr == '') return S; + var fillLen = intMaxLength - stringLength; + var stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length)); + if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen); + return left ? stringFiller + S : S + stringFiller; + }; + + },{"./_defined":99,"./_string-repeat":181,"./_to-length":189}],181:[function(require,module,exports){ + 'use strict'; + var toInteger = require('./_to-integer'); + var defined = require('./_defined'); + + module.exports = function repeat(count) { + var str = String(defined(this)); + var res = ''; + var n = toInteger(count); + if (n < 0 || n == Infinity) throw RangeError("Count can't be negative"); + for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) res += str; + return res; + }; + + },{"./_defined":99,"./_to-integer":187}],182:[function(require,module,exports){ + var $export = require('./_export'); + var defined = require('./_defined'); + var fails = require('./_fails'); + var spaces = require('./_string-ws'); + var space = '[' + spaces + ']'; + var non = '\u200b\u0085'; + var ltrim = RegExp('^' + space + space + '*'); + var rtrim = RegExp(space + space + '*$'); + + var exporter = function (KEY, exec, ALIAS) { + var exp = {}; + var FORCE = fails(function () { + return !!spaces[KEY]() || non[KEY]() != non; + }); + var fn = exp[KEY] = FORCE ? exec(trim) : spaces[KEY]; + if (ALIAS) exp[ALIAS] = fn; + $export($export.P + $export.F * FORCE, 'String', exp); + }; + + // 1 -> String#trimLeft + // 2 -> String#trimRight + // 3 -> String#trim + var trim = exporter.trim = function (string, TYPE) { + string = String(defined(string)); + if (TYPE & 1) string = string.replace(ltrim, ''); + if (TYPE & 2) string = string.replace(rtrim, ''); + return string; + }; + + module.exports = exporter; + + },{"./_defined":99,"./_export":104,"./_fails":106,"./_string-ws":183}],183:[function(require,module,exports){ + module.exports = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' + + '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + + },{}],184:[function(require,module,exports){ + var ctx = require('./_ctx'); + var invoke = require('./_invoke'); + var html = require('./_html'); + var cel = require('./_dom-create'); + var global = require('./_global'); + var process = global.process; + var setTask = global.setImmediate; + var clearTask = global.clearImmediate; + var MessageChannel = global.MessageChannel; + var Dispatch = global.Dispatch; + var counter = 0; + var queue = {}; + var ONREADYSTATECHANGE = 'onreadystatechange'; + var defer, channel, port; + var run = function () { + var id = +this; + // eslint-disable-next-line no-prototype-builtins + if (queue.hasOwnProperty(id)) { + var fn = queue[id]; + delete queue[id]; + fn(); + } + }; + var listener = function (event) { + run.call(event.data); + }; + // Node.js 0.9+ & IE10+ has setImmediate, otherwise: + if (!setTask || !clearTask) { + setTask = function setImmediate(fn) { + var args = []; + var i = 1; + while (arguments.length > i) args.push(arguments[i++]); + queue[++counter] = function () { + // eslint-disable-next-line no-new-func + invoke(typeof fn == 'function' ? fn : Function(fn), args); + }; + defer(counter); + return counter; + }; + clearTask = function clearImmediate(id) { + delete queue[id]; + }; + // Node.js 0.8- + if (require('./_cof')(process) == 'process') { + defer = function (id) { + process.nextTick(ctx(run, id, 1)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(ctx(run, id, 1)); + }; + // Browsers with MessageChannel, includes WebWorkers + } else if (MessageChannel) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = listener; + defer = ctx(port.postMessage, port, 1); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) { + defer = function (id) { + global.postMessage(id + '', '*'); + }; + global.addEventListener('message', listener, false); + // IE8- + } else if (ONREADYSTATECHANGE in cel('script')) { + defer = function (id) { + html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () { + html.removeChild(this); + run.call(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(ctx(run, id, 1), 0); + }; + } + } + module.exports = { + set: setTask, + clear: clearTask + }; + + },{"./_cof":89,"./_ctx":96,"./_dom-create":101,"./_global":112,"./_html":115,"./_invoke":118}],185:[function(require,module,exports){ + var toInteger = require('./_to-integer'); + var max = Math.max; + var min = Math.min; + module.exports = function (index, length) { + index = toInteger(index); + return index < 0 ? max(index + length, 0) : min(index, length); + }; + + },{"./_to-integer":187}],186:[function(require,module,exports){ + // https://tc39.github.io/ecma262/#sec-toindex + var toInteger = require('./_to-integer'); + var toLength = require('./_to-length'); + module.exports = function (it) { + if (it === undefined) return 0; + var number = toInteger(it); + var length = toLength(number); + if (number !== length) throw RangeError('Wrong length!'); + return length; + }; + + },{"./_to-integer":187,"./_to-length":189}],187:[function(require,module,exports){ + // 7.1.4 ToInteger + var ceil = Math.ceil; + var floor = Math.floor; + module.exports = function (it) { + return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); + }; + + },{}],188:[function(require,module,exports){ + // to indexed object, toObject with fallback for non-array-like ES3 strings + var IObject = require('./_iobject'); + var defined = require('./_defined'); + module.exports = function (it) { + return IObject(defined(it)); + }; + + },{"./_defined":99,"./_iobject":119}],189:[function(require,module,exports){ + // 7.1.15 ToLength + var toInteger = require('./_to-integer'); + var min = Math.min; + module.exports = function (it) { + return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 + }; + + },{"./_to-integer":187}],190:[function(require,module,exports){ + // 7.1.13 ToObject(argument) + var defined = require('./_defined'); + module.exports = function (it) { + return Object(defined(it)); + }; + + },{"./_defined":99}],191:[function(require,module,exports){ + // 7.1.1 ToPrimitive(input [, PreferredType]) + var isObject = require('./_is-object'); + // instead of the ES6 spec version, we didn't implement @@toPrimitive case + // and the second argument - flag - preferred type is a string + module.exports = function (it, S) { + if (!isObject(it)) return it; + var fn, val; + if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; + if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val; + if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; + throw TypeError("Can't convert object to primitive value"); + }; + + },{"./_is-object":123}],192:[function(require,module,exports){ + 'use strict'; + if (require('./_descriptors')) { + var LIBRARY = require('./_library'); + var global = require('./_global'); + var fails = require('./_fails'); + var $export = require('./_export'); + var $typed = require('./_typed'); + var $buffer = require('./_typed-buffer'); + var ctx = require('./_ctx'); + var anInstance = require('./_an-instance'); + var propertyDesc = require('./_property-desc'); + var hide = require('./_hide'); + var redefineAll = require('./_redefine-all'); + var toInteger = require('./_to-integer'); + var toLength = require('./_to-length'); + var toIndex = require('./_to-index'); + var toAbsoluteIndex = require('./_to-absolute-index'); + var toPrimitive = require('./_to-primitive'); + var has = require('./_has'); + var classof = require('./_classof'); + var isObject = require('./_is-object'); + var toObject = require('./_to-object'); + var isArrayIter = require('./_is-array-iter'); + var create = require('./_object-create'); + var getPrototypeOf = require('./_object-gpo'); + var gOPN = require('./_object-gopn').f; + var getIterFn = require('./core.get-iterator-method'); + var uid = require('./_uid'); + var wks = require('./_wks'); + var createArrayMethod = require('./_array-methods'); + var createArrayIncludes = require('./_array-includes'); + var speciesConstructor = require('./_species-constructor'); + var ArrayIterators = require('./es6.array.iterator'); + var Iterators = require('./_iterators'); + var $iterDetect = require('./_iter-detect'); + var setSpecies = require('./_set-species'); + var arrayFill = require('./_array-fill'); + var arrayCopyWithin = require('./_array-copy-within'); + var $DP = require('./_object-dp'); + var $GOPD = require('./_object-gopd'); + var dP = $DP.f; + var gOPD = $GOPD.f; + var RangeError = global.RangeError; + var TypeError = global.TypeError; + var Uint8Array = global.Uint8Array; + var ARRAY_BUFFER = 'ArrayBuffer'; + var SHARED_BUFFER = 'Shared' + ARRAY_BUFFER; + var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT'; + var PROTOTYPE = 'prototype'; + var ArrayProto = Array[PROTOTYPE]; + var $ArrayBuffer = $buffer.ArrayBuffer; + var $DataView = $buffer.DataView; + var arrayForEach = createArrayMethod(0); + var arrayFilter = createArrayMethod(2); + var arraySome = createArrayMethod(3); + var arrayEvery = createArrayMethod(4); + var arrayFind = createArrayMethod(5); + var arrayFindIndex = createArrayMethod(6); + var arrayIncludes = createArrayIncludes(true); + var arrayIndexOf = createArrayIncludes(false); + var arrayValues = ArrayIterators.values; + var arrayKeys = ArrayIterators.keys; + var arrayEntries = ArrayIterators.entries; + var arrayLastIndexOf = ArrayProto.lastIndexOf; + var arrayReduce = ArrayProto.reduce; + var arrayReduceRight = ArrayProto.reduceRight; + var arrayJoin = ArrayProto.join; + var arraySort = ArrayProto.sort; + var arraySlice = ArrayProto.slice; + var arrayToString = ArrayProto.toString; + var arrayToLocaleString = ArrayProto.toLocaleString; + var ITERATOR = wks('iterator'); + var TAG = wks('toStringTag'); + var TYPED_CONSTRUCTOR = uid('typed_constructor'); + var DEF_CONSTRUCTOR = uid('def_constructor'); + var ALL_CONSTRUCTORS = $typed.CONSTR; + var TYPED_ARRAY = $typed.TYPED; + var VIEW = $typed.VIEW; + var WRONG_LENGTH = 'Wrong length!'; + + var $map = createArrayMethod(1, function (O, length) { + return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length); + }); + + var LITTLE_ENDIAN = fails(function () { + // eslint-disable-next-line no-undef + return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1; + }); + + var FORCED_SET = !!Uint8Array && !!Uint8Array[PROTOTYPE].set && fails(function () { + new Uint8Array(1).set({}); + }); + + var toOffset = function (it, BYTES) { + var offset = toInteger(it); + if (offset < 0 || offset % BYTES) throw RangeError('Wrong offset!'); + return offset; + }; + + var validate = function (it) { + if (isObject(it) && TYPED_ARRAY in it) return it; + throw TypeError(it + ' is not a typed array!'); + }; + + var allocate = function (C, length) { + if (!(isObject(C) && TYPED_CONSTRUCTOR in C)) { + throw TypeError('It is not a typed array constructor!'); + } return new C(length); + }; + + var speciesFromList = function (O, list) { + return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list); + }; + + var fromList = function (C, list) { + var index = 0; + var length = list.length; + var result = allocate(C, length); + while (length > index) result[index] = list[index++]; + return result; + }; + + var addGetter = function (it, key, internal) { + dP(it, key, { get: function () { return this._d[internal]; } }); + }; + + var $from = function from(source /* , mapfn, thisArg */) { + var O = toObject(source); + var aLen = arguments.length; + var mapfn = aLen > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + var iterFn = getIterFn(O); + var i, length, values, result, step, iterator; + if (iterFn != undefined && !isArrayIter(iterFn)) { + for (iterator = iterFn.call(O), values = [], i = 0; !(step = iterator.next()).done; i++) { + values.push(step.value); + } O = values; + } + if (mapping && aLen > 2) mapfn = ctx(mapfn, arguments[2], 2); + for (i = 0, length = toLength(O.length), result = allocate(this, length); length > i; i++) { + result[i] = mapping ? mapfn(O[i], i) : O[i]; + } + return result; + }; + + var $of = function of(/* ...items */) { + var index = 0; + var length = arguments.length; + var result = allocate(this, length); + while (length > index) result[index] = arguments[index++]; + return result; + }; + + // iOS Safari 6.x fails here + var TO_LOCALE_BUG = !!Uint8Array && fails(function () { arrayToLocaleString.call(new Uint8Array(1)); }); + + var $toLocaleString = function toLocaleString() { + return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this), arguments); + }; + + var proto = { + copyWithin: function copyWithin(target, start /* , end */) { + return arrayCopyWithin.call(validate(this), target, start, arguments.length > 2 ? arguments[2] : undefined); + }, + every: function every(callbackfn /* , thisArg */) { + return arrayEvery(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); + }, + fill: function fill(value /* , start, end */) { // eslint-disable-line no-unused-vars + return arrayFill.apply(validate(this), arguments); + }, + filter: function filter(callbackfn /* , thisArg */) { + return speciesFromList(this, arrayFilter(validate(this), callbackfn, + arguments.length > 1 ? arguments[1] : undefined)); + }, + find: function find(predicate /* , thisArg */) { + return arrayFind(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined); + }, + findIndex: function findIndex(predicate /* , thisArg */) { + return arrayFindIndex(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined); + }, + forEach: function forEach(callbackfn /* , thisArg */) { + arrayForEach(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); + }, + indexOf: function indexOf(searchElement /* , fromIndex */) { + return arrayIndexOf(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); + }, + includes: function includes(searchElement /* , fromIndex */) { + return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); + }, + join: function join(separator) { // eslint-disable-line no-unused-vars + return arrayJoin.apply(validate(this), arguments); + }, + lastIndexOf: function lastIndexOf(searchElement /* , fromIndex */) { // eslint-disable-line no-unused-vars + return arrayLastIndexOf.apply(validate(this), arguments); + }, + map: function map(mapfn /* , thisArg */) { + return $map(validate(this), mapfn, arguments.length > 1 ? arguments[1] : undefined); + }, + reduce: function reduce(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars + return arrayReduce.apply(validate(this), arguments); + }, + reduceRight: function reduceRight(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars + return arrayReduceRight.apply(validate(this), arguments); + }, + reverse: function reverse() { + var that = this; + var length = validate(that).length; + var middle = Math.floor(length / 2); + var index = 0; + var value; + while (index < middle) { + value = that[index]; + that[index++] = that[--length]; + that[length] = value; + } return that; + }, + some: function some(callbackfn /* , thisArg */) { + return arraySome(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); + }, + sort: function sort(comparefn) { + return arraySort.call(validate(this), comparefn); + }, + subarray: function subarray(begin, end) { + var O = validate(this); + var length = O.length; + var $begin = toAbsoluteIndex(begin, length); + return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))( + O.buffer, + O.byteOffset + $begin * O.BYTES_PER_ELEMENT, + toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - $begin) + ); + } + }; + + var $slice = function slice(start, end) { + return speciesFromList(this, arraySlice.call(validate(this), start, end)); + }; + + var $set = function set(arrayLike /* , offset */) { + validate(this); + var offset = toOffset(arguments[1], 1); + var length = this.length; + var src = toObject(arrayLike); + var len = toLength(src.length); + var index = 0; + if (len + offset > length) throw RangeError(WRONG_LENGTH); + while (index < len) this[offset + index] = src[index++]; + }; + + var $iterators = { + entries: function entries() { + return arrayEntries.call(validate(this)); + }, + keys: function keys() { + return arrayKeys.call(validate(this)); + }, + values: function values() { + return arrayValues.call(validate(this)); + } + }; + + var isTAIndex = function (target, key) { + return isObject(target) + && target[TYPED_ARRAY] + && typeof key != 'symbol' + && key in target + && String(+key) == String(key); + }; + var $getDesc = function getOwnPropertyDescriptor(target, key) { + return isTAIndex(target, key = toPrimitive(key, true)) + ? propertyDesc(2, target[key]) + : gOPD(target, key); + }; + var $setDesc = function defineProperty(target, key, desc) { + if (isTAIndex(target, key = toPrimitive(key, true)) + && isObject(desc) + && has(desc, 'value') + && !has(desc, 'get') + && !has(desc, 'set') + // TODO: add validation descriptor w/o calling accessors + && !desc.configurable + && (!has(desc, 'writable') || desc.writable) + && (!has(desc, 'enumerable') || desc.enumerable) + ) { + target[key] = desc.value; + return target; + } return dP(target, key, desc); + }; + + if (!ALL_CONSTRUCTORS) { + $GOPD.f = $getDesc; + $DP.f = $setDesc; + } + + $export($export.S + $export.F * !ALL_CONSTRUCTORS, 'Object', { + getOwnPropertyDescriptor: $getDesc, + defineProperty: $setDesc + }); + + if (fails(function () { arrayToString.call({}); })) { + arrayToString = arrayToLocaleString = function toString() { + return arrayJoin.call(this); + }; + } + + var $TypedArrayPrototype$ = redefineAll({}, proto); + redefineAll($TypedArrayPrototype$, $iterators); + hide($TypedArrayPrototype$, ITERATOR, $iterators.values); + redefineAll($TypedArrayPrototype$, { + slice: $slice, + set: $set, + constructor: function () { /* noop */ }, + toString: arrayToString, + toLocaleString: $toLocaleString + }); + addGetter($TypedArrayPrototype$, 'buffer', 'b'); + addGetter($TypedArrayPrototype$, 'byteOffset', 'o'); + addGetter($TypedArrayPrototype$, 'byteLength', 'l'); + addGetter($TypedArrayPrototype$, 'length', 'e'); + dP($TypedArrayPrototype$, TAG, { + get: function () { return this[TYPED_ARRAY]; } + }); + + // eslint-disable-next-line max-statements + module.exports = function (KEY, BYTES, wrapper, CLAMPED) { + CLAMPED = !!CLAMPED; + var NAME = KEY + (CLAMPED ? 'Clamped' : '') + 'Array'; + var GETTER = 'get' + KEY; + var SETTER = 'set' + KEY; + var TypedArray = global[NAME]; + var Base = TypedArray || {}; + var TAC = TypedArray && getPrototypeOf(TypedArray); + var FORCED = !TypedArray || !$typed.ABV; + var O = {}; + var TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE]; + var getter = function (that, index) { + var data = that._d; + return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN); + }; + var setter = function (that, index, value) { + var data = that._d; + if (CLAMPED) value = (value = Math.round(value)) < 0 ? 0 : value > 0xff ? 0xff : value & 0xff; + data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN); + }; + var addElement = function (that, index) { + dP(that, index, { + get: function () { + return getter(this, index); + }, + set: function (value) { + return setter(this, index, value); + }, + enumerable: true + }); + }; + if (FORCED) { + TypedArray = wrapper(function (that, data, $offset, $length) { + anInstance(that, TypedArray, NAME, '_d'); + var index = 0; + var offset = 0; + var buffer, byteLength, length, klass; + if (!isObject(data)) { + length = toIndex(data); + byteLength = length * BYTES; + buffer = new $ArrayBuffer(byteLength); + } else if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) { + buffer = data; + offset = toOffset($offset, BYTES); + var $len = data.byteLength; + if ($length === undefined) { + if ($len % BYTES) throw RangeError(WRONG_LENGTH); + byteLength = $len - offset; + if (byteLength < 0) throw RangeError(WRONG_LENGTH); + } else { + byteLength = toLength($length) * BYTES; + if (byteLength + offset > $len) throw RangeError(WRONG_LENGTH); + } + length = byteLength / BYTES; + } else if (TYPED_ARRAY in data) { + return fromList(TypedArray, data); + } else { + return $from.call(TypedArray, data); + } + hide(that, '_d', { + b: buffer, + o: offset, + l: byteLength, + e: length, + v: new $DataView(buffer) + }); + while (index < length) addElement(that, index++); + }); + TypedArrayPrototype = TypedArray[PROTOTYPE] = create($TypedArrayPrototype$); + hide(TypedArrayPrototype, 'constructor', TypedArray); + } else if (!fails(function () { + TypedArray(1); + }) || !fails(function () { + new TypedArray(-1); // eslint-disable-line no-new + }) || !$iterDetect(function (iter) { + new TypedArray(); // eslint-disable-line no-new + new TypedArray(null); // eslint-disable-line no-new + new TypedArray(1.5); // eslint-disable-line no-new + new TypedArray(iter); // eslint-disable-line no-new + }, true)) { + TypedArray = wrapper(function (that, data, $offset, $length) { + anInstance(that, TypedArray, NAME); + var klass; + // `ws` module bug, temporarily remove validation length for Uint8Array + // https://github.com/websockets/ws/pull/645 + if (!isObject(data)) return new Base(toIndex(data)); + if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) { + return $length !== undefined + ? new Base(data, toOffset($offset, BYTES), $length) + : $offset !== undefined + ? new Base(data, toOffset($offset, BYTES)) + : new Base(data); + } + if (TYPED_ARRAY in data) return fromList(TypedArray, data); + return $from.call(TypedArray, data); + }); + arrayForEach(TAC !== Function.prototype ? gOPN(Base).concat(gOPN(TAC)) : gOPN(Base), function (key) { + if (!(key in TypedArray)) hide(TypedArray, key, Base[key]); + }); + TypedArray[PROTOTYPE] = TypedArrayPrototype; + if (!LIBRARY) TypedArrayPrototype.constructor = TypedArray; + } + var $nativeIterator = TypedArrayPrototype[ITERATOR]; + var CORRECT_ITER_NAME = !!$nativeIterator + && ($nativeIterator.name == 'values' || $nativeIterator.name == undefined); + var $iterator = $iterators.values; + hide(TypedArray, TYPED_CONSTRUCTOR, true); + hide(TypedArrayPrototype, TYPED_ARRAY, NAME); + hide(TypedArrayPrototype, VIEW, true); + hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray); + + if (CLAMPED ? new TypedArray(1)[TAG] != NAME : !(TAG in TypedArrayPrototype)) { + dP(TypedArrayPrototype, TAG, { + get: function () { return NAME; } + }); + } + + O[NAME] = TypedArray; + + $export($export.G + $export.W + $export.F * (TypedArray != Base), O); + + $export($export.S, NAME, { + BYTES_PER_ELEMENT: BYTES + }); + + $export($export.S + $export.F * fails(function () { Base.of.call(TypedArray, 1); }), NAME, { + from: $from, + of: $of + }); + + if (!(BYTES_PER_ELEMENT in TypedArrayPrototype)) hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES); + + $export($export.P, NAME, proto); + + setSpecies(NAME); + + $export($export.P + $export.F * FORCED_SET, NAME, { set: $set }); + + $export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators); + + if (!LIBRARY && TypedArrayPrototype.toString != arrayToString) TypedArrayPrototype.toString = arrayToString; + + $export($export.P + $export.F * fails(function () { + new TypedArray(1).slice(); + }), NAME, { slice: $slice }); + + $export($export.P + $export.F * (fails(function () { + return [1, 2].toLocaleString() != new TypedArray([1, 2]).toLocaleString(); + }) || !fails(function () { + TypedArrayPrototype.toLocaleString.call([1, 2]); + })), NAME, { toLocaleString: $toLocaleString }); + + Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator; + if (!LIBRARY && !CORRECT_ITER_NAME) hide(TypedArrayPrototype, ITERATOR, $iterator); + }; + } else module.exports = function () { /* empty */ }; + + },{"./_an-instance":77,"./_array-copy-within":79,"./_array-fill":80,"./_array-includes":82,"./_array-methods":83,"./_classof":88,"./_ctx":96,"./_descriptors":100,"./_export":104,"./_fails":106,"./_global":112,"./_has":113,"./_hide":114,"./_is-array-iter":120,"./_is-object":123,"./_iter-detect":128,"./_iterators":130,"./_library":131,"./_object-create":142,"./_object-dp":143,"./_object-gopd":146,"./_object-gopn":148,"./_object-gpo":150,"./_property-desc":161,"./_redefine-all":162,"./_set-species":171,"./_species-constructor":175,"./_to-absolute-index":185,"./_to-index":186,"./_to-integer":187,"./_to-length":189,"./_to-object":190,"./_to-primitive":191,"./_typed":194,"./_typed-buffer":193,"./_uid":195,"./_wks":200,"./core.get-iterator-method":201,"./es6.array.iterator":213}],193:[function(require,module,exports){ + 'use strict'; + var global = require('./_global'); + var DESCRIPTORS = require('./_descriptors'); + var LIBRARY = require('./_library'); + var $typed = require('./_typed'); + var hide = require('./_hide'); + var redefineAll = require('./_redefine-all'); + var fails = require('./_fails'); + var anInstance = require('./_an-instance'); + var toInteger = require('./_to-integer'); + var toLength = require('./_to-length'); + var toIndex = require('./_to-index'); + var gOPN = require('./_object-gopn').f; + var dP = require('./_object-dp').f; + var arrayFill = require('./_array-fill'); + var setToStringTag = require('./_set-to-string-tag'); + var ARRAY_BUFFER = 'ArrayBuffer'; + var DATA_VIEW = 'DataView'; + var PROTOTYPE = 'prototype'; + var WRONG_LENGTH = 'Wrong length!'; + var WRONG_INDEX = 'Wrong index!'; + var $ArrayBuffer = global[ARRAY_BUFFER]; + var $DataView = global[DATA_VIEW]; + var Math = global.Math; + var RangeError = global.RangeError; + // eslint-disable-next-line no-shadow-restricted-names + var Infinity = global.Infinity; + var BaseBuffer = $ArrayBuffer; + var abs = Math.abs; + var pow = Math.pow; + var floor = Math.floor; + var log = Math.log; + var LN2 = Math.LN2; + var BUFFER = 'buffer'; + var BYTE_LENGTH = 'byteLength'; + var BYTE_OFFSET = 'byteOffset'; + var $BUFFER = DESCRIPTORS ? '_b' : BUFFER; + var $LENGTH = DESCRIPTORS ? '_l' : BYTE_LENGTH; + var $OFFSET = DESCRIPTORS ? '_o' : BYTE_OFFSET; + + // IEEE754 conversions based on https://github.com/feross/ieee754 + function packIEEE754(value, mLen, nBytes) { + var buffer = new Array(nBytes); + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var rt = mLen === 23 ? pow(2, -24) - pow(2, -77) : 0; + var i = 0; + var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0; + var e, m, c; + value = abs(value); + // eslint-disable-next-line no-self-compare + if (value != value || value === Infinity) { + // eslint-disable-next-line no-self-compare + m = value != value ? 1 : 0; + e = eMax; + } else { + e = floor(log(value) / LN2); + if (value * (c = pow(2, -e)) < 1) { + e--; + c *= 2; + } + if (e + eBias >= 1) { + value += rt / c; + } else { + value += rt * pow(2, 1 - eBias); + } + if (value * c >= 2) { + e++; + c /= 2; + } + if (e + eBias >= eMax) { + m = 0; + e = eMax; + } else if (e + eBias >= 1) { + m = (value * c - 1) * pow(2, mLen); + e = e + eBias; + } else { + m = value * pow(2, eBias - 1) * pow(2, mLen); + e = 0; + } + } + for (; mLen >= 8; buffer[i++] = m & 255, m /= 256, mLen -= 8); + e = e << mLen | m; + eLen += mLen; + for (; eLen > 0; buffer[i++] = e & 255, e /= 256, eLen -= 8); + buffer[--i] |= s * 128; + return buffer; + } + function unpackIEEE754(buffer, mLen, nBytes) { + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var nBits = eLen - 7; + var i = nBytes - 1; + var s = buffer[i--]; + var e = s & 127; + var m; + s >>= 7; + for (; nBits > 0; e = e * 256 + buffer[i], i--, nBits -= 8); + m = e & (1 << -nBits) - 1; + e >>= -nBits; + nBits += mLen; + for (; nBits > 0; m = m * 256 + buffer[i], i--, nBits -= 8); + if (e === 0) { + e = 1 - eBias; + } else if (e === eMax) { + return m ? NaN : s ? -Infinity : Infinity; + } else { + m = m + pow(2, mLen); + e = e - eBias; + } return (s ? -1 : 1) * m * pow(2, e - mLen); + } + + function unpackI32(bytes) { + return bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0]; + } + function packI8(it) { + return [it & 0xff]; + } + function packI16(it) { + return [it & 0xff, it >> 8 & 0xff]; + } + function packI32(it) { + return [it & 0xff, it >> 8 & 0xff, it >> 16 & 0xff, it >> 24 & 0xff]; + } + function packF64(it) { + return packIEEE754(it, 52, 8); + } + function packF32(it) { + return packIEEE754(it, 23, 4); + } + + function addGetter(C, key, internal) { + dP(C[PROTOTYPE], key, { get: function () { return this[internal]; } }); + } + + function get(view, bytes, index, isLittleEndian) { + var numIndex = +index; + var intIndex = toIndex(numIndex); + if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX); + var store = view[$BUFFER]._b; + var start = intIndex + view[$OFFSET]; + var pack = store.slice(start, start + bytes); + return isLittleEndian ? pack : pack.reverse(); + } + function set(view, bytes, index, conversion, value, isLittleEndian) { + var numIndex = +index; + var intIndex = toIndex(numIndex); + if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX); + var store = view[$BUFFER]._b; + var start = intIndex + view[$OFFSET]; + var pack = conversion(+value); + for (var i = 0; i < bytes; i++) store[start + i] = pack[isLittleEndian ? i : bytes - i - 1]; + } + + if (!$typed.ABV) { + $ArrayBuffer = function ArrayBuffer(length) { + anInstance(this, $ArrayBuffer, ARRAY_BUFFER); + var byteLength = toIndex(length); + this._b = arrayFill.call(new Array(byteLength), 0); + this[$LENGTH] = byteLength; + }; + + $DataView = function DataView(buffer, byteOffset, byteLength) { + anInstance(this, $DataView, DATA_VIEW); + anInstance(buffer, $ArrayBuffer, DATA_VIEW); + var bufferLength = buffer[$LENGTH]; + var offset = toInteger(byteOffset); + if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset!'); + byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength); + if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH); + this[$BUFFER] = buffer; + this[$OFFSET] = offset; + this[$LENGTH] = byteLength; + }; + + if (DESCRIPTORS) { + addGetter($ArrayBuffer, BYTE_LENGTH, '_l'); + addGetter($DataView, BUFFER, '_b'); + addGetter($DataView, BYTE_LENGTH, '_l'); + addGetter($DataView, BYTE_OFFSET, '_o'); + } + + redefineAll($DataView[PROTOTYPE], { + getInt8: function getInt8(byteOffset) { + return get(this, 1, byteOffset)[0] << 24 >> 24; + }, + getUint8: function getUint8(byteOffset) { + return get(this, 1, byteOffset)[0]; + }, + getInt16: function getInt16(byteOffset /* , littleEndian */) { + var bytes = get(this, 2, byteOffset, arguments[1]); + return (bytes[1] << 8 | bytes[0]) << 16 >> 16; + }, + getUint16: function getUint16(byteOffset /* , littleEndian */) { + var bytes = get(this, 2, byteOffset, arguments[1]); + return bytes[1] << 8 | bytes[0]; + }, + getInt32: function getInt32(byteOffset /* , littleEndian */) { + return unpackI32(get(this, 4, byteOffset, arguments[1])); + }, + getUint32: function getUint32(byteOffset /* , littleEndian */) { + return unpackI32(get(this, 4, byteOffset, arguments[1])) >>> 0; + }, + getFloat32: function getFloat32(byteOffset /* , littleEndian */) { + return unpackIEEE754(get(this, 4, byteOffset, arguments[1]), 23, 4); + }, + getFloat64: function getFloat64(byteOffset /* , littleEndian */) { + return unpackIEEE754(get(this, 8, byteOffset, arguments[1]), 52, 8); + }, + setInt8: function setInt8(byteOffset, value) { + set(this, 1, byteOffset, packI8, value); + }, + setUint8: function setUint8(byteOffset, value) { + set(this, 1, byteOffset, packI8, value); + }, + setInt16: function setInt16(byteOffset, value /* , littleEndian */) { + set(this, 2, byteOffset, packI16, value, arguments[2]); + }, + setUint16: function setUint16(byteOffset, value /* , littleEndian */) { + set(this, 2, byteOffset, packI16, value, arguments[2]); + }, + setInt32: function setInt32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packI32, value, arguments[2]); + }, + setUint32: function setUint32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packI32, value, arguments[2]); + }, + setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packF32, value, arguments[2]); + }, + setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) { + set(this, 8, byteOffset, packF64, value, arguments[2]); + } + }); + } else { + if (!fails(function () { + $ArrayBuffer(1); + }) || !fails(function () { + new $ArrayBuffer(-1); // eslint-disable-line no-new + }) || fails(function () { + new $ArrayBuffer(); // eslint-disable-line no-new + new $ArrayBuffer(1.5); // eslint-disable-line no-new + new $ArrayBuffer(NaN); // eslint-disable-line no-new + return $ArrayBuffer.name != ARRAY_BUFFER; + })) { + $ArrayBuffer = function ArrayBuffer(length) { + anInstance(this, $ArrayBuffer); + return new BaseBuffer(toIndex(length)); + }; + var ArrayBufferProto = $ArrayBuffer[PROTOTYPE] = BaseBuffer[PROTOTYPE]; + for (var keys = gOPN(BaseBuffer), j = 0, key; keys.length > j;) { + if (!((key = keys[j++]) in $ArrayBuffer)) hide($ArrayBuffer, key, BaseBuffer[key]); + } + if (!LIBRARY) ArrayBufferProto.constructor = $ArrayBuffer; + } + // iOS Safari 7.x bug + var view = new $DataView(new $ArrayBuffer(2)); + var $setInt8 = $DataView[PROTOTYPE].setInt8; + view.setInt8(0, 2147483648); + view.setInt8(1, 2147483649); + if (view.getInt8(0) || !view.getInt8(1)) redefineAll($DataView[PROTOTYPE], { + setInt8: function setInt8(byteOffset, value) { + $setInt8.call(this, byteOffset, value << 24 >> 24); + }, + setUint8: function setUint8(byteOffset, value) { + $setInt8.call(this, byteOffset, value << 24 >> 24); + } + }, true); + } + setToStringTag($ArrayBuffer, ARRAY_BUFFER); + setToStringTag($DataView, DATA_VIEW); + hide($DataView[PROTOTYPE], $typed.VIEW, true); + exports[ARRAY_BUFFER] = $ArrayBuffer; + exports[DATA_VIEW] = $DataView; + + },{"./_an-instance":77,"./_array-fill":80,"./_descriptors":100,"./_fails":106,"./_global":112,"./_hide":114,"./_library":131,"./_object-dp":143,"./_object-gopn":148,"./_redefine-all":162,"./_set-to-string-tag":172,"./_to-index":186,"./_to-integer":187,"./_to-length":189,"./_typed":194}],194:[function(require,module,exports){ + var global = require('./_global'); + var hide = require('./_hide'); + var uid = require('./_uid'); + var TYPED = uid('typed_array'); + var VIEW = uid('view'); + var ABV = !!(global.ArrayBuffer && global.DataView); + var CONSTR = ABV; + var i = 0; + var l = 9; + var Typed; + + var TypedArrayConstructors = ( + 'Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array' + ).split(','); + + while (i < l) { + if (Typed = global[TypedArrayConstructors[i++]]) { + hide(Typed.prototype, TYPED, true); + hide(Typed.prototype, VIEW, true); + } else CONSTR = false; + } + + module.exports = { + ABV: ABV, + CONSTR: CONSTR, + TYPED: TYPED, + VIEW: VIEW + }; + + },{"./_global":112,"./_hide":114,"./_uid":195}],195:[function(require,module,exports){ + var id = 0; + var px = Math.random(); + module.exports = function (key) { + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); + }; + + },{}],196:[function(require,module,exports){ + var global = require('./_global'); + var navigator = global.navigator; + + module.exports = navigator && navigator.userAgent || ''; + + },{"./_global":112}],197:[function(require,module,exports){ + var isObject = require('./_is-object'); + module.exports = function (it, TYPE) { + if (!isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!'); + return it; + }; + + },{"./_is-object":123}],198:[function(require,module,exports){ + var global = require('./_global'); + var core = require('./_core'); + var LIBRARY = require('./_library'); + var wksExt = require('./_wks-ext'); + var defineProperty = require('./_object-dp').f; + module.exports = function (name) { + var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {}); + if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) }); + }; + + },{"./_core":94,"./_global":112,"./_library":131,"./_object-dp":143,"./_wks-ext":199}],199:[function(require,module,exports){ + exports.f = require('./_wks'); + + },{"./_wks":200}],200:[function(require,module,exports){ + var store = require('./_shared')('wks'); + var uid = require('./_uid'); + var Symbol = require('./_global').Symbol; + var USE_SYMBOL = typeof Symbol == 'function'; + + var $exports = module.exports = function (name) { + return store[name] || (store[name] = + USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name)); + }; + + $exports.store = store; + + },{"./_global":112,"./_shared":174,"./_uid":195}],201:[function(require,module,exports){ + var classof = require('./_classof'); + var ITERATOR = require('./_wks')('iterator'); + var Iterators = require('./_iterators'); + module.exports = require('./_core').getIteratorMethod = function (it) { + if (it != undefined) return it[ITERATOR] + || it['@@iterator'] + || Iterators[classof(it)]; + }; + + },{"./_classof":88,"./_core":94,"./_iterators":130,"./_wks":200}],202:[function(require,module,exports){ + // https://github.com/benjamingr/RexExp.escape + var $export = require('./_export'); + var $re = require('./_replacer')(/[\\^$*+?.()|[\]{}]/g, '\\$&'); + + $export($export.S, 'RegExp', { escape: function escape(it) { return $re(it); } }); + + },{"./_export":104,"./_replacer":166}],203:[function(require,module,exports){ + // 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length) + var $export = require('./_export'); + + $export($export.P, 'Array', { copyWithin: require('./_array-copy-within') }); + + require('./_add-to-unscopables')('copyWithin'); + + },{"./_add-to-unscopables":75,"./_array-copy-within":79,"./_export":104}],204:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $every = require('./_array-methods')(4); + + $export($export.P + $export.F * !require('./_strict-method')([].every, true), 'Array', { + // 22.1.3.5 / 15.4.4.16 Array.prototype.every(callbackfn [, thisArg]) + every: function every(callbackfn /* , thisArg */) { + return $every(this, callbackfn, arguments[1]); + } + }); + + },{"./_array-methods":83,"./_export":104,"./_strict-method":176}],205:[function(require,module,exports){ + // 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length) + var $export = require('./_export'); + + $export($export.P, 'Array', { fill: require('./_array-fill') }); + + require('./_add-to-unscopables')('fill'); + + },{"./_add-to-unscopables":75,"./_array-fill":80,"./_export":104}],206:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $filter = require('./_array-methods')(2); + + $export($export.P + $export.F * !require('./_strict-method')([].filter, true), 'Array', { + // 22.1.3.7 / 15.4.4.20 Array.prototype.filter(callbackfn [, thisArg]) + filter: function filter(callbackfn /* , thisArg */) { + return $filter(this, callbackfn, arguments[1]); + } + }); + + },{"./_array-methods":83,"./_export":104,"./_strict-method":176}],207:[function(require,module,exports){ + 'use strict'; + // 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined) + var $export = require('./_export'); + var $find = require('./_array-methods')(6); + var KEY = 'findIndex'; + var forced = true; + // Shouldn't skip holes + if (KEY in []) Array(1)[KEY](function () { forced = false; }); + $export($export.P + $export.F * forced, 'Array', { + findIndex: function findIndex(callbackfn /* , that = undefined */) { + return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } + }); + require('./_add-to-unscopables')(KEY); + + },{"./_add-to-unscopables":75,"./_array-methods":83,"./_export":104}],208:[function(require,module,exports){ + 'use strict'; + // 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined) + var $export = require('./_export'); + var $find = require('./_array-methods')(5); + var KEY = 'find'; + var forced = true; + // Shouldn't skip holes + if (KEY in []) Array(1)[KEY](function () { forced = false; }); + $export($export.P + $export.F * forced, 'Array', { + find: function find(callbackfn /* , that = undefined */) { + return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } + }); + require('./_add-to-unscopables')(KEY); + + },{"./_add-to-unscopables":75,"./_array-methods":83,"./_export":104}],209:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $forEach = require('./_array-methods')(0); + var STRICT = require('./_strict-method')([].forEach, true); + + $export($export.P + $export.F * !STRICT, 'Array', { + // 22.1.3.10 / 15.4.4.18 Array.prototype.forEach(callbackfn [, thisArg]) + forEach: function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments[1]); + } + }); + + },{"./_array-methods":83,"./_export":104,"./_strict-method":176}],210:[function(require,module,exports){ + 'use strict'; + var ctx = require('./_ctx'); + var $export = require('./_export'); + var toObject = require('./_to-object'); + var call = require('./_iter-call'); + var isArrayIter = require('./_is-array-iter'); + var toLength = require('./_to-length'); + var createProperty = require('./_create-property'); + var getIterFn = require('./core.get-iterator-method'); + + $export($export.S + $export.F * !require('./_iter-detect')(function (iter) { Array.from(iter); }), 'Array', { + // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined) + from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { + var O = toObject(arrayLike); + var C = typeof this == 'function' ? this : Array; + var aLen = arguments.length; + var mapfn = aLen > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + var index = 0; + var iterFn = getIterFn(O); + var length, result, step, iterator; + if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2); + // if object isn't iterable or it's array with default iterator - use simple case + if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) { + for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) { + createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value); + } + } else { + length = toLength(O.length); + for (result = new C(length); length > index; index++) { + createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]); + } + } + result.length = index; + return result; + } + }); + + },{"./_create-property":95,"./_ctx":96,"./_export":104,"./_is-array-iter":120,"./_iter-call":125,"./_iter-detect":128,"./_to-length":189,"./_to-object":190,"./core.get-iterator-method":201}],211:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $indexOf = require('./_array-includes')(false); + var $native = [].indexOf; + var NEGATIVE_ZERO = !!$native && 1 / [1].indexOf(1, -0) < 0; + + $export($export.P + $export.F * (NEGATIVE_ZERO || !require('./_strict-method')($native)), 'Array', { + // 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex]) + indexOf: function indexOf(searchElement /* , fromIndex = 0 */) { + return NEGATIVE_ZERO + // convert -0 to +0 + ? $native.apply(this, arguments) || 0 + : $indexOf(this, searchElement, arguments[1]); + } + }); + + },{"./_array-includes":82,"./_export":104,"./_strict-method":176}],212:[function(require,module,exports){ + // 22.1.2.2 / 15.4.3.2 Array.isArray(arg) + var $export = require('./_export'); + + $export($export.S, 'Array', { isArray: require('./_is-array') }); + + },{"./_export":104,"./_is-array":121}],213:[function(require,module,exports){ + 'use strict'; + var addToUnscopables = require('./_add-to-unscopables'); + var step = require('./_iter-step'); + var Iterators = require('./_iterators'); + var toIObject = require('./_to-iobject'); + + // 22.1.3.4 Array.prototype.entries() + // 22.1.3.13 Array.prototype.keys() + // 22.1.3.29 Array.prototype.values() + // 22.1.3.30 Array.prototype[@@iterator]() + module.exports = require('./_iter-define')(Array, 'Array', function (iterated, kind) { + this._t = toIObject(iterated); // target + this._i = 0; // next index + this._k = kind; // kind + // 22.1.5.2.1 %ArrayIteratorPrototype%.next() + }, function () { + var O = this._t; + var kind = this._k; + var index = this._i++; + if (!O || index >= O.length) { + this._t = undefined; + return step(1); + } + if (kind == 'keys') return step(0, index); + if (kind == 'values') return step(0, O[index]); + return step(0, [index, O[index]]); + }, 'values'); + + // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7) + Iterators.Arguments = Iterators.Array; + + addToUnscopables('keys'); + addToUnscopables('values'); + addToUnscopables('entries'); + + },{"./_add-to-unscopables":75,"./_iter-define":127,"./_iter-step":129,"./_iterators":130,"./_to-iobject":188}],214:[function(require,module,exports){ + 'use strict'; + // 22.1.3.13 Array.prototype.join(separator) + var $export = require('./_export'); + var toIObject = require('./_to-iobject'); + var arrayJoin = [].join; + + // fallback for not array-like strings + $export($export.P + $export.F * (require('./_iobject') != Object || !require('./_strict-method')(arrayJoin)), 'Array', { + join: function join(separator) { + return arrayJoin.call(toIObject(this), separator === undefined ? ',' : separator); + } + }); + + },{"./_export":104,"./_iobject":119,"./_strict-method":176,"./_to-iobject":188}],215:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var toIObject = require('./_to-iobject'); + var toInteger = require('./_to-integer'); + var toLength = require('./_to-length'); + var $native = [].lastIndexOf; + var NEGATIVE_ZERO = !!$native && 1 / [1].lastIndexOf(1, -0) < 0; + + $export($export.P + $export.F * (NEGATIVE_ZERO || !require('./_strict-method')($native)), 'Array', { + // 22.1.3.14 / 15.4.4.15 Array.prototype.lastIndexOf(searchElement [, fromIndex]) + lastIndexOf: function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) { + // convert -0 to +0 + if (NEGATIVE_ZERO) return $native.apply(this, arguments) || 0; + var O = toIObject(this); + var length = toLength(O.length); + var index = length - 1; + if (arguments.length > 1) index = Math.min(index, toInteger(arguments[1])); + if (index < 0) index = length + index; + for (;index >= 0; index--) if (index in O) if (O[index] === searchElement) return index || 0; + return -1; + } + }); + + },{"./_export":104,"./_strict-method":176,"./_to-integer":187,"./_to-iobject":188,"./_to-length":189}],216:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $map = require('./_array-methods')(1); + + $export($export.P + $export.F * !require('./_strict-method')([].map, true), 'Array', { + // 22.1.3.15 / 15.4.4.19 Array.prototype.map(callbackfn [, thisArg]) + map: function map(callbackfn /* , thisArg */) { + return $map(this, callbackfn, arguments[1]); + } + }); + + },{"./_array-methods":83,"./_export":104,"./_strict-method":176}],217:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var createProperty = require('./_create-property'); + + // WebKit Array.of isn't generic + $export($export.S + $export.F * require('./_fails')(function () { + function F() { /* empty */ } + return !(Array.of.call(F) instanceof F); + }), 'Array', { + // 22.1.2.3 Array.of( ...items) + of: function of(/* ...args */) { + var index = 0; + var aLen = arguments.length; + var result = new (typeof this == 'function' ? this : Array)(aLen); + while (aLen > index) createProperty(result, index, arguments[index++]); + result.length = aLen; + return result; + } + }); + + },{"./_create-property":95,"./_export":104,"./_fails":106}],218:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $reduce = require('./_array-reduce'); + + $export($export.P + $export.F * !require('./_strict-method')([].reduceRight, true), 'Array', { + // 22.1.3.19 / 15.4.4.22 Array.prototype.reduceRight(callbackfn [, initialValue]) + reduceRight: function reduceRight(callbackfn /* , initialValue */) { + return $reduce(this, callbackfn, arguments.length, arguments[1], true); + } + }); + + },{"./_array-reduce":84,"./_export":104,"./_strict-method":176}],219:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $reduce = require('./_array-reduce'); + + $export($export.P + $export.F * !require('./_strict-method')([].reduce, true), 'Array', { + // 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue]) + reduce: function reduce(callbackfn /* , initialValue */) { + return $reduce(this, callbackfn, arguments.length, arguments[1], false); + } + }); + + },{"./_array-reduce":84,"./_export":104,"./_strict-method":176}],220:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var html = require('./_html'); + var cof = require('./_cof'); + var toAbsoluteIndex = require('./_to-absolute-index'); + var toLength = require('./_to-length'); + var arraySlice = [].slice; + + // fallback for not array-like ES3 strings and DOM objects + $export($export.P + $export.F * require('./_fails')(function () { + if (html) arraySlice.call(html); + }), 'Array', { + slice: function slice(begin, end) { + var len = toLength(this.length); + var klass = cof(this); + end = end === undefined ? len : end; + if (klass == 'Array') return arraySlice.call(this, begin, end); + var start = toAbsoluteIndex(begin, len); + var upTo = toAbsoluteIndex(end, len); + var size = toLength(upTo - start); + var cloned = new Array(size); + var i = 0; + for (; i < size; i++) cloned[i] = klass == 'String' + ? this.charAt(start + i) + : this[start + i]; + return cloned; + } + }); + + },{"./_cof":89,"./_export":104,"./_fails":106,"./_html":115,"./_to-absolute-index":185,"./_to-length":189}],221:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $some = require('./_array-methods')(3); + + $export($export.P + $export.F * !require('./_strict-method')([].some, true), 'Array', { + // 22.1.3.23 / 15.4.4.17 Array.prototype.some(callbackfn [, thisArg]) + some: function some(callbackfn /* , thisArg */) { + return $some(this, callbackfn, arguments[1]); + } + }); + + },{"./_array-methods":83,"./_export":104,"./_strict-method":176}],222:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var aFunction = require('./_a-function'); + var toObject = require('./_to-object'); + var fails = require('./_fails'); + var $sort = [].sort; + var test = [1, 2, 3]; + + $export($export.P + $export.F * (fails(function () { + // IE8- + test.sort(undefined); + }) || !fails(function () { + // V8 bug + test.sort(null); + // Old WebKit + }) || !require('./_strict-method')($sort)), 'Array', { + // 22.1.3.25 Array.prototype.sort(comparefn) + sort: function sort(comparefn) { + return comparefn === undefined + ? $sort.call(toObject(this)) + : $sort.call(toObject(this), aFunction(comparefn)); + } + }); + + },{"./_a-function":73,"./_export":104,"./_fails":106,"./_strict-method":176,"./_to-object":190}],223:[function(require,module,exports){ + require('./_set-species')('Array'); + + },{"./_set-species":171}],224:[function(require,module,exports){ + // 20.3.3.1 / 15.9.4.4 Date.now() + var $export = require('./_export'); + + $export($export.S, 'Date', { now: function () { return new Date().getTime(); } }); + + },{"./_export":104}],225:[function(require,module,exports){ + // 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString() + var $export = require('./_export'); + var toISOString = require('./_date-to-iso-string'); + + // PhantomJS / old WebKit has a broken implementations + $export($export.P + $export.F * (Date.prototype.toISOString !== toISOString), 'Date', { + toISOString: toISOString + }); + + },{"./_date-to-iso-string":97,"./_export":104}],226:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var toObject = require('./_to-object'); + var toPrimitive = require('./_to-primitive'); + + $export($export.P + $export.F * require('./_fails')(function () { + return new Date(NaN).toJSON() !== null + || Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1; + }), 'Date', { + // eslint-disable-next-line no-unused-vars + toJSON: function toJSON(key) { + var O = toObject(this); + var pv = toPrimitive(O); + return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString(); + } + }); + + },{"./_export":104,"./_fails":106,"./_to-object":190,"./_to-primitive":191}],227:[function(require,module,exports){ + var TO_PRIMITIVE = require('./_wks')('toPrimitive'); + var proto = Date.prototype; + + if (!(TO_PRIMITIVE in proto)) require('./_hide')(proto, TO_PRIMITIVE, require('./_date-to-primitive')); + + },{"./_date-to-primitive":98,"./_hide":114,"./_wks":200}],228:[function(require,module,exports){ + var DateProto = Date.prototype; + var INVALID_DATE = 'Invalid Date'; + var TO_STRING = 'toString'; + var $toString = DateProto[TO_STRING]; + var getTime = DateProto.getTime; + if (new Date(NaN) + '' != INVALID_DATE) { + require('./_redefine')(DateProto, TO_STRING, function toString() { + var value = getTime.call(this); + // eslint-disable-next-line no-self-compare + return value === value ? $toString.call(this) : INVALID_DATE; + }); + } + + },{"./_redefine":163}],229:[function(require,module,exports){ + // 19.2.3.2 / 15.3.4.5 Function.prototype.bind(thisArg, args...) + var $export = require('./_export'); + + $export($export.P, 'Function', { bind: require('./_bind') }); + + },{"./_bind":87,"./_export":104}],230:[function(require,module,exports){ + 'use strict'; + var isObject = require('./_is-object'); + var getPrototypeOf = require('./_object-gpo'); + var HAS_INSTANCE = require('./_wks')('hasInstance'); + var FunctionProto = Function.prototype; + // 19.2.3.6 Function.prototype[@@hasInstance](V) + if (!(HAS_INSTANCE in FunctionProto)) require('./_object-dp').f(FunctionProto, HAS_INSTANCE, { value: function (O) { + if (typeof this != 'function' || !isObject(O)) return false; + if (!isObject(this.prototype)) return O instanceof this; + // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this: + while (O = getPrototypeOf(O)) if (this.prototype === O) return true; + return false; + } }); + + },{"./_is-object":123,"./_object-dp":143,"./_object-gpo":150,"./_wks":200}],231:[function(require,module,exports){ + var dP = require('./_object-dp').f; + var FProto = Function.prototype; + var nameRE = /^\s*function ([^ (]*)/; + var NAME = 'name'; + + // 19.2.4.2 name + NAME in FProto || require('./_descriptors') && dP(FProto, NAME, { + configurable: true, + get: function () { + try { + return ('' + this).match(nameRE)[1]; + } catch (e) { + return ''; + } + } + }); + + },{"./_descriptors":100,"./_object-dp":143}],232:[function(require,module,exports){ + 'use strict'; + var strong = require('./_collection-strong'); + var validate = require('./_validate-collection'); + var MAP = 'Map'; + + // 23.1 Map Objects + module.exports = require('./_collection')(MAP, function (get) { + return function Map() { return get(this, arguments.length > 0 ? arguments[0] : undefined); }; + }, { + // 23.1.3.6 Map.prototype.get(key) + get: function get(key) { + var entry = strong.getEntry(validate(this, MAP), key); + return entry && entry.v; + }, + // 23.1.3.9 Map.prototype.set(key, value) + set: function set(key, value) { + return strong.def(validate(this, MAP), key === 0 ? 0 : key, value); + } + }, strong, true); + + },{"./_collection":93,"./_collection-strong":90,"./_validate-collection":197}],233:[function(require,module,exports){ + // 20.2.2.3 Math.acosh(x) + var $export = require('./_export'); + var log1p = require('./_math-log1p'); + var sqrt = Math.sqrt; + var $acosh = Math.acosh; + + $export($export.S + $export.F * !($acosh + // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509 + && Math.floor($acosh(Number.MAX_VALUE)) == 710 + // Tor Browser bug: Math.acosh(Infinity) -> NaN + && $acosh(Infinity) == Infinity + ), 'Math', { + acosh: function acosh(x) { + return (x = +x) < 1 ? NaN : x > 94906265.62425156 + ? Math.log(x) + Math.LN2 + : log1p(x - 1 + sqrt(x - 1) * sqrt(x + 1)); + } + }); + + },{"./_export":104,"./_math-log1p":134}],234:[function(require,module,exports){ + // 20.2.2.5 Math.asinh(x) + var $export = require('./_export'); + var $asinh = Math.asinh; + + function asinh(x) { + return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : Math.log(x + Math.sqrt(x * x + 1)); + } + + // Tor Browser bug: Math.asinh(0) -> -0 + $export($export.S + $export.F * !($asinh && 1 / $asinh(0) > 0), 'Math', { asinh: asinh }); + + },{"./_export":104}],235:[function(require,module,exports){ + // 20.2.2.7 Math.atanh(x) + var $export = require('./_export'); + var $atanh = Math.atanh; + + // Tor Browser bug: Math.atanh(-0) -> 0 + $export($export.S + $export.F * !($atanh && 1 / $atanh(-0) < 0), 'Math', { + atanh: function atanh(x) { + return (x = +x) == 0 ? x : Math.log((1 + x) / (1 - x)) / 2; + } + }); + + },{"./_export":104}],236:[function(require,module,exports){ + // 20.2.2.9 Math.cbrt(x) + var $export = require('./_export'); + var sign = require('./_math-sign'); + + $export($export.S, 'Math', { + cbrt: function cbrt(x) { + return sign(x = +x) * Math.pow(Math.abs(x), 1 / 3); + } + }); + + },{"./_export":104,"./_math-sign":136}],237:[function(require,module,exports){ + // 20.2.2.11 Math.clz32(x) + var $export = require('./_export'); + + $export($export.S, 'Math', { + clz32: function clz32(x) { + return (x >>>= 0) ? 31 - Math.floor(Math.log(x + 0.5) * Math.LOG2E) : 32; + } + }); + + },{"./_export":104}],238:[function(require,module,exports){ + // 20.2.2.12 Math.cosh(x) + var $export = require('./_export'); + var exp = Math.exp; + + $export($export.S, 'Math', { + cosh: function cosh(x) { + return (exp(x = +x) + exp(-x)) / 2; + } + }); + + },{"./_export":104}],239:[function(require,module,exports){ + // 20.2.2.14 Math.expm1(x) + var $export = require('./_export'); + var $expm1 = require('./_math-expm1'); + + $export($export.S + $export.F * ($expm1 != Math.expm1), 'Math', { expm1: $expm1 }); + + },{"./_export":104,"./_math-expm1":132}],240:[function(require,module,exports){ + // 20.2.2.16 Math.fround(x) + var $export = require('./_export'); + + $export($export.S, 'Math', { fround: require('./_math-fround') }); + + },{"./_export":104,"./_math-fround":133}],241:[function(require,module,exports){ + // 20.2.2.17 Math.hypot([value1[, value2[, … ]]]) + var $export = require('./_export'); + var abs = Math.abs; + + $export($export.S, 'Math', { + hypot: function hypot(value1, value2) { // eslint-disable-line no-unused-vars + var sum = 0; + var i = 0; + var aLen = arguments.length; + var larg = 0; + var arg, div; + while (i < aLen) { + arg = abs(arguments[i++]); + if (larg < arg) { + div = larg / arg; + sum = sum * div * div + 1; + larg = arg; + } else if (arg > 0) { + div = arg / larg; + sum += div * div; + } else sum += arg; + } + return larg === Infinity ? Infinity : larg * Math.sqrt(sum); + } + }); + + },{"./_export":104}],242:[function(require,module,exports){ + // 20.2.2.18 Math.imul(x, y) + var $export = require('./_export'); + var $imul = Math.imul; + + // some WebKit versions fails with big numbers, some has wrong arity + $export($export.S + $export.F * require('./_fails')(function () { + return $imul(0xffffffff, 5) != -5 || $imul.length != 2; + }), 'Math', { + imul: function imul(x, y) { + var UINT16 = 0xffff; + var xn = +x; + var yn = +y; + var xl = UINT16 & xn; + var yl = UINT16 & yn; + return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0); + } + }); + + },{"./_export":104,"./_fails":106}],243:[function(require,module,exports){ + // 20.2.2.21 Math.log10(x) + var $export = require('./_export'); + + $export($export.S, 'Math', { + log10: function log10(x) { + return Math.log(x) * Math.LOG10E; + } + }); + + },{"./_export":104}],244:[function(require,module,exports){ + // 20.2.2.20 Math.log1p(x) + var $export = require('./_export'); + + $export($export.S, 'Math', { log1p: require('./_math-log1p') }); + + },{"./_export":104,"./_math-log1p":134}],245:[function(require,module,exports){ + // 20.2.2.22 Math.log2(x) + var $export = require('./_export'); + + $export($export.S, 'Math', { + log2: function log2(x) { + return Math.log(x) / Math.LN2; + } + }); + + },{"./_export":104}],246:[function(require,module,exports){ + // 20.2.2.28 Math.sign(x) + var $export = require('./_export'); + + $export($export.S, 'Math', { sign: require('./_math-sign') }); + + },{"./_export":104,"./_math-sign":136}],247:[function(require,module,exports){ + // 20.2.2.30 Math.sinh(x) + var $export = require('./_export'); + var expm1 = require('./_math-expm1'); + var exp = Math.exp; + + // V8 near Chromium 38 has a problem with very small numbers + $export($export.S + $export.F * require('./_fails')(function () { + return !Math.sinh(-2e-17) != -2e-17; + }), 'Math', { + sinh: function sinh(x) { + return Math.abs(x = +x) < 1 + ? (expm1(x) - expm1(-x)) / 2 + : (exp(x - 1) - exp(-x - 1)) * (Math.E / 2); + } + }); + + },{"./_export":104,"./_fails":106,"./_math-expm1":132}],248:[function(require,module,exports){ + // 20.2.2.33 Math.tanh(x) + var $export = require('./_export'); + var expm1 = require('./_math-expm1'); + var exp = Math.exp; + + $export($export.S, 'Math', { + tanh: function tanh(x) { + var a = expm1(x = +x); + var b = expm1(-x); + return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x)); + } + }); + + },{"./_export":104,"./_math-expm1":132}],249:[function(require,module,exports){ + // 20.2.2.34 Math.trunc(x) + var $export = require('./_export'); + + $export($export.S, 'Math', { + trunc: function trunc(it) { + return (it > 0 ? Math.floor : Math.ceil)(it); + } + }); + + },{"./_export":104}],250:[function(require,module,exports){ + 'use strict'; + var global = require('./_global'); + var has = require('./_has'); + var cof = require('./_cof'); + var inheritIfRequired = require('./_inherit-if-required'); + var toPrimitive = require('./_to-primitive'); + var fails = require('./_fails'); + var gOPN = require('./_object-gopn').f; + var gOPD = require('./_object-gopd').f; + var dP = require('./_object-dp').f; + var $trim = require('./_string-trim').trim; + var NUMBER = 'Number'; + var $Number = global[NUMBER]; + var Base = $Number; + var proto = $Number.prototype; + // Opera ~12 has broken Object#toString + var BROKEN_COF = cof(require('./_object-create')(proto)) == NUMBER; + var TRIM = 'trim' in String.prototype; + + // 7.1.3 ToNumber(argument) + var toNumber = function (argument) { + var it = toPrimitive(argument, false); + if (typeof it == 'string' && it.length > 2) { + it = TRIM ? it.trim() : $trim(it, 3); + var first = it.charCodeAt(0); + var third, radix, maxCode; + if (first === 43 || first === 45) { + third = it.charCodeAt(2); + if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix + } else if (first === 48) { + switch (it.charCodeAt(1)) { + case 66: case 98: radix = 2; maxCode = 49; break; // fast equal /^0b[01]+$/i + case 79: case 111: radix = 8; maxCode = 55; break; // fast equal /^0o[0-7]+$/i + default: return +it; + } + for (var digits = it.slice(2), i = 0, l = digits.length, code; i < l; i++) { + code = digits.charCodeAt(i); + // parseInt parses a string to a first unavailable symbol + // but ToNumber should return NaN if a string contains unavailable symbols + if (code < 48 || code > maxCode) return NaN; + } return parseInt(digits, radix); + } + } return +it; + }; + + if (!$Number(' 0o1') || !$Number('0b1') || $Number('+0x1')) { + $Number = function Number(value) { + var it = arguments.length < 1 ? 0 : value; + var that = this; + return that instanceof $Number + // check on 1..constructor(foo) case + && (BROKEN_COF ? fails(function () { proto.valueOf.call(that); }) : cof(that) != NUMBER) + ? inheritIfRequired(new Base(toNumber(it)), that, $Number) : toNumber(it); + }; + for (var keys = require('./_descriptors') ? gOPN(Base) : ( + // ES3: + 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + + // ES6 (in case, if modules with ES6 Number statics required before): + 'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' + + 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger' + ).split(','), j = 0, key; keys.length > j; j++) { + if (has(Base, key = keys[j]) && !has($Number, key)) { + dP($Number, key, gOPD(Base, key)); + } + } + $Number.prototype = proto; + proto.constructor = $Number; + require('./_redefine')(global, NUMBER, $Number); + } + + },{"./_cof":89,"./_descriptors":100,"./_fails":106,"./_global":112,"./_has":113,"./_inherit-if-required":117,"./_object-create":142,"./_object-dp":143,"./_object-gopd":146,"./_object-gopn":148,"./_redefine":163,"./_string-trim":182,"./_to-primitive":191}],251:[function(require,module,exports){ + // 20.1.2.1 Number.EPSILON + var $export = require('./_export'); + + $export($export.S, 'Number', { EPSILON: Math.pow(2, -52) }); + + },{"./_export":104}],252:[function(require,module,exports){ + // 20.1.2.2 Number.isFinite(number) + var $export = require('./_export'); + var _isFinite = require('./_global').isFinite; + + $export($export.S, 'Number', { + isFinite: function isFinite(it) { + return typeof it == 'number' && _isFinite(it); + } + }); + + },{"./_export":104,"./_global":112}],253:[function(require,module,exports){ + // 20.1.2.3 Number.isInteger(number) + var $export = require('./_export'); + + $export($export.S, 'Number', { isInteger: require('./_is-integer') }); + + },{"./_export":104,"./_is-integer":122}],254:[function(require,module,exports){ + // 20.1.2.4 Number.isNaN(number) + var $export = require('./_export'); + + $export($export.S, 'Number', { + isNaN: function isNaN(number) { + // eslint-disable-next-line no-self-compare + return number != number; + } + }); + + },{"./_export":104}],255:[function(require,module,exports){ + // 20.1.2.5 Number.isSafeInteger(number) + var $export = require('./_export'); + var isInteger = require('./_is-integer'); + var abs = Math.abs; + + $export($export.S, 'Number', { + isSafeInteger: function isSafeInteger(number) { + return isInteger(number) && abs(number) <= 0x1fffffffffffff; + } + }); + + },{"./_export":104,"./_is-integer":122}],256:[function(require,module,exports){ + // 20.1.2.6 Number.MAX_SAFE_INTEGER + var $export = require('./_export'); + + $export($export.S, 'Number', { MAX_SAFE_INTEGER: 0x1fffffffffffff }); + + },{"./_export":104}],257:[function(require,module,exports){ + // 20.1.2.10 Number.MIN_SAFE_INTEGER + var $export = require('./_export'); + + $export($export.S, 'Number', { MIN_SAFE_INTEGER: -0x1fffffffffffff }); + + },{"./_export":104}],258:[function(require,module,exports){ + var $export = require('./_export'); + var $parseFloat = require('./_parse-float'); + // 20.1.2.12 Number.parseFloat(string) + $export($export.S + $export.F * (Number.parseFloat != $parseFloat), 'Number', { parseFloat: $parseFloat }); + + },{"./_export":104,"./_parse-float":157}],259:[function(require,module,exports){ + var $export = require('./_export'); + var $parseInt = require('./_parse-int'); + // 20.1.2.13 Number.parseInt(string, radix) + $export($export.S + $export.F * (Number.parseInt != $parseInt), 'Number', { parseInt: $parseInt }); + + },{"./_export":104,"./_parse-int":158}],260:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var toInteger = require('./_to-integer'); + var aNumberValue = require('./_a-number-value'); + var repeat = require('./_string-repeat'); + var $toFixed = 1.0.toFixed; + var floor = Math.floor; + var data = [0, 0, 0, 0, 0, 0]; + var ERROR = 'Number.toFixed: incorrect invocation!'; + var ZERO = '0'; + + var multiply = function (n, c) { + var i = -1; + var c2 = c; + while (++i < 6) { + c2 += n * data[i]; + data[i] = c2 % 1e7; + c2 = floor(c2 / 1e7); + } + }; + var divide = function (n) { + var i = 6; + var c = 0; + while (--i >= 0) { + c += data[i]; + data[i] = floor(c / n); + c = (c % n) * 1e7; + } + }; + var numToString = function () { + var i = 6; + var s = ''; + while (--i >= 0) { + if (s !== '' || i === 0 || data[i] !== 0) { + var t = String(data[i]); + s = s === '' ? t : s + repeat.call(ZERO, 7 - t.length) + t; + } + } return s; + }; + var pow = function (x, n, acc) { + return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc); + }; + var log = function (x) { + var n = 0; + var x2 = x; + while (x2 >= 4096) { + n += 12; + x2 /= 4096; + } + while (x2 >= 2) { + n += 1; + x2 /= 2; + } return n; + }; + + $export($export.P + $export.F * (!!$toFixed && ( + 0.00008.toFixed(3) !== '0.000' || + 0.9.toFixed(0) !== '1' || + 1.255.toFixed(2) !== '1.25' || + 1000000000000000128.0.toFixed(0) !== '1000000000000000128' + ) || !require('./_fails')(function () { + // V8 ~ Android 4.3- + $toFixed.call({}); + })), 'Number', { + toFixed: function toFixed(fractionDigits) { + var x = aNumberValue(this, ERROR); + var f = toInteger(fractionDigits); + var s = ''; + var m = ZERO; + var e, z, j, k; + if (f < 0 || f > 20) throw RangeError(ERROR); + // eslint-disable-next-line no-self-compare + if (x != x) return 'NaN'; + if (x <= -1e21 || x >= 1e21) return String(x); + if (x < 0) { + s = '-'; + x = -x; + } + if (x > 1e-21) { + e = log(x * pow(2, 69, 1)) - 69; + z = e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1); + z *= 0x10000000000000; + e = 52 - e; + if (e > 0) { + multiply(0, z); + j = f; + while (j >= 7) { + multiply(1e7, 0); + j -= 7; + } + multiply(pow(10, j, 1), 0); + j = e - 1; + while (j >= 23) { + divide(1 << 23); + j -= 23; + } + divide(1 << j); + multiply(1, 1); + divide(2); + m = numToString(); + } else { + multiply(0, z); + multiply(1 << -e, 0); + m = numToString() + repeat.call(ZERO, f); + } + } + if (f > 0) { + k = m.length; + m = s + (k <= f ? '0.' + repeat.call(ZERO, f - k) + m : m.slice(0, k - f) + '.' + m.slice(k - f)); + } else { + m = s + m; + } return m; + } + }); + + },{"./_a-number-value":74,"./_export":104,"./_fails":106,"./_string-repeat":181,"./_to-integer":187}],261:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $fails = require('./_fails'); + var aNumberValue = require('./_a-number-value'); + var $toPrecision = 1.0.toPrecision; + + $export($export.P + $export.F * ($fails(function () { + // IE7- + return $toPrecision.call(1, undefined) !== '1'; + }) || !$fails(function () { + // V8 ~ Android 4.3- + $toPrecision.call({}); + })), 'Number', { + toPrecision: function toPrecision(precision) { + var that = aNumberValue(this, 'Number#toPrecision: incorrect invocation!'); + return precision === undefined ? $toPrecision.call(that) : $toPrecision.call(that, precision); + } + }); + + },{"./_a-number-value":74,"./_export":104,"./_fails":106}],262:[function(require,module,exports){ + // 19.1.3.1 Object.assign(target, source) + var $export = require('./_export'); + + $export($export.S + $export.F, 'Object', { assign: require('./_object-assign') }); + + },{"./_export":104,"./_object-assign":141}],263:[function(require,module,exports){ + var $export = require('./_export'); + // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) + $export($export.S, 'Object', { create: require('./_object-create') }); + + },{"./_export":104,"./_object-create":142}],264:[function(require,module,exports){ + var $export = require('./_export'); + // 19.1.2.3 / 15.2.3.7 Object.defineProperties(O, Properties) + $export($export.S + $export.F * !require('./_descriptors'), 'Object', { defineProperties: require('./_object-dps') }); + + },{"./_descriptors":100,"./_export":104,"./_object-dps":144}],265:[function(require,module,exports){ + var $export = require('./_export'); + // 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes) + $export($export.S + $export.F * !require('./_descriptors'), 'Object', { defineProperty: require('./_object-dp').f }); + + },{"./_descriptors":100,"./_export":104,"./_object-dp":143}],266:[function(require,module,exports){ + // 19.1.2.5 Object.freeze(O) + var isObject = require('./_is-object'); + var meta = require('./_meta').onFreeze; + + require('./_object-sap')('freeze', function ($freeze) { + return function freeze(it) { + return $freeze && isObject(it) ? $freeze(meta(it)) : it; + }; + }); + + },{"./_is-object":123,"./_meta":137,"./_object-sap":154}],267:[function(require,module,exports){ + // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P) + var toIObject = require('./_to-iobject'); + var $getOwnPropertyDescriptor = require('./_object-gopd').f; + + require('./_object-sap')('getOwnPropertyDescriptor', function () { + return function getOwnPropertyDescriptor(it, key) { + return $getOwnPropertyDescriptor(toIObject(it), key); + }; + }); + + },{"./_object-gopd":146,"./_object-sap":154,"./_to-iobject":188}],268:[function(require,module,exports){ + // 19.1.2.7 Object.getOwnPropertyNames(O) + require('./_object-sap')('getOwnPropertyNames', function () { + return require('./_object-gopn-ext').f; + }); + + },{"./_object-gopn-ext":147,"./_object-sap":154}],269:[function(require,module,exports){ + // 19.1.2.9 Object.getPrototypeOf(O) + var toObject = require('./_to-object'); + var $getPrototypeOf = require('./_object-gpo'); + + require('./_object-sap')('getPrototypeOf', function () { + return function getPrototypeOf(it) { + return $getPrototypeOf(toObject(it)); + }; + }); + + },{"./_object-gpo":150,"./_object-sap":154,"./_to-object":190}],270:[function(require,module,exports){ + // 19.1.2.11 Object.isExtensible(O) + var isObject = require('./_is-object'); + + require('./_object-sap')('isExtensible', function ($isExtensible) { + return function isExtensible(it) { + return isObject(it) ? $isExtensible ? $isExtensible(it) : true : false; + }; + }); + + },{"./_is-object":123,"./_object-sap":154}],271:[function(require,module,exports){ + // 19.1.2.12 Object.isFrozen(O) + var isObject = require('./_is-object'); + + require('./_object-sap')('isFrozen', function ($isFrozen) { + return function isFrozen(it) { + return isObject(it) ? $isFrozen ? $isFrozen(it) : false : true; + }; + }); + + },{"./_is-object":123,"./_object-sap":154}],272:[function(require,module,exports){ + // 19.1.2.13 Object.isSealed(O) + var isObject = require('./_is-object'); + + require('./_object-sap')('isSealed', function ($isSealed) { + return function isSealed(it) { + return isObject(it) ? $isSealed ? $isSealed(it) : false : true; + }; + }); + + },{"./_is-object":123,"./_object-sap":154}],273:[function(require,module,exports){ + // 19.1.3.10 Object.is(value1, value2) + var $export = require('./_export'); + $export($export.S, 'Object', { is: require('./_same-value') }); + + },{"./_export":104,"./_same-value":167}],274:[function(require,module,exports){ + // 19.1.2.14 Object.keys(O) + var toObject = require('./_to-object'); + var $keys = require('./_object-keys'); + + require('./_object-sap')('keys', function () { + return function keys(it) { + return $keys(toObject(it)); + }; + }); + + },{"./_object-keys":152,"./_object-sap":154,"./_to-object":190}],275:[function(require,module,exports){ + // 19.1.2.15 Object.preventExtensions(O) + var isObject = require('./_is-object'); + var meta = require('./_meta').onFreeze; + + require('./_object-sap')('preventExtensions', function ($preventExtensions) { + return function preventExtensions(it) { + return $preventExtensions && isObject(it) ? $preventExtensions(meta(it)) : it; + }; + }); + + },{"./_is-object":123,"./_meta":137,"./_object-sap":154}],276:[function(require,module,exports){ + // 19.1.2.17 Object.seal(O) + var isObject = require('./_is-object'); + var meta = require('./_meta').onFreeze; + + require('./_object-sap')('seal', function ($seal) { + return function seal(it) { + return $seal && isObject(it) ? $seal(meta(it)) : it; + }; + }); + + },{"./_is-object":123,"./_meta":137,"./_object-sap":154}],277:[function(require,module,exports){ + // 19.1.3.19 Object.setPrototypeOf(O, proto) + var $export = require('./_export'); + $export($export.S, 'Object', { setPrototypeOf: require('./_set-proto').set }); + + },{"./_export":104,"./_set-proto":170}],278:[function(require,module,exports){ + 'use strict'; + // 19.1.3.6 Object.prototype.toString() + var classof = require('./_classof'); + var test = {}; + test[require('./_wks')('toStringTag')] = 'z'; + if (test + '' != '[object z]') { + require('./_redefine')(Object.prototype, 'toString', function toString() { + return '[object ' + classof(this) + ']'; + }, true); + } + + },{"./_classof":88,"./_redefine":163,"./_wks":200}],279:[function(require,module,exports){ + var $export = require('./_export'); + var $parseFloat = require('./_parse-float'); + // 18.2.4 parseFloat(string) + $export($export.G + $export.F * (parseFloat != $parseFloat), { parseFloat: $parseFloat }); + + },{"./_export":104,"./_parse-float":157}],280:[function(require,module,exports){ + var $export = require('./_export'); + var $parseInt = require('./_parse-int'); + // 18.2.5 parseInt(string, radix) + $export($export.G + $export.F * (parseInt != $parseInt), { parseInt: $parseInt }); + + },{"./_export":104,"./_parse-int":158}],281:[function(require,module,exports){ + 'use strict'; + var LIBRARY = require('./_library'); + var global = require('./_global'); + var ctx = require('./_ctx'); + var classof = require('./_classof'); + var $export = require('./_export'); + var isObject = require('./_is-object'); + var aFunction = require('./_a-function'); + var anInstance = require('./_an-instance'); + var forOf = require('./_for-of'); + var speciesConstructor = require('./_species-constructor'); + var task = require('./_task').set; + var microtask = require('./_microtask')(); + var newPromiseCapabilityModule = require('./_new-promise-capability'); + var perform = require('./_perform'); + var userAgent = require('./_user-agent'); + var promiseResolve = require('./_promise-resolve'); + var PROMISE = 'Promise'; + var TypeError = global.TypeError; + var process = global.process; + var versions = process && process.versions; + var v8 = versions && versions.v8 || ''; + var $Promise = global[PROMISE]; + var isNode = classof(process) == 'process'; + var empty = function () { /* empty */ }; + var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper; + var newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f; + + var USE_NATIVE = !!function () { + try { + // correct subclassing with @@species support + var promise = $Promise.resolve(1); + var FakePromise = (promise.constructor = {})[require('./_wks')('species')] = function (exec) { + exec(empty, empty); + }; + // unhandled rejections tracking support, NodeJS Promise without it fails @@species test + return (isNode || typeof PromiseRejectionEvent == 'function') + && promise.then(empty) instanceof FakePromise + // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // we can't detect it synchronously, so just check versions + && v8.indexOf('6.6') !== 0 + && userAgent.indexOf('Chrome/66') === -1; + } catch (e) { /* empty */ } + }(); + + // helpers + var isThenable = function (it) { + var then; + return isObject(it) && typeof (then = it.then) == 'function' ? then : false; + }; + var notify = function (promise, isReject) { + if (promise._n) return; + promise._n = true; + var chain = promise._c; + microtask(function () { + var value = promise._v; + var ok = promise._s == 1; + var i = 0; + var run = function (reaction) { + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (promise._h == 2) onHandleUnhandled(promise); + promise._h = 1; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // may throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(TypeError('Promise-chain cycle')); + } else if (then = isThenable(result)) { + then.call(result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (e) { + if (domain && !exited) domain.exit(); + reject(e); + } + }; + while (chain.length > i) run(chain[i++]); // variable length - can't use forEach + promise._c = []; + promise._n = false; + if (isReject && !promise._h) onUnhandled(promise); + }); + }; + var onUnhandled = function (promise) { + task.call(global, function () { + var value = promise._v; + var unhandled = isUnhandled(promise); + var result, handler, console; + if (unhandled) { + result = perform(function () { + if (isNode) { + process.emit('unhandledRejection', value, promise); + } else if (handler = global.onunhandledrejection) { + handler({ promise: promise, reason: value }); + } else if ((console = global.console) && console.error) { + console.error('Unhandled promise rejection', value); + } + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + promise._h = isNode || isUnhandled(promise) ? 2 : 1; + } promise._a = undefined; + if (unhandled && result.e) throw result.v; + }); + }; + var isUnhandled = function (promise) { + return promise._h !== 1 && (promise._a || promise._c).length === 0; + }; + var onHandleUnhandled = function (promise) { + task.call(global, function () { + var handler; + if (isNode) { + process.emit('rejectionHandled', promise); + } else if (handler = global.onrejectionhandled) { + handler({ promise: promise, reason: promise._v }); + } + }); + }; + var $reject = function (value) { + var promise = this; + if (promise._d) return; + promise._d = true; + promise = promise._w || promise; // unwrap + promise._v = value; + promise._s = 2; + if (!promise._a) promise._a = promise._c.slice(); + notify(promise, true); + }; + var $resolve = function (value) { + var promise = this; + var then; + if (promise._d) return; + promise._d = true; + promise = promise._w || promise; // unwrap + try { + if (promise === value) throw TypeError("Promise can't be resolved itself"); + if (then = isThenable(value)) { + microtask(function () { + var wrapper = { _w: promise, _d: false }; // wrap + try { + then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1)); + } catch (e) { + $reject.call(wrapper, e); + } + }); + } else { + promise._v = value; + promise._s = 1; + notify(promise, false); + } + } catch (e) { + $reject.call({ _w: promise, _d: false }, e); // wrap + } + }; + + // constructor polyfill + if (!USE_NATIVE) { + // 25.4.3.1 Promise(executor) + $Promise = function Promise(executor) { + anInstance(this, $Promise, PROMISE, '_h'); + aFunction(executor); + Internal.call(this); + try { + executor(ctx($resolve, this, 1), ctx($reject, this, 1)); + } catch (err) { + $reject.call(this, err); + } + }; + // eslint-disable-next-line no-unused-vars + Internal = function Promise(executor) { + this._c = []; // <- awaiting reactions + this._a = undefined; // <- checked in isUnhandled reactions + this._s = 0; // <- state + this._d = false; // <- done + this._v = undefined; // <- value + this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled + this._n = false; // <- notify + }; + Internal.prototype = require('./_redefine-all')($Promise.prototype, { + // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected) + then: function then(onFulfilled, onRejected) { + var reaction = newPromiseCapability(speciesConstructor(this, $Promise)); + reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true; + reaction.fail = typeof onRejected == 'function' && onRejected; + reaction.domain = isNode ? process.domain : undefined; + this._c.push(reaction); + if (this._a) this._a.push(reaction); + if (this._s) notify(this, false); + return reaction.promise; + }, + // 25.4.5.1 Promise.prototype.catch(onRejected) + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + OwnPromiseCapability = function () { + var promise = new Internal(); + this.promise = promise; + this.resolve = ctx($resolve, promise, 1); + this.reject = ctx($reject, promise, 1); + }; + newPromiseCapabilityModule.f = newPromiseCapability = function (C) { + return C === $Promise || C === Wrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + } + + $export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise }); + require('./_set-to-string-tag')($Promise, PROMISE); + require('./_set-species')(PROMISE); + Wrapper = require('./_core')[PROMISE]; + + // statics + $export($export.S + $export.F * !USE_NATIVE, PROMISE, { + // 25.4.4.5 Promise.reject(r) + reject: function reject(r) { + var capability = newPromiseCapability(this); + var $$reject = capability.reject; + $$reject(r); + return capability.promise; + } + }); + $export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, { + // 25.4.4.6 Promise.resolve(x) + resolve: function resolve(x) { + return promiseResolve(LIBRARY && this === Wrapper ? $Promise : this, x); + } + }); + $export($export.S + $export.F * !(USE_NATIVE && require('./_iter-detect')(function (iter) { + $Promise.all(iter)['catch'](empty); + })), PROMISE, { + // 25.4.4.1 Promise.all(iterable) + all: function all(iterable) { + var C = this; + var capability = newPromiseCapability(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var values = []; + var index = 0; + var remaining = 1; + forOf(iterable, false, function (promise) { + var $index = index++; + var alreadyCalled = false; + values.push(undefined); + remaining++; + C.resolve(promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[$index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.e) reject(result.v); + return capability.promise; + }, + // 25.4.4.4 Promise.race(iterable) + race: function race(iterable) { + var C = this; + var capability = newPromiseCapability(C); + var reject = capability.reject; + var result = perform(function () { + forOf(iterable, false, function (promise) { + C.resolve(promise).then(capability.resolve, reject); + }); + }); + if (result.e) reject(result.v); + return capability.promise; + } + }); + + },{"./_a-function":73,"./_an-instance":77,"./_classof":88,"./_core":94,"./_ctx":96,"./_export":104,"./_for-of":110,"./_global":112,"./_is-object":123,"./_iter-detect":128,"./_library":131,"./_microtask":139,"./_new-promise-capability":140,"./_perform":159,"./_promise-resolve":160,"./_redefine-all":162,"./_set-species":171,"./_set-to-string-tag":172,"./_species-constructor":175,"./_task":184,"./_user-agent":196,"./_wks":200}],282:[function(require,module,exports){ + // 26.1.1 Reflect.apply(target, thisArgument, argumentsList) + var $export = require('./_export'); + var aFunction = require('./_a-function'); + var anObject = require('./_an-object'); + var rApply = (require('./_global').Reflect || {}).apply; + var fApply = Function.apply; + // MS Edge argumentsList argument is optional + $export($export.S + $export.F * !require('./_fails')(function () { + rApply(function () { /* empty */ }); + }), 'Reflect', { + apply: function apply(target, thisArgument, argumentsList) { + var T = aFunction(target); + var L = anObject(argumentsList); + return rApply ? rApply(T, thisArgument, L) : fApply.call(T, thisArgument, L); + } + }); + + },{"./_a-function":73,"./_an-object":78,"./_export":104,"./_fails":106,"./_global":112}],283:[function(require,module,exports){ + // 26.1.2 Reflect.construct(target, argumentsList [, newTarget]) + var $export = require('./_export'); + var create = require('./_object-create'); + var aFunction = require('./_a-function'); + var anObject = require('./_an-object'); + var isObject = require('./_is-object'); + var fails = require('./_fails'); + var bind = require('./_bind'); + var rConstruct = (require('./_global').Reflect || {}).construct; + + // MS Edge supports only 2 arguments and argumentsList argument is optional + // FF Nightly sets third argument as `new.target`, but does not create `this` from it + var NEW_TARGET_BUG = fails(function () { + function F() { /* empty */ } + return !(rConstruct(function () { /* empty */ }, [], F) instanceof F); + }); + var ARGS_BUG = !fails(function () { + rConstruct(function () { /* empty */ }); + }); + + $export($export.S + $export.F * (NEW_TARGET_BUG || ARGS_BUG), 'Reflect', { + construct: function construct(Target, args /* , newTarget */) { + aFunction(Target); + anObject(args); + var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]); + if (ARGS_BUG && !NEW_TARGET_BUG) return rConstruct(Target, args, newTarget); + if (Target == newTarget) { + // w/o altered newTarget, optimization for 0-4 arguments + switch (args.length) { + case 0: return new Target(); + case 1: return new Target(args[0]); + case 2: return new Target(args[0], args[1]); + case 3: return new Target(args[0], args[1], args[2]); + case 4: return new Target(args[0], args[1], args[2], args[3]); + } + // w/o altered newTarget, lot of arguments case + var $args = [null]; + $args.push.apply($args, args); + return new (bind.apply(Target, $args))(); + } + // with altered newTarget, not support built-in constructors + var proto = newTarget.prototype; + var instance = create(isObject(proto) ? proto : Object.prototype); + var result = Function.apply.call(Target, instance, args); + return isObject(result) ? result : instance; + } + }); + + },{"./_a-function":73,"./_an-object":78,"./_bind":87,"./_export":104,"./_fails":106,"./_global":112,"./_is-object":123,"./_object-create":142}],284:[function(require,module,exports){ + // 26.1.3 Reflect.defineProperty(target, propertyKey, attributes) + var dP = require('./_object-dp'); + var $export = require('./_export'); + var anObject = require('./_an-object'); + var toPrimitive = require('./_to-primitive'); + + // MS Edge has broken Reflect.defineProperty - throwing instead of returning false + $export($export.S + $export.F * require('./_fails')(function () { + // eslint-disable-next-line no-undef + Reflect.defineProperty(dP.f({}, 1, { value: 1 }), 1, { value: 2 }); + }), 'Reflect', { + defineProperty: function defineProperty(target, propertyKey, attributes) { + anObject(target); + propertyKey = toPrimitive(propertyKey, true); + anObject(attributes); + try { + dP.f(target, propertyKey, attributes); + return true; + } catch (e) { + return false; + } + } + }); + + },{"./_an-object":78,"./_export":104,"./_fails":106,"./_object-dp":143,"./_to-primitive":191}],285:[function(require,module,exports){ + // 26.1.4 Reflect.deleteProperty(target, propertyKey) + var $export = require('./_export'); + var gOPD = require('./_object-gopd').f; + var anObject = require('./_an-object'); + + $export($export.S, 'Reflect', { + deleteProperty: function deleteProperty(target, propertyKey) { + var desc = gOPD(anObject(target), propertyKey); + return desc && !desc.configurable ? false : delete target[propertyKey]; + } + }); + + },{"./_an-object":78,"./_export":104,"./_object-gopd":146}],286:[function(require,module,exports){ + 'use strict'; + // 26.1.5 Reflect.enumerate(target) + var $export = require('./_export'); + var anObject = require('./_an-object'); + var Enumerate = function (iterated) { + this._t = anObject(iterated); // target + this._i = 0; // next index + var keys = this._k = []; // keys + var key; + for (key in iterated) keys.push(key); + }; + require('./_iter-create')(Enumerate, 'Object', function () { + var that = this; + var keys = that._k; + var key; + do { + if (that._i >= keys.length) return { value: undefined, done: true }; + } while (!((key = keys[that._i++]) in that._t)); + return { value: key, done: false }; + }); + + $export($export.S, 'Reflect', { + enumerate: function enumerate(target) { + return new Enumerate(target); + } + }); + + },{"./_an-object":78,"./_export":104,"./_iter-create":126}],287:[function(require,module,exports){ + // 26.1.7 Reflect.getOwnPropertyDescriptor(target, propertyKey) + var gOPD = require('./_object-gopd'); + var $export = require('./_export'); + var anObject = require('./_an-object'); + + $export($export.S, 'Reflect', { + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) { + return gOPD.f(anObject(target), propertyKey); + } + }); + + },{"./_an-object":78,"./_export":104,"./_object-gopd":146}],288:[function(require,module,exports){ + // 26.1.8 Reflect.getPrototypeOf(target) + var $export = require('./_export'); + var getProto = require('./_object-gpo'); + var anObject = require('./_an-object'); + + $export($export.S, 'Reflect', { + getPrototypeOf: function getPrototypeOf(target) { + return getProto(anObject(target)); + } + }); + + },{"./_an-object":78,"./_export":104,"./_object-gpo":150}],289:[function(require,module,exports){ + // 26.1.6 Reflect.get(target, propertyKey [, receiver]) + var gOPD = require('./_object-gopd'); + var getPrototypeOf = require('./_object-gpo'); + var has = require('./_has'); + var $export = require('./_export'); + var isObject = require('./_is-object'); + var anObject = require('./_an-object'); + + function get(target, propertyKey /* , receiver */) { + var receiver = arguments.length < 3 ? target : arguments[2]; + var desc, proto; + if (anObject(target) === receiver) return target[propertyKey]; + if (desc = gOPD.f(target, propertyKey)) return has(desc, 'value') + ? desc.value + : desc.get !== undefined + ? desc.get.call(receiver) + : undefined; + if (isObject(proto = getPrototypeOf(target))) return get(proto, propertyKey, receiver); + } + + $export($export.S, 'Reflect', { get: get }); + + },{"./_an-object":78,"./_export":104,"./_has":113,"./_is-object":123,"./_object-gopd":146,"./_object-gpo":150}],290:[function(require,module,exports){ + // 26.1.9 Reflect.has(target, propertyKey) + var $export = require('./_export'); + + $export($export.S, 'Reflect', { + has: function has(target, propertyKey) { + return propertyKey in target; + } + }); + + },{"./_export":104}],291:[function(require,module,exports){ + // 26.1.10 Reflect.isExtensible(target) + var $export = require('./_export'); + var anObject = require('./_an-object'); + var $isExtensible = Object.isExtensible; + + $export($export.S, 'Reflect', { + isExtensible: function isExtensible(target) { + anObject(target); + return $isExtensible ? $isExtensible(target) : true; + } + }); + + },{"./_an-object":78,"./_export":104}],292:[function(require,module,exports){ + // 26.1.11 Reflect.ownKeys(target) + var $export = require('./_export'); + + $export($export.S, 'Reflect', { ownKeys: require('./_own-keys') }); + + },{"./_export":104,"./_own-keys":156}],293:[function(require,module,exports){ + // 26.1.12 Reflect.preventExtensions(target) + var $export = require('./_export'); + var anObject = require('./_an-object'); + var $preventExtensions = Object.preventExtensions; + + $export($export.S, 'Reflect', { + preventExtensions: function preventExtensions(target) { + anObject(target); + try { + if ($preventExtensions) $preventExtensions(target); + return true; + } catch (e) { + return false; + } + } + }); + + },{"./_an-object":78,"./_export":104}],294:[function(require,module,exports){ + // 26.1.14 Reflect.setPrototypeOf(target, proto) + var $export = require('./_export'); + var setProto = require('./_set-proto'); + + if (setProto) $export($export.S, 'Reflect', { + setPrototypeOf: function setPrototypeOf(target, proto) { + setProto.check(target, proto); + try { + setProto.set(target, proto); + return true; + } catch (e) { + return false; + } + } + }); + + },{"./_export":104,"./_set-proto":170}],295:[function(require,module,exports){ + // 26.1.13 Reflect.set(target, propertyKey, V [, receiver]) + var dP = require('./_object-dp'); + var gOPD = require('./_object-gopd'); + var getPrototypeOf = require('./_object-gpo'); + var has = require('./_has'); + var $export = require('./_export'); + var createDesc = require('./_property-desc'); + var anObject = require('./_an-object'); + var isObject = require('./_is-object'); + + function set(target, propertyKey, V /* , receiver */) { + var receiver = arguments.length < 4 ? target : arguments[3]; + var ownDesc = gOPD.f(anObject(target), propertyKey); + var existingDescriptor, proto; + if (!ownDesc) { + if (isObject(proto = getPrototypeOf(target))) { + return set(proto, propertyKey, V, receiver); + } + ownDesc = createDesc(0); + } + if (has(ownDesc, 'value')) { + if (ownDesc.writable === false || !isObject(receiver)) return false; + if (existingDescriptor = gOPD.f(receiver, propertyKey)) { + if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false; + existingDescriptor.value = V; + dP.f(receiver, propertyKey, existingDescriptor); + } else dP.f(receiver, propertyKey, createDesc(0, V)); + return true; + } + return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true); + } + + $export($export.S, 'Reflect', { set: set }); + + },{"./_an-object":78,"./_export":104,"./_has":113,"./_is-object":123,"./_object-dp":143,"./_object-gopd":146,"./_object-gpo":150,"./_property-desc":161}],296:[function(require,module,exports){ + var global = require('./_global'); + var inheritIfRequired = require('./_inherit-if-required'); + var dP = require('./_object-dp').f; + var gOPN = require('./_object-gopn').f; + var isRegExp = require('./_is-regexp'); + var $flags = require('./_flags'); + var $RegExp = global.RegExp; + var Base = $RegExp; + var proto = $RegExp.prototype; + var re1 = /a/g; + var re2 = /a/g; + // "new" creates a new object, old webkit buggy here + var CORRECT_NEW = new $RegExp(re1) !== re1; + + if (require('./_descriptors') && (!CORRECT_NEW || require('./_fails')(function () { + re2[require('./_wks')('match')] = false; + // RegExp constructor can alter flags and IsRegExp works correct with @@match + return $RegExp(re1) != re1 || $RegExp(re2) == re2 || $RegExp(re1, 'i') != '/a/i'; + }))) { + $RegExp = function RegExp(p, f) { + var tiRE = this instanceof $RegExp; + var piRE = isRegExp(p); + var fiU = f === undefined; + return !tiRE && piRE && p.constructor === $RegExp && fiU ? p + : inheritIfRequired(CORRECT_NEW + ? new Base(piRE && !fiU ? p.source : p, f) + : Base((piRE = p instanceof $RegExp) ? p.source : p, piRE && fiU ? $flags.call(p) : f) + , tiRE ? this : proto, $RegExp); + }; + var proxy = function (key) { + key in $RegExp || dP($RegExp, key, { + configurable: true, + get: function () { return Base[key]; }, + set: function (it) { Base[key] = it; } + }); + }; + for (var keys = gOPN(Base), i = 0; keys.length > i;) proxy(keys[i++]); + proto.constructor = $RegExp; + $RegExp.prototype = proto; + require('./_redefine')(global, 'RegExp', $RegExp); + } + + require('./_set-species')('RegExp'); + + },{"./_descriptors":100,"./_fails":106,"./_flags":108,"./_global":112,"./_inherit-if-required":117,"./_is-regexp":124,"./_object-dp":143,"./_object-gopn":148,"./_redefine":163,"./_set-species":171,"./_wks":200}],297:[function(require,module,exports){ + 'use strict'; + var regexpExec = require('./_regexp-exec'); + require('./_export')({ + target: 'RegExp', + proto: true, + forced: regexpExec !== /./.exec + }, { + exec: regexpExec + }); + + },{"./_export":104,"./_regexp-exec":165}],298:[function(require,module,exports){ + // 21.2.5.3 get RegExp.prototype.flags() + if (require('./_descriptors') && /./g.flags != 'g') require('./_object-dp').f(RegExp.prototype, 'flags', { + configurable: true, + get: require('./_flags') + }); + + },{"./_descriptors":100,"./_flags":108,"./_object-dp":143}],299:[function(require,module,exports){ + 'use strict'; + + var anObject = require('./_an-object'); + var toLength = require('./_to-length'); + var advanceStringIndex = require('./_advance-string-index'); + var regExpExec = require('./_regexp-exec-abstract'); + + // @@match logic + require('./_fix-re-wks')('match', 1, function (defined, MATCH, $match, maybeCallNative) { + return [ + // `String.prototype.match` method + // https://tc39.github.io/ecma262/#sec-string.prototype.match + function match(regexp) { + var O = defined(this); + var fn = regexp == undefined ? undefined : regexp[MATCH]; + return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O)); + }, + // `RegExp.prototype[@@match]` method + // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match + function (regexp) { + var res = maybeCallNative($match, regexp, this); + if (res.done) return res.value; + var rx = anObject(regexp); + var S = String(this); + if (!rx.global) return regExpExec(rx, S); + var fullUnicode = rx.unicode; + rx.lastIndex = 0; + var A = []; + var n = 0; + var result; + while ((result = regExpExec(rx, S)) !== null) { + var matchStr = String(result[0]); + A[n] = matchStr; + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); + n++; + } + return n === 0 ? null : A; + } + ]; + }); + + },{"./_advance-string-index":76,"./_an-object":78,"./_fix-re-wks":107,"./_regexp-exec-abstract":164,"./_to-length":189}],300:[function(require,module,exports){ + 'use strict'; + + var anObject = require('./_an-object'); + var toObject = require('./_to-object'); + var toLength = require('./_to-length'); + var toInteger = require('./_to-integer'); + var advanceStringIndex = require('./_advance-string-index'); + var regExpExec = require('./_regexp-exec-abstract'); + var max = Math.max; + var min = Math.min; + var floor = Math.floor; + var SUBSTITUTION_SYMBOLS = /\$([$&`']|\d\d?|<[^>]*>)/g; + var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&`']|\d\d?)/g; + + var maybeToString = function (it) { + return it === undefined ? it : String(it); + }; + + // @@replace logic + require('./_fix-re-wks')('replace', 2, function (defined, REPLACE, $replace, maybeCallNative) { + return [ + // `String.prototype.replace` method + // https://tc39.github.io/ecma262/#sec-string.prototype.replace + function replace(searchValue, replaceValue) { + var O = defined(this); + var fn = searchValue == undefined ? undefined : searchValue[REPLACE]; + return fn !== undefined + ? fn.call(searchValue, O, replaceValue) + : $replace.call(String(O), searchValue, replaceValue); + }, + // `RegExp.prototype[@@replace]` method + // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace + function (regexp, replaceValue) { + var res = maybeCallNative($replace, regexp, this, replaceValue); + if (res.done) return res.value; + + var rx = anObject(regexp); + var S = String(this); + var functionalReplace = typeof replaceValue === 'function'; + if (!functionalReplace) replaceValue = String(replaceValue); + var global = rx.global; + if (global) { + var fullUnicode = rx.unicode; + rx.lastIndex = 0; + } + var results = []; + while (true) { + var result = regExpExec(rx, S); + if (result === null) break; + results.push(result); + if (!global) break; + var matchStr = String(result[0]); + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); + } + var accumulatedResult = ''; + var nextSourcePosition = 0; + for (var i = 0; i < results.length; i++) { + result = results[i]; + var matched = String(result[0]); + var position = max(min(toInteger(result.index), S.length), 0); + var captures = []; + // NOTE: This is equivalent to + // captures = result.slice(1).map(maybeToString) + // but for some reason `nativeSlice.call(result, 1, result.length)` (called in + // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and + // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. + for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j])); + var namedCaptures = result.groups; + if (functionalReplace) { + var replacerArgs = [matched].concat(captures, position, S); + if (namedCaptures !== undefined) replacerArgs.push(namedCaptures); + var replacement = String(replaceValue.apply(undefined, replacerArgs)); + } else { + replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); + } + if (position >= nextSourcePosition) { + accumulatedResult += S.slice(nextSourcePosition, position) + replacement; + nextSourcePosition = position + matched.length; + } + } + return accumulatedResult + S.slice(nextSourcePosition); + } + ]; + + // https://tc39.github.io/ecma262/#sec-getsubstitution + function getSubstitution(matched, str, position, captures, namedCaptures, replacement) { + var tailPos = position + matched.length; + var m = captures.length; + var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; + if (namedCaptures !== undefined) { + namedCaptures = toObject(namedCaptures); + symbols = SUBSTITUTION_SYMBOLS; + } + return $replace.call(replacement, symbols, function (match, ch) { + var capture; + switch (ch.charAt(0)) { + case '$': return '$'; + case '&': return matched; + case '`': return str.slice(0, position); + case "'": return str.slice(tailPos); + case '<': + capture = namedCaptures[ch.slice(1, -1)]; + break; + default: // \d\d? + var n = +ch; + if (n === 0) return match; + if (n > m) { + var f = floor(n / 10); + if (f === 0) return match; + if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1); + return match; + } + capture = captures[n - 1]; + } + return capture === undefined ? '' : capture; + }); + } + }); + + },{"./_advance-string-index":76,"./_an-object":78,"./_fix-re-wks":107,"./_regexp-exec-abstract":164,"./_to-integer":187,"./_to-length":189,"./_to-object":190}],301:[function(require,module,exports){ + 'use strict'; + + var anObject = require('./_an-object'); + var sameValue = require('./_same-value'); + var regExpExec = require('./_regexp-exec-abstract'); + + // @@search logic + require('./_fix-re-wks')('search', 1, function (defined, SEARCH, $search, maybeCallNative) { + return [ + // `String.prototype.search` method + // https://tc39.github.io/ecma262/#sec-string.prototype.search + function search(regexp) { + var O = defined(this); + var fn = regexp == undefined ? undefined : regexp[SEARCH]; + return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O)); + }, + // `RegExp.prototype[@@search]` method + // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@search + function (regexp) { + var res = maybeCallNative($search, regexp, this); + if (res.done) return res.value; + var rx = anObject(regexp); + var S = String(this); + var previousLastIndex = rx.lastIndex; + if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0; + var result = regExpExec(rx, S); + if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex; + return result === null ? -1 : result.index; + } + ]; + }); + + },{"./_an-object":78,"./_fix-re-wks":107,"./_regexp-exec-abstract":164,"./_same-value":167}],302:[function(require,module,exports){ + 'use strict'; + + var isRegExp = require('./_is-regexp'); + var anObject = require('./_an-object'); + var speciesConstructor = require('./_species-constructor'); + var advanceStringIndex = require('./_advance-string-index'); + var toLength = require('./_to-length'); + var callRegExpExec = require('./_regexp-exec-abstract'); + var regexpExec = require('./_regexp-exec'); + var fails = require('./_fails'); + var $min = Math.min; + var $push = [].push; + var $SPLIT = 'split'; + var LENGTH = 'length'; + var LAST_INDEX = 'lastIndex'; + var MAX_UINT32 = 0xffffffff; + + // babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError + var SUPPORTS_Y = !fails(function () { RegExp(MAX_UINT32, 'y'); }); + + // @@split logic + require('./_fix-re-wks')('split', 2, function (defined, SPLIT, $split, maybeCallNative) { + var internalSplit; + if ( + 'abbc'[$SPLIT](/(b)*/)[1] == 'c' || + 'test'[$SPLIT](/(?:)/, -1)[LENGTH] != 4 || + 'ab'[$SPLIT](/(?:ab)*/)[LENGTH] != 2 || + '.'[$SPLIT](/(.?)(.?)/)[LENGTH] != 4 || + '.'[$SPLIT](/()()/)[LENGTH] > 1 || + ''[$SPLIT](/.?/)[LENGTH] + ) { + // based on es5-shim implementation, need to rework it + internalSplit = function (separator, limit) { + var string = String(this); + if (separator === undefined && limit === 0) return []; + // If `separator` is not a regex, use native split + if (!isRegExp(separator)) return $split.call(string, separator, limit); + var output = []; + var flags = (separator.ignoreCase ? 'i' : '') + + (separator.multiline ? 'm' : '') + + (separator.unicode ? 'u' : '') + + (separator.sticky ? 'y' : ''); + var lastLastIndex = 0; + var splitLimit = limit === undefined ? MAX_UINT32 : limit >>> 0; + // Make `global` and avoid `lastIndex` issues by working with a copy + var separatorCopy = new RegExp(separator.source, flags + 'g'); + var match, lastIndex, lastLength; + while (match = regexpExec.call(separatorCopy, string)) { + lastIndex = separatorCopy[LAST_INDEX]; + if (lastIndex > lastLastIndex) { + output.push(string.slice(lastLastIndex, match.index)); + if (match[LENGTH] > 1 && match.index < string[LENGTH]) $push.apply(output, match.slice(1)); + lastLength = match[0][LENGTH]; + lastLastIndex = lastIndex; + if (output[LENGTH] >= splitLimit) break; + } + if (separatorCopy[LAST_INDEX] === match.index) separatorCopy[LAST_INDEX]++; // Avoid an infinite loop + } + if (lastLastIndex === string[LENGTH]) { + if (lastLength || !separatorCopy.test('')) output.push(''); + } else output.push(string.slice(lastLastIndex)); + return output[LENGTH] > splitLimit ? output.slice(0, splitLimit) : output; + }; + // Chakra, V8 + } else if ('0'[$SPLIT](undefined, 0)[LENGTH]) { + internalSplit = function (separator, limit) { + return separator === undefined && limit === 0 ? [] : $split.call(this, separator, limit); + }; + } else { + internalSplit = $split; + } + + return [ + // `String.prototype.split` method + // https://tc39.github.io/ecma262/#sec-string.prototype.split + function split(separator, limit) { + var O = defined(this); + var splitter = separator == undefined ? undefined : separator[SPLIT]; + return splitter !== undefined + ? splitter.call(separator, O, limit) + : internalSplit.call(String(O), separator, limit); + }, + // `RegExp.prototype[@@split]` method + // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split + // + // NOTE: This cannot be properly polyfilled in engines that don't support + // the 'y' flag. + function (regexp, limit) { + var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== $split); + if (res.done) return res.value; + + var rx = anObject(regexp); + var S = String(this); + var C = speciesConstructor(rx, RegExp); + + var unicodeMatching = rx.unicode; + var flags = (rx.ignoreCase ? 'i' : '') + + (rx.multiline ? 'm' : '') + + (rx.unicode ? 'u' : '') + + (SUPPORTS_Y ? 'y' : 'g'); + + // ^(? + rx + ) is needed, in combination with some S slicing, to + // simulate the 'y' flag. + var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags); + var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; + if (lim === 0) return []; + if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : []; + var p = 0; + var q = 0; + var A = []; + while (q < S.length) { + splitter.lastIndex = SUPPORTS_Y ? q : 0; + var z = callRegExpExec(splitter, SUPPORTS_Y ? S : S.slice(q)); + var e; + if ( + z === null || + (e = $min(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p + ) { + q = advanceStringIndex(S, q, unicodeMatching); + } else { + A.push(S.slice(p, q)); + if (A.length === lim) return A; + for (var i = 1; i <= z.length - 1; i++) { + A.push(z[i]); + if (A.length === lim) return A; + } + q = p = e; + } + } + A.push(S.slice(p)); + return A; + } + ]; + }); + + },{"./_advance-string-index":76,"./_an-object":78,"./_fails":106,"./_fix-re-wks":107,"./_is-regexp":124,"./_regexp-exec":165,"./_regexp-exec-abstract":164,"./_species-constructor":175,"./_to-length":189}],303:[function(require,module,exports){ + 'use strict'; + require('./es6.regexp.flags'); + var anObject = require('./_an-object'); + var $flags = require('./_flags'); + var DESCRIPTORS = require('./_descriptors'); + var TO_STRING = 'toString'; + var $toString = /./[TO_STRING]; + + var define = function (fn) { + require('./_redefine')(RegExp.prototype, TO_STRING, fn, true); + }; + + // 21.2.5.14 RegExp.prototype.toString() + if (require('./_fails')(function () { return $toString.call({ source: 'a', flags: 'b' }) != '/a/b'; })) { + define(function toString() { + var R = anObject(this); + return '/'.concat(R.source, '/', + 'flags' in R ? R.flags : !DESCRIPTORS && R instanceof RegExp ? $flags.call(R) : undefined); + }); + // FF44- RegExp#toString has a wrong name + } else if ($toString.name != TO_STRING) { + define(function toString() { + return $toString.call(this); + }); + } + + },{"./_an-object":78,"./_descriptors":100,"./_fails":106,"./_flags":108,"./_redefine":163,"./es6.regexp.flags":298}],304:[function(require,module,exports){ + 'use strict'; + var strong = require('./_collection-strong'); + var validate = require('./_validate-collection'); + var SET = 'Set'; + + // 23.2 Set Objects + module.exports = require('./_collection')(SET, function (get) { + return function Set() { return get(this, arguments.length > 0 ? arguments[0] : undefined); }; + }, { + // 23.2.3.1 Set.prototype.add(value) + add: function add(value) { + return strong.def(validate(this, SET), value = value === 0 ? 0 : value, value); + } + }, strong); + + },{"./_collection":93,"./_collection-strong":90,"./_validate-collection":197}],305:[function(require,module,exports){ + 'use strict'; + // B.2.3.2 String.prototype.anchor(name) + require('./_string-html')('anchor', function (createHTML) { + return function anchor(name) { + return createHTML(this, 'a', 'name', name); + }; + }); + + },{"./_string-html":179}],306:[function(require,module,exports){ + 'use strict'; + // B.2.3.3 String.prototype.big() + require('./_string-html')('big', function (createHTML) { + return function big() { + return createHTML(this, 'big', '', ''); + }; + }); + + },{"./_string-html":179}],307:[function(require,module,exports){ + 'use strict'; + // B.2.3.4 String.prototype.blink() + require('./_string-html')('blink', function (createHTML) { + return function blink() { + return createHTML(this, 'blink', '', ''); + }; + }); + + },{"./_string-html":179}],308:[function(require,module,exports){ + 'use strict'; + // B.2.3.5 String.prototype.bold() + require('./_string-html')('bold', function (createHTML) { + return function bold() { + return createHTML(this, 'b', '', ''); + }; + }); + + },{"./_string-html":179}],309:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $at = require('./_string-at')(false); + $export($export.P, 'String', { + // 21.1.3.3 String.prototype.codePointAt(pos) + codePointAt: function codePointAt(pos) { + return $at(this, pos); + } + }); + + },{"./_export":104,"./_string-at":177}],310:[function(require,module,exports){ + // 21.1.3.6 String.prototype.endsWith(searchString [, endPosition]) + 'use strict'; + var $export = require('./_export'); + var toLength = require('./_to-length'); + var context = require('./_string-context'); + var ENDS_WITH = 'endsWith'; + var $endsWith = ''[ENDS_WITH]; + + $export($export.P + $export.F * require('./_fails-is-regexp')(ENDS_WITH), 'String', { + endsWith: function endsWith(searchString /* , endPosition = @length */) { + var that = context(this, searchString, ENDS_WITH); + var endPosition = arguments.length > 1 ? arguments[1] : undefined; + var len = toLength(that.length); + var end = endPosition === undefined ? len : Math.min(toLength(endPosition), len); + var search = String(searchString); + return $endsWith + ? $endsWith.call(that, search, end) + : that.slice(end - search.length, end) === search; + } + }); + + },{"./_export":104,"./_fails-is-regexp":105,"./_string-context":178,"./_to-length":189}],311:[function(require,module,exports){ + 'use strict'; + // B.2.3.6 String.prototype.fixed() + require('./_string-html')('fixed', function (createHTML) { + return function fixed() { + return createHTML(this, 'tt', '', ''); + }; + }); + + },{"./_string-html":179}],312:[function(require,module,exports){ + 'use strict'; + // B.2.3.7 String.prototype.fontcolor(color) + require('./_string-html')('fontcolor', function (createHTML) { + return function fontcolor(color) { + return createHTML(this, 'font', 'color', color); + }; + }); + + },{"./_string-html":179}],313:[function(require,module,exports){ + 'use strict'; + // B.2.3.8 String.prototype.fontsize(size) + require('./_string-html')('fontsize', function (createHTML) { + return function fontsize(size) { + return createHTML(this, 'font', 'size', size); + }; + }); + + },{"./_string-html":179}],314:[function(require,module,exports){ + var $export = require('./_export'); + var toAbsoluteIndex = require('./_to-absolute-index'); + var fromCharCode = String.fromCharCode; + var $fromCodePoint = String.fromCodePoint; + + // length should be 1, old FF problem + $export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', { + // 21.1.2.2 String.fromCodePoint(...codePoints) + fromCodePoint: function fromCodePoint(x) { // eslint-disable-line no-unused-vars + var res = []; + var aLen = arguments.length; + var i = 0; + var code; + while (aLen > i) { + code = +arguments[i++]; + if (toAbsoluteIndex(code, 0x10ffff) !== code) throw RangeError(code + ' is not a valid code point'); + res.push(code < 0x10000 + ? fromCharCode(code) + : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00) + ); + } return res.join(''); + } + }); + + },{"./_export":104,"./_to-absolute-index":185}],315:[function(require,module,exports){ + // 21.1.3.7 String.prototype.includes(searchString, position = 0) + 'use strict'; + var $export = require('./_export'); + var context = require('./_string-context'); + var INCLUDES = 'includes'; + + $export($export.P + $export.F * require('./_fails-is-regexp')(INCLUDES), 'String', { + includes: function includes(searchString /* , position = 0 */) { + return !!~context(this, searchString, INCLUDES) + .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined); + } + }); + + },{"./_export":104,"./_fails-is-regexp":105,"./_string-context":178}],316:[function(require,module,exports){ + 'use strict'; + // B.2.3.9 String.prototype.italics() + require('./_string-html')('italics', function (createHTML) { + return function italics() { + return createHTML(this, 'i', '', ''); + }; + }); + + },{"./_string-html":179}],317:[function(require,module,exports){ + 'use strict'; + var $at = require('./_string-at')(true); + + // 21.1.3.27 String.prototype[@@iterator]() + require('./_iter-define')(String, 'String', function (iterated) { + this._t = String(iterated); // target + this._i = 0; // next index + // 21.1.5.2.1 %StringIteratorPrototype%.next() + }, function () { + var O = this._t; + var index = this._i; + var point; + if (index >= O.length) return { value: undefined, done: true }; + point = $at(O, index); + this._i += point.length; + return { value: point, done: false }; + }); + + },{"./_iter-define":127,"./_string-at":177}],318:[function(require,module,exports){ + 'use strict'; + // B.2.3.10 String.prototype.link(url) + require('./_string-html')('link', function (createHTML) { + return function link(url) { + return createHTML(this, 'a', 'href', url); + }; + }); + + },{"./_string-html":179}],319:[function(require,module,exports){ + var $export = require('./_export'); + var toIObject = require('./_to-iobject'); + var toLength = require('./_to-length'); + + $export($export.S, 'String', { + // 21.1.2.4 String.raw(callSite, ...substitutions) + raw: function raw(callSite) { + var tpl = toIObject(callSite.raw); + var len = toLength(tpl.length); + var aLen = arguments.length; + var res = []; + var i = 0; + while (len > i) { + res.push(String(tpl[i++])); + if (i < aLen) res.push(String(arguments[i])); + } return res.join(''); + } + }); + + },{"./_export":104,"./_to-iobject":188,"./_to-length":189}],320:[function(require,module,exports){ + var $export = require('./_export'); + + $export($export.P, 'String', { + // 21.1.3.13 String.prototype.repeat(count) + repeat: require('./_string-repeat') + }); + + },{"./_export":104,"./_string-repeat":181}],321:[function(require,module,exports){ + 'use strict'; + // B.2.3.11 String.prototype.small() + require('./_string-html')('small', function (createHTML) { + return function small() { + return createHTML(this, 'small', '', ''); + }; + }); + + },{"./_string-html":179}],322:[function(require,module,exports){ + // 21.1.3.18 String.prototype.startsWith(searchString [, position ]) + 'use strict'; + var $export = require('./_export'); + var toLength = require('./_to-length'); + var context = require('./_string-context'); + var STARTS_WITH = 'startsWith'; + var $startsWith = ''[STARTS_WITH]; + + $export($export.P + $export.F * require('./_fails-is-regexp')(STARTS_WITH), 'String', { + startsWith: function startsWith(searchString /* , position = 0 */) { + var that = context(this, searchString, STARTS_WITH); + var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length)); + var search = String(searchString); + return $startsWith + ? $startsWith.call(that, search, index) + : that.slice(index, index + search.length) === search; + } + }); + + },{"./_export":104,"./_fails-is-regexp":105,"./_string-context":178,"./_to-length":189}],323:[function(require,module,exports){ + 'use strict'; + // B.2.3.12 String.prototype.strike() + require('./_string-html')('strike', function (createHTML) { + return function strike() { + return createHTML(this, 'strike', '', ''); + }; + }); + + },{"./_string-html":179}],324:[function(require,module,exports){ + 'use strict'; + // B.2.3.13 String.prototype.sub() + require('./_string-html')('sub', function (createHTML) { + return function sub() { + return createHTML(this, 'sub', '', ''); + }; + }); + + },{"./_string-html":179}],325:[function(require,module,exports){ + 'use strict'; + // B.2.3.14 String.prototype.sup() + require('./_string-html')('sup', function (createHTML) { + return function sup() { + return createHTML(this, 'sup', '', ''); + }; + }); + + },{"./_string-html":179}],326:[function(require,module,exports){ + 'use strict'; + // 21.1.3.25 String.prototype.trim() + require('./_string-trim')('trim', function ($trim) { + return function trim() { + return $trim(this, 3); + }; + }); + + },{"./_string-trim":182}],327:[function(require,module,exports){ + 'use strict'; + // ECMAScript 6 symbols shim + var global = require('./_global'); + var has = require('./_has'); + var DESCRIPTORS = require('./_descriptors'); + var $export = require('./_export'); + var redefine = require('./_redefine'); + var META = require('./_meta').KEY; + var $fails = require('./_fails'); + var shared = require('./_shared'); + var setToStringTag = require('./_set-to-string-tag'); + var uid = require('./_uid'); + var wks = require('./_wks'); + var wksExt = require('./_wks-ext'); + var wksDefine = require('./_wks-define'); + var enumKeys = require('./_enum-keys'); + var isArray = require('./_is-array'); + var anObject = require('./_an-object'); + var isObject = require('./_is-object'); + var toObject = require('./_to-object'); + var toIObject = require('./_to-iobject'); + var toPrimitive = require('./_to-primitive'); + var createDesc = require('./_property-desc'); + var _create = require('./_object-create'); + var gOPNExt = require('./_object-gopn-ext'); + var $GOPD = require('./_object-gopd'); + var $GOPS = require('./_object-gops'); + var $DP = require('./_object-dp'); + var $keys = require('./_object-keys'); + var gOPD = $GOPD.f; + var dP = $DP.f; + var gOPN = gOPNExt.f; + var $Symbol = global.Symbol; + var $JSON = global.JSON; + var _stringify = $JSON && $JSON.stringify; + var PROTOTYPE = 'prototype'; + var HIDDEN = wks('_hidden'); + var TO_PRIMITIVE = wks('toPrimitive'); + var isEnum = {}.propertyIsEnumerable; + var SymbolRegistry = shared('symbol-registry'); + var AllSymbols = shared('symbols'); + var OPSymbols = shared('op-symbols'); + var ObjectProto = Object[PROTOTYPE]; + var USE_NATIVE = typeof $Symbol == 'function' && !!$GOPS.f; + var QObject = global.QObject; + // Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 + var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild; + + // fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 + var setSymbolDesc = DESCRIPTORS && $fails(function () { + return _create(dP({}, 'a', { + get: function () { return dP(this, 'a', { value: 7 }).a; } + })).a != 7; + }) ? function (it, key, D) { + var protoDesc = gOPD(ObjectProto, key); + if (protoDesc) delete ObjectProto[key]; + dP(it, key, D); + if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc); + } : dP; + + var wrap = function (tag) { + var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]); + sym._k = tag; + return sym; + }; + + var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) { + return typeof it == 'symbol'; + } : function (it) { + return it instanceof $Symbol; + }; + + var $defineProperty = function defineProperty(it, key, D) { + if (it === ObjectProto) $defineProperty(OPSymbols, key, D); + anObject(it); + key = toPrimitive(key, true); + anObject(D); + if (has(AllSymbols, key)) { + if (!D.enumerable) { + if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {})); + it[HIDDEN][key] = true; + } else { + if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false; + D = _create(D, { enumerable: createDesc(0, false) }); + } return setSymbolDesc(it, key, D); + } return dP(it, key, D); + }; + var $defineProperties = function defineProperties(it, P) { + anObject(it); + var keys = enumKeys(P = toIObject(P)); + var i = 0; + var l = keys.length; + var key; + while (l > i) $defineProperty(it, key = keys[i++], P[key]); + return it; + }; + var $create = function create(it, P) { + return P === undefined ? _create(it) : $defineProperties(_create(it), P); + }; + var $propertyIsEnumerable = function propertyIsEnumerable(key) { + var E = isEnum.call(this, key = toPrimitive(key, true)); + if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false; + return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true; + }; + var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) { + it = toIObject(it); + key = toPrimitive(key, true); + if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return; + var D = gOPD(it, key); + if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true; + return D; + }; + var $getOwnPropertyNames = function getOwnPropertyNames(it) { + var names = gOPN(toIObject(it)); + var result = []; + var i = 0; + var key; + while (names.length > i) { + if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key); + } return result; + }; + var $getOwnPropertySymbols = function getOwnPropertySymbols(it) { + var IS_OP = it === ObjectProto; + var names = gOPN(IS_OP ? OPSymbols : toIObject(it)); + var result = []; + var i = 0; + var key; + while (names.length > i) { + if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]); + } return result; + }; + + // 19.4.1.1 Symbol([description]) + if (!USE_NATIVE) { + $Symbol = function Symbol() { + if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!'); + var tag = uid(arguments.length > 0 ? arguments[0] : undefined); + var $set = function (value) { + if (this === ObjectProto) $set.call(OPSymbols, value); + if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false; + setSymbolDesc(this, tag, createDesc(1, value)); + }; + if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set }); + return wrap(tag); + }; + redefine($Symbol[PROTOTYPE], 'toString', function toString() { + return this._k; + }); + + $GOPD.f = $getOwnPropertyDescriptor; + $DP.f = $defineProperty; + require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames; + require('./_object-pie').f = $propertyIsEnumerable; + $GOPS.f = $getOwnPropertySymbols; + + if (DESCRIPTORS && !require('./_library')) { + redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true); + } + + wksExt.f = function (name) { + return wrap(wks(name)); + }; + } + + $export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol }); + + for (var es6Symbols = ( + // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14 + 'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables' + ).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]); + + for (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]); + + $export($export.S + $export.F * !USE_NATIVE, 'Symbol', { + // 19.4.2.1 Symbol.for(key) + 'for': function (key) { + return has(SymbolRegistry, key += '') + ? SymbolRegistry[key] + : SymbolRegistry[key] = $Symbol(key); + }, + // 19.4.2.5 Symbol.keyFor(sym) + keyFor: function keyFor(sym) { + if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!'); + for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key; + }, + useSetter: function () { setter = true; }, + useSimple: function () { setter = false; } + }); + + $export($export.S + $export.F * !USE_NATIVE, 'Object', { + // 19.1.2.2 Object.create(O [, Properties]) + create: $create, + // 19.1.2.4 Object.defineProperty(O, P, Attributes) + defineProperty: $defineProperty, + // 19.1.2.3 Object.defineProperties(O, Properties) + defineProperties: $defineProperties, + // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P) + getOwnPropertyDescriptor: $getOwnPropertyDescriptor, + // 19.1.2.7 Object.getOwnPropertyNames(O) + getOwnPropertyNames: $getOwnPropertyNames, + // 19.1.2.8 Object.getOwnPropertySymbols(O) + getOwnPropertySymbols: $getOwnPropertySymbols + }); + + // Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives + // https://bugs.chromium.org/p/v8/issues/detail?id=3443 + var FAILS_ON_PRIMITIVES = $fails(function () { $GOPS.f(1); }); + + $export($export.S + $export.F * FAILS_ON_PRIMITIVES, 'Object', { + getOwnPropertySymbols: function getOwnPropertySymbols(it) { + return $GOPS.f(toObject(it)); + } + }); + + // 24.3.2 JSON.stringify(value [, replacer [, space]]) + $JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () { + var S = $Symbol(); + // MS Edge converts symbol values to JSON as {} + // WebKit converts symbol values to JSON as null + // V8 throws on boxed symbols + return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}'; + })), 'JSON', { + stringify: function stringify(it) { + var args = [it]; + var i = 1; + var replacer, $replacer; + while (arguments.length > i) args.push(arguments[i++]); + $replacer = replacer = args[1]; + if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined + if (!isArray(replacer)) replacer = function (key, value) { + if (typeof $replacer == 'function') value = $replacer.call(this, key, value); + if (!isSymbol(value)) return value; + }; + args[1] = replacer; + return _stringify.apply($JSON, args); + } + }); + + // 19.4.3.4 Symbol.prototype[@@toPrimitive](hint) + $Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf); + // 19.4.3.5 Symbol.prototype[@@toStringTag] + setToStringTag($Symbol, 'Symbol'); + // 20.2.1.9 Math[@@toStringTag] + setToStringTag(Math, 'Math', true); + // 24.3.3 JSON[@@toStringTag] + setToStringTag(global.JSON, 'JSON', true); + + },{"./_an-object":78,"./_descriptors":100,"./_enum-keys":103,"./_export":104,"./_fails":106,"./_global":112,"./_has":113,"./_hide":114,"./_is-array":121,"./_is-object":123,"./_library":131,"./_meta":137,"./_object-create":142,"./_object-dp":143,"./_object-gopd":146,"./_object-gopn":148,"./_object-gopn-ext":147,"./_object-gops":149,"./_object-keys":152,"./_object-pie":153,"./_property-desc":161,"./_redefine":163,"./_set-to-string-tag":172,"./_shared":174,"./_to-iobject":188,"./_to-object":190,"./_to-primitive":191,"./_uid":195,"./_wks":200,"./_wks-define":198,"./_wks-ext":199}],328:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var $typed = require('./_typed'); + var buffer = require('./_typed-buffer'); + var anObject = require('./_an-object'); + var toAbsoluteIndex = require('./_to-absolute-index'); + var toLength = require('./_to-length'); + var isObject = require('./_is-object'); + var ArrayBuffer = require('./_global').ArrayBuffer; + var speciesConstructor = require('./_species-constructor'); + var $ArrayBuffer = buffer.ArrayBuffer; + var $DataView = buffer.DataView; + var $isView = $typed.ABV && ArrayBuffer.isView; + var $slice = $ArrayBuffer.prototype.slice; + var VIEW = $typed.VIEW; + var ARRAY_BUFFER = 'ArrayBuffer'; + + $export($export.G + $export.W + $export.F * (ArrayBuffer !== $ArrayBuffer), { ArrayBuffer: $ArrayBuffer }); + + $export($export.S + $export.F * !$typed.CONSTR, ARRAY_BUFFER, { + // 24.1.3.1 ArrayBuffer.isView(arg) + isView: function isView(it) { + return $isView && $isView(it) || isObject(it) && VIEW in it; + } + }); + + $export($export.P + $export.U + $export.F * require('./_fails')(function () { + return !new $ArrayBuffer(2).slice(1, undefined).byteLength; + }), ARRAY_BUFFER, { + // 24.1.4.3 ArrayBuffer.prototype.slice(start, end) + slice: function slice(start, end) { + if ($slice !== undefined && end === undefined) return $slice.call(anObject(this), start); // FF fix + var len = anObject(this).byteLength; + var first = toAbsoluteIndex(start, len); + var fin = toAbsoluteIndex(end === undefined ? len : end, len); + var result = new (speciesConstructor(this, $ArrayBuffer))(toLength(fin - first)); + var viewS = new $DataView(this); + var viewT = new $DataView(result); + var index = 0; + while (first < fin) { + viewT.setUint8(index++, viewS.getUint8(first++)); + } return result; + } + }); + + require('./_set-species')(ARRAY_BUFFER); + + },{"./_an-object":78,"./_export":104,"./_fails":106,"./_global":112,"./_is-object":123,"./_set-species":171,"./_species-constructor":175,"./_to-absolute-index":185,"./_to-length":189,"./_typed":194,"./_typed-buffer":193}],329:[function(require,module,exports){ + var $export = require('./_export'); + $export($export.G + $export.W + $export.F * !require('./_typed').ABV, { + DataView: require('./_typed-buffer').DataView + }); + + },{"./_export":104,"./_typed":194,"./_typed-buffer":193}],330:[function(require,module,exports){ + require('./_typed-array')('Float32', 4, function (init) { + return function Float32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; + }); + + },{"./_typed-array":192}],331:[function(require,module,exports){ + require('./_typed-array')('Float64', 8, function (init) { + return function Float64Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; + }); + + },{"./_typed-array":192}],332:[function(require,module,exports){ + require('./_typed-array')('Int16', 2, function (init) { + return function Int16Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; + }); + + },{"./_typed-array":192}],333:[function(require,module,exports){ + require('./_typed-array')('Int32', 4, function (init) { + return function Int32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; + }); + + },{"./_typed-array":192}],334:[function(require,module,exports){ + require('./_typed-array')('Int8', 1, function (init) { + return function Int8Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; + }); + + },{"./_typed-array":192}],335:[function(require,module,exports){ + require('./_typed-array')('Uint16', 2, function (init) { + return function Uint16Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; + }); + + },{"./_typed-array":192}],336:[function(require,module,exports){ + require('./_typed-array')('Uint32', 4, function (init) { + return function Uint32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; + }); + + },{"./_typed-array":192}],337:[function(require,module,exports){ + require('./_typed-array')('Uint8', 1, function (init) { + return function Uint8Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; + }); + + },{"./_typed-array":192}],338:[function(require,module,exports){ + require('./_typed-array')('Uint8', 1, function (init) { + return function Uint8ClampedArray(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; + }, true); + + },{"./_typed-array":192}],339:[function(require,module,exports){ + 'use strict'; + var global = require('./_global'); + var each = require('./_array-methods')(0); + var redefine = require('./_redefine'); + var meta = require('./_meta'); + var assign = require('./_object-assign'); + var weak = require('./_collection-weak'); + var isObject = require('./_is-object'); + var validate = require('./_validate-collection'); + var NATIVE_WEAK_MAP = require('./_validate-collection'); + var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global; + var WEAK_MAP = 'WeakMap'; + var getWeak = meta.getWeak; + var isExtensible = Object.isExtensible; + var uncaughtFrozenStore = weak.ufstore; + var InternalMap; + + var wrapper = function (get) { + return function WeakMap() { + return get(this, arguments.length > 0 ? arguments[0] : undefined); + }; + }; + + var methods = { + // 23.3.3.3 WeakMap.prototype.get(key) + get: function get(key) { + if (isObject(key)) { + var data = getWeak(key); + if (data === true) return uncaughtFrozenStore(validate(this, WEAK_MAP)).get(key); + return data ? data[this._i] : undefined; + } + }, + // 23.3.3.5 WeakMap.prototype.set(key, value) + set: function set(key, value) { + return weak.def(validate(this, WEAK_MAP), key, value); + } + }; + + // 23.3 WeakMap Objects + var $WeakMap = module.exports = require('./_collection')(WEAK_MAP, wrapper, methods, weak, true, true); + + // IE11 WeakMap frozen keys fix + if (NATIVE_WEAK_MAP && IS_IE11) { + InternalMap = weak.getConstructor(wrapper, WEAK_MAP); + assign(InternalMap.prototype, methods); + meta.NEED = true; + each(['delete', 'has', 'get', 'set'], function (key) { + var proto = $WeakMap.prototype; + var method = proto[key]; + redefine(proto, key, function (a, b) { + // store frozen objects on internal weakmap shim + if (isObject(a) && !isExtensible(a)) { + if (!this._f) this._f = new InternalMap(); + var result = this._f[key](a, b); + return key == 'set' ? this : result; + // store all the rest on native weakmap + } return method.call(this, a, b); + }); + }); + } + + },{"./_array-methods":83,"./_collection":93,"./_collection-weak":92,"./_global":112,"./_is-object":123,"./_meta":137,"./_object-assign":141,"./_redefine":163,"./_validate-collection":197}],340:[function(require,module,exports){ + 'use strict'; + var weak = require('./_collection-weak'); + var validate = require('./_validate-collection'); + var WEAK_SET = 'WeakSet'; + + // 23.4 WeakSet Objects + require('./_collection')(WEAK_SET, function (get) { + return function WeakSet() { return get(this, arguments.length > 0 ? arguments[0] : undefined); }; + }, { + // 23.4.3.1 WeakSet.prototype.add(value) + add: function add(value) { + return weak.def(validate(this, WEAK_SET), value, true); + } + }, weak, false, true); + + },{"./_collection":93,"./_collection-weak":92,"./_validate-collection":197}],341:[function(require,module,exports){ + 'use strict'; + // https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap + var $export = require('./_export'); + var flattenIntoArray = require('./_flatten-into-array'); + var toObject = require('./_to-object'); + var toLength = require('./_to-length'); + var aFunction = require('./_a-function'); + var arraySpeciesCreate = require('./_array-species-create'); + + $export($export.P, 'Array', { + flatMap: function flatMap(callbackfn /* , thisArg */) { + var O = toObject(this); + var sourceLen, A; + aFunction(callbackfn); + sourceLen = toLength(O.length); + A = arraySpeciesCreate(O, 0); + flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments[1]); + return A; + } + }); + + require('./_add-to-unscopables')('flatMap'); + + },{"./_a-function":73,"./_add-to-unscopables":75,"./_array-species-create":86,"./_export":104,"./_flatten-into-array":109,"./_to-length":189,"./_to-object":190}],342:[function(require,module,exports){ + 'use strict'; + // https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatten + var $export = require('./_export'); + var flattenIntoArray = require('./_flatten-into-array'); + var toObject = require('./_to-object'); + var toLength = require('./_to-length'); + var toInteger = require('./_to-integer'); + var arraySpeciesCreate = require('./_array-species-create'); + + $export($export.P, 'Array', { + flatten: function flatten(/* depthArg = 1 */) { + var depthArg = arguments[0]; + var O = toObject(this); + var sourceLen = toLength(O.length); + var A = arraySpeciesCreate(O, 0); + flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toInteger(depthArg)); + return A; + } + }); + + require('./_add-to-unscopables')('flatten'); + + },{"./_add-to-unscopables":75,"./_array-species-create":86,"./_export":104,"./_flatten-into-array":109,"./_to-integer":187,"./_to-length":189,"./_to-object":190}],343:[function(require,module,exports){ + 'use strict'; + // https://github.com/tc39/Array.prototype.includes + var $export = require('./_export'); + var $includes = require('./_array-includes')(true); + + $export($export.P, 'Array', { + includes: function includes(el /* , fromIndex = 0 */) { + return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); + } + }); + + require('./_add-to-unscopables')('includes'); + + },{"./_add-to-unscopables":75,"./_array-includes":82,"./_export":104}],344:[function(require,module,exports){ + // https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask + var $export = require('./_export'); + var microtask = require('./_microtask')(); + var process = require('./_global').process; + var isNode = require('./_cof')(process) == 'process'; + + $export($export.G, { + asap: function asap(fn) { + var domain = isNode && process.domain; + microtask(domain ? domain.bind(fn) : fn); + } + }); + + },{"./_cof":89,"./_export":104,"./_global":112,"./_microtask":139}],345:[function(require,module,exports){ + // https://github.com/ljharb/proposal-is-error + var $export = require('./_export'); + var cof = require('./_cof'); + + $export($export.S, 'Error', { + isError: function isError(it) { + return cof(it) === 'Error'; + } + }); + + },{"./_cof":89,"./_export":104}],346:[function(require,module,exports){ + // https://github.com/tc39/proposal-global + var $export = require('./_export'); + + $export($export.G, { global: require('./_global') }); + + },{"./_export":104,"./_global":112}],347:[function(require,module,exports){ + // https://tc39.github.io/proposal-setmap-offrom/#sec-map.from + require('./_set-collection-from')('Map'); + + },{"./_set-collection-from":168}],348:[function(require,module,exports){ + // https://tc39.github.io/proposal-setmap-offrom/#sec-map.of + require('./_set-collection-of')('Map'); + + },{"./_set-collection-of":169}],349:[function(require,module,exports){ + // https://github.com/DavidBruant/Map-Set.prototype.toJSON + var $export = require('./_export'); + + $export($export.P + $export.R, 'Map', { toJSON: require('./_collection-to-json')('Map') }); + + },{"./_collection-to-json":91,"./_export":104}],350:[function(require,module,exports){ + // https://rwaldron.github.io/proposal-math-extensions/ + var $export = require('./_export'); + + $export($export.S, 'Math', { + clamp: function clamp(x, lower, upper) { + return Math.min(upper, Math.max(lower, x)); + } + }); + + },{"./_export":104}],351:[function(require,module,exports){ + // https://rwaldron.github.io/proposal-math-extensions/ + var $export = require('./_export'); + + $export($export.S, 'Math', { DEG_PER_RAD: Math.PI / 180 }); + + },{"./_export":104}],352:[function(require,module,exports){ + // https://rwaldron.github.io/proposal-math-extensions/ + var $export = require('./_export'); + var RAD_PER_DEG = 180 / Math.PI; + + $export($export.S, 'Math', { + degrees: function degrees(radians) { + return radians * RAD_PER_DEG; + } + }); + + },{"./_export":104}],353:[function(require,module,exports){ + // https://rwaldron.github.io/proposal-math-extensions/ + var $export = require('./_export'); + var scale = require('./_math-scale'); + var fround = require('./_math-fround'); + + $export($export.S, 'Math', { + fscale: function fscale(x, inLow, inHigh, outLow, outHigh) { + return fround(scale(x, inLow, inHigh, outLow, outHigh)); + } + }); + + },{"./_export":104,"./_math-fround":133,"./_math-scale":135}],354:[function(require,module,exports){ + // https://gist.github.com/BrendanEich/4294d5c212a6d2254703 + var $export = require('./_export'); + + $export($export.S, 'Math', { + iaddh: function iaddh(x0, x1, y0, y1) { + var $x0 = x0 >>> 0; + var $x1 = x1 >>> 0; + var $y0 = y0 >>> 0; + return $x1 + (y1 >>> 0) + (($x0 & $y0 | ($x0 | $y0) & ~($x0 + $y0 >>> 0)) >>> 31) | 0; + } + }); + + },{"./_export":104}],355:[function(require,module,exports){ + // https://gist.github.com/BrendanEich/4294d5c212a6d2254703 + var $export = require('./_export'); + + $export($export.S, 'Math', { + imulh: function imulh(u, v) { + var UINT16 = 0xffff; + var $u = +u; + var $v = +v; + var u0 = $u & UINT16; + var v0 = $v & UINT16; + var u1 = $u >> 16; + var v1 = $v >> 16; + var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16); + return u1 * v1 + (t >> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >> 16); + } + }); + + },{"./_export":104}],356:[function(require,module,exports){ + // https://gist.github.com/BrendanEich/4294d5c212a6d2254703 + var $export = require('./_export'); + + $export($export.S, 'Math', { + isubh: function isubh(x0, x1, y0, y1) { + var $x0 = x0 >>> 0; + var $x1 = x1 >>> 0; + var $y0 = y0 >>> 0; + return $x1 - (y1 >>> 0) - ((~$x0 & $y0 | ~($x0 ^ $y0) & $x0 - $y0 >>> 0) >>> 31) | 0; + } + }); + + },{"./_export":104}],357:[function(require,module,exports){ + // https://rwaldron.github.io/proposal-math-extensions/ + var $export = require('./_export'); + + $export($export.S, 'Math', { RAD_PER_DEG: 180 / Math.PI }); + + },{"./_export":104}],358:[function(require,module,exports){ + // https://rwaldron.github.io/proposal-math-extensions/ + var $export = require('./_export'); + var DEG_PER_RAD = Math.PI / 180; + + $export($export.S, 'Math', { + radians: function radians(degrees) { + return degrees * DEG_PER_RAD; + } + }); + + },{"./_export":104}],359:[function(require,module,exports){ + // https://rwaldron.github.io/proposal-math-extensions/ + var $export = require('./_export'); + + $export($export.S, 'Math', { scale: require('./_math-scale') }); + + },{"./_export":104,"./_math-scale":135}],360:[function(require,module,exports){ + // http://jfbastien.github.io/papers/Math.signbit.html + var $export = require('./_export'); + + $export($export.S, 'Math', { signbit: function signbit(x) { + // eslint-disable-next-line no-self-compare + return (x = +x) != x ? x : x == 0 ? 1 / x == Infinity : x > 0; + } }); + + },{"./_export":104}],361:[function(require,module,exports){ + // https://gist.github.com/BrendanEich/4294d5c212a6d2254703 + var $export = require('./_export'); + + $export($export.S, 'Math', { + umulh: function umulh(u, v) { + var UINT16 = 0xffff; + var $u = +u; + var $v = +v; + var u0 = $u & UINT16; + var v0 = $v & UINT16; + var u1 = $u >>> 16; + var v1 = $v >>> 16; + var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16); + return u1 * v1 + (t >>> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >>> 16); + } + }); + + },{"./_export":104}],362:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var toObject = require('./_to-object'); + var aFunction = require('./_a-function'); + var $defineProperty = require('./_object-dp'); + + // B.2.2.2 Object.prototype.__defineGetter__(P, getter) + require('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', { + __defineGetter__: function __defineGetter__(P, getter) { + $defineProperty.f(toObject(this), P, { get: aFunction(getter), enumerable: true, configurable: true }); + } + }); + + },{"./_a-function":73,"./_descriptors":100,"./_export":104,"./_object-dp":143,"./_object-forced-pam":145,"./_to-object":190}],363:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var toObject = require('./_to-object'); + var aFunction = require('./_a-function'); + var $defineProperty = require('./_object-dp'); + + // B.2.2.3 Object.prototype.__defineSetter__(P, setter) + require('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', { + __defineSetter__: function __defineSetter__(P, setter) { + $defineProperty.f(toObject(this), P, { set: aFunction(setter), enumerable: true, configurable: true }); + } + }); + + },{"./_a-function":73,"./_descriptors":100,"./_export":104,"./_object-dp":143,"./_object-forced-pam":145,"./_to-object":190}],364:[function(require,module,exports){ + // https://github.com/tc39/proposal-object-values-entries + var $export = require('./_export'); + var $entries = require('./_object-to-array')(true); + + $export($export.S, 'Object', { + entries: function entries(it) { + return $entries(it); + } + }); + + },{"./_export":104,"./_object-to-array":155}],365:[function(require,module,exports){ + // https://github.com/tc39/proposal-object-getownpropertydescriptors + var $export = require('./_export'); + var ownKeys = require('./_own-keys'); + var toIObject = require('./_to-iobject'); + var gOPD = require('./_object-gopd'); + var createProperty = require('./_create-property'); + + $export($export.S, 'Object', { + getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) { + var O = toIObject(object); + var getDesc = gOPD.f; + var keys = ownKeys(O); + var result = {}; + var i = 0; + var key, desc; + while (keys.length > i) { + desc = getDesc(O, key = keys[i++]); + if (desc !== undefined) createProperty(result, key, desc); + } + return result; + } + }); + + },{"./_create-property":95,"./_export":104,"./_object-gopd":146,"./_own-keys":156,"./_to-iobject":188}],366:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var toObject = require('./_to-object'); + var toPrimitive = require('./_to-primitive'); + var getPrototypeOf = require('./_object-gpo'); + var getOwnPropertyDescriptor = require('./_object-gopd').f; + + // B.2.2.4 Object.prototype.__lookupGetter__(P) + require('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', { + __lookupGetter__: function __lookupGetter__(P) { + var O = toObject(this); + var K = toPrimitive(P, true); + var D; + do { + if (D = getOwnPropertyDescriptor(O, K)) return D.get; + } while (O = getPrototypeOf(O)); + } + }); + + },{"./_descriptors":100,"./_export":104,"./_object-forced-pam":145,"./_object-gopd":146,"./_object-gpo":150,"./_to-object":190,"./_to-primitive":191}],367:[function(require,module,exports){ + 'use strict'; + var $export = require('./_export'); + var toObject = require('./_to-object'); + var toPrimitive = require('./_to-primitive'); + var getPrototypeOf = require('./_object-gpo'); + var getOwnPropertyDescriptor = require('./_object-gopd').f; + + // B.2.2.5 Object.prototype.__lookupSetter__(P) + require('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', { + __lookupSetter__: function __lookupSetter__(P) { + var O = toObject(this); + var K = toPrimitive(P, true); + var D; + do { + if (D = getOwnPropertyDescriptor(O, K)) return D.set; + } while (O = getPrototypeOf(O)); + } + }); + + },{"./_descriptors":100,"./_export":104,"./_object-forced-pam":145,"./_object-gopd":146,"./_object-gpo":150,"./_to-object":190,"./_to-primitive":191}],368:[function(require,module,exports){ + // https://github.com/tc39/proposal-object-values-entries + var $export = require('./_export'); + var $values = require('./_object-to-array')(false); + + $export($export.S, 'Object', { + values: function values(it) { + return $values(it); + } + }); + + },{"./_export":104,"./_object-to-array":155}],369:[function(require,module,exports){ + 'use strict'; + // https://github.com/zenparsing/es-observable + var $export = require('./_export'); + var global = require('./_global'); + var core = require('./_core'); + var microtask = require('./_microtask')(); + var OBSERVABLE = require('./_wks')('observable'); + var aFunction = require('./_a-function'); + var anObject = require('./_an-object'); + var anInstance = require('./_an-instance'); + var redefineAll = require('./_redefine-all'); + var hide = require('./_hide'); + var forOf = require('./_for-of'); + var RETURN = forOf.RETURN; + + var getMethod = function (fn) { + return fn == null ? undefined : aFunction(fn); + }; + + var cleanupSubscription = function (subscription) { + var cleanup = subscription._c; + if (cleanup) { + subscription._c = undefined; + cleanup(); + } + }; + + var subscriptionClosed = function (subscription) { + return subscription._o === undefined; + }; + + var closeSubscription = function (subscription) { + if (!subscriptionClosed(subscription)) { + subscription._o = undefined; + cleanupSubscription(subscription); + } + }; + + var Subscription = function (observer, subscriber) { + anObject(observer); + this._c = undefined; + this._o = observer; + observer = new SubscriptionObserver(this); + try { + var cleanup = subscriber(observer); + var subscription = cleanup; + if (cleanup != null) { + if (typeof cleanup.unsubscribe === 'function') cleanup = function () { subscription.unsubscribe(); }; + else aFunction(cleanup); + this._c = cleanup; + } + } catch (e) { + observer.error(e); + return; + } if (subscriptionClosed(this)) cleanupSubscription(this); + }; + + Subscription.prototype = redefineAll({}, { + unsubscribe: function unsubscribe() { closeSubscription(this); } + }); + + var SubscriptionObserver = function (subscription) { + this._s = subscription; + }; + + SubscriptionObserver.prototype = redefineAll({}, { + next: function next(value) { + var subscription = this._s; + if (!subscriptionClosed(subscription)) { + var observer = subscription._o; + try { + var m = getMethod(observer.next); + if (m) return m.call(observer, value); + } catch (e) { + try { + closeSubscription(subscription); + } finally { + throw e; + } + } + } + }, + error: function error(value) { + var subscription = this._s; + if (subscriptionClosed(subscription)) throw value; + var observer = subscription._o; + subscription._o = undefined; + try { + var m = getMethod(observer.error); + if (!m) throw value; + value = m.call(observer, value); + } catch (e) { + try { + cleanupSubscription(subscription); + } finally { + throw e; + } + } cleanupSubscription(subscription); + return value; + }, + complete: function complete(value) { + var subscription = this._s; + if (!subscriptionClosed(subscription)) { + var observer = subscription._o; + subscription._o = undefined; + try { + var m = getMethod(observer.complete); + value = m ? m.call(observer, value) : undefined; + } catch (e) { + try { + cleanupSubscription(subscription); + } finally { + throw e; + } + } cleanupSubscription(subscription); + return value; + } + } + }); + + var $Observable = function Observable(subscriber) { + anInstance(this, $Observable, 'Observable', '_f')._f = aFunction(subscriber); + }; + + redefineAll($Observable.prototype, { + subscribe: function subscribe(observer) { + return new Subscription(observer, this._f); + }, + forEach: function forEach(fn) { + var that = this; + return new (core.Promise || global.Promise)(function (resolve, reject) { + aFunction(fn); + var subscription = that.subscribe({ + next: function (value) { + try { + return fn(value); + } catch (e) { + reject(e); + subscription.unsubscribe(); + } + }, + error: reject, + complete: resolve + }); + }); + } + }); + + redefineAll($Observable, { + from: function from(x) { + var C = typeof this === 'function' ? this : $Observable; + var method = getMethod(anObject(x)[OBSERVABLE]); + if (method) { + var observable = anObject(method.call(x)); + return observable.constructor === C ? observable : new C(function (observer) { + return observable.subscribe(observer); + }); + } + return new C(function (observer) { + var done = false; + microtask(function () { + if (!done) { + try { + if (forOf(x, false, function (it) { + observer.next(it); + if (done) return RETURN; + }) === RETURN) return; + } catch (e) { + if (done) throw e; + observer.error(e); + return; + } observer.complete(); + } + }); + return function () { done = true; }; + }); + }, + of: function of() { + for (var i = 0, l = arguments.length, items = new Array(l); i < l;) items[i] = arguments[i++]; + return new (typeof this === 'function' ? this : $Observable)(function (observer) { + var done = false; + microtask(function () { + if (!done) { + for (var j = 0; j < items.length; ++j) { + observer.next(items[j]); + if (done) return; + } observer.complete(); + } + }); + return function () { done = true; }; + }); + } + }); + + hide($Observable.prototype, OBSERVABLE, function () { return this; }); + + $export($export.G, { Observable: $Observable }); + + require('./_set-species')('Observable'); + + },{"./_a-function":73,"./_an-instance":77,"./_an-object":78,"./_core":94,"./_export":104,"./_for-of":110,"./_global":112,"./_hide":114,"./_microtask":139,"./_redefine-all":162,"./_set-species":171,"./_wks":200}],370:[function(require,module,exports){ + // https://github.com/tc39/proposal-promise-finally + 'use strict'; + var $export = require('./_export'); + var core = require('./_core'); + var global = require('./_global'); + var speciesConstructor = require('./_species-constructor'); + var promiseResolve = require('./_promise-resolve'); + + $export($export.P + $export.R, 'Promise', { 'finally': function (onFinally) { + var C = speciesConstructor(this, core.Promise || global.Promise); + var isFunction = typeof onFinally == 'function'; + return this.then( + isFunction ? function (x) { + return promiseResolve(C, onFinally()).then(function () { return x; }); + } : onFinally, + isFunction ? function (e) { + return promiseResolve(C, onFinally()).then(function () { throw e; }); + } : onFinally + ); + } }); + + },{"./_core":94,"./_export":104,"./_global":112,"./_promise-resolve":160,"./_species-constructor":175}],371:[function(require,module,exports){ + 'use strict'; + // https://github.com/tc39/proposal-promise-try + var $export = require('./_export'); + var newPromiseCapability = require('./_new-promise-capability'); + var perform = require('./_perform'); + + $export($export.S, 'Promise', { 'try': function (callbackfn) { + var promiseCapability = newPromiseCapability.f(this); + var result = perform(callbackfn); + (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v); + return promiseCapability.promise; + } }); + + },{"./_export":104,"./_new-promise-capability":140,"./_perform":159}],372:[function(require,module,exports){ + var metadata = require('./_metadata'); + var anObject = require('./_an-object'); + var toMetaKey = metadata.key; + var ordinaryDefineOwnMetadata = metadata.set; + + metadata.exp({ defineMetadata: function defineMetadata(metadataKey, metadataValue, target, targetKey) { + ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), toMetaKey(targetKey)); + } }); + + },{"./_an-object":78,"./_metadata":138}],373:[function(require,module,exports){ + var metadata = require('./_metadata'); + var anObject = require('./_an-object'); + var toMetaKey = metadata.key; + var getOrCreateMetadataMap = metadata.map; + var store = metadata.store; + + metadata.exp({ deleteMetadata: function deleteMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetaKey(arguments[2]); + var metadataMap = getOrCreateMetadataMap(anObject(target), targetKey, false); + if (metadataMap === undefined || !metadataMap['delete'](metadataKey)) return false; + if (metadataMap.size) return true; + var targetMetadata = store.get(target); + targetMetadata['delete'](targetKey); + return !!targetMetadata.size || store['delete'](target); + } }); + + },{"./_an-object":78,"./_metadata":138}],374:[function(require,module,exports){ + var Set = require('./es6.set'); + var from = require('./_array-from-iterable'); + var metadata = require('./_metadata'); + var anObject = require('./_an-object'); + var getPrototypeOf = require('./_object-gpo'); + var ordinaryOwnMetadataKeys = metadata.keys; + var toMetaKey = metadata.key; + + var ordinaryMetadataKeys = function (O, P) { + var oKeys = ordinaryOwnMetadataKeys(O, P); + var parent = getPrototypeOf(O); + if (parent === null) return oKeys; + var pKeys = ordinaryMetadataKeys(parent, P); + return pKeys.length ? oKeys.length ? from(new Set(oKeys.concat(pKeys))) : pKeys : oKeys; + }; + + metadata.exp({ getMetadataKeys: function getMetadataKeys(target /* , targetKey */) { + return ordinaryMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1])); + } }); + + },{"./_an-object":78,"./_array-from-iterable":81,"./_metadata":138,"./_object-gpo":150,"./es6.set":304}],375:[function(require,module,exports){ + var metadata = require('./_metadata'); + var anObject = require('./_an-object'); + var getPrototypeOf = require('./_object-gpo'); + var ordinaryHasOwnMetadata = metadata.has; + var ordinaryGetOwnMetadata = metadata.get; + var toMetaKey = metadata.key; + + var ordinaryGetMetadata = function (MetadataKey, O, P) { + var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P); + if (hasOwn) return ordinaryGetOwnMetadata(MetadataKey, O, P); + var parent = getPrototypeOf(O); + return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined; + }; + + metadata.exp({ getMetadata: function getMetadata(metadataKey, target /* , targetKey */) { + return ordinaryGetMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2])); + } }); + + },{"./_an-object":78,"./_metadata":138,"./_object-gpo":150}],376:[function(require,module,exports){ + var metadata = require('./_metadata'); + var anObject = require('./_an-object'); + var ordinaryOwnMetadataKeys = metadata.keys; + var toMetaKey = metadata.key; + + metadata.exp({ getOwnMetadataKeys: function getOwnMetadataKeys(target /* , targetKey */) { + return ordinaryOwnMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1])); + } }); + + },{"./_an-object":78,"./_metadata":138}],377:[function(require,module,exports){ + var metadata = require('./_metadata'); + var anObject = require('./_an-object'); + var ordinaryGetOwnMetadata = metadata.get; + var toMetaKey = metadata.key; + + metadata.exp({ getOwnMetadata: function getOwnMetadata(metadataKey, target /* , targetKey */) { + return ordinaryGetOwnMetadata(metadataKey, anObject(target) + , arguments.length < 3 ? undefined : toMetaKey(arguments[2])); + } }); + + },{"./_an-object":78,"./_metadata":138}],378:[function(require,module,exports){ + var metadata = require('./_metadata'); + var anObject = require('./_an-object'); + var getPrototypeOf = require('./_object-gpo'); + var ordinaryHasOwnMetadata = metadata.has; + var toMetaKey = metadata.key; + + var ordinaryHasMetadata = function (MetadataKey, O, P) { + var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P); + if (hasOwn) return true; + var parent = getPrototypeOf(O); + return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false; + }; + + metadata.exp({ hasMetadata: function hasMetadata(metadataKey, target /* , targetKey */) { + return ordinaryHasMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2])); + } }); + + },{"./_an-object":78,"./_metadata":138,"./_object-gpo":150}],379:[function(require,module,exports){ + var metadata = require('./_metadata'); + var anObject = require('./_an-object'); + var ordinaryHasOwnMetadata = metadata.has; + var toMetaKey = metadata.key; + + metadata.exp({ hasOwnMetadata: function hasOwnMetadata(metadataKey, target /* , targetKey */) { + return ordinaryHasOwnMetadata(metadataKey, anObject(target) + , arguments.length < 3 ? undefined : toMetaKey(arguments[2])); + } }); + + },{"./_an-object":78,"./_metadata":138}],380:[function(require,module,exports){ + var $metadata = require('./_metadata'); + var anObject = require('./_an-object'); + var aFunction = require('./_a-function'); + var toMetaKey = $metadata.key; + var ordinaryDefineOwnMetadata = $metadata.set; + + $metadata.exp({ metadata: function metadata(metadataKey, metadataValue) { + return function decorator(target, targetKey) { + ordinaryDefineOwnMetadata( + metadataKey, metadataValue, + (targetKey !== undefined ? anObject : aFunction)(target), + toMetaKey(targetKey) + ); + }; + } }); + + },{"./_a-function":73,"./_an-object":78,"./_metadata":138}],381:[function(require,module,exports){ + // https://tc39.github.io/proposal-setmap-offrom/#sec-set.from + require('./_set-collection-from')('Set'); + + },{"./_set-collection-from":168}],382:[function(require,module,exports){ + // https://tc39.github.io/proposal-setmap-offrom/#sec-set.of + require('./_set-collection-of')('Set'); + + },{"./_set-collection-of":169}],383:[function(require,module,exports){ + // https://github.com/DavidBruant/Map-Set.prototype.toJSON + var $export = require('./_export'); + + $export($export.P + $export.R, 'Set', { toJSON: require('./_collection-to-json')('Set') }); + + },{"./_collection-to-json":91,"./_export":104}],384:[function(require,module,exports){ + 'use strict'; + // https://github.com/mathiasbynens/String.prototype.at + var $export = require('./_export'); + var $at = require('./_string-at')(true); + var $fails = require('./_fails'); + + var FORCED = $fails(function () { + return '𠮷'.at(0) !== '𠮷'; + }); + + $export($export.P + $export.F * FORCED, 'String', { + at: function at(pos) { + return $at(this, pos); + } + }); + + },{"./_export":104,"./_fails":106,"./_string-at":177}],385:[function(require,module,exports){ + 'use strict'; + // https://tc39.github.io/String.prototype.matchAll/ + var $export = require('./_export'); + var defined = require('./_defined'); + var toLength = require('./_to-length'); + var isRegExp = require('./_is-regexp'); + var getFlags = require('./_flags'); + var RegExpProto = RegExp.prototype; + + var $RegExpStringIterator = function (regexp, string) { + this._r = regexp; + this._s = string; + }; + + require('./_iter-create')($RegExpStringIterator, 'RegExp String', function next() { + var match = this._r.exec(this._s); + return { value: match, done: match === null }; + }); + + $export($export.P, 'String', { + matchAll: function matchAll(regexp) { + defined(this); + if (!isRegExp(regexp)) throw TypeError(regexp + ' is not a regexp!'); + var S = String(this); + var flags = 'flags' in RegExpProto ? String(regexp.flags) : getFlags.call(regexp); + var rx = new RegExp(regexp.source, ~flags.indexOf('g') ? flags : 'g' + flags); + rx.lastIndex = toLength(regexp.lastIndex); + return new $RegExpStringIterator(rx, S); + } + }); + + },{"./_defined":99,"./_export":104,"./_flags":108,"./_is-regexp":124,"./_iter-create":126,"./_to-length":189}],386:[function(require,module,exports){ + 'use strict'; + // https://github.com/tc39/proposal-string-pad-start-end + var $export = require('./_export'); + var $pad = require('./_string-pad'); + var userAgent = require('./_user-agent'); + + // https://github.com/zloirock/core-js/issues/280 + var WEBKIT_BUG = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent); + + $export($export.P + $export.F * WEBKIT_BUG, 'String', { + padEnd: function padEnd(maxLength /* , fillString = ' ' */) { + return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false); + } + }); + + },{"./_export":104,"./_string-pad":180,"./_user-agent":196}],387:[function(require,module,exports){ + 'use strict'; + // https://github.com/tc39/proposal-string-pad-start-end + var $export = require('./_export'); + var $pad = require('./_string-pad'); + var userAgent = require('./_user-agent'); + + // https://github.com/zloirock/core-js/issues/280 + var WEBKIT_BUG = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent); + + $export($export.P + $export.F * WEBKIT_BUG, 'String', { + padStart: function padStart(maxLength /* , fillString = ' ' */) { + return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true); + } + }); + + },{"./_export":104,"./_string-pad":180,"./_user-agent":196}],388:[function(require,module,exports){ + 'use strict'; + // https://github.com/sebmarkbage/ecmascript-string-left-right-trim + require('./_string-trim')('trimLeft', function ($trim) { + return function trimLeft() { + return $trim(this, 1); + }; + }, 'trimStart'); + + },{"./_string-trim":182}],389:[function(require,module,exports){ + 'use strict'; + // https://github.com/sebmarkbage/ecmascript-string-left-right-trim + require('./_string-trim')('trimRight', function ($trim) { + return function trimRight() { + return $trim(this, 2); + }; + }, 'trimEnd'); + + },{"./_string-trim":182}],390:[function(require,module,exports){ + require('./_wks-define')('asyncIterator'); + + },{"./_wks-define":198}],391:[function(require,module,exports){ + require('./_wks-define')('observable'); + + },{"./_wks-define":198}],392:[function(require,module,exports){ + // https://github.com/tc39/proposal-global + var $export = require('./_export'); + + $export($export.S, 'System', { global: require('./_global') }); + + },{"./_export":104,"./_global":112}],393:[function(require,module,exports){ + // https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from + require('./_set-collection-from')('WeakMap'); + + },{"./_set-collection-from":168}],394:[function(require,module,exports){ + // https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of + require('./_set-collection-of')('WeakMap'); + + },{"./_set-collection-of":169}],395:[function(require,module,exports){ + // https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.from + require('./_set-collection-from')('WeakSet'); + + },{"./_set-collection-from":168}],396:[function(require,module,exports){ + // https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.of + require('./_set-collection-of')('WeakSet'); + + },{"./_set-collection-of":169}],397:[function(require,module,exports){ + var $iterators = require('./es6.array.iterator'); + var getKeys = require('./_object-keys'); + var redefine = require('./_redefine'); + var global = require('./_global'); + var hide = require('./_hide'); + var Iterators = require('./_iterators'); + var wks = require('./_wks'); + var ITERATOR = wks('iterator'); + var TO_STRING_TAG = wks('toStringTag'); + var ArrayValues = Iterators.Array; + + var DOMIterables = { + CSSRuleList: true, // TODO: Not spec compliant, should be false. + CSSStyleDeclaration: false, + CSSValueList: false, + ClientRectList: false, + DOMRectList: false, + DOMStringList: false, + DOMTokenList: true, + DataTransferItemList: false, + FileList: false, + HTMLAllCollection: false, + HTMLCollection: false, + HTMLFormElement: false, + HTMLSelectElement: false, + MediaList: true, // TODO: Not spec compliant, should be false. + MimeTypeArray: false, + NamedNodeMap: false, + NodeList: true, + PaintRequestList: false, + Plugin: false, + PluginArray: false, + SVGLengthList: false, + SVGNumberList: false, + SVGPathSegList: false, + SVGPointList: false, + SVGStringList: false, + SVGTransformList: false, + SourceBufferList: false, + StyleSheetList: true, // TODO: Not spec compliant, should be false. + TextTrackCueList: false, + TextTrackList: false, + TouchList: false + }; + + for (var collections = getKeys(DOMIterables), i = 0; i < collections.length; i++) { + var NAME = collections[i]; + var explicit = DOMIterables[NAME]; + var Collection = global[NAME]; + var proto = Collection && Collection.prototype; + var key; + if (proto) { + if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues); + if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME); + Iterators[NAME] = ArrayValues; + if (explicit) for (key in $iterators) if (!proto[key]) redefine(proto, key, $iterators[key], true); + } + } + + },{"./_global":112,"./_hide":114,"./_iterators":130,"./_object-keys":152,"./_redefine":163,"./_wks":200,"./es6.array.iterator":213}],398:[function(require,module,exports){ + var $export = require('./_export'); + var $task = require('./_task'); + $export($export.G + $export.B, { + setImmediate: $task.set, + clearImmediate: $task.clear + }); + + },{"./_export":104,"./_task":184}],399:[function(require,module,exports){ + // ie9- setTimeout & setInterval additional parameters fix + var global = require('./_global'); + var $export = require('./_export'); + var userAgent = require('./_user-agent'); + var slice = [].slice; + var MSIE = /MSIE .\./.test(userAgent); // <- dirty ie9- check + var wrap = function (set) { + return function (fn, time /* , ...args */) { + var boundArgs = arguments.length > 2; + var args = boundArgs ? slice.call(arguments, 2) : false; + return set(boundArgs ? function () { + // eslint-disable-next-line no-new-func + (typeof fn == 'function' ? fn : Function(fn)).apply(this, args); + } : fn, time); + }; + }; + $export($export.G + $export.B + $export.F * MSIE, { + setTimeout: wrap(global.setTimeout), + setInterval: wrap(global.setInterval) + }); + + },{"./_export":104,"./_global":112,"./_user-agent":196}],400:[function(require,module,exports){ + require('./modules/es6.symbol'); + require('./modules/es6.object.create'); + require('./modules/es6.object.define-property'); + require('./modules/es6.object.define-properties'); + require('./modules/es6.object.get-own-property-descriptor'); + require('./modules/es6.object.get-prototype-of'); + require('./modules/es6.object.keys'); + require('./modules/es6.object.get-own-property-names'); + require('./modules/es6.object.freeze'); + require('./modules/es6.object.seal'); + require('./modules/es6.object.prevent-extensions'); + require('./modules/es6.object.is-frozen'); + require('./modules/es6.object.is-sealed'); + require('./modules/es6.object.is-extensible'); + require('./modules/es6.object.assign'); + require('./modules/es6.object.is'); + require('./modules/es6.object.set-prototype-of'); + require('./modules/es6.object.to-string'); + require('./modules/es6.function.bind'); + require('./modules/es6.function.name'); + require('./modules/es6.function.has-instance'); + require('./modules/es6.parse-int'); + require('./modules/es6.parse-float'); + require('./modules/es6.number.constructor'); + require('./modules/es6.number.to-fixed'); + require('./modules/es6.number.to-precision'); + require('./modules/es6.number.epsilon'); + require('./modules/es6.number.is-finite'); + require('./modules/es6.number.is-integer'); + require('./modules/es6.number.is-nan'); + require('./modules/es6.number.is-safe-integer'); + require('./modules/es6.number.max-safe-integer'); + require('./modules/es6.number.min-safe-integer'); + require('./modules/es6.number.parse-float'); + require('./modules/es6.number.parse-int'); + require('./modules/es6.math.acosh'); + require('./modules/es6.math.asinh'); + require('./modules/es6.math.atanh'); + require('./modules/es6.math.cbrt'); + require('./modules/es6.math.clz32'); + require('./modules/es6.math.cosh'); + require('./modules/es6.math.expm1'); + require('./modules/es6.math.fround'); + require('./modules/es6.math.hypot'); + require('./modules/es6.math.imul'); + require('./modules/es6.math.log10'); + require('./modules/es6.math.log1p'); + require('./modules/es6.math.log2'); + require('./modules/es6.math.sign'); + require('./modules/es6.math.sinh'); + require('./modules/es6.math.tanh'); + require('./modules/es6.math.trunc'); + require('./modules/es6.string.from-code-point'); + require('./modules/es6.string.raw'); + require('./modules/es6.string.trim'); + require('./modules/es6.string.iterator'); + require('./modules/es6.string.code-point-at'); + require('./modules/es6.string.ends-with'); + require('./modules/es6.string.includes'); + require('./modules/es6.string.repeat'); + require('./modules/es6.string.starts-with'); + require('./modules/es6.string.anchor'); + require('./modules/es6.string.big'); + require('./modules/es6.string.blink'); + require('./modules/es6.string.bold'); + require('./modules/es6.string.fixed'); + require('./modules/es6.string.fontcolor'); + require('./modules/es6.string.fontsize'); + require('./modules/es6.string.italics'); + require('./modules/es6.string.link'); + require('./modules/es6.string.small'); + require('./modules/es6.string.strike'); + require('./modules/es6.string.sub'); + require('./modules/es6.string.sup'); + require('./modules/es6.date.now'); + require('./modules/es6.date.to-json'); + require('./modules/es6.date.to-iso-string'); + require('./modules/es6.date.to-string'); + require('./modules/es6.date.to-primitive'); + require('./modules/es6.array.is-array'); + require('./modules/es6.array.from'); + require('./modules/es6.array.of'); + require('./modules/es6.array.join'); + require('./modules/es6.array.slice'); + require('./modules/es6.array.sort'); + require('./modules/es6.array.for-each'); + require('./modules/es6.array.map'); + require('./modules/es6.array.filter'); + require('./modules/es6.array.some'); + require('./modules/es6.array.every'); + require('./modules/es6.array.reduce'); + require('./modules/es6.array.reduce-right'); + require('./modules/es6.array.index-of'); + require('./modules/es6.array.last-index-of'); + require('./modules/es6.array.copy-within'); + require('./modules/es6.array.fill'); + require('./modules/es6.array.find'); + require('./modules/es6.array.find-index'); + require('./modules/es6.array.species'); + require('./modules/es6.array.iterator'); + require('./modules/es6.regexp.constructor'); + require('./modules/es6.regexp.exec'); + require('./modules/es6.regexp.to-string'); + require('./modules/es6.regexp.flags'); + require('./modules/es6.regexp.match'); + require('./modules/es6.regexp.replace'); + require('./modules/es6.regexp.search'); + require('./modules/es6.regexp.split'); + require('./modules/es6.promise'); + require('./modules/es6.map'); + require('./modules/es6.set'); + require('./modules/es6.weak-map'); + require('./modules/es6.weak-set'); + require('./modules/es6.typed.array-buffer'); + require('./modules/es6.typed.data-view'); + require('./modules/es6.typed.int8-array'); + require('./modules/es6.typed.uint8-array'); + require('./modules/es6.typed.uint8-clamped-array'); + require('./modules/es6.typed.int16-array'); + require('./modules/es6.typed.uint16-array'); + require('./modules/es6.typed.int32-array'); + require('./modules/es6.typed.uint32-array'); + require('./modules/es6.typed.float32-array'); + require('./modules/es6.typed.float64-array'); + require('./modules/es6.reflect.apply'); + require('./modules/es6.reflect.construct'); + require('./modules/es6.reflect.define-property'); + require('./modules/es6.reflect.delete-property'); + require('./modules/es6.reflect.enumerate'); + require('./modules/es6.reflect.get'); + require('./modules/es6.reflect.get-own-property-descriptor'); + require('./modules/es6.reflect.get-prototype-of'); + require('./modules/es6.reflect.has'); + require('./modules/es6.reflect.is-extensible'); + require('./modules/es6.reflect.own-keys'); + require('./modules/es6.reflect.prevent-extensions'); + require('./modules/es6.reflect.set'); + require('./modules/es6.reflect.set-prototype-of'); + require('./modules/es7.array.includes'); + require('./modules/es7.array.flat-map'); + require('./modules/es7.array.flatten'); + require('./modules/es7.string.at'); + require('./modules/es7.string.pad-start'); + require('./modules/es7.string.pad-end'); + require('./modules/es7.string.trim-left'); + require('./modules/es7.string.trim-right'); + require('./modules/es7.string.match-all'); + require('./modules/es7.symbol.async-iterator'); + require('./modules/es7.symbol.observable'); + require('./modules/es7.object.get-own-property-descriptors'); + require('./modules/es7.object.values'); + require('./modules/es7.object.entries'); + require('./modules/es7.object.define-getter'); + require('./modules/es7.object.define-setter'); + require('./modules/es7.object.lookup-getter'); + require('./modules/es7.object.lookup-setter'); + require('./modules/es7.map.to-json'); + require('./modules/es7.set.to-json'); + require('./modules/es7.map.of'); + require('./modules/es7.set.of'); + require('./modules/es7.weak-map.of'); + require('./modules/es7.weak-set.of'); + require('./modules/es7.map.from'); + require('./modules/es7.set.from'); + require('./modules/es7.weak-map.from'); + require('./modules/es7.weak-set.from'); + require('./modules/es7.global'); + require('./modules/es7.system.global'); + require('./modules/es7.error.is-error'); + require('./modules/es7.math.clamp'); + require('./modules/es7.math.deg-per-rad'); + require('./modules/es7.math.degrees'); + require('./modules/es7.math.fscale'); + require('./modules/es7.math.iaddh'); + require('./modules/es7.math.isubh'); + require('./modules/es7.math.imulh'); + require('./modules/es7.math.rad-per-deg'); + require('./modules/es7.math.radians'); + require('./modules/es7.math.scale'); + require('./modules/es7.math.umulh'); + require('./modules/es7.math.signbit'); + require('./modules/es7.promise.finally'); + require('./modules/es7.promise.try'); + require('./modules/es7.reflect.define-metadata'); + require('./modules/es7.reflect.delete-metadata'); + require('./modules/es7.reflect.get-metadata'); + require('./modules/es7.reflect.get-metadata-keys'); + require('./modules/es7.reflect.get-own-metadata'); + require('./modules/es7.reflect.get-own-metadata-keys'); + require('./modules/es7.reflect.has-metadata'); + require('./modules/es7.reflect.has-own-metadata'); + require('./modules/es7.reflect.metadata'); + require('./modules/es7.asap'); + require('./modules/es7.observable'); + require('./modules/web.timers'); + require('./modules/web.immediate'); + require('./modules/web.dom.iterable'); + module.exports = require('./modules/_core'); + + },{"./modules/_core":94,"./modules/es6.array.copy-within":203,"./modules/es6.array.every":204,"./modules/es6.array.fill":205,"./modules/es6.array.filter":206,"./modules/es6.array.find":208,"./modules/es6.array.find-index":207,"./modules/es6.array.for-each":209,"./modules/es6.array.from":210,"./modules/es6.array.index-of":211,"./modules/es6.array.is-array":212,"./modules/es6.array.iterator":213,"./modules/es6.array.join":214,"./modules/es6.array.last-index-of":215,"./modules/es6.array.map":216,"./modules/es6.array.of":217,"./modules/es6.array.reduce":219,"./modules/es6.array.reduce-right":218,"./modules/es6.array.slice":220,"./modules/es6.array.some":221,"./modules/es6.array.sort":222,"./modules/es6.array.species":223,"./modules/es6.date.now":224,"./modules/es6.date.to-iso-string":225,"./modules/es6.date.to-json":226,"./modules/es6.date.to-primitive":227,"./modules/es6.date.to-string":228,"./modules/es6.function.bind":229,"./modules/es6.function.has-instance":230,"./modules/es6.function.name":231,"./modules/es6.map":232,"./modules/es6.math.acosh":233,"./modules/es6.math.asinh":234,"./modules/es6.math.atanh":235,"./modules/es6.math.cbrt":236,"./modules/es6.math.clz32":237,"./modules/es6.math.cosh":238,"./modules/es6.math.expm1":239,"./modules/es6.math.fround":240,"./modules/es6.math.hypot":241,"./modules/es6.math.imul":242,"./modules/es6.math.log10":243,"./modules/es6.math.log1p":244,"./modules/es6.math.log2":245,"./modules/es6.math.sign":246,"./modules/es6.math.sinh":247,"./modules/es6.math.tanh":248,"./modules/es6.math.trunc":249,"./modules/es6.number.constructor":250,"./modules/es6.number.epsilon":251,"./modules/es6.number.is-finite":252,"./modules/es6.number.is-integer":253,"./modules/es6.number.is-nan":254,"./modules/es6.number.is-safe-integer":255,"./modules/es6.number.max-safe-integer":256,"./modules/es6.number.min-safe-integer":257,"./modules/es6.number.parse-float":258,"./modules/es6.number.parse-int":259,"./modules/es6.number.to-fixed":260,"./modules/es6.number.to-precision":261,"./modules/es6.object.assign":262,"./modules/es6.object.create":263,"./modules/es6.object.define-properties":264,"./modules/es6.object.define-property":265,"./modules/es6.object.freeze":266,"./modules/es6.object.get-own-property-descriptor":267,"./modules/es6.object.get-own-property-names":268,"./modules/es6.object.get-prototype-of":269,"./modules/es6.object.is":273,"./modules/es6.object.is-extensible":270,"./modules/es6.object.is-frozen":271,"./modules/es6.object.is-sealed":272,"./modules/es6.object.keys":274,"./modules/es6.object.prevent-extensions":275,"./modules/es6.object.seal":276,"./modules/es6.object.set-prototype-of":277,"./modules/es6.object.to-string":278,"./modules/es6.parse-float":279,"./modules/es6.parse-int":280,"./modules/es6.promise":281,"./modules/es6.reflect.apply":282,"./modules/es6.reflect.construct":283,"./modules/es6.reflect.define-property":284,"./modules/es6.reflect.delete-property":285,"./modules/es6.reflect.enumerate":286,"./modules/es6.reflect.get":289,"./modules/es6.reflect.get-own-property-descriptor":287,"./modules/es6.reflect.get-prototype-of":288,"./modules/es6.reflect.has":290,"./modules/es6.reflect.is-extensible":291,"./modules/es6.reflect.own-keys":292,"./modules/es6.reflect.prevent-extensions":293,"./modules/es6.reflect.set":295,"./modules/es6.reflect.set-prototype-of":294,"./modules/es6.regexp.constructor":296,"./modules/es6.regexp.exec":297,"./modules/es6.regexp.flags":298,"./modules/es6.regexp.match":299,"./modules/es6.regexp.replace":300,"./modules/es6.regexp.search":301,"./modules/es6.regexp.split":302,"./modules/es6.regexp.to-string":303,"./modules/es6.set":304,"./modules/es6.string.anchor":305,"./modules/es6.string.big":306,"./modules/es6.string.blink":307,"./modules/es6.string.bold":308,"./modules/es6.string.code-point-at":309,"./modules/es6.string.ends-with":310,"./modules/es6.string.fixed":311,"./modules/es6.string.fontcolor":312,"./modules/es6.string.fontsize":313,"./modules/es6.string.from-code-point":314,"./modules/es6.string.includes":315,"./modules/es6.string.italics":316,"./modules/es6.string.iterator":317,"./modules/es6.string.link":318,"./modules/es6.string.raw":319,"./modules/es6.string.repeat":320,"./modules/es6.string.small":321,"./modules/es6.string.starts-with":322,"./modules/es6.string.strike":323,"./modules/es6.string.sub":324,"./modules/es6.string.sup":325,"./modules/es6.string.trim":326,"./modules/es6.symbol":327,"./modules/es6.typed.array-buffer":328,"./modules/es6.typed.data-view":329,"./modules/es6.typed.float32-array":330,"./modules/es6.typed.float64-array":331,"./modules/es6.typed.int16-array":332,"./modules/es6.typed.int32-array":333,"./modules/es6.typed.int8-array":334,"./modules/es6.typed.uint16-array":335,"./modules/es6.typed.uint32-array":336,"./modules/es6.typed.uint8-array":337,"./modules/es6.typed.uint8-clamped-array":338,"./modules/es6.weak-map":339,"./modules/es6.weak-set":340,"./modules/es7.array.flat-map":341,"./modules/es7.array.flatten":342,"./modules/es7.array.includes":343,"./modules/es7.asap":344,"./modules/es7.error.is-error":345,"./modules/es7.global":346,"./modules/es7.map.from":347,"./modules/es7.map.of":348,"./modules/es7.map.to-json":349,"./modules/es7.math.clamp":350,"./modules/es7.math.deg-per-rad":351,"./modules/es7.math.degrees":352,"./modules/es7.math.fscale":353,"./modules/es7.math.iaddh":354,"./modules/es7.math.imulh":355,"./modules/es7.math.isubh":356,"./modules/es7.math.rad-per-deg":357,"./modules/es7.math.radians":358,"./modules/es7.math.scale":359,"./modules/es7.math.signbit":360,"./modules/es7.math.umulh":361,"./modules/es7.object.define-getter":362,"./modules/es7.object.define-setter":363,"./modules/es7.object.entries":364,"./modules/es7.object.get-own-property-descriptors":365,"./modules/es7.object.lookup-getter":366,"./modules/es7.object.lookup-setter":367,"./modules/es7.object.values":368,"./modules/es7.observable":369,"./modules/es7.promise.finally":370,"./modules/es7.promise.try":371,"./modules/es7.reflect.define-metadata":372,"./modules/es7.reflect.delete-metadata":373,"./modules/es7.reflect.get-metadata":375,"./modules/es7.reflect.get-metadata-keys":374,"./modules/es7.reflect.get-own-metadata":377,"./modules/es7.reflect.get-own-metadata-keys":376,"./modules/es7.reflect.has-metadata":378,"./modules/es7.reflect.has-own-metadata":379,"./modules/es7.reflect.metadata":380,"./modules/es7.set.from":381,"./modules/es7.set.of":382,"./modules/es7.set.to-json":383,"./modules/es7.string.at":384,"./modules/es7.string.match-all":385,"./modules/es7.string.pad-end":386,"./modules/es7.string.pad-start":387,"./modules/es7.string.trim-left":388,"./modules/es7.string.trim-right":389,"./modules/es7.symbol.async-iterator":390,"./modules/es7.symbol.observable":391,"./modules/es7.system.global":392,"./modules/es7.weak-map.from":393,"./modules/es7.weak-map.of":394,"./modules/es7.weak-set.from":395,"./modules/es7.weak-set.of":396,"./modules/web.dom.iterable":397,"./modules/web.immediate":398,"./modules/web.timers":399}],401:[function(require,module,exports){ + /*! Buttons for DataTables 1.7.1 + * ©2016-2021 SpryMedia Ltd - datatables.net/license + */ + + (function( factory ){ + if ( typeof define === 'function' && define.amd ) { + // AMD + define( ['jquery', 'datatables.net'], function ( $ ) { + return factory( $, window, document ); + } ); + } + else if ( typeof exports === 'object' ) { + // CommonJS + module.exports = function (root, $) { + if ( ! root ) { + root = window; + } + + if ( ! $ || ! $.fn.dataTable ) { + $ = require('datatables.net')(root, $).$; + } + + return factory( $, root, root.document ); + }; + } + else { + // Browser + factory( jQuery, window, document ); + } + }(function( $, window, document, undefined ) { + 'use strict'; + var DataTable = $.fn.dataTable; + + + // Used for namespacing events added to the document by each instance, so they + // can be removed on destroy + var _instCounter = 0; + + // Button namespacing counter for namespacing events on individual buttons + var _buttonCounter = 0; + + var _dtButtons = DataTable.ext.buttons; + + // Allow for jQuery slim + function _fadeIn(el, duration, fn) { + if ($.fn.animate) { + el + .stop() + .fadeIn( duration, fn ); + } + else { + el.css('display', 'block'); + + if (fn) { + fn.call(el); + } + } + } + + function _fadeOut(el, duration, fn) { + if ($.fn.animate) { + el + .stop() + .fadeOut( duration, fn ); + } + else { + el.css('display', 'none'); + + if (fn) { + fn.call(el); + } + } + } + + /** + * [Buttons description] + * @param {[type]} + * @param {[type]} + */ + var Buttons = function( dt, config ) + { + // If not created with a `new` keyword then we return a wrapper function that + // will take the settings object for a DT. This allows easy use of new instances + // with the `layout` option - e.g. `topLeft: $.fn.dataTable.Buttons( ... )`. + if ( !(this instanceof Buttons) ) { + return function (settings) { + return new Buttons( settings, dt ).container(); + }; + } + + // If there is no config set it to an empty object + if ( typeof( config ) === 'undefined' ) { + config = {}; + } + + // Allow a boolean true for defaults + if ( config === true ) { + config = {}; + } + + // For easy configuration of buttons an array can be given + if ( Array.isArray( config ) ) { + config = { buttons: config }; + } + + this.c = $.extend( true, {}, Buttons.defaults, config ); + + // Don't want a deep copy for the buttons + if ( config.buttons ) { + this.c.buttons = config.buttons; + } + + this.s = { + dt: new DataTable.Api( dt ), + buttons: [], + listenKeys: '', + namespace: 'dtb'+(_instCounter++) + }; + + this.dom = { + container: $('<'+this.c.dom.container.tag+'/>') + .addClass( this.c.dom.container.className ) + }; + + this._constructor(); + }; + + + $.extend( Buttons.prototype, { + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Public methods + */ + + /** + * Get the action of a button + * @param {int|string} Button index + * @return {function} + *//** + * Set the action of a button + * @param {node} node Button element + * @param {function} action Function to set + * @return {Buttons} Self for chaining + */ + action: function ( node, action ) + { + var button = this._nodeToButton( node ); + + if ( action === undefined ) { + return button.conf.action; + } + + button.conf.action = action; + + return this; + }, + + /** + * Add an active class to the button to make to look active or get current + * active state. + * @param {node} node Button element + * @param {boolean} [flag] Enable / disable flag + * @return {Buttons} Self for chaining or boolean for getter + */ + active: function ( node, flag ) { + var button = this._nodeToButton( node ); + var klass = this.c.dom.button.active; + var jqNode = $(button.node); + + if ( flag === undefined ) { + return jqNode.hasClass( klass ); + } + + jqNode.toggleClass( klass, flag === undefined ? true : flag ); + + return this; + }, + + /** + * Add a new button + * @param {object} config Button configuration object, base string name or function + * @param {int|string} [idx] Button index for where to insert the button + * @return {Buttons} Self for chaining + */ + add: function ( config, idx ) + { + var buttons = this.s.buttons; + + if ( typeof idx === 'string' ) { + var split = idx.split('-'); + var base = this.s; + + for ( var i=0, ien=split.length-1 ; i=0 ; i-- ) { + this.remove( button.buttons[i].node ); + } + } + + // Allow the button to remove event handlers, etc + if ( button.conf.destroy ) { + button.conf.destroy.call( dt.button(node), dt, $(node), button.conf ); + } + + this._removeKey( button.conf ); + + $(button.node).remove(); + + var idx = $.inArray( button, host ); + host.splice( idx, 1 ); + + return this; + }, + + /** + * Get the text for a button + * @param {int|string} node Button index + * @return {string} Button text + *//** + * Set the text for a button + * @param {int|string|function} node Button index + * @param {string} label Text + * @return {Buttons} Self for chaining + */ + text: function ( node, label ) + { + var button = this._nodeToButton( node ); + var buttonLiner = this.c.dom.collection.buttonLiner; + var linerTag = button.inCollection && buttonLiner && buttonLiner.tag ? + buttonLiner.tag : + this.c.dom.buttonLiner.tag; + var dt = this.s.dt; + var jqNode = $(button.node); + var text = function ( opt ) { + return typeof opt === 'function' ? + opt( dt, jqNode, button.conf ) : + opt; + }; + + if ( label === undefined ) { + return text( button.conf.text ); + } + + button.conf.text = label; + + if ( linerTag ) { + jqNode.children( linerTag ).html( text(label) ); + } + else { + jqNode.html( text(label) ); + } + + return this; + }, + + + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Constructor + */ + + /** + * Buttons constructor + * @private + */ + _constructor: function () + { + var that = this; + var dt = this.s.dt; + var dtSettings = dt.settings()[0]; + var buttons = this.c.buttons; + + if ( ! dtSettings._buttons ) { + dtSettings._buttons = []; + } + + dtSettings._buttons.push( { + inst: this, + name: this.c.name + } ); + + for ( var i=0, ien=buttons.length ; i'); + + built.conf._collection = built.collection; + + this._expandButton( built.buttons, built.conf.buttons, true, attachPoint ); + } + + // init call is made here, rather than buildButton as it needs to + // be selectable, and for that it needs to be in the buttons array + if ( conf.init ) { + conf.init.call( dt.button( built.node ), dt, $(built.node), conf ); + } + + buttonCounter++; + } + }, + + /** + * Create an individual button + * @param {object} config Resolved button configuration + * @param {boolean} inCollection `true` if a collection button + * @return {jQuery} Created button node (jQuery) + * @private + */ + _buildButton: function ( config, inCollection ) + { + var buttonDom = this.c.dom.button; + var linerDom = this.c.dom.buttonLiner; + var collectionDom = this.c.dom.collection; + var dt = this.s.dt; + var text = function ( opt ) { + return typeof opt === 'function' ? + opt( dt, button, config ) : + opt; + }; + + if ( inCollection && collectionDom.button ) { + buttonDom = collectionDom.button; + } + + if ( inCollection && collectionDom.buttonLiner ) { + linerDom = collectionDom.buttonLiner; + } + + // Make sure that the button is available based on whatever requirements + // it has. For example, PDF button require pdfmake + if ( config.available && ! config.available( dt, config ) ) { + return false; + } + + var action = function ( e, dt, button, config ) { + config.action.call( dt.button( button ), e, dt, button, config ); + + $(dt.table().node()).triggerHandler( 'buttons-action.dt', [ + dt.button( button ), dt, button, config + ] ); + }; + + var tag = config.tag || buttonDom.tag; + var clickBlurs = config.clickBlurs === undefined ? true : config.clickBlurs + var button = $('<'+tag+'/>') + .addClass( buttonDom.className ) + .attr( 'tabindex', this.s.dt.settings()[0].iTabIndex ) + .attr( 'aria-controls', this.s.dt.table().node().id ) + .on( 'click.dtb', function (e) { + e.preventDefault(); + + if ( ! button.hasClass( buttonDom.disabled ) && config.action ) { + action( e, dt, button, config ); + } + if( clickBlurs ) { + button.trigger('blur'); + } + } ) + .on( 'keyup.dtb', function (e) { + if ( e.keyCode === 13 ) { + if ( ! button.hasClass( buttonDom.disabled ) && config.action ) { + action( e, dt, button, config ); + } + } + } ); + + // Make `a` tags act like a link + if ( tag.toLowerCase() === 'a' ) { + button.attr( 'href', '#' ); + } + + // Button tags should have `type=button` so they don't have any default behaviour + if ( tag.toLowerCase() === 'button' ) { + button.attr( 'type', 'button' ); + } + + if ( linerDom.tag ) { + var liner = $('<'+linerDom.tag+'/>') + .html( text( config.text ) ) + .addClass( linerDom.className ); + + if ( linerDom.tag.toLowerCase() === 'a' ) { + liner.attr( 'href', '#' ); + } + + button.append( liner ); + } + else { + button.html( text( config.text ) ); + } + + if ( config.enabled === false ) { + button.addClass( buttonDom.disabled ); + } + + if ( config.className ) { + button.addClass( config.className ); + } + + if ( config.titleAttr ) { + button.attr( 'title', text( config.titleAttr ) ); + } + + if ( config.attr ) { + button.attr( config.attr ); + } + + if ( ! config.namespace ) { + config.namespace = '.dt-button-'+(_buttonCounter++); + } + + var buttonContainer = this.c.dom.buttonContainer; + var inserter; + if ( buttonContainer && buttonContainer.tag ) { + inserter = $('<'+buttonContainer.tag+'/>') + .addClass( buttonContainer.className ) + .append( button ); + } + else { + inserter = button; + } + + this._addKey( config ); + + // Style integration callback for DOM manipulation + // Note that this is _not_ documented. It is currently + // for style integration only + if( this.c.buttonCreated ) { + inserter = this.c.buttonCreated( config, inserter ); + } + + return { + conf: config, + node: button.get(0), + inserter: inserter, + buttons: [], + inCollection: inCollection, + collection: null + }; + }, + + /** + * Get the button object from a node (recursive) + * @param {node} node Button node + * @param {array} [buttons] Button array, uses base if not defined + * @return {object} Button object + * @private + */ + _nodeToButton: function ( node, buttons ) + { + if ( ! buttons ) { + buttons = this.s.buttons; + } + + for ( var i=0, ien=buttons.length ; i 30 ) { + // Protect against misconfiguration killing the browser + throw 'Buttons: Too many iterations'; + } + } + + return Array.isArray( base ) ? + base : + $.extend( {}, base ); + }; + + conf = toConfObject( conf ); + + while ( conf && conf.extend ) { + // Use `toConfObject` in case the button definition being extended + // is itself a string or a function + if ( ! _dtButtons[ conf.extend ] ) { + throw 'Cannot extend unknown button type: '+conf.extend; + } + + var objArray = toConfObject( _dtButtons[ conf.extend ] ); + if ( Array.isArray( objArray ) ) { + return objArray; + } + else if ( ! objArray ) { + // This is a little brutal as it might be possible to have a + // valid button without the extend, but if there is no extend + // then the host button would be acting in an undefined state + return false; + } + + // Stash the current class name + var originalClassName = objArray.className; + + conf = $.extend( {}, objArray, conf ); + + // The extend will have overwritten the original class name if the + // `conf` object also assigned a class, but we want to concatenate + // them so they are list that is combined from all extended buttons + if ( originalClassName && conf.className !== originalClassName ) { + conf.className = originalClassName+' '+conf.className; + } + + // Buttons to be added to a collection -gives the ability to define + // if buttons should be added to the start or end of a collection + var postfixButtons = conf.postfixButtons; + if ( postfixButtons ) { + if ( ! conf.buttons ) { + conf.buttons = []; + } + + for ( i=0, ien=postfixButtons.length ; i') + .addClass('dt-button-collection') + .addClass(options.collectionLayout) + .css('display', 'none'); + + content = $(content) + .addClass(options.contentClassName) + .attr('role', 'menu') + .appendTo(display); + + hostNode.attr( 'aria-expanded', 'true' ); + + if ( hostNode.parents('body')[0] !== document.body ) { + hostNode = document.body.lastChild; + } + + if ( options.collectionTitle ) { + display.prepend('
    '+options.collectionTitle+'
    '); + } + + _fadeIn( display.insertAfter( hostNode ), options.fade ); + + var tableContainer = $( hostButton.table().container() ); + var position = display.css( 'position' ); + + if ( options.align === 'dt-container' ) { + hostNode = hostNode.parent(); + display.css('width', tableContainer.width()); + } + + // Align the popover relative to the DataTables container + // Useful for wide popovers such as SearchPanes + if (position === 'absolute') { + // Align relative to the host button + var hostPosition = hostNode.position(); + var buttonPosition = $(hostButton.node()).position(); + + display.css( { + top: buttonPosition.top + hostNode.outerHeight(), + left: hostPosition.left + } ); + + // calculate overflow when positioned beneath + var collectionHeight = display.outerHeight(); + var tableBottom = tableContainer.offset().top + tableContainer.height(); + var listBottom = buttonPosition.top + hostNode.outerHeight() + collectionHeight; + var bottomOverflow = listBottom - tableBottom; + + // calculate overflow when positioned above + var listTop = buttonPosition.top - collectionHeight; + var tableTop = tableContainer.offset().top; + var topOverflow = tableTop - listTop; + + // if bottom overflow is larger, move to the top because it fits better, or if dropup is requested + var moveTop = buttonPosition.top - collectionHeight - 5; + if ( (bottomOverflow > topOverflow || options.dropup) && -moveTop < tableTop ) { + display.css( 'top', moveTop); + } + + // Get the size of the container (left and width - and thus also right) + var tableLeft = tableContainer.offset().left; + var tableWidth = tableContainer.width(); + var tableRight = tableLeft + tableWidth; + + // Get the size of the popover (left and width - and ...) + var popoverLeft = display.offset().left; + var popoverWidth = display.width(); + var popoverRight = popoverLeft + popoverWidth; + + // Get the size of the host buttons (left and width - and ...) + var buttonsLeft = hostNode.offset().left; + var buttonsWidth = hostNode.outerWidth() + var buttonsRight = buttonsLeft + buttonsWidth; + + if ( + display.hasClass( options.rightAlignClassName ) || + display.hasClass( options.leftAlignClassName ) || + options.align === 'dt-container' + ){ + // You've then got all the numbers you need to do some calculations and if statements, + // so we can do some quick JS maths and apply it only once + // If it has the right align class OR the buttons are right aligned OR the button container is floated right, + // then calculate left position for the popover to align the popover to the right hand + // side of the button - check to see if the left of the popover is inside the table container. + // If not, move the popover so it is, but not more than it means that the popover is to the right of the table container + var popoverShuffle = 0; + if ( display.hasClass( options.rightAlignClassName )) { + popoverShuffle = buttonsRight - popoverRight; + if(tableLeft > (popoverLeft + popoverShuffle)){ + var leftGap = tableLeft - (popoverLeft + popoverShuffle); + var rightGap = tableRight - (popoverRight + popoverShuffle); + + if(leftGap > rightGap){ + popoverShuffle += rightGap; + } + else { + popoverShuffle += leftGap; + } + } + } + // else attempt to left align the popover to the button. Similar to above, if the popover's right goes past the table container's right, + // then move it back, but not so much that it goes past the left of the table container + else { + popoverShuffle = tableLeft - popoverLeft; + + if(tableRight < (popoverRight + popoverShuffle)){ + var leftGap = tableLeft - (popoverLeft + popoverShuffle); + var rightGap = tableRight - (popoverRight + popoverShuffle); + + if(leftGap > rightGap ){ + popoverShuffle += rightGap; + } + else { + popoverShuffle += leftGap; + } + + } + } + + display.css('left', display.position().left + popoverShuffle); + } + else { + var top = hostNode.offset().top + var popoverShuffle = 0; + + popoverShuffle = options.align === 'button-right' + ? buttonsRight - popoverRight + : buttonsLeft - popoverLeft; + + display.css('left', display.position().left + popoverShuffle); + } + + + } + else { + // Fix position - centre on screen + var top = display.height() / 2; + if ( top > $(window).height() / 2 ) { + top = $(window).height() / 2; + } + + display.css( 'marginTop', top*-1 ); + } + + if ( options.background ) { + Buttons.background( true, options.backgroundClassName, options.fade, hostNode ); + } + + // This is bonkers, but if we don't have a click listener on the + // background element, iOS Safari will ignore the body click + // listener below. An empty function here is all that is + // required to make it work... + $('div.dt-button-background').on( 'click.dtb-collection', function () {} ); + + $('body') + .on( 'click.dtb-collection', function (e) { + // andSelf is deprecated in jQ1.8, but we want 1.7 compat + var back = $.fn.addBack ? 'addBack' : 'andSelf'; + var parent = $(e.target).parent()[0]; + + if (( ! $(e.target).parents()[back]().filter( content ).length && !$(parent).hasClass('dt-buttons')) || $(e.target).hasClass('dt-button-background')) { + close(); + } + } ) + .on( 'keyup.dtb-collection', function (e) { + if ( e.keyCode === 27 ) { + close(); + } + } ); + + if ( options.autoClose ) { + setTimeout( function () { + dt.on( 'buttons-action.b-internal', function (e, btn, dt, node) { + if ( node[0] === hostNode[0] ) { + return; + } + close(); + } ); + }, 0); + } + + $(display).trigger('buttons-popover.dt'); + } + } ); + + + + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Statics + */ + + /** + * Show / hide a background layer behind a collection + * @param {boolean} Flag to indicate if the background should be shown or + * hidden + * @param {string} Class to assign to the background + * @static + */ + Buttons.background = function ( show, className, fade, insertPoint ) { + if ( fade === undefined ) { + fade = 400; + } + if ( ! insertPoint ) { + insertPoint = document.body; + } + + if ( show ) { + _fadeIn( + $('
    ') + .addClass( className ) + .css( 'display', 'none' ) + .insertAfter( insertPoint ), + fade + ); + } + else { + _fadeOut( + $('div.'+className), + fade, + function () { + $(this) + .removeClass( className ) + .remove(); + } + ); + } + }; + + /** + * Instance selector - select Buttons instances based on an instance selector + * value from the buttons assigned to a DataTable. This is only useful if + * multiple instances are attached to a DataTable. + * @param {string|int|array} Instance selector - see `instance-selector` + * documentation on the DataTables site + * @param {array} Button instance array that was attached to the DataTables + * settings object + * @return {array} Buttons instances + * @static + */ + Buttons.instanceSelector = function ( group, buttons ) + { + if ( group === undefined || group === null ) { + return $.map( buttons, function ( v ) { + return v.inst; + } ); + } + + var ret = []; + var names = $.map( buttons, function ( v ) { + return v.name; + } ); + + // Flatten the group selector into an array of single options + var process = function ( input ) { + if ( Array.isArray( input ) ) { + for ( var i=0, ien=input.length ; i)<[^<]*)*<\/script>/gi, '' ); + + // Always remove comments + str = str.replace( //g, '' ); + + if ( ! config || config.stripHtml ) { + str = str.replace( /<[^>]*>/g, '' ); + } + + if ( ! config || config.trim ) { + str = str.replace( /^\s+|\s+$/g, '' ); + } + + if ( ! config || config.stripNewlines ) { + str = str.replace( /\n/g, ' ' ); + } + + if ( ! config || config.decodeEntities ) { + _exportTextarea.innerHTML = str; + str = _exportTextarea.value; + } + + return str; + }; + + + /** + * Buttons defaults. For full documentation, please refer to the docs/option + * directory or the DataTables site. + * @type {Object} + * @static + */ + Buttons.defaults = { + buttons: [ 'copy', 'excel', 'csv', 'pdf', 'print' ], + name: 'main', + tabIndex: 0, + dom: { + container: { + tag: 'div', + className: 'dt-buttons' + }, + collection: { + tag: 'div', + className: '' + }, + button: { + tag: 'button', + className: 'dt-button', + active: 'active', + disabled: 'disabled' + }, + buttonLiner: { + tag: 'span', + className: '' + } + } + }; + + /** + * Version information + * @type {string} + * @static + */ + Buttons.version = '1.7.1'; + + + $.extend( _dtButtons, { + collection: { + text: function ( dt ) { + return dt.i18n( 'buttons.collection', 'Collection' ); + }, + className: 'buttons-collection', + init: function ( dt, button, config ) { + button.attr( 'aria-expanded', false ); + }, + action: function ( e, dt, button, config ) { + e.stopPropagation(); + + if ( config._collection.parents('body').length ) { + this.popover(false, config); + } + else { + this.popover(config._collection, config); + } + }, + attr: { + 'aria-haspopup': true + } + // Also the popover options, defined in Buttons.popover + }, + copy: function ( dt, conf ) { + if ( _dtButtons.copyHtml5 ) { + return 'copyHtml5'; + } + }, + csv: function ( dt, conf ) { + if ( _dtButtons.csvHtml5 && _dtButtons.csvHtml5.available( dt, conf ) ) { + return 'csvHtml5'; + } + }, + excel: function ( dt, conf ) { + if ( _dtButtons.excelHtml5 && _dtButtons.excelHtml5.available( dt, conf ) ) { + return 'excelHtml5'; + } + }, + pdf: function ( dt, conf ) { + if ( _dtButtons.pdfHtml5 && _dtButtons.pdfHtml5.available( dt, conf ) ) { + return 'pdfHtml5'; + } + }, + pageLength: function ( dt ) { + var lengthMenu = dt.settings()[0].aLengthMenu; + var vals = []; + var lang = []; + var text = function ( dt ) { + return dt.i18n( 'buttons.pageLength', { + "-1": 'Show all rows', + _: 'Show %d rows' + }, dt.page.len() ); + }; + + // Support for DataTables 1.x 2D array + if (Array.isArray( lengthMenu[0] )) { + vals = lengthMenu[0]; + lang = lengthMenu[1]; + } + else { + for (var i=0 ; i 1 ) { + buttons.splice( 1, buttons.length ); + } + + return buttons; + } ); + + // Active buttons + DataTable.Api.registerPlural( 'buttons().active()', 'button().active()', function ( flag ) { + if ( flag === undefined ) { + return this.map( function ( set ) { + return set.inst.active( set.node ); + } ); + } + + return this.each( function ( set ) { + set.inst.active( set.node, flag ); + } ); + } ); + + // Get / set button action + DataTable.Api.registerPlural( 'buttons().action()', 'button().action()', function ( action ) { + if ( action === undefined ) { + return this.map( function ( set ) { + return set.inst.action( set.node ); + } ); + } + + return this.each( function ( set ) { + set.inst.action( set.node, action ); + } ); + } ); + + // Enable / disable buttons + DataTable.Api.register( ['buttons().enable()', 'button().enable()'], function ( flag ) { + return this.each( function ( set ) { + set.inst.enable( set.node, flag ); + } ); + } ); + + // Disable buttons + DataTable.Api.register( ['buttons().disable()', 'button().disable()'], function () { + return this.each( function ( set ) { + set.inst.disable( set.node ); + } ); + } ); + + // Get button nodes + DataTable.Api.registerPlural( 'buttons().nodes()', 'button().node()', function () { + var jq = $(); + + // jQuery will automatically reduce duplicates to a single entry + $( this.each( function ( set ) { + jq = jq.add( set.inst.node( set.node ) ); + } ) ); + + return jq; + } ); + + // Get / set button processing state + DataTable.Api.registerPlural( 'buttons().processing()', 'button().processing()', function ( flag ) { + if ( flag === undefined ) { + return this.map( function ( set ) { + return set.inst.processing( set.node ); + } ); + } + + return this.each( function ( set ) { + set.inst.processing( set.node, flag ); + } ); + } ); + + // Get / set button text (i.e. the button labels) + DataTable.Api.registerPlural( 'buttons().text()', 'button().text()', function ( label ) { + if ( label === undefined ) { + return this.map( function ( set ) { + return set.inst.text( set.node ); + } ); + } + + return this.each( function ( set ) { + set.inst.text( set.node, label ); + } ); + } ); + + // Trigger a button's action + DataTable.Api.registerPlural( 'buttons().trigger()', 'button().trigger()', function () { + return this.each( function ( set ) { + set.inst.node( set.node ).trigger( 'click' ); + } ); + } ); + + // Button resolver to the popover + DataTable.Api.register( 'button().popover()', function (content, options) { + return this.map( function ( set ) { + return set.inst._popover( content, this.button(this[0].node), options ); + } ); + } ); + + // Get the container elements + DataTable.Api.register( 'buttons().containers()', function () { + var jq = $(); + var groupSelector = this._groupSelector; + + // We need to use the group selector directly, since if there are no buttons + // the result set will be empty + this.iterator( true, 'table', function ( ctx ) { + if ( ctx._buttons ) { + var insts = Buttons.instanceSelector( groupSelector, ctx._buttons ); + + for ( var i=0, ien=insts.length ; i'+title+'' : ''; + + _fadeIn( + $('
    ') + .html( title ) + .append( $('
    ')[ typeof message === 'string' ? 'html' : 'append' ]( message ) ) + .css( 'display', 'none' ) + .appendTo( 'body' ) + ); + + if ( time !== undefined && time !== 0 ) { + _infoTimer = setTimeout( function () { + that.buttons.info( false ); + }, time ); + } + + this.on('destroy.btn-info', function () { + that.buttons.info(false); + }); + + return this; + } ); + + // Get data from the table for export - this is common to a number of plug-in + // buttons so it is included in the Buttons core library + DataTable.Api.register( 'buttons.exportData()', function ( options ) { + if ( this.context.length ) { + return _exportData( new DataTable.Api( this.context[0] ), options ); + } + } ); + + // Get information about the export that is common to many of the export data + // types (DRY) + DataTable.Api.register( 'buttons.exportInfo()', function ( conf ) { + if ( ! conf ) { + conf = {}; + } + + return { + filename: _filename( conf ), + title: _title( conf ), + messageTop: _message(this, conf.message || conf.messageTop, 'top'), + messageBottom: _message(this, conf.messageBottom, 'bottom') + }; + } ); + + + + /** + * Get the file name for an exported file. + * + * @param {object} config Button configuration + * @param {boolean} incExtension Include the file name extension + */ + var _filename = function ( config ) + { + // Backwards compatibility + var filename = config.filename === '*' && config.title !== '*' && config.title !== undefined && config.title !== null && config.title !== '' ? + config.title : + config.filename; + + if ( typeof filename === 'function' ) { + filename = filename(); + } + + if ( filename === undefined || filename === null ) { + return null; + } + + if ( filename.indexOf( '*' ) !== -1 ) { + filename = filename.replace( '*', $('head > title').text() ).trim(); + } + + // Strip characters which the OS will object to + filename = filename.replace(/[^a-zA-Z0-9_\u00A1-\uFFFF\.,\-_ !\(\)]/g, ""); + + var extension = _stringOrFunction( config.extension ); + if ( ! extension ) { + extension = ''; + } + + return filename + extension; + }; + + /** + * Simply utility method to allow parameters to be given as a function + * + * @param {undefined|string|function} option Option + * @return {null|string} Resolved value + */ + var _stringOrFunction = function ( option ) + { + if ( option === null || option === undefined ) { + return null; + } + else if ( typeof option === 'function' ) { + return option(); + } + return option; + }; + + /** + * Get the title for an exported file. + * + * @param {object} config Button configuration + */ + var _title = function ( config ) + { + var title = _stringOrFunction( config.title ); + + return title === null ? + null : title.indexOf( '*' ) !== -1 ? + title.replace( '*', $('head > title').text() || 'Exported data' ) : + title; + }; + + var _message = function ( dt, option, position ) + { + var message = _stringOrFunction( option ); + if ( message === null ) { + return null; + } + + var caption = $('caption', dt.table().container()).eq(0); + if ( message === '*' ) { + var side = caption.css( 'caption-side' ); + if ( side !== position ) { + return null; + } + + return caption.length ? + caption.text() : + ''; + } + + return message; + }; + + + + + var _exportTextarea = $('"; + support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; + + // Support: IE <=9 only + // IE <=9 replaces "; + support.option = !!div.lastChild; + } )(); + + + // We have to close these tags to support XHTML (trac-13200) + var wrapMap = { + + // XHTML parsers do not magically insert elements in the + // same way that tag soup parsers do. So we cannot shorten + // this by omitting or other required elements. + thead: [ 1, "", "
    " ], + col: [ 2, "", "
    " ], + tr: [ 2, "", "
    " ], + td: [ 3, "", "
    " ], + + _default: [ 0, "", "" ] + }; + + wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; + wrapMap.th = wrapMap.td; + + // Support: IE <=9 only + if ( !support.option ) { + wrapMap.optgroup = wrapMap.option = [ 1, "" ]; + } + + + function getAll( context, tag ) { + + // Support: IE <=9 - 11 only + // Use typeof to avoid zero-argument method invocation on host objects (trac-15151) + var ret; + + if ( typeof context.getElementsByTagName !== "undefined" ) { + ret = context.getElementsByTagName( tag || "*" ); + + } else if ( typeof context.querySelectorAll !== "undefined" ) { + ret = context.querySelectorAll( tag || "*" ); + + } else { + ret = []; + } + + if ( tag === undefined || tag && nodeName( context, tag ) ) { + return jQuery.merge( [ context ], ret ); + } + + return ret; + } + + + // Mark scripts as having already been evaluated + function setGlobalEval( elems, refElements ) { + var i = 0, + l = elems.length; + + for ( ; i < l; i++ ) { + dataPriv.set( + elems[ i ], + "globalEval", + !refElements || dataPriv.get( refElements[ i ], "globalEval" ) + ); + } + } + + + var rhtml = /<|&#?\w+;/; + + function buildFragment( elems, context, scripts, selection, ignored ) { + var elem, tmp, tag, wrap, attached, j, + fragment = context.createDocumentFragment(), + nodes = [], + i = 0, + l = elems.length; + + for ( ; i < l; i++ ) { + elem = elems[ i ]; + + if ( elem || elem === 0 ) { + + // Add nodes directly + if ( toType( elem ) === "object" ) { + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); + + // Convert non-html into a text node + } else if ( !rhtml.test( elem ) ) { + nodes.push( context.createTextNode( elem ) ); + + // Convert html into DOM nodes + } else { + tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); + + // Deserialize a standard representation + tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); + wrap = wrapMap[ tag ] || wrapMap._default; + tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; + + // Descend through wrappers to the right content + j = wrap[ 0 ]; + while ( j-- ) { + tmp = tmp.lastChild; + } + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( nodes, tmp.childNodes ); + + // Remember the top-level container + tmp = fragment.firstChild; + + // Ensure the created nodes are orphaned (trac-12392) + tmp.textContent = ""; + } + } + } + + // Remove wrapper from fragment + fragment.textContent = ""; + + i = 0; + while ( ( elem = nodes[ i++ ] ) ) { + + // Skip elements already in the context collection (trac-4087) + if ( selection && jQuery.inArray( elem, selection ) > -1 ) { + if ( ignored ) { + ignored.push( elem ); + } + continue; + } + + attached = isAttached( elem ); + + // Append to fragment + tmp = getAll( fragment.appendChild( elem ), "script" ); + + // Preserve script evaluation history + if ( attached ) { + setGlobalEval( tmp ); + } + + // Capture executables + if ( scripts ) { + j = 0; + while ( ( elem = tmp[ j++ ] ) ) { + if ( rscriptType.test( elem.type || "" ) ) { + scripts.push( elem ); + } + } + } + } + + return fragment; + } + + + var rtypenamespace = /^([^.]*)(?:\.(.+)|)/; + + function returnTrue() { + return true; + } + + function returnFalse() { + return false; + } + + function on( elem, types, selector, data, fn, one ) { + var origFn, type; + + // Types can be a map of types/handlers + if ( typeof types === "object" ) { + + // ( types-Object, selector, data ) + if ( typeof selector !== "string" ) { + + // ( types-Object, data ) + data = data || selector; + selector = undefined; + } + for ( type in types ) { + on( elem, type, selector, data, types[ type ], one ); + } + return elem; + } + + if ( data == null && fn == null ) { + + // ( types, fn ) + fn = selector; + data = selector = undefined; + } else if ( fn == null ) { + if ( typeof selector === "string" ) { + + // ( types, selector, fn ) + fn = data; + data = undefined; + } else { + + // ( types, data, fn ) + fn = data; + data = selector; + selector = undefined; + } + } + if ( fn === false ) { + fn = returnFalse; + } else if ( !fn ) { + return elem; + } + + if ( one === 1 ) { + origFn = fn; + fn = function( event ) { + + // Can use an empty set, since event contains the info + jQuery().off( event ); + return origFn.apply( this, arguments ); + }; + + // Use same guid so caller can remove using origFn + fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); + } + return elem.each( function() { + jQuery.event.add( this, types, fn, data, selector ); + } ); + } + + /* + * Helper functions for managing events -- not part of the public interface. + * Props to Dean Edwards' addEvent library for many of the ideas. + */ + jQuery.event = { + + global: {}, + + add: function( elem, types, handler, data, selector ) { + + var handleObjIn, eventHandle, tmp, + events, t, handleObj, + special, handlers, type, namespaces, origType, + elemData = dataPriv.get( elem ); + + // Only attach events to objects that accept data + if ( !acceptData( elem ) ) { + return; + } + + // Caller can pass in an object of custom data in lieu of the handler + if ( handler.handler ) { + handleObjIn = handler; + handler = handleObjIn.handler; + selector = handleObjIn.selector; + } + + // Ensure that invalid selectors throw exceptions at attach time + // Evaluate against documentElement in case elem is a non-element node (e.g., document) + if ( selector ) { + jQuery.find.matchesSelector( documentElement, selector ); + } + + // Make sure that the handler has a unique ID, used to find/remove it later + if ( !handler.guid ) { + handler.guid = jQuery.guid++; + } + + // Init the element's event structure and main handler, if this is the first + if ( !( events = elemData.events ) ) { + events = elemData.events = Object.create( null ); + } + if ( !( eventHandle = elemData.handle ) ) { + eventHandle = elemData.handle = function( e ) { + + // Discard the second event of a jQuery.event.trigger() and + // when an event is called after a page has unloaded + return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? + jQuery.event.dispatch.apply( elem, arguments ) : undefined; + }; + } + + // Handle multiple events separated by a space + types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[ t ] ) || []; + type = origType = tmp[ 1 ]; + namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); + + // There *must* be a type, no attaching namespace-only handlers + if ( !type ) { + continue; + } + + // If event changes its type, use the special event handlers for the changed type + special = jQuery.event.special[ type ] || {}; + + // If selector defined, determine special event api type, otherwise given type + type = ( selector ? special.delegateType : special.bindType ) || type; + + // Update special based on newly reset type + special = jQuery.event.special[ type ] || {}; + + // handleObj is passed to all event handlers + handleObj = jQuery.extend( { + type: type, + origType: origType, + data: data, + handler: handler, + guid: handler.guid, + selector: selector, + needsContext: selector && jQuery.expr.match.needsContext.test( selector ), + namespace: namespaces.join( "." ) + }, handleObjIn ); + + // Init the event handler queue if we're the first + if ( !( handlers = events[ type ] ) ) { + handlers = events[ type ] = []; + handlers.delegateCount = 0; + + // Only use addEventListener if the special events handler returns false + if ( !special.setup || + special.setup.call( elem, data, namespaces, eventHandle ) === false ) { + + if ( elem.addEventListener ) { + elem.addEventListener( type, eventHandle ); + } + } + } + + if ( special.add ) { + special.add.call( elem, handleObj ); + + if ( !handleObj.handler.guid ) { + handleObj.handler.guid = handler.guid; + } + } + + // Add to the element's handler list, delegates in front + if ( selector ) { + handlers.splice( handlers.delegateCount++, 0, handleObj ); + } else { + handlers.push( handleObj ); + } + + // Keep track of which events have ever been used, for event optimization + jQuery.event.global[ type ] = true; + } + + }, + + // Detach an event or set of events from an element + remove: function( elem, types, handler, selector, mappedTypes ) { + + var j, origCount, tmp, + events, t, handleObj, + special, handlers, type, namespaces, origType, + elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); + + if ( !elemData || !( events = elemData.events ) ) { + return; + } + + // Once for each type.namespace in types; type may be omitted + types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[ t ] ) || []; + type = origType = tmp[ 1 ]; + namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); + + // Unbind all events (on this namespace, if provided) for the element + if ( !type ) { + for ( type in events ) { + jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); + } + continue; + } + + special = jQuery.event.special[ type ] || {}; + type = ( selector ? special.delegateType : special.bindType ) || type; + handlers = events[ type ] || []; + tmp = tmp[ 2 ] && + new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); + + // Remove matching events + origCount = j = handlers.length; + while ( j-- ) { + handleObj = handlers[ j ]; + + if ( ( mappedTypes || origType === handleObj.origType ) && + ( !handler || handler.guid === handleObj.guid ) && + ( !tmp || tmp.test( handleObj.namespace ) ) && + ( !selector || selector === handleObj.selector || + selector === "**" && handleObj.selector ) ) { + handlers.splice( j, 1 ); + + if ( handleObj.selector ) { + handlers.delegateCount--; + } + if ( special.remove ) { + special.remove.call( elem, handleObj ); + } + } + } + + // Remove generic event handler if we removed something and no more handlers exist + // (avoids potential for endless recursion during removal of special event handlers) + if ( origCount && !handlers.length ) { + if ( !special.teardown || + special.teardown.call( elem, namespaces, elemData.handle ) === false ) { + + jQuery.removeEvent( elem, type, elemData.handle ); + } + + delete events[ type ]; + } + } + + // Remove data and the expando if it's no longer used + if ( jQuery.isEmptyObject( events ) ) { + dataPriv.remove( elem, "handle events" ); + } + }, + + dispatch: function( nativeEvent ) { + + var i, j, ret, matched, handleObj, handlerQueue, + args = new Array( arguments.length ), + + // Make a writable jQuery.Event from the native event object + event = jQuery.event.fix( nativeEvent ), + + handlers = ( + dataPriv.get( this, "events" ) || Object.create( null ) + )[ event.type ] || [], + special = jQuery.event.special[ event.type ] || {}; + + // Use the fix-ed jQuery.Event rather than the (read-only) native event + args[ 0 ] = event; + + for ( i = 1; i < arguments.length; i++ ) { + args[ i ] = arguments[ i ]; + } + + event.delegateTarget = this; + + // Call the preDispatch hook for the mapped type, and let it bail if desired + if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { + return; + } + + // Determine handlers + handlerQueue = jQuery.event.handlers.call( this, event, handlers ); + + // Run delegates first; they may want to stop propagation beneath us + i = 0; + while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { + event.currentTarget = matched.elem; + + j = 0; + while ( ( handleObj = matched.handlers[ j++ ] ) && + !event.isImmediatePropagationStopped() ) { + + // If the event is namespaced, then each handler is only invoked if it is + // specially universal or its namespaces are a superset of the event's. + if ( !event.rnamespace || handleObj.namespace === false || + event.rnamespace.test( handleObj.namespace ) ) { + + event.handleObj = handleObj; + event.data = handleObj.data; + + ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || + handleObj.handler ).apply( matched.elem, args ); + + if ( ret !== undefined ) { + if ( ( event.result = ret ) === false ) { + event.preventDefault(); + event.stopPropagation(); + } + } + } + } + } + + // Call the postDispatch hook for the mapped type + if ( special.postDispatch ) { + special.postDispatch.call( this, event ); + } + + return event.result; + }, + + handlers: function( event, handlers ) { + var i, handleObj, sel, matchedHandlers, matchedSelectors, + handlerQueue = [], + delegateCount = handlers.delegateCount, + cur = event.target; + + // Find delegate handlers + if ( delegateCount && + + // Support: IE <=9 + // Black-hole SVG instance trees (trac-13180) + cur.nodeType && + + // Support: Firefox <=42 + // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) + // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click + // Support: IE 11 only + // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) + !( event.type === "click" && event.button >= 1 ) ) { + + for ( ; cur !== this; cur = cur.parentNode || this ) { + + // Don't check non-elements (trac-13208) + // Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764) + if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { + matchedHandlers = []; + matchedSelectors = {}; + for ( i = 0; i < delegateCount; i++ ) { + handleObj = handlers[ i ]; + + // Don't conflict with Object.prototype properties (trac-13203) + sel = handleObj.selector + " "; + + if ( matchedSelectors[ sel ] === undefined ) { + matchedSelectors[ sel ] = handleObj.needsContext ? + jQuery( sel, this ).index( cur ) > -1 : + jQuery.find( sel, this, null, [ cur ] ).length; + } + if ( matchedSelectors[ sel ] ) { + matchedHandlers.push( handleObj ); + } + } + if ( matchedHandlers.length ) { + handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); + } + } + } + } + + // Add the remaining (directly-bound) handlers + cur = this; + if ( delegateCount < handlers.length ) { + handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); + } + + return handlerQueue; + }, + + addProp: function( name, hook ) { + Object.defineProperty( jQuery.Event.prototype, name, { + enumerable: true, + configurable: true, + + get: isFunction( hook ) ? + function() { + if ( this.originalEvent ) { + return hook( this.originalEvent ); + } + } : + function() { + if ( this.originalEvent ) { + return this.originalEvent[ name ]; + } + }, + + set: function( value ) { + Object.defineProperty( this, name, { + enumerable: true, + configurable: true, + writable: true, + value: value + } ); + } + } ); + }, + + fix: function( originalEvent ) { + return originalEvent[ jQuery.expando ] ? + originalEvent : + new jQuery.Event( originalEvent ); + }, + + special: { + load: { + + // Prevent triggered image.load events from bubbling to window.load + noBubble: true + }, + click: { + + // Utilize native event to ensure correct state for checkable inputs + setup: function( data ) { + + // For mutual compressibility with _default, replace `this` access with a local var. + // `|| data` is dead code meant only to preserve the variable through minification. + var el = this || data; + + // Claim the first handler + if ( rcheckableType.test( el.type ) && + el.click && nodeName( el, "input" ) ) { + + // dataPriv.set( el, "click", ... ) + leverageNative( el, "click", true ); + } + + // Return false to allow normal processing in the caller + return false; + }, + trigger: function( data ) { + + // For mutual compressibility with _default, replace `this` access with a local var. + // `|| data` is dead code meant only to preserve the variable through minification. + var el = this || data; + + // Force setup before triggering a click + if ( rcheckableType.test( el.type ) && + el.click && nodeName( el, "input" ) ) { + + leverageNative( el, "click" ); + } + + // Return non-false to allow normal event-path propagation + return true; + }, + + // For cross-browser consistency, suppress native .click() on links + // Also prevent it if we're currently inside a leveraged native-event stack + _default: function( event ) { + var target = event.target; + return rcheckableType.test( target.type ) && + target.click && nodeName( target, "input" ) && + dataPriv.get( target, "click" ) || + nodeName( target, "a" ); + } + }, + + beforeunload: { + postDispatch: function( event ) { + + // Support: Firefox 20+ + // Firefox doesn't alert if the returnValue field is not set. + if ( event.result !== undefined && event.originalEvent ) { + event.originalEvent.returnValue = event.result; + } + } + } + } + }; + + // Ensure the presence of an event listener that handles manually-triggered + // synthetic events by interrupting progress until reinvoked in response to + // *native* events that it fires directly, ensuring that state changes have + // already occurred before other listeners are invoked. + function leverageNative( el, type, isSetup ) { + + // Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add + if ( !isSetup ) { + if ( dataPriv.get( el, type ) === undefined ) { + jQuery.event.add( el, type, returnTrue ); + } + return; + } + + // Register the controller as a special universal handler for all event namespaces + dataPriv.set( el, type, false ); + jQuery.event.add( el, type, { + namespace: false, + handler: function( event ) { + var result, + saved = dataPriv.get( this, type ); + + if ( ( event.isTrigger & 1 ) && this[ type ] ) { + + // Interrupt processing of the outer synthetic .trigger()ed event + if ( !saved ) { + + // Store arguments for use when handling the inner native event + // There will always be at least one argument (an event object), so this array + // will not be confused with a leftover capture object. + saved = slice.call( arguments ); + dataPriv.set( this, type, saved ); + + // Trigger the native event and capture its result + this[ type ](); + result = dataPriv.get( this, type ); + dataPriv.set( this, type, false ); + + if ( saved !== result ) { + + // Cancel the outer synthetic event + event.stopImmediatePropagation(); + event.preventDefault(); + + return result; + } + + // If this is an inner synthetic event for an event with a bubbling surrogate + // (focus or blur), assume that the surrogate already propagated from triggering + // the native event and prevent that from happening again here. + // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the + // bubbling surrogate propagates *after* the non-bubbling base), but that seems + // less bad than duplication. + } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { + event.stopPropagation(); + } + + // If this is a native event triggered above, everything is now in order + // Fire an inner synthetic event with the original arguments + } else if ( saved ) { + + // ...and capture the result + dataPriv.set( this, type, jQuery.event.trigger( + saved[ 0 ], + saved.slice( 1 ), + this + ) ); + + // Abort handling of the native event by all jQuery handlers while allowing + // native handlers on the same element to run. On target, this is achieved + // by stopping immediate propagation just on the jQuery event. However, + // the native event is re-wrapped by a jQuery one on each level of the + // propagation so the only way to stop it for jQuery is to stop it for + // everyone via native `stopPropagation()`. This is not a problem for + // focus/blur which don't bubble, but it does also stop click on checkboxes + // and radios. We accept this limitation. + event.stopPropagation(); + event.isImmediatePropagationStopped = returnTrue; + } + } + } ); + } + + jQuery.removeEvent = function( elem, type, handle ) { + + // This "if" is needed for plain objects + if ( elem.removeEventListener ) { + elem.removeEventListener( type, handle ); + } + }; + + jQuery.Event = function( src, props ) { + + // Allow instantiation without the 'new' keyword + if ( !( this instanceof jQuery.Event ) ) { + return new jQuery.Event( src, props ); + } + + // Event object + if ( src && src.type ) { + this.originalEvent = src; + this.type = src.type; + + // Events bubbling up the document may have been marked as prevented + // by a handler lower down the tree; reflect the correct value. + this.isDefaultPrevented = src.defaultPrevented || + src.defaultPrevented === undefined && + + // Support: Android <=2.3 only + src.returnValue === false ? + returnTrue : + returnFalse; + + // Create target properties + // Support: Safari <=6 - 7 only + // Target should not be a text node (trac-504, trac-13143) + this.target = ( src.target && src.target.nodeType === 3 ) ? + src.target.parentNode : + src.target; + + this.currentTarget = src.currentTarget; + this.relatedTarget = src.relatedTarget; + + // Event type + } else { + this.type = src; + } + + // Put explicitly provided properties onto the event object + if ( props ) { + jQuery.extend( this, props ); + } + + // Create a timestamp if incoming event doesn't have one + this.timeStamp = src && src.timeStamp || Date.now(); + + // Mark it as fixed + this[ jQuery.expando ] = true; + }; + + // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding + // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html + jQuery.Event.prototype = { + constructor: jQuery.Event, + isDefaultPrevented: returnFalse, + isPropagationStopped: returnFalse, + isImmediatePropagationStopped: returnFalse, + isSimulated: false, + + preventDefault: function() { + var e = this.originalEvent; + + this.isDefaultPrevented = returnTrue; + + if ( e && !this.isSimulated ) { + e.preventDefault(); + } + }, + stopPropagation: function() { + var e = this.originalEvent; + + this.isPropagationStopped = returnTrue; + + if ( e && !this.isSimulated ) { + e.stopPropagation(); + } + }, + stopImmediatePropagation: function() { + var e = this.originalEvent; + + this.isImmediatePropagationStopped = returnTrue; + + if ( e && !this.isSimulated ) { + e.stopImmediatePropagation(); + } + + this.stopPropagation(); + } + }; + + // Includes all common event props including KeyEvent and MouseEvent specific props + jQuery.each( { + altKey: true, + bubbles: true, + cancelable: true, + changedTouches: true, + ctrlKey: true, + detail: true, + eventPhase: true, + metaKey: true, + pageX: true, + pageY: true, + shiftKey: true, + view: true, + "char": true, + code: true, + charCode: true, + key: true, + keyCode: true, + button: true, + buttons: true, + clientX: true, + clientY: true, + offsetX: true, + offsetY: true, + pointerId: true, + pointerType: true, + screenX: true, + screenY: true, + targetTouches: true, + toElement: true, + touches: true, + which: true + }, jQuery.event.addProp ); + + jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { + + function focusMappedHandler( nativeEvent ) { + if ( document.documentMode ) { + + // Support: IE 11+ + // Attach a single focusin/focusout handler on the document while someone wants + // focus/blur. This is because the former are synchronous in IE while the latter + // are async. In other browsers, all those handlers are invoked synchronously. + + // `handle` from private data would already wrap the event, but we need + // to change the `type` here. + var handle = dataPriv.get( this, "handle" ), + event = jQuery.event.fix( nativeEvent ); + event.type = nativeEvent.type === "focusin" ? "focus" : "blur"; + event.isSimulated = true; + + // First, handle focusin/focusout + handle( nativeEvent ); + + // ...then, handle focus/blur + // + // focus/blur don't bubble while focusin/focusout do; simulate the former by only + // invoking the handler at the lower level. + if ( event.target === event.currentTarget ) { + + // The setup part calls `leverageNative`, which, in turn, calls + // `jQuery.event.add`, so event handle will already have been set + // by this point. + handle( event ); + } + } else { + + // For non-IE browsers, attach a single capturing handler on the document + // while someone wants focusin/focusout. + jQuery.event.simulate( delegateType, nativeEvent.target, + jQuery.event.fix( nativeEvent ) ); + } + } + + jQuery.event.special[ type ] = { + + // Utilize native event if possible so blur/focus sequence is correct + setup: function() { + + var attaches; + + // Claim the first handler + // dataPriv.set( this, "focus", ... ) + // dataPriv.set( this, "blur", ... ) + leverageNative( this, type, true ); + + if ( document.documentMode ) { + + // Support: IE 9 - 11+ + // We use the same native handler for focusin & focus (and focusout & blur) + // so we need to coordinate setup & teardown parts between those events. + // Use `delegateType` as the key as `type` is already used by `leverageNative`. + attaches = dataPriv.get( this, delegateType ); + if ( !attaches ) { + this.addEventListener( delegateType, focusMappedHandler ); + } + dataPriv.set( this, delegateType, ( attaches || 0 ) + 1 ); + } else { + + // Return false to allow normal processing in the caller + return false; + } + }, + trigger: function() { + + // Force setup before trigger + leverageNative( this, type ); + + // Return non-false to allow normal event-path propagation + return true; + }, + + teardown: function() { + var attaches; + + if ( document.documentMode ) { + attaches = dataPriv.get( this, delegateType ) - 1; + if ( !attaches ) { + this.removeEventListener( delegateType, focusMappedHandler ); + dataPriv.remove( this, delegateType ); + } else { + dataPriv.set( this, delegateType, attaches ); + } + } else { + + // Return false to indicate standard teardown should be applied + return false; + } + }, + + // Suppress native focus or blur if we're currently inside + // a leveraged native-event stack + _default: function( event ) { + return dataPriv.get( event.target, type ); + }, + + delegateType: delegateType + }; + + // Support: Firefox <=44 + // Firefox doesn't have focus(in | out) events + // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 + // + // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 + // focus(in | out) events fire after focus & blur events, + // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order + // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 + // + // Support: IE 9 - 11+ + // To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch, + // attach a single handler for both events in IE. + jQuery.event.special[ delegateType ] = { + setup: function() { + + // Handle: regular nodes (via `this.ownerDocument`), window + // (via `this.document`) & document (via `this`). + var doc = this.ownerDocument || this.document || this, + dataHolder = document.documentMode ? this : doc, + attaches = dataPriv.get( dataHolder, delegateType ); + + // Support: IE 9 - 11+ + // We use the same native handler for focusin & focus (and focusout & blur) + // so we need to coordinate setup & teardown parts between those events. + // Use `delegateType` as the key as `type` is already used by `leverageNative`. + if ( !attaches ) { + if ( document.documentMode ) { + this.addEventListener( delegateType, focusMappedHandler ); + } else { + doc.addEventListener( type, focusMappedHandler, true ); + } + } + dataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 ); + }, + teardown: function() { + var doc = this.ownerDocument || this.document || this, + dataHolder = document.documentMode ? this : doc, + attaches = dataPriv.get( dataHolder, delegateType ) - 1; + + if ( !attaches ) { + if ( document.documentMode ) { + this.removeEventListener( delegateType, focusMappedHandler ); + } else { + doc.removeEventListener( type, focusMappedHandler, true ); + } + dataPriv.remove( dataHolder, delegateType ); + } else { + dataPriv.set( dataHolder, delegateType, attaches ); + } + } + }; + } ); + + // Create mouseenter/leave events using mouseover/out and event-time checks + // so that event delegation works in jQuery. + // Do the same for pointerenter/pointerleave and pointerover/pointerout + // + // Support: Safari 7 only + // Safari sends mouseenter too often; see: + // https://bugs.chromium.org/p/chromium/issues/detail?id=470258 + // for the description of the bug (it existed in older Chrome versions as well). + jQuery.each( { + mouseenter: "mouseover", + mouseleave: "mouseout", + pointerenter: "pointerover", + pointerleave: "pointerout" + }, function( orig, fix ) { + jQuery.event.special[ orig ] = { + delegateType: fix, + bindType: fix, + + handle: function( event ) { + var ret, + target = this, + related = event.relatedTarget, + handleObj = event.handleObj; + + // For mouseenter/leave call the handler if related is outside the target. + // NB: No relatedTarget if the mouse left/entered the browser window + if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { + event.type = handleObj.origType; + ret = handleObj.handler.apply( this, arguments ); + event.type = fix; + } + return ret; + } + }; + } ); + + jQuery.fn.extend( { + + on: function( types, selector, data, fn ) { + return on( this, types, selector, data, fn ); + }, + one: function( types, selector, data, fn ) { + return on( this, types, selector, data, fn, 1 ); + }, + off: function( types, selector, fn ) { + var handleObj, type; + if ( types && types.preventDefault && types.handleObj ) { + + // ( event ) dispatched jQuery.Event + handleObj = types.handleObj; + jQuery( types.delegateTarget ).off( + handleObj.namespace ? + handleObj.origType + "." + handleObj.namespace : + handleObj.origType, + handleObj.selector, + handleObj.handler + ); + return this; + } + if ( typeof types === "object" ) { + + // ( types-object [, selector] ) + for ( type in types ) { + this.off( type, selector, types[ type ] ); + } + return this; + } + if ( selector === false || typeof selector === "function" ) { + + // ( types [, fn] ) + fn = selector; + selector = undefined; + } + if ( fn === false ) { + fn = returnFalse; + } + return this.each( function() { + jQuery.event.remove( this, types, fn, selector ); + } ); + } + } ); + + + var + + // Support: IE <=10 - 11, Edge 12 - 13 only + // In IE/Edge using regex groups here causes severe slowdowns. + // See https://connect.microsoft.com/IE/feedback/details/1736512/ + rnoInnerhtml = /\s*$/g; + + // Prefer a tbody over its parent table for containing new rows + function manipulationTarget( elem, content ) { + if ( nodeName( elem, "table" ) && + nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { + + return jQuery( elem ).children( "tbody" )[ 0 ] || elem; + } + + return elem; + } + + // Replace/restore the type attribute of script elements for safe DOM manipulation + function disableScript( elem ) { + elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; + return elem; + } + function restoreScript( elem ) { + if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { + elem.type = elem.type.slice( 5 ); + } else { + elem.removeAttribute( "type" ); + } + + return elem; + } + + function cloneCopyEvent( src, dest ) { + var i, l, type, pdataOld, udataOld, udataCur, events; + + if ( dest.nodeType !== 1 ) { + return; + } + + // 1. Copy private data: events, handlers, etc. + if ( dataPriv.hasData( src ) ) { + pdataOld = dataPriv.get( src ); + events = pdataOld.events; + + if ( events ) { + dataPriv.remove( dest, "handle events" ); + + for ( type in events ) { + for ( i = 0, l = events[ type ].length; i < l; i++ ) { + jQuery.event.add( dest, type, events[ type ][ i ] ); + } + } + } + } + + // 2. Copy user data + if ( dataUser.hasData( src ) ) { + udataOld = dataUser.access( src ); + udataCur = jQuery.extend( {}, udataOld ); + + dataUser.set( dest, udataCur ); + } + } + + // Fix IE bugs, see support tests + function fixInput( src, dest ) { + var nodeName = dest.nodeName.toLowerCase(); + + // Fails to persist the checked state of a cloned checkbox or radio button. + if ( nodeName === "input" && rcheckableType.test( src.type ) ) { + dest.checked = src.checked; + + // Fails to return the selected option to the default selected state when cloning options + } else if ( nodeName === "input" || nodeName === "textarea" ) { + dest.defaultValue = src.defaultValue; + } + } + + function domManip( collection, args, callback, ignored ) { + + // Flatten any nested arrays + args = flat( args ); + + var fragment, first, scripts, hasScripts, node, doc, + i = 0, + l = collection.length, + iNoClone = l - 1, + value = args[ 0 ], + valueIsFunction = isFunction( value ); + + // We can't cloneNode fragments that contain checked, in WebKit + if ( valueIsFunction || + ( l > 1 && typeof value === "string" && + !support.checkClone && rchecked.test( value ) ) ) { + return collection.each( function( index ) { + var self = collection.eq( index ); + if ( valueIsFunction ) { + args[ 0 ] = value.call( this, index, self.html() ); + } + domManip( self, args, callback, ignored ); + } ); + } + + if ( l ) { + fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); + first = fragment.firstChild; + + if ( fragment.childNodes.length === 1 ) { + fragment = first; + } + + // Require either new content or an interest in ignored elements to invoke the callback + if ( first || ignored ) { + scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); + hasScripts = scripts.length; + + // Use the original fragment for the last item + // instead of the first because it can end up + // being emptied incorrectly in certain situations (trac-8070). + for ( ; i < l; i++ ) { + node = fragment; + + if ( i !== iNoClone ) { + node = jQuery.clone( node, true, true ); + + // Keep references to cloned scripts for later restoration + if ( hasScripts ) { + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( scripts, getAll( node, "script" ) ); + } + } + + callback.call( collection[ i ], node, i ); + } + + if ( hasScripts ) { + doc = scripts[ scripts.length - 1 ].ownerDocument; + + // Re-enable scripts + jQuery.map( scripts, restoreScript ); + + // Evaluate executable scripts on first document insertion + for ( i = 0; i < hasScripts; i++ ) { + node = scripts[ i ]; + if ( rscriptType.test( node.type || "" ) && + !dataPriv.access( node, "globalEval" ) && + jQuery.contains( doc, node ) ) { + + if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { + + // Optional AJAX dependency, but won't run scripts if not present + if ( jQuery._evalUrl && !node.noModule ) { + jQuery._evalUrl( node.src, { + nonce: node.nonce || node.getAttribute( "nonce" ) + }, doc ); + } + } else { + + // Unwrap a CDATA section containing script contents. This shouldn't be + // needed as in XML documents they're already not visible when + // inspecting element contents and in HTML documents they have no + // meaning but we're preserving that logic for backwards compatibility. + // This will be removed completely in 4.0. See gh-4904. + DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); + } + } + } + } + } + } + + return collection; + } + + function remove( elem, selector, keepData ) { + var node, + nodes = selector ? jQuery.filter( selector, elem ) : elem, + i = 0; + + for ( ; ( node = nodes[ i ] ) != null; i++ ) { + if ( !keepData && node.nodeType === 1 ) { + jQuery.cleanData( getAll( node ) ); + } + + if ( node.parentNode ) { + if ( keepData && isAttached( node ) ) { + setGlobalEval( getAll( node, "script" ) ); + } + node.parentNode.removeChild( node ); + } + } + + return elem; + } + + jQuery.extend( { + htmlPrefilter: function( html ) { + return html; + }, + + clone: function( elem, dataAndEvents, deepDataAndEvents ) { + var i, l, srcElements, destElements, + clone = elem.cloneNode( true ), + inPage = isAttached( elem ); + + // Fix IE cloning issues + if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && + !jQuery.isXMLDoc( elem ) ) { + + // We eschew jQuery#find here for performance reasons: + // https://jsperf.com/getall-vs-sizzle/2 + destElements = getAll( clone ); + srcElements = getAll( elem ); + + for ( i = 0, l = srcElements.length; i < l; i++ ) { + fixInput( srcElements[ i ], destElements[ i ] ); + } + } + + // Copy the events from the original to the clone + if ( dataAndEvents ) { + if ( deepDataAndEvents ) { + srcElements = srcElements || getAll( elem ); + destElements = destElements || getAll( clone ); + + for ( i = 0, l = srcElements.length; i < l; i++ ) { + cloneCopyEvent( srcElements[ i ], destElements[ i ] ); + } + } else { + cloneCopyEvent( elem, clone ); + } + } + + // Preserve script evaluation history + destElements = getAll( clone, "script" ); + if ( destElements.length > 0 ) { + setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); + } + + // Return the cloned set + return clone; + }, + + cleanData: function( elems ) { + var data, elem, type, + special = jQuery.event.special, + i = 0; + + for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { + if ( acceptData( elem ) ) { + if ( ( data = elem[ dataPriv.expando ] ) ) { + if ( data.events ) { + for ( type in data.events ) { + if ( special[ type ] ) { + jQuery.event.remove( elem, type ); + + // This is a shortcut to avoid jQuery.event.remove's overhead + } else { + jQuery.removeEvent( elem, type, data.handle ); + } + } + } + + // Support: Chrome <=35 - 45+ + // Assign undefined instead of using delete, see Data#remove + elem[ dataPriv.expando ] = undefined; + } + if ( elem[ dataUser.expando ] ) { + + // Support: Chrome <=35 - 45+ + // Assign undefined instead of using delete, see Data#remove + elem[ dataUser.expando ] = undefined; + } + } + } + } + } ); + + jQuery.fn.extend( { + detach: function( selector ) { + return remove( this, selector, true ); + }, + + remove: function( selector ) { + return remove( this, selector ); + }, + + text: function( value ) { + return access( this, function( value ) { + return value === undefined ? + jQuery.text( this ) : + this.empty().each( function() { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + this.textContent = value; + } + } ); + }, null, value, arguments.length ); + }, + + append: function() { + return domManip( this, arguments, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + var target = manipulationTarget( this, elem ); + target.appendChild( elem ); + } + } ); + }, + + prepend: function() { + return domManip( this, arguments, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + var target = manipulationTarget( this, elem ); + target.insertBefore( elem, target.firstChild ); + } + } ); + }, + + before: function() { + return domManip( this, arguments, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this ); + } + } ); + }, + + after: function() { + return domManip( this, arguments, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this.nextSibling ); + } + } ); + }, + + empty: function() { + var elem, + i = 0; + + for ( ; ( elem = this[ i ] ) != null; i++ ) { + if ( elem.nodeType === 1 ) { + + // Prevent memory leaks + jQuery.cleanData( getAll( elem, false ) ); + + // Remove any remaining nodes + elem.textContent = ""; + } + } + + return this; + }, + + clone: function( dataAndEvents, deepDataAndEvents ) { + dataAndEvents = dataAndEvents == null ? false : dataAndEvents; + deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; + + return this.map( function() { + return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); + } ); + }, + + html: function( value ) { + return access( this, function( value ) { + var elem = this[ 0 ] || {}, + i = 0, + l = this.length; + + if ( value === undefined && elem.nodeType === 1 ) { + return elem.innerHTML; + } + + // See if we can take a shortcut and just use innerHTML + if ( typeof value === "string" && !rnoInnerhtml.test( value ) && + !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { + + value = jQuery.htmlPrefilter( value ); + + try { + for ( ; i < l; i++ ) { + elem = this[ i ] || {}; + + // Remove element nodes and prevent memory leaks + if ( elem.nodeType === 1 ) { + jQuery.cleanData( getAll( elem, false ) ); + elem.innerHTML = value; + } + } + + elem = 0; + + // If using innerHTML throws an exception, use the fallback method + } catch ( e ) {} + } + + if ( elem ) { + this.empty().append( value ); + } + }, null, value, arguments.length ); + }, + + replaceWith: function() { + var ignored = []; + + // Make the changes, replacing each non-ignored context element with the new content + return domManip( this, arguments, function( elem ) { + var parent = this.parentNode; + + if ( jQuery.inArray( this, ignored ) < 0 ) { + jQuery.cleanData( getAll( this ) ); + if ( parent ) { + parent.replaceChild( elem, this ); + } + } + + // Force callback invocation + }, ignored ); + } + } ); + + jQuery.each( { + appendTo: "append", + prependTo: "prepend", + insertBefore: "before", + insertAfter: "after", + replaceAll: "replaceWith" + }, function( name, original ) { + jQuery.fn[ name ] = function( selector ) { + var elems, + ret = [], + insert = jQuery( selector ), + last = insert.length - 1, + i = 0; + + for ( ; i <= last; i++ ) { + elems = i === last ? this : this.clone( true ); + jQuery( insert[ i ] )[ original ]( elems ); + + // Support: Android <=4.0 only, PhantomJS 1 only + // .get() because push.apply(_, arraylike) throws on ancient WebKit + push.apply( ret, elems.get() ); + } + + return this.pushStack( ret ); + }; + } ); + var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); + + var rcustomProp = /^--/; + + + var getStyles = function( elem ) { + + // Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150) + // IE throws on elements created in popups + // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" + var view = elem.ownerDocument.defaultView; + + if ( !view || !view.opener ) { + view = window; + } + + return view.getComputedStyle( elem ); + }; + + var swap = function( elem, options, callback ) { + var ret, name, + old = {}; + + // Remember the old values, and insert the new ones + for ( name in options ) { + old[ name ] = elem.style[ name ]; + elem.style[ name ] = options[ name ]; + } + + ret = callback.call( elem ); + + // Revert the old values + for ( name in options ) { + elem.style[ name ] = old[ name ]; + } + + return ret; + }; + + + var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); + + + + ( function() { + + // Executing both pixelPosition & boxSizingReliable tests require only one layout + // so they're executed at the same time to save the second computation. + function computeStyleTests() { + + // This is a singleton, we need to execute it only once + if ( !div ) { + return; + } + + container.style.cssText = "position:absolute;left:-11111px;width:60px;" + + "margin-top:1px;padding:0;border:0"; + div.style.cssText = + "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + + "margin:auto;border:1px;padding:1px;" + + "width:60%;top:1%"; + documentElement.appendChild( container ).appendChild( div ); + + var divStyle = window.getComputedStyle( div ); + pixelPositionVal = divStyle.top !== "1%"; + + // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 + reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; + + // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 + // Some styles come back with percentage values, even though they shouldn't + div.style.right = "60%"; + pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; + + // Support: IE 9 - 11 only + // Detect misreporting of content dimensions for box-sizing:border-box elements + boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; + + // Support: IE 9 only + // Detect overflow:scroll screwiness (gh-3699) + // Support: Chrome <=64 + // Don't get tricked when zoom affects offsetWidth (gh-4029) + div.style.position = "absolute"; + scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; + + documentElement.removeChild( container ); + + // Nullify the div so it wouldn't be stored in the memory and + // it will also be a sign that checks already performed + div = null; + } + + function roundPixelMeasures( measure ) { + return Math.round( parseFloat( measure ) ); + } + + var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, + reliableTrDimensionsVal, reliableMarginLeftVal, + container = document.createElement( "div" ), + div = document.createElement( "div" ); + + // Finish early in limited (non-browser) environments + if ( !div.style ) { + return; + } + + // Support: IE <=9 - 11 only + // Style of cloned element affects source element cloned (trac-8908) + div.style.backgroundClip = "content-box"; + div.cloneNode( true ).style.backgroundClip = ""; + support.clearCloneStyle = div.style.backgroundClip === "content-box"; + + jQuery.extend( support, { + boxSizingReliable: function() { + computeStyleTests(); + return boxSizingReliableVal; + }, + pixelBoxStyles: function() { + computeStyleTests(); + return pixelBoxStylesVal; + }, + pixelPosition: function() { + computeStyleTests(); + return pixelPositionVal; + }, + reliableMarginLeft: function() { + computeStyleTests(); + return reliableMarginLeftVal; + }, + scrollboxSize: function() { + computeStyleTests(); + return scrollboxSizeVal; + }, + + // Support: IE 9 - 11+, Edge 15 - 18+ + // IE/Edge misreport `getComputedStyle` of table rows with width/height + // set in CSS while `offset*` properties report correct values. + // Behavior in IE 9 is more subtle than in newer versions & it passes + // some versions of this test; make sure not to make it pass there! + // + // Support: Firefox 70+ + // Only Firefox includes border widths + // in computed dimensions. (gh-4529) + reliableTrDimensions: function() { + var table, tr, trChild, trStyle; + if ( reliableTrDimensionsVal == null ) { + table = document.createElement( "table" ); + tr = document.createElement( "tr" ); + trChild = document.createElement( "div" ); + + table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate"; + tr.style.cssText = "box-sizing:content-box;border:1px solid"; + + // Support: Chrome 86+ + // Height set through cssText does not get applied. + // Computed height then comes back as 0. + tr.style.height = "1px"; + trChild.style.height = "9px"; + + // Support: Android 8 Chrome 86+ + // In our bodyBackground.html iframe, + // display for all div elements is set to "inline", + // which causes a problem only in Android 8 Chrome 86. + // Ensuring the div is `display: block` + // gets around this issue. + trChild.style.display = "block"; + + documentElement + .appendChild( table ) + .appendChild( tr ) + .appendChild( trChild ); + + trStyle = window.getComputedStyle( tr ); + reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) + + parseInt( trStyle.borderTopWidth, 10 ) + + parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight; + + documentElement.removeChild( table ); + } + return reliableTrDimensionsVal; + } + } ); + } )(); + + + function curCSS( elem, name, computed ) { + var width, minWidth, maxWidth, ret, + isCustomProp = rcustomProp.test( name ), + + // Support: Firefox 51+ + // Retrieving style before computed somehow + // fixes an issue with getting wrong values + // on detached elements + style = elem.style; + + computed = computed || getStyles( elem ); + + // getPropertyValue is needed for: + // .css('filter') (IE 9 only, trac-12537) + // .css('--customProperty) (gh-3144) + if ( computed ) { + + // Support: IE <=9 - 11+ + // IE only supports `"float"` in `getPropertyValue`; in computed styles + // it's only available as `"cssFloat"`. We no longer modify properties + // sent to `.css()` apart from camelCasing, so we need to check both. + // Normally, this would create difference in behavior: if + // `getPropertyValue` returns an empty string, the value returned + // by `.css()` would be `undefined`. This is usually the case for + // disconnected elements. However, in IE even disconnected elements + // with no styles return `"none"` for `getPropertyValue( "float" )` + ret = computed.getPropertyValue( name ) || computed[ name ]; + + if ( isCustomProp && ret ) { + + // Support: Firefox 105+, Chrome <=105+ + // Spec requires trimming whitespace for custom properties (gh-4926). + // Firefox only trims leading whitespace. Chrome just collapses + // both leading & trailing whitespace to a single space. + // + // Fall back to `undefined` if empty string returned. + // This collapses a missing definition with property defined + // and set to an empty string but there's no standard API + // allowing us to differentiate them without a performance penalty + // and returning `undefined` aligns with older jQuery. + // + // rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED + // as whitespace while CSS does not, but this is not a problem + // because CSS preprocessing replaces them with U+000A LINE FEED + // (which *is* CSS whitespace) + // https://www.w3.org/TR/css-syntax-3/#input-preprocessing + ret = ret.replace( rtrimCSS, "$1" ) || undefined; + } + + if ( ret === "" && !isAttached( elem ) ) { + ret = jQuery.style( elem, name ); + } + + // A tribute to the "awesome hack by Dean Edwards" + // Android Browser returns percentage for some values, + // but width seems to be reliably pixels. + // This is against the CSSOM draft spec: + // https://drafts.csswg.org/cssom/#resolved-values + if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { + + // Remember the original values + width = style.width; + minWidth = style.minWidth; + maxWidth = style.maxWidth; + + // Put in the new values to get a computed value out + style.minWidth = style.maxWidth = style.width = ret; + ret = computed.width; + + // Revert the changed values + style.width = width; + style.minWidth = minWidth; + style.maxWidth = maxWidth; + } + } + + return ret !== undefined ? + + // Support: IE <=9 - 11 only + // IE returns zIndex value as an integer. + ret + "" : + ret; + } + + + function addGetHookIf( conditionFn, hookFn ) { + + // Define the hook, we'll check on the first run if it's really needed. + return { + get: function() { + if ( conditionFn() ) { + + // Hook not needed (or it's not possible to use it due + // to missing dependency), remove it. + delete this.get; + return; + } + + // Hook needed; redefine it so that the support test is not executed again. + return ( this.get = hookFn ).apply( this, arguments ); + } + }; + } + + + var cssPrefixes = [ "Webkit", "Moz", "ms" ], + emptyStyle = document.createElement( "div" ).style, + vendorProps = {}; + + // Return a vendor-prefixed property or undefined + function vendorPropName( name ) { + + // Check for vendor prefixed names + var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), + i = cssPrefixes.length; + + while ( i-- ) { + name = cssPrefixes[ i ] + capName; + if ( name in emptyStyle ) { + return name; + } + } + } + + // Return a potentially-mapped jQuery.cssProps or vendor prefixed property + function finalPropName( name ) { + var final = jQuery.cssProps[ name ] || vendorProps[ name ]; + + if ( final ) { + return final; + } + if ( name in emptyStyle ) { + return name; + } + return vendorProps[ name ] = vendorPropName( name ) || name; + } + + + var + + // Swappable if display is none or starts with table + // except "table", "table-cell", or "table-caption" + // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display + rdisplayswap = /^(none|table(?!-c[ea]).+)/, + cssShow = { position: "absolute", visibility: "hidden", display: "block" }, + cssNormalTransform = { + letterSpacing: "0", + fontWeight: "400" + }; + + function setPositiveNumber( _elem, value, subtract ) { + + // Any relative (+/-) values have already been + // normalized at this point + var matches = rcssNum.exec( value ); + return matches ? + + // Guard against undefined "subtract", e.g., when used as in cssHooks + Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : + value; + } + + function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { + var i = dimension === "width" ? 1 : 0, + extra = 0, + delta = 0, + marginDelta = 0; + + // Adjustment may not be necessary + if ( box === ( isBorderBox ? "border" : "content" ) ) { + return 0; + } + + for ( ; i < 4; i += 2 ) { + + // Both box models exclude margin + // Count margin delta separately to only add it after scroll gutter adjustment. + // This is needed to make negative margins work with `outerHeight( true )` (gh-3982). + if ( box === "margin" ) { + marginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); + } + + // If we get here with a content-box, we're seeking "padding" or "border" or "margin" + if ( !isBorderBox ) { + + // Add padding + delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + + // For "border" or "margin", add border + if ( box !== "padding" ) { + delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + + // But still keep track of it otherwise + } else { + extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + + // If we get here with a border-box (content + padding + border), we're seeking "content" or + // "padding" or "margin" + } else { + + // For "content", subtract padding + if ( box === "content" ) { + delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + } + + // For "content" or "padding", subtract border + if ( box !== "margin" ) { + delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + } + } + + // Account for positive content-box scroll gutter when requested by providing computedVal + if ( !isBorderBox && computedVal >= 0 ) { + + // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border + // Assuming integer scroll gutter, subtract the rest and round down + delta += Math.max( 0, Math.ceil( + elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - + computedVal - + delta - + extra - + 0.5 + + // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter + // Use an explicit zero to avoid NaN (gh-3964) + ) ) || 0; + } + + return delta + marginDelta; + } + + function getWidthOrHeight( elem, dimension, extra ) { + + // Start with computed style + var styles = getStyles( elem ), + + // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). + // Fake content-box until we know it's needed to know the true value. + boxSizingNeeded = !support.boxSizingReliable() || extra, + isBorderBox = boxSizingNeeded && + jQuery.css( elem, "boxSizing", false, styles ) === "border-box", + valueIsBorderBox = isBorderBox, + + val = curCSS( elem, dimension, styles ), + offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); + + // Support: Firefox <=54 + // Return a confounding non-pixel value or feign ignorance, as appropriate. + if ( rnumnonpx.test( val ) ) { + if ( !extra ) { + return val; + } + val = "auto"; + } + + + // Support: IE 9 - 11 only + // Use offsetWidth/offsetHeight for when box sizing is unreliable. + // In those cases, the computed value can be trusted to be border-box. + if ( ( !support.boxSizingReliable() && isBorderBox || + + // Support: IE 10 - 11+, Edge 15 - 18+ + // IE/Edge misreport `getComputedStyle` of table rows with width/height + // set in CSS while `offset*` properties report correct values. + // Interestingly, in some cases IE 9 doesn't suffer from this issue. + !support.reliableTrDimensions() && nodeName( elem, "tr" ) || + + // Fall back to offsetWidth/offsetHeight when value is "auto" + // This happens for inline elements with no explicit setting (gh-3571) + val === "auto" || + + // Support: Android <=4.1 - 4.3 only + // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) + !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && + + // Make sure the element is visible & connected + elem.getClientRects().length ) { + + isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; + + // Where available, offsetWidth/offsetHeight approximate border box dimensions. + // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the + // retrieved value as a content box dimension. + valueIsBorderBox = offsetProp in elem; + if ( valueIsBorderBox ) { + val = elem[ offsetProp ]; + } + } + + // Normalize "" and auto + val = parseFloat( val ) || 0; + + // Adjust for the element's box model + return ( val + + boxModelAdjustment( + elem, + dimension, + extra || ( isBorderBox ? "border" : "content" ), + valueIsBorderBox, + styles, + + // Provide the current computed size to request scroll gutter calculation (gh-3589) + val + ) + ) + "px"; + } + + jQuery.extend( { + + // Add in style property hooks for overriding the default + // behavior of getting and setting a style property + cssHooks: { + opacity: { + get: function( elem, computed ) { + if ( computed ) { + + // We should always get a number back from opacity + var ret = curCSS( elem, "opacity" ); + return ret === "" ? "1" : ret; + } + } + } + }, + + // Don't automatically add "px" to these possibly-unitless properties + cssNumber: { + animationIterationCount: true, + aspectRatio: true, + borderImageSlice: true, + columnCount: true, + flexGrow: true, + flexShrink: true, + fontWeight: true, + gridArea: true, + gridColumn: true, + gridColumnEnd: true, + gridColumnStart: true, + gridRow: true, + gridRowEnd: true, + gridRowStart: true, + lineHeight: true, + opacity: true, + order: true, + orphans: true, + scale: true, + widows: true, + zIndex: true, + zoom: true, + + // SVG-related + fillOpacity: true, + floodOpacity: true, + stopOpacity: true, + strokeMiterlimit: true, + strokeOpacity: true + }, + + // Add in properties whose names you wish to fix before + // setting or getting the value + cssProps: {}, + + // Get and set the style property on a DOM Node + style: function( elem, name, value, extra ) { + + // Don't set styles on text and comment nodes + if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { + return; + } + + // Make sure that we're working with the right name + var ret, type, hooks, + origName = camelCase( name ), + isCustomProp = rcustomProp.test( name ), + style = elem.style; + + // Make sure that we're working with the right name. We don't + // want to query the value if it is a CSS custom property + // since they are user-defined. + if ( !isCustomProp ) { + name = finalPropName( origName ); + } + + // Gets hook for the prefixed version, then unprefixed version + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // Check if we're setting a value + if ( value !== undefined ) { + type = typeof value; + + // Convert "+=" or "-=" to relative numbers (trac-7345) + if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { + value = adjustCSS( elem, name, ret ); + + // Fixes bug trac-9237 + type = "number"; + } + + // Make sure that null and NaN values aren't set (trac-7116) + if ( value == null || value !== value ) { + return; + } + + // If a number was passed in, add the unit (except for certain CSS properties) + // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append + // "px" to a few hardcoded values. + if ( type === "number" && !isCustomProp ) { + value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); + } + + // background-* props affect original clone's values + if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { + style[ name ] = "inherit"; + } + + // If a hook was provided, use that value, otherwise just set the specified value + if ( !hooks || !( "set" in hooks ) || + ( value = hooks.set( elem, value, extra ) ) !== undefined ) { + + if ( isCustomProp ) { + style.setProperty( name, value ); + } else { + style[ name ] = value; + } + } + + } else { + + // If a hook was provided get the non-computed value from there + if ( hooks && "get" in hooks && + ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { + + return ret; + } + + // Otherwise just get the value from the style object + return style[ name ]; + } + }, + + css: function( elem, name, extra, styles ) { + var val, num, hooks, + origName = camelCase( name ), + isCustomProp = rcustomProp.test( name ); + + // Make sure that we're working with the right name. We don't + // want to modify the value if it is a CSS custom property + // since they are user-defined. + if ( !isCustomProp ) { + name = finalPropName( origName ); + } + + // Try prefixed name followed by the unprefixed name + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // If a hook was provided get the computed value from there + if ( hooks && "get" in hooks ) { + val = hooks.get( elem, true, extra ); + } + + // Otherwise, if a way to get the computed value exists, use that + if ( val === undefined ) { + val = curCSS( elem, name, styles ); + } + + // Convert "normal" to computed value + if ( val === "normal" && name in cssNormalTransform ) { + val = cssNormalTransform[ name ]; + } + + // Make numeric if forced or a qualifier was provided and val looks numeric + if ( extra === "" || extra ) { + num = parseFloat( val ); + return extra === true || isFinite( num ) ? num || 0 : val; + } + + return val; + } + } ); + + jQuery.each( [ "height", "width" ], function( _i, dimension ) { + jQuery.cssHooks[ dimension ] = { + get: function( elem, computed, extra ) { + if ( computed ) { + + // Certain elements can have dimension info if we invisibly show them + // but it must have a current display style that would benefit + return rdisplayswap.test( jQuery.css( elem, "display" ) ) && + + // Support: Safari 8+ + // Table columns in Safari have non-zero offsetWidth & zero + // getBoundingClientRect().width unless display is changed. + // Support: IE <=11 only + // Running getBoundingClientRect on a disconnected node + // in IE throws an error. + ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? + swap( elem, cssShow, function() { + return getWidthOrHeight( elem, dimension, extra ); + } ) : + getWidthOrHeight( elem, dimension, extra ); + } + }, + + set: function( elem, value, extra ) { + var matches, + styles = getStyles( elem ), + + // Only read styles.position if the test has a chance to fail + // to avoid forcing a reflow. + scrollboxSizeBuggy = !support.scrollboxSize() && + styles.position === "absolute", + + // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) + boxSizingNeeded = scrollboxSizeBuggy || extra, + isBorderBox = boxSizingNeeded && + jQuery.css( elem, "boxSizing", false, styles ) === "border-box", + subtract = extra ? + boxModelAdjustment( + elem, + dimension, + extra, + isBorderBox, + styles + ) : + 0; + + // Account for unreliable border-box dimensions by comparing offset* to computed and + // faking a content-box to get border and padding (gh-3699) + if ( isBorderBox && scrollboxSizeBuggy ) { + subtract -= Math.ceil( + elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - + parseFloat( styles[ dimension ] ) - + boxModelAdjustment( elem, dimension, "border", false, styles ) - + 0.5 + ); + } + + // Convert to pixels if value adjustment is needed + if ( subtract && ( matches = rcssNum.exec( value ) ) && + ( matches[ 3 ] || "px" ) !== "px" ) { + + elem.style[ dimension ] = value; + value = jQuery.css( elem, dimension ); + } + + return setPositiveNumber( elem, value, subtract ); + } + }; + } ); + + jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, + function( elem, computed ) { + if ( computed ) { + return ( parseFloat( curCSS( elem, "marginLeft" ) ) || + elem.getBoundingClientRect().left - + swap( elem, { marginLeft: 0 }, function() { + return elem.getBoundingClientRect().left; + } ) + ) + "px"; + } + } + ); + + // These hooks are used by animate to expand properties + jQuery.each( { + margin: "", + padding: "", + border: "Width" + }, function( prefix, suffix ) { + jQuery.cssHooks[ prefix + suffix ] = { + expand: function( value ) { + var i = 0, + expanded = {}, + + // Assumes a single number if not a string + parts = typeof value === "string" ? value.split( " " ) : [ value ]; + + for ( ; i < 4; i++ ) { + expanded[ prefix + cssExpand[ i ] + suffix ] = + parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; + } + + return expanded; + } + }; + + if ( prefix !== "margin" ) { + jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; + } + } ); + + jQuery.fn.extend( { + css: function( name, value ) { + return access( this, function( elem, name, value ) { + var styles, len, + map = {}, + i = 0; + + if ( Array.isArray( name ) ) { + styles = getStyles( elem ); + len = name.length; + + for ( ; i < len; i++ ) { + map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); + } + + return map; + } + + return value !== undefined ? + jQuery.style( elem, name, value ) : + jQuery.css( elem, name ); + }, name, value, arguments.length > 1 ); + } + } ); + + + function Tween( elem, options, prop, end, easing ) { + return new Tween.prototype.init( elem, options, prop, end, easing ); + } + jQuery.Tween = Tween; + + Tween.prototype = { + constructor: Tween, + init: function( elem, options, prop, end, easing, unit ) { + this.elem = elem; + this.prop = prop; + this.easing = easing || jQuery.easing._default; + this.options = options; + this.start = this.now = this.cur(); + this.end = end; + this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); + }, + cur: function() { + var hooks = Tween.propHooks[ this.prop ]; + + return hooks && hooks.get ? + hooks.get( this ) : + Tween.propHooks._default.get( this ); + }, + run: function( percent ) { + var eased, + hooks = Tween.propHooks[ this.prop ]; + + if ( this.options.duration ) { + this.pos = eased = jQuery.easing[ this.easing ]( + percent, this.options.duration * percent, 0, 1, this.options.duration + ); + } else { + this.pos = eased = percent; + } + this.now = ( this.end - this.start ) * eased + this.start; + + if ( this.options.step ) { + this.options.step.call( this.elem, this.now, this ); + } + + if ( hooks && hooks.set ) { + hooks.set( this ); + } else { + Tween.propHooks._default.set( this ); + } + return this; + } + }; + + Tween.prototype.init.prototype = Tween.prototype; + + Tween.propHooks = { + _default: { + get: function( tween ) { + var result; + + // Use a property on the element directly when it is not a DOM element, + // or when there is no matching style property that exists. + if ( tween.elem.nodeType !== 1 || + tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { + return tween.elem[ tween.prop ]; + } + + // Passing an empty string as a 3rd parameter to .css will automatically + // attempt a parseFloat and fallback to a string if the parse fails. + // Simple values such as "10px" are parsed to Float; + // complex values such as "rotate(1rad)" are returned as-is. + result = jQuery.css( tween.elem, tween.prop, "" ); + + // Empty strings, null, undefined and "auto" are converted to 0. + return !result || result === "auto" ? 0 : result; + }, + set: function( tween ) { + + // Use step hook for back compat. + // Use cssHook if its there. + // Use .style if available and use plain properties where available. + if ( jQuery.fx.step[ tween.prop ] ) { + jQuery.fx.step[ tween.prop ]( tween ); + } else if ( tween.elem.nodeType === 1 && ( + jQuery.cssHooks[ tween.prop ] || + tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { + jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); + } else { + tween.elem[ tween.prop ] = tween.now; + } + } + } + }; + + // Support: IE <=9 only + // Panic based approach to setting things on disconnected nodes + Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { + set: function( tween ) { + if ( tween.elem.nodeType && tween.elem.parentNode ) { + tween.elem[ tween.prop ] = tween.now; + } + } + }; + + jQuery.easing = { + linear: function( p ) { + return p; + }, + swing: function( p ) { + return 0.5 - Math.cos( p * Math.PI ) / 2; + }, + _default: "swing" + }; + + jQuery.fx = Tween.prototype.init; + + // Back compat <1.8 extension point + jQuery.fx.step = {}; + + + + + var + fxNow, inProgress, + rfxtypes = /^(?:toggle|show|hide)$/, + rrun = /queueHooks$/; + + function schedule() { + if ( inProgress ) { + if ( document.hidden === false && window.requestAnimationFrame ) { + window.requestAnimationFrame( schedule ); + } else { + window.setTimeout( schedule, jQuery.fx.interval ); + } + + jQuery.fx.tick(); + } + } + + // Animations created synchronously will run synchronously + function createFxNow() { + window.setTimeout( function() { + fxNow = undefined; + } ); + return ( fxNow = Date.now() ); + } + + // Generate parameters to create a standard animation + function genFx( type, includeWidth ) { + var which, + i = 0, + attrs = { height: type }; + + // If we include width, step value is 1 to do all cssExpand values, + // otherwise step value is 2 to skip over Left and Right + includeWidth = includeWidth ? 1 : 0; + for ( ; i < 4; i += 2 - includeWidth ) { + which = cssExpand[ i ]; + attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; + } + + if ( includeWidth ) { + attrs.opacity = attrs.width = type; + } + + return attrs; + } + + function createTween( value, prop, animation ) { + var tween, + collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), + index = 0, + length = collection.length; + for ( ; index < length; index++ ) { + if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { + + // We're done with this property + return tween; + } + } + } + + function defaultPrefilter( elem, props, opts ) { + var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, + isBox = "width" in props || "height" in props, + anim = this, + orig = {}, + style = elem.style, + hidden = elem.nodeType && isHiddenWithinTree( elem ), + dataShow = dataPriv.get( elem, "fxshow" ); + + // Queue-skipping animations hijack the fx hooks + if ( !opts.queue ) { + hooks = jQuery._queueHooks( elem, "fx" ); + if ( hooks.unqueued == null ) { + hooks.unqueued = 0; + oldfire = hooks.empty.fire; + hooks.empty.fire = function() { + if ( !hooks.unqueued ) { + oldfire(); + } + }; + } + hooks.unqueued++; + + anim.always( function() { + + // Ensure the complete handler is called before this completes + anim.always( function() { + hooks.unqueued--; + if ( !jQuery.queue( elem, "fx" ).length ) { + hooks.empty.fire(); + } + } ); + } ); + } + + // Detect show/hide animations + for ( prop in props ) { + value = props[ prop ]; + if ( rfxtypes.test( value ) ) { + delete props[ prop ]; + toggle = toggle || value === "toggle"; + if ( value === ( hidden ? "hide" : "show" ) ) { + + // Pretend to be hidden if this is a "show" and + // there is still data from a stopped show/hide + if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { + hidden = true; + + // Ignore all other no-op show/hide data + } else { + continue; + } + } + orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); + } + } + + // Bail out if this is a no-op like .hide().hide() + propTween = !jQuery.isEmptyObject( props ); + if ( !propTween && jQuery.isEmptyObject( orig ) ) { + return; + } + + // Restrict "overflow" and "display" styles during box animations + if ( isBox && elem.nodeType === 1 ) { + + // Support: IE <=9 - 11, Edge 12 - 15 + // Record all 3 overflow attributes because IE does not infer the shorthand + // from identically-valued overflowX and overflowY and Edge just mirrors + // the overflowX value there. + opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; + + // Identify a display type, preferring old show/hide data over the CSS cascade + restoreDisplay = dataShow && dataShow.display; + if ( restoreDisplay == null ) { + restoreDisplay = dataPriv.get( elem, "display" ); + } + display = jQuery.css( elem, "display" ); + if ( display === "none" ) { + if ( restoreDisplay ) { + display = restoreDisplay; + } else { + + // Get nonempty value(s) by temporarily forcing visibility + showHide( [ elem ], true ); + restoreDisplay = elem.style.display || restoreDisplay; + display = jQuery.css( elem, "display" ); + showHide( [ elem ] ); + } + } + + // Animate inline elements as inline-block + if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { + if ( jQuery.css( elem, "float" ) === "none" ) { + + // Restore the original display value at the end of pure show/hide animations + if ( !propTween ) { + anim.done( function() { + style.display = restoreDisplay; + } ); + if ( restoreDisplay == null ) { + display = style.display; + restoreDisplay = display === "none" ? "" : display; + } + } + style.display = "inline-block"; + } + } + } + + if ( opts.overflow ) { + style.overflow = "hidden"; + anim.always( function() { + style.overflow = opts.overflow[ 0 ]; + style.overflowX = opts.overflow[ 1 ]; + style.overflowY = opts.overflow[ 2 ]; + } ); + } + + // Implement show/hide animations + propTween = false; + for ( prop in orig ) { + + // General show/hide setup for this element animation + if ( !propTween ) { + if ( dataShow ) { + if ( "hidden" in dataShow ) { + hidden = dataShow.hidden; + } + } else { + dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); + } + + // Store hidden/visible for toggle so `.stop().toggle()` "reverses" + if ( toggle ) { + dataShow.hidden = !hidden; + } + + // Show elements before animating them + if ( hidden ) { + showHide( [ elem ], true ); + } + + /* eslint-disable no-loop-func */ + + anim.done( function() { + + /* eslint-enable no-loop-func */ + + // The final step of a "hide" animation is actually hiding the element + if ( !hidden ) { + showHide( [ elem ] ); + } + dataPriv.remove( elem, "fxshow" ); + for ( prop in orig ) { + jQuery.style( elem, prop, orig[ prop ] ); + } + } ); + } + + // Per-property setup + propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); + if ( !( prop in dataShow ) ) { + dataShow[ prop ] = propTween.start; + if ( hidden ) { + propTween.end = propTween.start; + propTween.start = 0; + } + } + } + } + + function propFilter( props, specialEasing ) { + var index, name, easing, value, hooks; + + // camelCase, specialEasing and expand cssHook pass + for ( index in props ) { + name = camelCase( index ); + easing = specialEasing[ name ]; + value = props[ index ]; + if ( Array.isArray( value ) ) { + easing = value[ 1 ]; + value = props[ index ] = value[ 0 ]; + } + + if ( index !== name ) { + props[ name ] = value; + delete props[ index ]; + } + + hooks = jQuery.cssHooks[ name ]; + if ( hooks && "expand" in hooks ) { + value = hooks.expand( value ); + delete props[ name ]; + + // Not quite $.extend, this won't overwrite existing keys. + // Reusing 'index' because we have the correct "name" + for ( index in value ) { + if ( !( index in props ) ) { + props[ index ] = value[ index ]; + specialEasing[ index ] = easing; + } + } + } else { + specialEasing[ name ] = easing; + } + } + } + + function Animation( elem, properties, options ) { + var result, + stopped, + index = 0, + length = Animation.prefilters.length, + deferred = jQuery.Deferred().always( function() { + + // Don't match elem in the :animated selector + delete tick.elem; + } ), + tick = function() { + if ( stopped ) { + return false; + } + var currentTime = fxNow || createFxNow(), + remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), + + // Support: Android 2.3 only + // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497) + temp = remaining / animation.duration || 0, + percent = 1 - temp, + index = 0, + length = animation.tweens.length; + + for ( ; index < length; index++ ) { + animation.tweens[ index ].run( percent ); + } + + deferred.notifyWith( elem, [ animation, percent, remaining ] ); + + // If there's more to do, yield + if ( percent < 1 && length ) { + return remaining; + } + + // If this was an empty animation, synthesize a final progress notification + if ( !length ) { + deferred.notifyWith( elem, [ animation, 1, 0 ] ); + } + + // Resolve the animation and report its conclusion + deferred.resolveWith( elem, [ animation ] ); + return false; + }, + animation = deferred.promise( { + elem: elem, + props: jQuery.extend( {}, properties ), + opts: jQuery.extend( true, { + specialEasing: {}, + easing: jQuery.easing._default + }, options ), + originalProperties: properties, + originalOptions: options, + startTime: fxNow || createFxNow(), + duration: options.duration, + tweens: [], + createTween: function( prop, end ) { + var tween = jQuery.Tween( elem, animation.opts, prop, end, + animation.opts.specialEasing[ prop ] || animation.opts.easing ); + animation.tweens.push( tween ); + return tween; + }, + stop: function( gotoEnd ) { + var index = 0, + + // If we are going to the end, we want to run all the tweens + // otherwise we skip this part + length = gotoEnd ? animation.tweens.length : 0; + if ( stopped ) { + return this; + } + stopped = true; + for ( ; index < length; index++ ) { + animation.tweens[ index ].run( 1 ); + } + + // Resolve when we played the last frame; otherwise, reject + if ( gotoEnd ) { + deferred.notifyWith( elem, [ animation, 1, 0 ] ); + deferred.resolveWith( elem, [ animation, gotoEnd ] ); + } else { + deferred.rejectWith( elem, [ animation, gotoEnd ] ); + } + return this; + } + } ), + props = animation.props; + + propFilter( props, animation.opts.specialEasing ); + + for ( ; index < length; index++ ) { + result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); + if ( result ) { + if ( isFunction( result.stop ) ) { + jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = + result.stop.bind( result ); + } + return result; + } + } + + jQuery.map( props, createTween, animation ); + + if ( isFunction( animation.opts.start ) ) { + animation.opts.start.call( elem, animation ); + } + + // Attach callbacks from options + animation + .progress( animation.opts.progress ) + .done( animation.opts.done, animation.opts.complete ) + .fail( animation.opts.fail ) + .always( animation.opts.always ); + + jQuery.fx.timer( + jQuery.extend( tick, { + elem: elem, + anim: animation, + queue: animation.opts.queue + } ) + ); + + return animation; + } + + jQuery.Animation = jQuery.extend( Animation, { + + tweeners: { + "*": [ function( prop, value ) { + var tween = this.createTween( prop, value ); + adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); + return tween; + } ] + }, + + tweener: function( props, callback ) { + if ( isFunction( props ) ) { + callback = props; + props = [ "*" ]; + } else { + props = props.match( rnothtmlwhite ); + } + + var prop, + index = 0, + length = props.length; + + for ( ; index < length; index++ ) { + prop = props[ index ]; + Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; + Animation.tweeners[ prop ].unshift( callback ); + } + }, + + prefilters: [ defaultPrefilter ], + + prefilter: function( callback, prepend ) { + if ( prepend ) { + Animation.prefilters.unshift( callback ); + } else { + Animation.prefilters.push( callback ); + } + } + } ); + + jQuery.speed = function( speed, easing, fn ) { + var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { + complete: fn || !fn && easing || + isFunction( speed ) && speed, + duration: speed, + easing: fn && easing || easing && !isFunction( easing ) && easing + }; + + // Go to the end state if fx are off + if ( jQuery.fx.off ) { + opt.duration = 0; + + } else { + if ( typeof opt.duration !== "number" ) { + if ( opt.duration in jQuery.fx.speeds ) { + opt.duration = jQuery.fx.speeds[ opt.duration ]; + + } else { + opt.duration = jQuery.fx.speeds._default; + } + } + } + + // Normalize opt.queue - true/undefined/null -> "fx" + if ( opt.queue == null || opt.queue === true ) { + opt.queue = "fx"; + } + + // Queueing + opt.old = opt.complete; + + opt.complete = function() { + if ( isFunction( opt.old ) ) { + opt.old.call( this ); + } + + if ( opt.queue ) { + jQuery.dequeue( this, opt.queue ); + } + }; + + return opt; + }; + + jQuery.fn.extend( { + fadeTo: function( speed, to, easing, callback ) { + + // Show any hidden elements after setting opacity to 0 + return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() + + // Animate to the value specified + .end().animate( { opacity: to }, speed, easing, callback ); + }, + animate: function( prop, speed, easing, callback ) { + var empty = jQuery.isEmptyObject( prop ), + optall = jQuery.speed( speed, easing, callback ), + doAnimation = function() { + + // Operate on a copy of prop so per-property easing won't be lost + var anim = Animation( this, jQuery.extend( {}, prop ), optall ); + + // Empty animations, or finishing resolves immediately + if ( empty || dataPriv.get( this, "finish" ) ) { + anim.stop( true ); + } + }; + + doAnimation.finish = doAnimation; + + return empty || optall.queue === false ? + this.each( doAnimation ) : + this.queue( optall.queue, doAnimation ); + }, + stop: function( type, clearQueue, gotoEnd ) { + var stopQueue = function( hooks ) { + var stop = hooks.stop; + delete hooks.stop; + stop( gotoEnd ); + }; + + if ( typeof type !== "string" ) { + gotoEnd = clearQueue; + clearQueue = type; + type = undefined; + } + if ( clearQueue ) { + this.queue( type || "fx", [] ); + } + + return this.each( function() { + var dequeue = true, + index = type != null && type + "queueHooks", + timers = jQuery.timers, + data = dataPriv.get( this ); + + if ( index ) { + if ( data[ index ] && data[ index ].stop ) { + stopQueue( data[ index ] ); + } + } else { + for ( index in data ) { + if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { + stopQueue( data[ index ] ); + } + } + } + + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && + ( type == null || timers[ index ].queue === type ) ) { + + timers[ index ].anim.stop( gotoEnd ); + dequeue = false; + timers.splice( index, 1 ); + } + } + + // Start the next in the queue if the last step wasn't forced. + // Timers currently will call their complete callbacks, which + // will dequeue but only if they were gotoEnd. + if ( dequeue || !gotoEnd ) { + jQuery.dequeue( this, type ); + } + } ); + }, + finish: function( type ) { + if ( type !== false ) { + type = type || "fx"; + } + return this.each( function() { + var index, + data = dataPriv.get( this ), + queue = data[ type + "queue" ], + hooks = data[ type + "queueHooks" ], + timers = jQuery.timers, + length = queue ? queue.length : 0; + + // Enable finishing flag on private data + data.finish = true; + + // Empty the queue first + jQuery.queue( this, type, [] ); + + if ( hooks && hooks.stop ) { + hooks.stop.call( this, true ); + } + + // Look for any active animations, and finish them + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && timers[ index ].queue === type ) { + timers[ index ].anim.stop( true ); + timers.splice( index, 1 ); + } + } + + // Look for any animations in the old queue and finish them + for ( index = 0; index < length; index++ ) { + if ( queue[ index ] && queue[ index ].finish ) { + queue[ index ].finish.call( this ); + } + } + + // Turn off finishing flag + delete data.finish; + } ); + } + } ); + + jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) { + var cssFn = jQuery.fn[ name ]; + jQuery.fn[ name ] = function( speed, easing, callback ) { + return speed == null || typeof speed === "boolean" ? + cssFn.apply( this, arguments ) : + this.animate( genFx( name, true ), speed, easing, callback ); + }; + } ); + + // Generate shortcuts for custom animations + jQuery.each( { + slideDown: genFx( "show" ), + slideUp: genFx( "hide" ), + slideToggle: genFx( "toggle" ), + fadeIn: { opacity: "show" }, + fadeOut: { opacity: "hide" }, + fadeToggle: { opacity: "toggle" } + }, function( name, props ) { + jQuery.fn[ name ] = function( speed, easing, callback ) { + return this.animate( props, speed, easing, callback ); + }; + } ); + + jQuery.timers = []; + jQuery.fx.tick = function() { + var timer, + i = 0, + timers = jQuery.timers; + + fxNow = Date.now(); + + for ( ; i < timers.length; i++ ) { + timer = timers[ i ]; + + // Run the timer and safely remove it when done (allowing for external removal) + if ( !timer() && timers[ i ] === timer ) { + timers.splice( i--, 1 ); + } + } + + if ( !timers.length ) { + jQuery.fx.stop(); + } + fxNow = undefined; + }; + + jQuery.fx.timer = function( timer ) { + jQuery.timers.push( timer ); + jQuery.fx.start(); + }; + + jQuery.fx.interval = 13; + jQuery.fx.start = function() { + if ( inProgress ) { + return; + } + + inProgress = true; + schedule(); + }; + + jQuery.fx.stop = function() { + inProgress = null; + }; + + jQuery.fx.speeds = { + slow: 600, + fast: 200, + + // Default speed + _default: 400 + }; + + + // Based off of the plugin by Clint Helfers, with permission. + jQuery.fn.delay = function( time, type ) { + time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; + type = type || "fx"; + + return this.queue( type, function( next, hooks ) { + var timeout = window.setTimeout( next, time ); + hooks.stop = function() { + window.clearTimeout( timeout ); + }; + } ); + }; + + + ( function() { + var input = document.createElement( "input" ), + select = document.createElement( "select" ), + opt = select.appendChild( document.createElement( "option" ) ); + + input.type = "checkbox"; + + // Support: Android <=4.3 only + // Default value for a checkbox should be "on" + support.checkOn = input.value !== ""; + + // Support: IE <=11 only + // Must access selectedIndex to make default options select + support.optSelected = opt.selected; + + // Support: IE <=11 only + // An input loses its value after becoming a radio + input = document.createElement( "input" ); + input.value = "t"; + input.type = "radio"; + support.radioValue = input.value === "t"; + } )(); + + + var boolHook, + attrHandle = jQuery.expr.attrHandle; + + jQuery.fn.extend( { + attr: function( name, value ) { + return access( this, jQuery.attr, name, value, arguments.length > 1 ); + }, + + removeAttr: function( name ) { + return this.each( function() { + jQuery.removeAttr( this, name ); + } ); + } + } ); + + jQuery.extend( { + attr: function( elem, name, value ) { + var ret, hooks, + nType = elem.nodeType; + + // Don't get/set attributes on text, comment and attribute nodes + if ( nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + // Fallback to prop when attributes are not supported + if ( typeof elem.getAttribute === "undefined" ) { + return jQuery.prop( elem, name, value ); + } + + // Attribute hooks are determined by the lowercase version + // Grab necessary hook if one is defined + if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { + hooks = jQuery.attrHooks[ name.toLowerCase() ] || + ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); + } + + if ( value !== undefined ) { + if ( value === null ) { + jQuery.removeAttr( elem, name ); + return; + } + + if ( hooks && "set" in hooks && + ( ret = hooks.set( elem, value, name ) ) !== undefined ) { + return ret; + } + + elem.setAttribute( name, value + "" ); + return value; + } + + if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { + return ret; + } + + ret = jQuery.find.attr( elem, name ); + + // Non-existent attributes return null, we normalize to undefined + return ret == null ? undefined : ret; + }, + + attrHooks: { + type: { + set: function( elem, value ) { + if ( !support.radioValue && value === "radio" && + nodeName( elem, "input" ) ) { + var val = elem.value; + elem.setAttribute( "type", value ); + if ( val ) { + elem.value = val; + } + return value; + } + } + } + }, + + removeAttr: function( elem, value ) { + var name, + i = 0, + + // Attribute names can contain non-HTML whitespace characters + // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 + attrNames = value && value.match( rnothtmlwhite ); + + if ( attrNames && elem.nodeType === 1 ) { + while ( ( name = attrNames[ i++ ] ) ) { + elem.removeAttribute( name ); + } + } + } + } ); + + // Hooks for boolean attributes + boolHook = { + set: function( elem, value, name ) { + if ( value === false ) { + + // Remove boolean attributes when set to false + jQuery.removeAttr( elem, name ); + } else { + elem.setAttribute( name, name ); + } + return name; + } + }; + + jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) { + var getter = attrHandle[ name ] || jQuery.find.attr; + + attrHandle[ name ] = function( elem, name, isXML ) { + var ret, handle, + lowercaseName = name.toLowerCase(); + + if ( !isXML ) { + + // Avoid an infinite loop by temporarily removing this function from the getter + handle = attrHandle[ lowercaseName ]; + attrHandle[ lowercaseName ] = ret; + ret = getter( elem, name, isXML ) != null ? + lowercaseName : + null; + attrHandle[ lowercaseName ] = handle; + } + return ret; + }; + } ); + + + + + var rfocusable = /^(?:input|select|textarea|button)$/i, + rclickable = /^(?:a|area)$/i; + + jQuery.fn.extend( { + prop: function( name, value ) { + return access( this, jQuery.prop, name, value, arguments.length > 1 ); + }, + + removeProp: function( name ) { + return this.each( function() { + delete this[ jQuery.propFix[ name ] || name ]; + } ); + } + } ); + + jQuery.extend( { + prop: function( elem, name, value ) { + var ret, hooks, + nType = elem.nodeType; + + // Don't get/set properties on text, comment and attribute nodes + if ( nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { + + // Fix name and attach hooks + name = jQuery.propFix[ name ] || name; + hooks = jQuery.propHooks[ name ]; + } + + if ( value !== undefined ) { + if ( hooks && "set" in hooks && + ( ret = hooks.set( elem, value, name ) ) !== undefined ) { + return ret; + } + + return ( elem[ name ] = value ); + } + + if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { + return ret; + } + + return elem[ name ]; + }, + + propHooks: { + tabIndex: { + get: function( elem ) { + + // Support: IE <=9 - 11 only + // elem.tabIndex doesn't always return the + // correct value when it hasn't been explicitly set + // Use proper attribute retrieval (trac-12072) + var tabindex = jQuery.find.attr( elem, "tabindex" ); + + if ( tabindex ) { + return parseInt( tabindex, 10 ); + } + + if ( + rfocusable.test( elem.nodeName ) || + rclickable.test( elem.nodeName ) && + elem.href + ) { + return 0; + } + + return -1; + } + } + }, + + propFix: { + "for": "htmlFor", + "class": "className" + } + } ); + + // Support: IE <=11 only + // Accessing the selectedIndex property + // forces the browser to respect setting selected + // on the option + // The getter ensures a default option is selected + // when in an optgroup + // eslint rule "no-unused-expressions" is disabled for this code + // since it considers such accessions noop + if ( !support.optSelected ) { + jQuery.propHooks.selected = { + get: function( elem ) { + + /* eslint no-unused-expressions: "off" */ + + var parent = elem.parentNode; + if ( parent && parent.parentNode ) { + parent.parentNode.selectedIndex; + } + return null; + }, + set: function( elem ) { + + /* eslint no-unused-expressions: "off" */ + + var parent = elem.parentNode; + if ( parent ) { + parent.selectedIndex; + + if ( parent.parentNode ) { + parent.parentNode.selectedIndex; + } + } + } + }; + } + + jQuery.each( [ + "tabIndex", + "readOnly", + "maxLength", + "cellSpacing", + "cellPadding", + "rowSpan", + "colSpan", + "useMap", + "frameBorder", + "contentEditable" + ], function() { + jQuery.propFix[ this.toLowerCase() ] = this; + } ); + + + + + // Strip and collapse whitespace according to HTML spec + // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace + function stripAndCollapse( value ) { + var tokens = value.match( rnothtmlwhite ) || []; + return tokens.join( " " ); + } + + + function getClass( elem ) { + return elem.getAttribute && elem.getAttribute( "class" ) || ""; + } + + function classesToArray( value ) { + if ( Array.isArray( value ) ) { + return value; + } + if ( typeof value === "string" ) { + return value.match( rnothtmlwhite ) || []; + } + return []; + } + + jQuery.fn.extend( { + addClass: function( value ) { + var classNames, cur, curValue, className, i, finalValue; + + if ( isFunction( value ) ) { + return this.each( function( j ) { + jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); + } ); + } + + classNames = classesToArray( value ); + + if ( classNames.length ) { + return this.each( function() { + curValue = getClass( this ); + cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); + + if ( cur ) { + for ( i = 0; i < classNames.length; i++ ) { + className = classNames[ i ]; + if ( cur.indexOf( " " + className + " " ) < 0 ) { + cur += className + " "; + } + } + + // Only assign if different to avoid unneeded rendering. + finalValue = stripAndCollapse( cur ); + if ( curValue !== finalValue ) { + this.setAttribute( "class", finalValue ); + } + } + } ); + } + + return this; + }, + + removeClass: function( value ) { + var classNames, cur, curValue, className, i, finalValue; + + if ( isFunction( value ) ) { + return this.each( function( j ) { + jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); + } ); + } + + if ( !arguments.length ) { + return this.attr( "class", "" ); + } + + classNames = classesToArray( value ); + + if ( classNames.length ) { + return this.each( function() { + curValue = getClass( this ); + + // This expression is here for better compressibility (see addClass) + cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); + + if ( cur ) { + for ( i = 0; i < classNames.length; i++ ) { + className = classNames[ i ]; + + // Remove *all* instances + while ( cur.indexOf( " " + className + " " ) > -1 ) { + cur = cur.replace( " " + className + " ", " " ); + } + } + + // Only assign if different to avoid unneeded rendering. + finalValue = stripAndCollapse( cur ); + if ( curValue !== finalValue ) { + this.setAttribute( "class", finalValue ); + } + } + } ); + } + + return this; + }, + + toggleClass: function( value, stateVal ) { + var classNames, className, i, self, + type = typeof value, + isValidValue = type === "string" || Array.isArray( value ); + + if ( isFunction( value ) ) { + return this.each( function( i ) { + jQuery( this ).toggleClass( + value.call( this, i, getClass( this ), stateVal ), + stateVal + ); + } ); + } + + if ( typeof stateVal === "boolean" && isValidValue ) { + return stateVal ? this.addClass( value ) : this.removeClass( value ); + } + + classNames = classesToArray( value ); + + return this.each( function() { + if ( isValidValue ) { + + // Toggle individual class names + self = jQuery( this ); + + for ( i = 0; i < classNames.length; i++ ) { + className = classNames[ i ]; + + // Check each className given, space separated list + if ( self.hasClass( className ) ) { + self.removeClass( className ); + } else { + self.addClass( className ); + } + } + + // Toggle whole class name + } else if ( value === undefined || type === "boolean" ) { + className = getClass( this ); + if ( className ) { + + // Store className if set + dataPriv.set( this, "__className__", className ); + } + + // If the element has a class name or if we're passed `false`, + // then remove the whole classname (if there was one, the above saved it). + // Otherwise bring back whatever was previously saved (if anything), + // falling back to the empty string if nothing was stored. + if ( this.setAttribute ) { + this.setAttribute( "class", + className || value === false ? + "" : + dataPriv.get( this, "__className__" ) || "" + ); + } + } + } ); + }, + + hasClass: function( selector ) { + var className, elem, + i = 0; + + className = " " + selector + " "; + while ( ( elem = this[ i++ ] ) ) { + if ( elem.nodeType === 1 && + ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { + return true; + } + } + + return false; + } + } ); + + + + + var rreturn = /\r/g; + + jQuery.fn.extend( { + val: function( value ) { + var hooks, ret, valueIsFunction, + elem = this[ 0 ]; + + if ( !arguments.length ) { + if ( elem ) { + hooks = jQuery.valHooks[ elem.type ] || + jQuery.valHooks[ elem.nodeName.toLowerCase() ]; + + if ( hooks && + "get" in hooks && + ( ret = hooks.get( elem, "value" ) ) !== undefined + ) { + return ret; + } + + ret = elem.value; + + // Handle most common string cases + if ( typeof ret === "string" ) { + return ret.replace( rreturn, "" ); + } + + // Handle cases where value is null/undef or number + return ret == null ? "" : ret; + } + + return; + } + + valueIsFunction = isFunction( value ); + + return this.each( function( i ) { + var val; + + if ( this.nodeType !== 1 ) { + return; + } + + if ( valueIsFunction ) { + val = value.call( this, i, jQuery( this ).val() ); + } else { + val = value; + } + + // Treat null/undefined as ""; convert numbers to string + if ( val == null ) { + val = ""; + + } else if ( typeof val === "number" ) { + val += ""; + + } else if ( Array.isArray( val ) ) { + val = jQuery.map( val, function( value ) { + return value == null ? "" : value + ""; + } ); + } + + hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; + + // If set returns undefined, fall back to normal setting + if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { + this.value = val; + } + } ); + } + } ); + + jQuery.extend( { + valHooks: { + option: { + get: function( elem ) { + + var val = jQuery.find.attr( elem, "value" ); + return val != null ? + val : + + // Support: IE <=10 - 11 only + // option.text throws exceptions (trac-14686, trac-14858) + // Strip and collapse whitespace + // https://html.spec.whatwg.org/#strip-and-collapse-whitespace + stripAndCollapse( jQuery.text( elem ) ); + } + }, + select: { + get: function( elem ) { + var value, option, i, + options = elem.options, + index = elem.selectedIndex, + one = elem.type === "select-one", + values = one ? null : [], + max = one ? index + 1 : options.length; + + if ( index < 0 ) { + i = max; + + } else { + i = one ? index : 0; + } + + // Loop through all the selected options + for ( ; i < max; i++ ) { + option = options[ i ]; + + // Support: IE <=9 only + // IE8-9 doesn't update selected after form reset (trac-2551) + if ( ( option.selected || i === index ) && + + // Don't return options that are disabled or in a disabled optgroup + !option.disabled && + ( !option.parentNode.disabled || + !nodeName( option.parentNode, "optgroup" ) ) ) { + + // Get the specific value for the option + value = jQuery( option ).val(); + + // We don't need an array for one selects + if ( one ) { + return value; + } + + // Multi-Selects return an array + values.push( value ); + } + } + + return values; + }, + + set: function( elem, value ) { + var optionSet, option, + options = elem.options, + values = jQuery.makeArray( value ), + i = options.length; + + while ( i-- ) { + option = options[ i ]; + + /* eslint-disable no-cond-assign */ + + if ( option.selected = + jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 + ) { + optionSet = true; + } + + /* eslint-enable no-cond-assign */ + } + + // Force browsers to behave consistently when non-matching value is set + if ( !optionSet ) { + elem.selectedIndex = -1; + } + return values; + } + } + } + } ); + + // Radios and checkboxes getter/setter + jQuery.each( [ "radio", "checkbox" ], function() { + jQuery.valHooks[ this ] = { + set: function( elem, value ) { + if ( Array.isArray( value ) ) { + return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); + } + } + }; + if ( !support.checkOn ) { + jQuery.valHooks[ this ].get = function( elem ) { + return elem.getAttribute( "value" ) === null ? "on" : elem.value; + }; + } + } ); + + + + + // Return jQuery for attributes-only inclusion + var location = window.location; + + var nonce = { guid: Date.now() }; + + var rquery = ( /\?/ ); + + + + // Cross-browser xml parsing + jQuery.parseXML = function( data ) { + var xml, parserErrorElem; + if ( !data || typeof data !== "string" ) { + return null; + } + + // Support: IE 9 - 11 only + // IE throws on parseFromString with invalid input. + try { + xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); + } catch ( e ) {} + + parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ]; + if ( !xml || parserErrorElem ) { + jQuery.error( "Invalid XML: " + ( + parserErrorElem ? + jQuery.map( parserErrorElem.childNodes, function( el ) { + return el.textContent; + } ).join( "\n" ) : + data + ) ); + } + return xml; + }; + + + var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, + stopPropagationCallback = function( e ) { + e.stopPropagation(); + }; + + jQuery.extend( jQuery.event, { + + trigger: function( event, data, elem, onlyHandlers ) { + + var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, + eventPath = [ elem || document ], + type = hasOwn.call( event, "type" ) ? event.type : event, + namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; + + cur = lastElement = tmp = elem = elem || document; + + // Don't do events on text and comment nodes + if ( elem.nodeType === 3 || elem.nodeType === 8 ) { + return; + } + + // focus/blur morphs to focusin/out; ensure we're not firing them right now + if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { + return; + } + + if ( type.indexOf( "." ) > -1 ) { + + // Namespaced trigger; create a regexp to match event type in handle() + namespaces = type.split( "." ); + type = namespaces.shift(); + namespaces.sort(); + } + ontype = type.indexOf( ":" ) < 0 && "on" + type; + + // Caller can pass in a jQuery.Event object, Object, or just an event type string + event = event[ jQuery.expando ] ? + event : + new jQuery.Event( type, typeof event === "object" && event ); + + // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) + event.isTrigger = onlyHandlers ? 2 : 3; + event.namespace = namespaces.join( "." ); + event.rnamespace = event.namespace ? + new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : + null; + + // Clean up the event in case it is being reused + event.result = undefined; + if ( !event.target ) { + event.target = elem; + } + + // Clone any incoming data and prepend the event, creating the handler arg list + data = data == null ? + [ event ] : + jQuery.makeArray( data, [ event ] ); + + // Allow special events to draw outside the lines + special = jQuery.event.special[ type ] || {}; + if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { + return; + } + + // Determine event propagation path in advance, per W3C events spec (trac-9951) + // Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724) + if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { + + bubbleType = special.delegateType || type; + if ( !rfocusMorph.test( bubbleType + type ) ) { + cur = cur.parentNode; + } + for ( ; cur; cur = cur.parentNode ) { + eventPath.push( cur ); + tmp = cur; + } + + // Only add window if we got to document (e.g., not plain obj or detached DOM) + if ( tmp === ( elem.ownerDocument || document ) ) { + eventPath.push( tmp.defaultView || tmp.parentWindow || window ); + } + } + + // Fire handlers on the event path + i = 0; + while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { + lastElement = cur; + event.type = i > 1 ? + bubbleType : + special.bindType || type; + + // jQuery handler + handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] && + dataPriv.get( cur, "handle" ); + if ( handle ) { + handle.apply( cur, data ); + } + + // Native handler + handle = ontype && cur[ ontype ]; + if ( handle && handle.apply && acceptData( cur ) ) { + event.result = handle.apply( cur, data ); + if ( event.result === false ) { + event.preventDefault(); + } + } + } + event.type = type; + + // If nobody prevented the default action, do it now + if ( !onlyHandlers && !event.isDefaultPrevented() ) { + + if ( ( !special._default || + special._default.apply( eventPath.pop(), data ) === false ) && + acceptData( elem ) ) { + + // Call a native DOM method on the target with the same name as the event. + // Don't do default actions on window, that's where global variables be (trac-6170) + if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { + + // Don't re-trigger an onFOO event when we call its FOO() method + tmp = elem[ ontype ]; + + if ( tmp ) { + elem[ ontype ] = null; + } + + // Prevent re-triggering of the same event, since we already bubbled it above + jQuery.event.triggered = type; + + if ( event.isPropagationStopped() ) { + lastElement.addEventListener( type, stopPropagationCallback ); + } + + elem[ type ](); + + if ( event.isPropagationStopped() ) { + lastElement.removeEventListener( type, stopPropagationCallback ); + } + + jQuery.event.triggered = undefined; + + if ( tmp ) { + elem[ ontype ] = tmp; + } + } + } + } + + return event.result; + }, + + // Piggyback on a donor event to simulate a different one + // Used only for `focus(in | out)` events + simulate: function( type, elem, event ) { + var e = jQuery.extend( + new jQuery.Event(), + event, + { + type: type, + isSimulated: true + } + ); + + jQuery.event.trigger( e, null, elem ); + } + + } ); + + jQuery.fn.extend( { + + trigger: function( type, data ) { + return this.each( function() { + jQuery.event.trigger( type, data, this ); + } ); + }, + triggerHandler: function( type, data ) { + var elem = this[ 0 ]; + if ( elem ) { + return jQuery.event.trigger( type, data, elem, true ); + } + } + } ); + + + var + rbracket = /\[\]$/, + rCRLF = /\r?\n/g, + rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, + rsubmittable = /^(?:input|select|textarea|keygen)/i; + + function buildParams( prefix, obj, traditional, add ) { + var name; + + if ( Array.isArray( obj ) ) { + + // Serialize array item. + jQuery.each( obj, function( i, v ) { + if ( traditional || rbracket.test( prefix ) ) { + + // Treat each array item as a scalar. + add( prefix, v ); + + } else { + + // Item is non-scalar (array or object), encode its numeric index. + buildParams( + prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", + v, + traditional, + add + ); + } + } ); + + } else if ( !traditional && toType( obj ) === "object" ) { + + // Serialize object item. + for ( name in obj ) { + buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); + } + + } else { + + // Serialize scalar item. + add( prefix, obj ); + } + } + + // Serialize an array of form elements or a set of + // key/values into a query string + jQuery.param = function( a, traditional ) { + var prefix, + s = [], + add = function( key, valueOrFunction ) { + + // If value is a function, invoke it and use its return value + var value = isFunction( valueOrFunction ) ? + valueOrFunction() : + valueOrFunction; + + s[ s.length ] = encodeURIComponent( key ) + "=" + + encodeURIComponent( value == null ? "" : value ); + }; + + if ( a == null ) { + return ""; + } + + // If an array was passed in, assume that it is an array of form elements. + if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { + + // Serialize the form elements + jQuery.each( a, function() { + add( this.name, this.value ); + } ); + + } else { + + // If traditional, encode the "old" way (the way 1.3.2 or older + // did it), otherwise encode params recursively. + for ( prefix in a ) { + buildParams( prefix, a[ prefix ], traditional, add ); + } + } + + // Return the resulting serialization + return s.join( "&" ); + }; + + jQuery.fn.extend( { + serialize: function() { + return jQuery.param( this.serializeArray() ); + }, + serializeArray: function() { + return this.map( function() { + + // Can add propHook for "elements" to filter or add form elements + var elements = jQuery.prop( this, "elements" ); + return elements ? jQuery.makeArray( elements ) : this; + } ).filter( function() { + var type = this.type; + + // Use .is( ":disabled" ) so that fieldset[disabled] works + return this.name && !jQuery( this ).is( ":disabled" ) && + rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && + ( this.checked || !rcheckableType.test( type ) ); + } ).map( function( _i, elem ) { + var val = jQuery( this ).val(); + + if ( val == null ) { + return null; + } + + if ( Array.isArray( val ) ) { + return jQuery.map( val, function( val ) { + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; + } ); + } + + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; + } ).get(); + } + } ); + + + var + r20 = /%20/g, + rhash = /#.*$/, + rantiCache = /([?&])_=[^&]*/, + rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, + + // trac-7653, trac-8125, trac-8152: local protocol detection + rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, + rnoContent = /^(?:GET|HEAD)$/, + rprotocol = /^\/\//, + + /* Prefilters + * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) + * 2) These are called: + * - BEFORE asking for a transport + * - AFTER param serialization (s.data is a string if s.processData is true) + * 3) key is the dataType + * 4) the catchall symbol "*" can be used + * 5) execution will start with transport dataType and THEN continue down to "*" if needed + */ + prefilters = {}, + + /* Transports bindings + * 1) key is the dataType + * 2) the catchall symbol "*" can be used + * 3) selection will start with transport dataType and THEN go to "*" if needed + */ + transports = {}, + + // Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression + allTypes = "*/".concat( "*" ), + + // Anchor tag for parsing the document origin + originAnchor = document.createElement( "a" ); + + originAnchor.href = location.href; + + // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport + function addToPrefiltersOrTransports( structure ) { + + // dataTypeExpression is optional and defaults to "*" + return function( dataTypeExpression, func ) { + + if ( typeof dataTypeExpression !== "string" ) { + func = dataTypeExpression; + dataTypeExpression = "*"; + } + + var dataType, + i = 0, + dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; + + if ( isFunction( func ) ) { + + // For each dataType in the dataTypeExpression + while ( ( dataType = dataTypes[ i++ ] ) ) { + + // Prepend if requested + if ( dataType[ 0 ] === "+" ) { + dataType = dataType.slice( 1 ) || "*"; + ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); + + // Otherwise append + } else { + ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); + } + } + } + }; + } + + // Base inspection function for prefilters and transports + function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { + + var inspected = {}, + seekingTransport = ( structure === transports ); + + function inspect( dataType ) { + var selected; + inspected[ dataType ] = true; + jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { + var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); + if ( typeof dataTypeOrTransport === "string" && + !seekingTransport && !inspected[ dataTypeOrTransport ] ) { + + options.dataTypes.unshift( dataTypeOrTransport ); + inspect( dataTypeOrTransport ); + return false; + } else if ( seekingTransport ) { + return !( selected = dataTypeOrTransport ); + } + } ); + return selected; + } + + return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); + } + + // A special extend for ajax options + // that takes "flat" options (not to be deep extended) + // Fixes trac-9887 + function ajaxExtend( target, src ) { + var key, deep, + flatOptions = jQuery.ajaxSettings.flatOptions || {}; + + for ( key in src ) { + if ( src[ key ] !== undefined ) { + ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; + } + } + if ( deep ) { + jQuery.extend( true, target, deep ); + } + + return target; + } + + /* Handles responses to an ajax request: + * - finds the right dataType (mediates between content-type and expected dataType) + * - returns the corresponding response + */ + function ajaxHandleResponses( s, jqXHR, responses ) { + + var ct, type, finalDataType, firstDataType, + contents = s.contents, + dataTypes = s.dataTypes; + + // Remove auto dataType and get content-type in the process + while ( dataTypes[ 0 ] === "*" ) { + dataTypes.shift(); + if ( ct === undefined ) { + ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); + } + } + + // Check if we're dealing with a known content-type + if ( ct ) { + for ( type in contents ) { + if ( contents[ type ] && contents[ type ].test( ct ) ) { + dataTypes.unshift( type ); + break; + } + } + } + + // Check to see if we have a response for the expected dataType + if ( dataTypes[ 0 ] in responses ) { + finalDataType = dataTypes[ 0 ]; + } else { + + // Try convertible dataTypes + for ( type in responses ) { + if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { + finalDataType = type; + break; + } + if ( !firstDataType ) { + firstDataType = type; + } + } + + // Or just use first one + finalDataType = finalDataType || firstDataType; + } + + // If we found a dataType + // We add the dataType to the list if needed + // and return the corresponding response + if ( finalDataType ) { + if ( finalDataType !== dataTypes[ 0 ] ) { + dataTypes.unshift( finalDataType ); + } + return responses[ finalDataType ]; + } + } + + /* Chain conversions given the request and the original response + * Also sets the responseXXX fields on the jqXHR instance + */ + function ajaxConvert( s, response, jqXHR, isSuccess ) { + var conv2, current, conv, tmp, prev, + converters = {}, + + // Work with a copy of dataTypes in case we need to modify it for conversion + dataTypes = s.dataTypes.slice(); + + // Create converters map with lowercased keys + if ( dataTypes[ 1 ] ) { + for ( conv in s.converters ) { + converters[ conv.toLowerCase() ] = s.converters[ conv ]; + } + } + + current = dataTypes.shift(); + + // Convert to each sequential dataType + while ( current ) { + + if ( s.responseFields[ current ] ) { + jqXHR[ s.responseFields[ current ] ] = response; + } + + // Apply the dataFilter if provided + if ( !prev && isSuccess && s.dataFilter ) { + response = s.dataFilter( response, s.dataType ); + } + + prev = current; + current = dataTypes.shift(); + + if ( current ) { + + // There's only work to do if current dataType is non-auto + if ( current === "*" ) { + + current = prev; + + // Convert response if prev dataType is non-auto and differs from current + } else if ( prev !== "*" && prev !== current ) { + + // Seek a direct converter + conv = converters[ prev + " " + current ] || converters[ "* " + current ]; + + // If none found, seek a pair + if ( !conv ) { + for ( conv2 in converters ) { + + // If conv2 outputs current + tmp = conv2.split( " " ); + if ( tmp[ 1 ] === current ) { + + // If prev can be converted to accepted input + conv = converters[ prev + " " + tmp[ 0 ] ] || + converters[ "* " + tmp[ 0 ] ]; + if ( conv ) { + + // Condense equivalence converters + if ( conv === true ) { + conv = converters[ conv2 ]; + + // Otherwise, insert the intermediate dataType + } else if ( converters[ conv2 ] !== true ) { + current = tmp[ 0 ]; + dataTypes.unshift( tmp[ 1 ] ); + } + break; + } + } + } + } + + // Apply converter (if not an equivalence) + if ( conv !== true ) { + + // Unless errors are allowed to bubble, catch and return them + if ( conv && s.throws ) { + response = conv( response ); + } else { + try { + response = conv( response ); + } catch ( e ) { + return { + state: "parsererror", + error: conv ? e : "No conversion from " + prev + " to " + current + }; + } + } + } + } + } + } + + return { state: "success", data: response }; + } + + jQuery.extend( { + + // Counter for holding the number of active queries + active: 0, + + // Last-Modified header cache for next request + lastModified: {}, + etag: {}, + + ajaxSettings: { + url: location.href, + type: "GET", + isLocal: rlocalProtocol.test( location.protocol ), + global: true, + processData: true, + async: true, + contentType: "application/x-www-form-urlencoded; charset=UTF-8", + + /* + timeout: 0, + data: null, + dataType: null, + username: null, + password: null, + cache: null, + throws: false, + traditional: false, + headers: {}, + */ + + accepts: { + "*": allTypes, + text: "text/plain", + html: "text/html", + xml: "application/xml, text/xml", + json: "application/json, text/javascript" + }, + + contents: { + xml: /\bxml\b/, + html: /\bhtml/, + json: /\bjson\b/ + }, + + responseFields: { + xml: "responseXML", + text: "responseText", + json: "responseJSON" + }, + + // Data converters + // Keys separate source (or catchall "*") and destination types with a single space + converters: { + + // Convert anything to text + "* text": String, + + // Text to html (true = no transformation) + "text html": true, + + // Evaluate text as a json expression + "text json": JSON.parse, + + // Parse text as xml + "text xml": jQuery.parseXML + }, + + // For options that shouldn't be deep extended: + // you can add your own custom options here if + // and when you create one that shouldn't be + // deep extended (see ajaxExtend) + flatOptions: { + url: true, + context: true + } + }, + + // Creates a full fledged settings object into target + // with both ajaxSettings and settings fields. + // If target is omitted, writes into ajaxSettings. + ajaxSetup: function( target, settings ) { + return settings ? + + // Building a settings object + ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : + + // Extending ajaxSettings + ajaxExtend( jQuery.ajaxSettings, target ); + }, + + ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), + ajaxTransport: addToPrefiltersOrTransports( transports ), + + // Main method + ajax: function( url, options ) { + + // If url is an object, simulate pre-1.5 signature + if ( typeof url === "object" ) { + options = url; + url = undefined; + } + + // Force options to be an object + options = options || {}; + + var transport, + + // URL without anti-cache param + cacheURL, + + // Response headers + responseHeadersString, + responseHeaders, + + // timeout handle + timeoutTimer, + + // Url cleanup var + urlAnchor, + + // Request state (becomes false upon send and true upon completion) + completed, + + // To know if global events are to be dispatched + fireGlobals, + + // Loop variable + i, + + // uncached part of the url + uncached, + + // Create the final options object + s = jQuery.ajaxSetup( {}, options ), + + // Callbacks context + callbackContext = s.context || s, + + // Context for global events is callbackContext if it is a DOM node or jQuery collection + globalEventContext = s.context && + ( callbackContext.nodeType || callbackContext.jquery ) ? + jQuery( callbackContext ) : + jQuery.event, + + // Deferreds + deferred = jQuery.Deferred(), + completeDeferred = jQuery.Callbacks( "once memory" ), + + // Status-dependent callbacks + statusCode = s.statusCode || {}, + + // Headers (they are sent all at once) + requestHeaders = {}, + requestHeadersNames = {}, + + // Default abort message + strAbort = "canceled", + + // Fake xhr + jqXHR = { + readyState: 0, + + // Builds headers hashtable if needed + getResponseHeader: function( key ) { + var match; + if ( completed ) { + if ( !responseHeaders ) { + responseHeaders = {}; + while ( ( match = rheaders.exec( responseHeadersString ) ) ) { + responseHeaders[ match[ 1 ].toLowerCase() + " " ] = + ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) + .concat( match[ 2 ] ); + } + } + match = responseHeaders[ key.toLowerCase() + " " ]; + } + return match == null ? null : match.join( ", " ); + }, + + // Raw string + getAllResponseHeaders: function() { + return completed ? responseHeadersString : null; + }, + + // Caches the header + setRequestHeader: function( name, value ) { + if ( completed == null ) { + name = requestHeadersNames[ name.toLowerCase() ] = + requestHeadersNames[ name.toLowerCase() ] || name; + requestHeaders[ name ] = value; + } + return this; + }, + + // Overrides response content-type header + overrideMimeType: function( type ) { + if ( completed == null ) { + s.mimeType = type; + } + return this; + }, + + // Status-dependent callbacks + statusCode: function( map ) { + var code; + if ( map ) { + if ( completed ) { + + // Execute the appropriate callbacks + jqXHR.always( map[ jqXHR.status ] ); + } else { + + // Lazy-add the new callbacks in a way that preserves old ones + for ( code in map ) { + statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; + } + } + } + return this; + }, + + // Cancel the request + abort: function( statusText ) { + var finalText = statusText || strAbort; + if ( transport ) { + transport.abort( finalText ); + } + done( 0, finalText ); + return this; + } + }; + + // Attach deferreds + deferred.promise( jqXHR ); + + // Add protocol if not provided (prefilters might expect it) + // Handle falsy url in the settings object (trac-10093: consistency with old signature) + // We also use the url parameter if available + s.url = ( ( url || s.url || location.href ) + "" ) + .replace( rprotocol, location.protocol + "//" ); + + // Alias method option to type as per ticket trac-12004 + s.type = options.method || options.type || s.method || s.type; + + // Extract dataTypes list + s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; + + // A cross-domain request is in order when the origin doesn't match the current origin. + if ( s.crossDomain == null ) { + urlAnchor = document.createElement( "a" ); + + // Support: IE <=8 - 11, Edge 12 - 15 + // IE throws exception on accessing the href property if url is malformed, + // e.g. http://example.com:80x/ + try { + urlAnchor.href = s.url; + + // Support: IE <=8 - 11 only + // Anchor's host property isn't correctly set when s.url is relative + urlAnchor.href = urlAnchor.href; + s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== + urlAnchor.protocol + "//" + urlAnchor.host; + } catch ( e ) { + + // If there is an error parsing the URL, assume it is crossDomain, + // it can be rejected by the transport if it is invalid + s.crossDomain = true; + } + } + + // Convert data if not already a string + if ( s.data && s.processData && typeof s.data !== "string" ) { + s.data = jQuery.param( s.data, s.traditional ); + } + + // Apply prefilters + inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); + + // If request was aborted inside a prefilter, stop there + if ( completed ) { + return jqXHR; + } + + // We can fire global events as of now if asked to + // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118) + fireGlobals = jQuery.event && s.global; + + // Watch for a new set of requests + if ( fireGlobals && jQuery.active++ === 0 ) { + jQuery.event.trigger( "ajaxStart" ); + } + + // Uppercase the type + s.type = s.type.toUpperCase(); + + // Determine if request has content + s.hasContent = !rnoContent.test( s.type ); + + // Save the URL in case we're toying with the If-Modified-Since + // and/or If-None-Match header later on + // Remove hash to simplify url manipulation + cacheURL = s.url.replace( rhash, "" ); + + // More options handling for requests with no content + if ( !s.hasContent ) { + + // Remember the hash so we can put it back + uncached = s.url.slice( cacheURL.length ); + + // If data is available and should be processed, append data to url + if ( s.data && ( s.processData || typeof s.data === "string" ) ) { + cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; + + // trac-9682: remove data so that it's not used in an eventual retry + delete s.data; + } + + // Add or update anti-cache param if needed + if ( s.cache === false ) { + cacheURL = cacheURL.replace( rantiCache, "$1" ); + uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) + + uncached; + } + + // Put hash and anti-cache on the URL that will be requested (gh-1732) + s.url = cacheURL + uncached; + + // Change '%20' to '+' if this is encoded form body content (gh-2658) + } else if ( s.data && s.processData && + ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { + s.data = s.data.replace( r20, "+" ); + } + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + if ( jQuery.lastModified[ cacheURL ] ) { + jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); + } + if ( jQuery.etag[ cacheURL ] ) { + jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); + } + } + + // Set the correct header, if data is being sent + if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { + jqXHR.setRequestHeader( "Content-Type", s.contentType ); + } + + // Set the Accepts header for the server, depending on the dataType + jqXHR.setRequestHeader( + "Accept", + s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? + s.accepts[ s.dataTypes[ 0 ] ] + + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : + s.accepts[ "*" ] + ); + + // Check for headers option + for ( i in s.headers ) { + jqXHR.setRequestHeader( i, s.headers[ i ] ); + } + + // Allow custom headers/mimetypes and early abort + if ( s.beforeSend && + ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { + + // Abort if not done already and return + return jqXHR.abort(); + } + + // Aborting is no longer a cancellation + strAbort = "abort"; + + // Install callbacks on deferreds + completeDeferred.add( s.complete ); + jqXHR.done( s.success ); + jqXHR.fail( s.error ); + + // Get transport + transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); + + // If no transport, we auto-abort + if ( !transport ) { + done( -1, "No Transport" ); + } else { + jqXHR.readyState = 1; + + // Send global event + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); + } + + // If request was aborted inside ajaxSend, stop there + if ( completed ) { + return jqXHR; + } + + // Timeout + if ( s.async && s.timeout > 0 ) { + timeoutTimer = window.setTimeout( function() { + jqXHR.abort( "timeout" ); + }, s.timeout ); + } + + try { + completed = false; + transport.send( requestHeaders, done ); + } catch ( e ) { + + // Rethrow post-completion exceptions + if ( completed ) { + throw e; + } + + // Propagate others as results + done( -1, e ); + } + } + + // Callback for when everything is done + function done( status, nativeStatusText, responses, headers ) { + var isSuccess, success, error, response, modified, + statusText = nativeStatusText; + + // Ignore repeat invocations + if ( completed ) { + return; + } + + completed = true; + + // Clear timeout if it exists + if ( timeoutTimer ) { + window.clearTimeout( timeoutTimer ); + } + + // Dereference transport for early garbage collection + // (no matter how long the jqXHR object will be used) + transport = undefined; + + // Cache response headers + responseHeadersString = headers || ""; + + // Set readyState + jqXHR.readyState = status > 0 ? 4 : 0; + + // Determine if successful + isSuccess = status >= 200 && status < 300 || status === 304; + + // Get response data + if ( responses ) { + response = ajaxHandleResponses( s, jqXHR, responses ); + } + + // Use a noop converter for missing script but not if jsonp + if ( !isSuccess && + jQuery.inArray( "script", s.dataTypes ) > -1 && + jQuery.inArray( "json", s.dataTypes ) < 0 ) { + s.converters[ "text script" ] = function() {}; + } + + // Convert no matter what (that way responseXXX fields are always set) + response = ajaxConvert( s, response, jqXHR, isSuccess ); + + // If successful, handle type chaining + if ( isSuccess ) { + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + modified = jqXHR.getResponseHeader( "Last-Modified" ); + if ( modified ) { + jQuery.lastModified[ cacheURL ] = modified; + } + modified = jqXHR.getResponseHeader( "etag" ); + if ( modified ) { + jQuery.etag[ cacheURL ] = modified; + } + } + + // if no content + if ( status === 204 || s.type === "HEAD" ) { + statusText = "nocontent"; + + // if not modified + } else if ( status === 304 ) { + statusText = "notmodified"; + + // If we have data, let's convert it + } else { + statusText = response.state; + success = response.data; + error = response.error; + isSuccess = !error; + } + } else { + + // Extract error from statusText and normalize for non-aborts + error = statusText; + if ( status || !statusText ) { + statusText = "error"; + if ( status < 0 ) { + status = 0; + } + } + } + + // Set data for the fake xhr object + jqXHR.status = status; + jqXHR.statusText = ( nativeStatusText || statusText ) + ""; + + // Success/Error + if ( isSuccess ) { + deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); + } else { + deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); + } + + // Status-dependent callbacks + jqXHR.statusCode( statusCode ); + statusCode = undefined; + + if ( fireGlobals ) { + globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", + [ jqXHR, s, isSuccess ? success : error ] ); + } + + // Complete + completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); + + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); + + // Handle the global AJAX counter + if ( !( --jQuery.active ) ) { + jQuery.event.trigger( "ajaxStop" ); + } + } + } + + return jqXHR; + }, + + getJSON: function( url, data, callback ) { + return jQuery.get( url, data, callback, "json" ); + }, + + getScript: function( url, callback ) { + return jQuery.get( url, undefined, callback, "script" ); + } + } ); + + jQuery.each( [ "get", "post" ], function( _i, method ) { + jQuery[ method ] = function( url, data, callback, type ) { + + // Shift arguments if data argument was omitted + if ( isFunction( data ) ) { + type = type || callback; + callback = data; + data = undefined; + } + + // The url can be an options object (which then must have .url) + return jQuery.ajax( jQuery.extend( { + url: url, + type: method, + dataType: type, + data: data, + success: callback + }, jQuery.isPlainObject( url ) && url ) ); + }; + } ); + + jQuery.ajaxPrefilter( function( s ) { + var i; + for ( i in s.headers ) { + if ( i.toLowerCase() === "content-type" ) { + s.contentType = s.headers[ i ] || ""; + } + } + } ); + + + jQuery._evalUrl = function( url, options, doc ) { + return jQuery.ajax( { + url: url, + + // Make this explicit, since user can override this through ajaxSetup (trac-11264) + type: "GET", + dataType: "script", + cache: true, + async: false, + global: false, + + // Only evaluate the response if it is successful (gh-4126) + // dataFilter is not invoked for failure responses, so using it instead + // of the default converter is kludgy but it works. + converters: { + "text script": function() {} + }, + dataFilter: function( response ) { + jQuery.globalEval( response, options, doc ); + } + } ); + }; + + + jQuery.fn.extend( { + wrapAll: function( html ) { + var wrap; + + if ( this[ 0 ] ) { + if ( isFunction( html ) ) { + html = html.call( this[ 0 ] ); + } + + // The elements to wrap the target around + wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); + + if ( this[ 0 ].parentNode ) { + wrap.insertBefore( this[ 0 ] ); + } + + wrap.map( function() { + var elem = this; + + while ( elem.firstElementChild ) { + elem = elem.firstElementChild; + } + + return elem; + } ).append( this ); + } + + return this; + }, + + wrapInner: function( html ) { + if ( isFunction( html ) ) { + return this.each( function( i ) { + jQuery( this ).wrapInner( html.call( this, i ) ); + } ); + } + + return this.each( function() { + var self = jQuery( this ), + contents = self.contents(); + + if ( contents.length ) { + contents.wrapAll( html ); + + } else { + self.append( html ); + } + } ); + }, + + wrap: function( html ) { + var htmlIsFunction = isFunction( html ); + + return this.each( function( i ) { + jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); + } ); + }, + + unwrap: function( selector ) { + this.parent( selector ).not( "body" ).each( function() { + jQuery( this ).replaceWith( this.childNodes ); + } ); + return this; + } + } ); + + + jQuery.expr.pseudos.hidden = function( elem ) { + return !jQuery.expr.pseudos.visible( elem ); + }; + jQuery.expr.pseudos.visible = function( elem ) { + return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); + }; + + + + + jQuery.ajaxSettings.xhr = function() { + try { + return new window.XMLHttpRequest(); + } catch ( e ) {} + }; + + var xhrSuccessStatus = { + + // File protocol always yields status code 0, assume 200 + 0: 200, + + // Support: IE <=9 only + // trac-1450: sometimes IE returns 1223 when it should be 204 + 1223: 204 + }, + xhrSupported = jQuery.ajaxSettings.xhr(); + + support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); + support.ajax = xhrSupported = !!xhrSupported; + + jQuery.ajaxTransport( function( options ) { + var callback, errorCallback; + + // Cross domain only allowed if supported through XMLHttpRequest + if ( support.cors || xhrSupported && !options.crossDomain ) { + return { + send: function( headers, complete ) { + var i, + xhr = options.xhr(); + + xhr.open( + options.type, + options.url, + options.async, + options.username, + options.password + ); + + // Apply custom fields if provided + if ( options.xhrFields ) { + for ( i in options.xhrFields ) { + xhr[ i ] = options.xhrFields[ i ]; + } + } + + // Override mime type if needed + if ( options.mimeType && xhr.overrideMimeType ) { + xhr.overrideMimeType( options.mimeType ); + } + + // X-Requested-With header + // For cross-domain requests, seeing as conditions for a preflight are + // akin to a jigsaw puzzle, we simply never set it to be sure. + // (it can always be set on a per-request basis or even using ajaxSetup) + // For same-domain requests, won't change header if already provided. + if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { + headers[ "X-Requested-With" ] = "XMLHttpRequest"; + } + + // Set headers + for ( i in headers ) { + xhr.setRequestHeader( i, headers[ i ] ); + } + + // Callback + callback = function( type ) { + return function() { + if ( callback ) { + callback = errorCallback = xhr.onload = + xhr.onerror = xhr.onabort = xhr.ontimeout = + xhr.onreadystatechange = null; + + if ( type === "abort" ) { + xhr.abort(); + } else if ( type === "error" ) { + + // Support: IE <=9 only + // On a manual native abort, IE9 throws + // errors on any property access that is not readyState + if ( typeof xhr.status !== "number" ) { + complete( 0, "error" ); + } else { + complete( + + // File: protocol always yields status 0; see trac-8605, trac-14207 + xhr.status, + xhr.statusText + ); + } + } else { + complete( + xhrSuccessStatus[ xhr.status ] || xhr.status, + xhr.statusText, + + // Support: IE <=9 only + // IE9 has no XHR2 but throws on binary (trac-11426) + // For XHR2 non-text, let the caller handle it (gh-2498) + ( xhr.responseType || "text" ) !== "text" || + typeof xhr.responseText !== "string" ? + { binary: xhr.response } : + { text: xhr.responseText }, + xhr.getAllResponseHeaders() + ); + } + } + }; + }; + + // Listen to events + xhr.onload = callback(); + errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); + + // Support: IE 9 only + // Use onreadystatechange to replace onabort + // to handle uncaught aborts + if ( xhr.onabort !== undefined ) { + xhr.onabort = errorCallback; + } else { + xhr.onreadystatechange = function() { + + // Check readyState before timeout as it changes + if ( xhr.readyState === 4 ) { + + // Allow onerror to be called first, + // but that will not handle a native abort + // Also, save errorCallback to a variable + // as xhr.onerror cannot be accessed + window.setTimeout( function() { + if ( callback ) { + errorCallback(); + } + } ); + } + }; + } + + // Create the abort callback + callback = callback( "abort" ); + + try { + + // Do send the request (this may raise an exception) + xhr.send( options.hasContent && options.data || null ); + } catch ( e ) { + + // trac-14683: Only rethrow if this hasn't been notified as an error yet + if ( callback ) { + throw e; + } + } + }, + + abort: function() { + if ( callback ) { + callback(); + } + } + }; + } + } ); + + + + + // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) + jQuery.ajaxPrefilter( function( s ) { + if ( s.crossDomain ) { + s.contents.script = false; + } + } ); + + // Install script dataType + jQuery.ajaxSetup( { + accepts: { + script: "text/javascript, application/javascript, " + + "application/ecmascript, application/x-ecmascript" + }, + contents: { + script: /\b(?:java|ecma)script\b/ + }, + converters: { + "text script": function( text ) { + jQuery.globalEval( text ); + return text; + } + } + } ); + + // Handle cache's special case and crossDomain + jQuery.ajaxPrefilter( "script", function( s ) { + if ( s.cache === undefined ) { + s.cache = false; + } + if ( s.crossDomain ) { + s.type = "GET"; + } + } ); + + // Bind script tag hack transport + jQuery.ajaxTransport( "script", function( s ) { + + // This transport only deals with cross domain or forced-by-attrs requests + if ( s.crossDomain || s.scriptAttrs ) { + var script, callback; + return { + send: function( _, complete ) { + script = jQuery( "