· 9 years ago · Mar 21, 2017, 10:50 AM
1/*!
2 * @atlassian/aui - Atlassian User Interface Framework
3 * @version v6.0.6
4 * @link https://docs.atlassian.com/aui/latest/
5 * @license Apache-2.0
6 * @author [object Object]
7 */
8// node_modules/@atlassian/aui/src/js/aui/jquery.js
9(typeof window === 'undefined' ? global : window).__307d3e18fd611f85395c67cddeb1fe24 = (function () {
10 var module = {
11 exports: {}
12 };
13 var exports = module.exports;
14
15 "use strict";
16
17 Object.defineProperty(exports, "__esModule", {
18 value: true
19 });
20 exports.default = window.jQuery || window.Zepto;
21 module.exports = exports['default'];
22
23 return module.exports;
24}).call(this);
25// node_modules/@atlassian/aui/src/js/aui/create-element.js
26(typeof window === 'undefined' ? global : window).__fd277fcde858b82a198666a405e85600 = (function () {
27 var module = {
28 exports: {}
29 };
30 var exports = module.exports;
31
32 'use strict';
33
34 Object.defineProperty(exports, "__esModule", {
35 value: true
36 });
37
38 var _jquery = __307d3e18fd611f85395c67cddeb1fe24;
39
40 var _jquery2 = _interopRequireDefault(_jquery);
41
42 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
43
44 function createElement() {
45 var res = null;
46
47 if (arguments.length && typeof arguments[0] === 'string') {
48 res = (0, _jquery2.default)(document.createElement(arguments[0]));
49
50 if (arguments.length === 2) {
51 res.html(arguments[1]);
52 }
53 }
54
55 //We can't use the deprecate module or we will introduce a circular dependency
56 if (typeof console !== 'undefined' && console.warn) {
57 console.warn('AJS\'s create element functionality has been deprecated since 5.9.0.\nNo alternative will be provided.\nUse document.createElement() or jQuery.parseHTML(), or preferably use a templating library.');
58 }
59
60 return res;
61 }
62
63 exports.default = createElement;
64 module.exports = exports['default'];
65
66 return module.exports;
67}).call(this);
68// node_modules/object-assign/index.js
69(typeof window === 'undefined' ? global : window).__20af9d35c28a1911e53d45bf2b6d5c6f = (function () {
70 var module = {
71 exports: {}
72 };
73 var exports = module.exports;
74
75 /* eslint-disable no-unused-vars */
76 var hasOwnProperty = Object.prototype.hasOwnProperty;
77 var propIsEnumerable = Object.prototype.propertyIsEnumerable;
78
79 function toObject(val) {
80 if (val === null || val === undefined) {
81 throw new TypeError('Object.assign cannot be called with null or undefined');
82 }
83
84 return Object(val);
85 }
86
87 module.exports = Object.assign || function (target, source) {
88 var from;
89 var to = toObject(target);
90 var symbols;
91
92 for (var s = 1; s < arguments.length; s++) {
93 from = Object(arguments[s]);
94
95 for (var key in from) {
96 if (hasOwnProperty.call(from, key)) {
97 to[key] = from[key];
98 }
99 }
100
101 if (Object.getOwnPropertySymbols) {
102 symbols = Object.getOwnPropertySymbols(from);
103 for (var i = 0; i < symbols.length; i++) {
104 if (propIsEnumerable.call(from, symbols[i])) {
105 to[symbols[i]] = from[symbols[i]];
106 }
107 }
108 }
109 }
110
111 return to;
112 };
113
114
115 return module.exports;
116}).call(this);
117// node_modules/@atlassian/aui/src/js/aui/internal/globalize.js
118(typeof window === 'undefined' ? global : window).__4d02fe17b8e885a34493e34af3d145dd = (function () {
119 var module = {
120 exports: {}
121 };
122 var exports = module.exports;
123
124 'use strict';
125
126 Object.defineProperty(exports, "__esModule", {
127 value: true
128 });
129
130 exports.default = function (name, value) {
131 window[NAMESPACE] = (0, _objectAssign2.default)(_createElement2.default, window[NAMESPACE]);
132
133 return window[NAMESPACE][name] = value;
134 };
135
136 var _createElement = __fd277fcde858b82a198666a405e85600;
137
138 var _createElement2 = _interopRequireDefault(_createElement);
139
140 var _objectAssign = __20af9d35c28a1911e53d45bf2b6d5c6f;
141
142 var _objectAssign2 = _interopRequireDefault(_objectAssign);
143
144 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
145
146 var NAMESPACE = 'AJS';
147
148 module.exports = exports['default'];
149
150 return module.exports;
151}).call(this);
152// node_modules/@atlassian/aui/src/js/aui/internal/log.js
153(typeof window === 'undefined' ? global : window).__cf890abdf040e0993fb71f2f839bc972 = (function () {
154 var module = {
155 exports: {}
156 };
157 var exports = module.exports;
158
159 'use strict';
160
161 Object.defineProperty(exports, "__esModule", {
162 value: true
163 });
164 exports.error = exports.warn = exports.log = undefined;
165
166 var _globalize = __4d02fe17b8e885a34493e34af3d145dd;
167
168 var _globalize2 = _interopRequireDefault(_globalize);
169
170 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
171
172 function polyfillConsole(prop) {
173 return function () {
174 if (typeof console !== 'undefined' && console[prop]) {
175 Function.prototype.apply.call(console[prop], console, arguments);
176 }
177 };
178 }
179
180 var log = polyfillConsole('log');
181 var warn = polyfillConsole('warn');
182 var error = polyfillConsole('error');
183
184 (0, _globalize2.default)('error', error);
185 (0, _globalize2.default)('log', log);
186 (0, _globalize2.default)('warn', warn);
187
188 exports.log = log;
189 exports.warn = warn;
190 exports.error = error;
191
192 return module.exports;
193}).call(this);
194// node_modules/skatejs/lib/constants.js
195(typeof window === 'undefined' ? global : window).__3ceacf009ef9ceb3c52ebb9324915170 = (function () {
196 var module = {
197 exports: {}
198 };
199 var exports = module.exports;
200 var defineDependencies = {
201 "module": module,
202 "exports": exports
203 };
204 var define = function defineReplacementWrapper(generatedModuleName) {
205 return function defineReplacement(name, deps, func) {
206 var root = (typeof window === 'undefined' ? global : window);
207 var defineGlobal = root.define;
208 var rval;
209 var type;
210
211 func = [func, deps, name].filter(function (cur) {
212 return typeof cur === 'function';
213 })[0];
214 deps = [deps, name, []].filter(Array.isArray)[0];
215 rval = func.apply(null, deps.map(function (value) {
216 return defineDependencies[value];
217 }));
218 type = typeof rval;
219
220 // Support existing AMD libs.
221 if (typeof defineGlobal === 'function') {
222 // Almond always expects a name so resolve one (#29).
223 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
224 }
225
226 // Some processors like Babel don't check to make sure that the module value
227 // is not a primitive before calling Object.defineProperty() on it. We ensure
228 // it is an instance so that it can.
229 if (type === 'string') {
230 rval = String(rval);
231 } else if (type === 'number') {
232 rval = Number(rval);
233 } else if (type === 'boolean') {
234 rval = Boolean(rval);
235 }
236
237 // Reset the exports to the defined module. This is how we convert AMD to
238 // CommonJS and ensures both can either co-exist, or be used separately. We
239 // only set it if it is not defined because there is no object representation
240 // of undefined, thus calling Object.defineProperty() on it would fail.
241 if (rval !== undefined) {
242 exports = module.exports = rval;
243 }
244 };
245 }("__3ceacf009ef9ceb3c52ebb9324915170");
246 define.amd = true;
247
248 (function (factory) {
249 if (typeof define === "function" && define.amd) {
250 define(["exports"], factory);
251 } else if (typeof exports !== "undefined") {
252 factory(exports);
253 }
254 })(function (exports) {
255
256 Object.defineProperty(exports, "__esModule", {
257 value: true
258 });
259
260 var ATTR_IGNORE = "data-skate-ignore";
261 exports.ATTR_IGNORE = ATTR_IGNORE;
262 var TYPE_ATTRIBUTE = "a";
263 exports.TYPE_ATTRIBUTE = TYPE_ATTRIBUTE;
264 var TYPE_CLASSNAME = "c";
265 exports.TYPE_CLASSNAME = TYPE_CLASSNAME;
266 var TYPE_ELEMENT = "t";
267 exports.TYPE_ELEMENT = TYPE_ELEMENT;
268 });
269
270 return module.exports;
271}).call(this);
272// node_modules/skatejs/lib/version.js
273(typeof window === 'undefined' ? global : window).__15c28555b7ada36a99309d466d5cff55 = (function () {
274 var module = {
275 exports: {}
276 };
277 var exports = module.exports;
278 var defineDependencies = {
279 "module": module,
280 "exports": exports
281 };
282 var define = function defineReplacementWrapper(generatedModuleName) {
283 return function defineReplacement(name, deps, func) {
284 var root = (typeof window === 'undefined' ? global : window);
285 var defineGlobal = root.define;
286 var rval;
287 var type;
288
289 func = [func, deps, name].filter(function (cur) {
290 return typeof cur === 'function';
291 })[0];
292 deps = [deps, name, []].filter(Array.isArray)[0];
293 rval = func.apply(null, deps.map(function (value) {
294 return defineDependencies[value];
295 }));
296 type = typeof rval;
297
298 // Support existing AMD libs.
299 if (typeof defineGlobal === 'function') {
300 // Almond always expects a name so resolve one (#29).
301 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
302 }
303
304 // Some processors like Babel don't check to make sure that the module value
305 // is not a primitive before calling Object.defineProperty() on it. We ensure
306 // it is an instance so that it can.
307 if (type === 'string') {
308 rval = String(rval);
309 } else if (type === 'number') {
310 rval = Number(rval);
311 } else if (type === 'boolean') {
312 rval = Boolean(rval);
313 }
314
315 // Reset the exports to the defined module. This is how we convert AMD to
316 // CommonJS and ensures both can either co-exist, or be used separately. We
317 // only set it if it is not defined because there is no object representation
318 // of undefined, thus calling Object.defineProperty() on it would fail.
319 if (rval !== undefined) {
320 exports = module.exports = rval;
321 }
322 };
323 }("__15c28555b7ada36a99309d466d5cff55");
324 define.amd = true;
325
326 (function (factory) {
327 if (typeof define === "function" && define.amd) {
328 define(["exports", "module"], factory);
329 } else if (typeof exports !== "undefined" && typeof module !== "undefined") {
330 factory(exports, module);
331 }
332 })(function (exports, module) {
333
334 module.exports = "0.13.17";
335 });
336
337 return module.exports;
338}).call(this);
339// node_modules/skatejs/lib/globals.js
340(typeof window === 'undefined' ? global : window).__df73b283f1d40e8f4912fb904e42aa12 = (function () {
341 var module = {
342 exports: {}
343 };
344 var exports = module.exports;
345 var defineDependencies = {
346 "module": module,
347 "exports": exports,
348 "./version": __15c28555b7ada36a99309d466d5cff55,
349 "./version": __15c28555b7ada36a99309d466d5cff55
350 };
351 var define = function defineReplacementWrapper(generatedModuleName) {
352 return function defineReplacement(name, deps, func) {
353 var root = (typeof window === 'undefined' ? global : window);
354 var defineGlobal = root.define;
355 var rval;
356 var type;
357
358 func = [func, deps, name].filter(function (cur) {
359 return typeof cur === 'function';
360 })[0];
361 deps = [deps, name, []].filter(Array.isArray)[0];
362 rval = func.apply(null, deps.map(function (value) {
363 return defineDependencies[value];
364 }));
365 type = typeof rval;
366
367 // Support existing AMD libs.
368 if (typeof defineGlobal === 'function') {
369 // Almond always expects a name so resolve one (#29).
370 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
371 }
372
373 // Some processors like Babel don't check to make sure that the module value
374 // is not a primitive before calling Object.defineProperty() on it. We ensure
375 // it is an instance so that it can.
376 if (type === 'string') {
377 rval = String(rval);
378 } else if (type === 'number') {
379 rval = Number(rval);
380 } else if (type === 'boolean') {
381 rval = Boolean(rval);
382 }
383
384 // Reset the exports to the defined module. This is how we convert AMD to
385 // CommonJS and ensures both can either co-exist, or be used separately. We
386 // only set it if it is not defined because there is no object representation
387 // of undefined, thus calling Object.defineProperty() on it would fail.
388 if (rval !== undefined) {
389 exports = module.exports = rval;
390 }
391 };
392 }("__df73b283f1d40e8f4912fb904e42aa12");
393 define.amd = true;
394
395 (function (factory) {
396 if (typeof define === "function" && define.amd) {
397 define(["exports", "module", "./version"], factory);
398 } else if (typeof exports !== "undefined" && typeof module !== "undefined") {
399 factory(exports, module, __15c28555b7ada36a99309d466d5cff55);
400 }
401 })(function (exports, module, _version) {
402
403 var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
404
405 var version = _interopRequire(_version);
406
407 var VERSION = "__skate_" + version.replace(/[^\w]/g, "_");
408
409 if (!window[VERSION]) {
410 window[VERSION] = {
411 observer: undefined,
412 registry: {}
413 };
414 }
415
416 module.exports = window[VERSION];
417 });
418
419 return module.exports;
420}).call(this);
421// node_modules/skatejs/lib/data.js
422(typeof window === 'undefined' ? global : window).__4666b4efa3069445b77e23d8419d0090 = (function () {
423 var module = {
424 exports: {}
425 };
426 var exports = module.exports;
427 var defineDependencies = {
428 "module": module,
429 "exports": exports
430 };
431 var define = function defineReplacementWrapper(generatedModuleName) {
432 return function defineReplacement(name, deps, func) {
433 var root = (typeof window === 'undefined' ? global : window);
434 var defineGlobal = root.define;
435 var rval;
436 var type;
437
438 func = [func, deps, name].filter(function (cur) {
439 return typeof cur === 'function';
440 })[0];
441 deps = [deps, name, []].filter(Array.isArray)[0];
442 rval = func.apply(null, deps.map(function (value) {
443 return defineDependencies[value];
444 }));
445 type = typeof rval;
446
447 // Support existing AMD libs.
448 if (typeof defineGlobal === 'function') {
449 // Almond always expects a name so resolve one (#29).
450 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
451 }
452
453 // Some processors like Babel don't check to make sure that the module value
454 // is not a primitive before calling Object.defineProperty() on it. We ensure
455 // it is an instance so that it can.
456 if (type === 'string') {
457 rval = String(rval);
458 } else if (type === 'number') {
459 rval = Number(rval);
460 } else if (type === 'boolean') {
461 rval = Boolean(rval);
462 }
463
464 // Reset the exports to the defined module. This is how we convert AMD to
465 // CommonJS and ensures both can either co-exist, or be used separately. We
466 // only set it if it is not defined because there is no object representation
467 // of undefined, thus calling Object.defineProperty() on it would fail.
468 if (rval !== undefined) {
469 exports = module.exports = rval;
470 }
471 };
472 }("__4666b4efa3069445b77e23d8419d0090");
473 define.amd = true;
474
475 (function (factory) {
476 if (typeof define === "function" && define.amd) {
477 define(["exports", "module"], factory);
478 } else if (typeof exports !== "undefined" && typeof module !== "undefined") {
479 factory(exports, module);
480 }
481 })(function (exports, module) {
482
483 module.exports = function (element) {
484 var namespace = arguments[1] === undefined ? "" : arguments[1];
485
486 var data = element.__SKATE_DATA || (element.__SKATE_DATA = {});
487 return namespace && (data[namespace] || (data[namespace] = {})) || data;
488 };
489 });
490
491 return module.exports;
492}).call(this);
493// node_modules/skatejs/lib/mutation-observer.js
494(typeof window === 'undefined' ? global : window).__c91177d0507115b2c279ac28adb63576 = (function () {
495 var module = {
496 exports: {}
497 };
498 var exports = module.exports;
499 var defineDependencies = {
500 "module": module,
501 "exports": exports
502 };
503 var define = function defineReplacementWrapper(generatedModuleName) {
504 return function defineReplacement(name, deps, func) {
505 var root = (typeof window === 'undefined' ? global : window);
506 var defineGlobal = root.define;
507 var rval;
508 var type;
509
510 func = [func, deps, name].filter(function (cur) {
511 return typeof cur === 'function';
512 })[0];
513 deps = [deps, name, []].filter(Array.isArray)[0];
514 rval = func.apply(null, deps.map(function (value) {
515 return defineDependencies[value];
516 }));
517 type = typeof rval;
518
519 // Support existing AMD libs.
520 if (typeof defineGlobal === 'function') {
521 // Almond always expects a name so resolve one (#29).
522 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
523 }
524
525 // Some processors like Babel don't check to make sure that the module value
526 // is not a primitive before calling Object.defineProperty() on it. We ensure
527 // it is an instance so that it can.
528 if (type === 'string') {
529 rval = String(rval);
530 } else if (type === 'number') {
531 rval = Number(rval);
532 } else if (type === 'boolean') {
533 rval = Boolean(rval);
534 }
535
536 // Reset the exports to the defined module. This is how we convert AMD to
537 // CommonJS and ensures both can either co-exist, or be used separately. We
538 // only set it if it is not defined because there is no object representation
539 // of undefined, thus calling Object.defineProperty() on it would fail.
540 if (rval !== undefined) {
541 exports = module.exports = rval;
542 }
543 };
544 }("__c91177d0507115b2c279ac28adb63576");
545 define.amd = true;
546
547 (function (factory) {
548 if (typeof define === "function" && define.amd) {
549 define(["exports"], factory);
550 } else if (typeof exports !== "undefined") {
551 factory(exports);
552 }
553 })(function (exports) {
554
555 (function (self) {
556 // Atlassian: added IIFE
557 /**
558 * @license
559 * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
560 * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
561 * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
562 * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
563 * Code distributed by Google as part of the polymer project is also
564 * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
565 */
566 // @version 0.7.15
567 if (typeof WeakMap === "undefined") {
568 (function () {
569 var defineProperty = Object.defineProperty;
570 var counter = Date.now() % 1000000000;
571 var WeakMap = function WeakMap() {
572 this.name = "__st" + (Math.random() * 1000000000 >>> 0) + (counter++ + "__");
573 };
574 WeakMap.prototype = {
575 set: function set(key, value) {
576 var entry = key[this.name];
577 if (entry && entry[0] === key) entry[1] = value;else defineProperty(key, this.name, {
578 value: [key, value],
579 writable: true
580 });
581 return this;
582 },
583 get: function get(key) {
584 var entry;
585 return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined;
586 },
587 "delete": function _delete(key) {
588 var entry = key[this.name];
589 if (!entry || entry[0] !== key) {
590 return false;
591 }entry[0] = entry[1] = undefined;
592 return true;
593 },
594 has: function has(key) {
595 var entry = key[this.name];
596 if (!entry) {
597 return false;
598 }return entry[0] === key;
599 }
600 };
601 window.WeakMap = WeakMap;
602 })();
603 }
604
605 (function (global) {
606 if (global.JsMutationObserver) {
607 return;
608 }
609 var registrationsTable = new WeakMap();
610 var setImmediate;
611 if (/Trident|Edge/.test(navigator.userAgent)) {
612 setImmediate = setTimeout;
613 } else if (window.setImmediate) {
614 setImmediate = window.setImmediate;
615 } else {
616 var setImmediateQueue = [];
617 var sentinel = String(Math.random());
618 window.addEventListener("message", function (e) {
619 if (e.data === sentinel) {
620 var queue = setImmediateQueue;
621 setImmediateQueue = [];
622 queue.forEach(function (func) {
623 func();
624 });
625 }
626 });
627 setImmediate = function (func) {
628 setImmediateQueue.push(func);
629 window.postMessage(sentinel, "*");
630 };
631 }
632 var isScheduled = false;
633 var scheduledObservers = [];
634 function scheduleCallback(observer) {
635 scheduledObservers.push(observer);
636 if (!isScheduled) {
637 isScheduled = true;
638 setImmediate(dispatchCallbacks);
639 }
640 }
641 function wrapIfNeeded(node) {
642 return window.ShadowDOMPolyfill && window.ShadowDOMPolyfill.wrapIfNeeded(node) || node;
643 }
644 function dispatchCallbacks() {
645 isScheduled = false;
646 var observers = scheduledObservers;
647 scheduledObservers = [];
648 observers.sort(function (o1, o2) {
649 return o1.uid_ - o2.uid_;
650 });
651 var anyNonEmpty = false;
652 observers.forEach(function (observer) {
653 var queue = observer.takeRecords();
654 removeTransientObserversFor(observer);
655 if (queue.length) {
656 observer.callback_(queue, observer);
657 anyNonEmpty = true;
658 }
659 });
660 if (anyNonEmpty) dispatchCallbacks();
661 }
662 function removeTransientObserversFor(observer) {
663 observer.nodes_.forEach(function (node) {
664 var registrations = registrationsTable.get(node);
665 if (!registrations) return;
666 registrations.forEach(function (registration) {
667 if (registration.observer === observer) registration.removeTransientObservers();
668 });
669 });
670 }
671 function forEachAncestorAndObserverEnqueueRecord(target, callback) {
672 for (var node = target; node; node = node.parentNode) {
673 var registrations = registrationsTable.get(node);
674 if (registrations) {
675 for (var j = 0; j < registrations.length; j++) {
676 var registration = registrations[j];
677 var options = registration.options;
678 if (node !== target && !options.subtree) continue;
679 var record = callback(options);
680 if (record) registration.enqueue(record);
681 }
682 }
683 }
684 }
685 var uidCounter = 0;
686 function JsMutationObserver(callback) {
687 this.callback_ = callback;
688 this.nodes_ = [];
689 this.records_ = [];
690 this.uid_ = ++uidCounter;
691 }
692 JsMutationObserver.prototype = {
693 observe: function observe(target, options) {
694 target = wrapIfNeeded(target);
695 if (!options.childList && !options.attributes && !options.characterData || options.attributeOldValue && !options.attributes || options.attributeFilter && options.attributeFilter.length && !options.attributes || options.characterDataOldValue && !options.characterData) {
696 throw new SyntaxError();
697 }
698 var registrations = registrationsTable.get(target);
699 if (!registrations) registrationsTable.set(target, registrations = []);
700 var registration;
701 for (var i = 0; i < registrations.length; i++) {
702 if (registrations[i].observer === this) {
703 registration = registrations[i];
704 registration.removeListeners();
705 registration.options = options;
706 break;
707 }
708 }
709 if (!registration) {
710 registration = new Registration(this, target, options);
711 registrations.push(registration);
712 this.nodes_.push(target);
713 }
714 registration.addListeners();
715 },
716 disconnect: function disconnect() {
717 this.nodes_.forEach(function (node) {
718 var registrations = registrationsTable.get(node);
719 for (var i = 0; i < registrations.length; i++) {
720 var registration = registrations[i];
721 if (registration.observer === this) {
722 registration.removeListeners();
723 registrations.splice(i, 1);
724 break;
725 }
726 }
727 }, this);
728 this.records_ = [];
729 },
730 takeRecords: function takeRecords() {
731 var copyOfRecords = this.records_;
732 this.records_ = [];
733 return copyOfRecords;
734 }
735 };
736 function MutationRecord(type, target) {
737 this.type = type;
738 this.target = target;
739 this.addedNodes = [];
740 this.removedNodes = [];
741 this.previousSibling = null;
742 this.nextSibling = null;
743 this.attributeName = null;
744 this.attributeNamespace = null;
745 this.oldValue = null;
746 }
747 function copyMutationRecord(original) {
748 var record = new MutationRecord(original.type, original.target);
749 record.addedNodes = original.addedNodes.slice();
750 record.removedNodes = original.removedNodes.slice();
751 record.previousSibling = original.previousSibling;
752 record.nextSibling = original.nextSibling;
753 record.attributeName = original.attributeName;
754 record.attributeNamespace = original.attributeNamespace;
755 record.oldValue = original.oldValue;
756 return record;
757 }
758 var currentRecord, recordWithOldValue;
759 function getRecord(type, target) {
760 return currentRecord = new MutationRecord(type, target);
761 }
762 function getRecordWithOldValue(oldValue) {
763 if (recordWithOldValue) {
764 return recordWithOldValue;
765 }recordWithOldValue = copyMutationRecord(currentRecord);
766 recordWithOldValue.oldValue = oldValue;
767 return recordWithOldValue;
768 }
769 function clearRecords() {
770 currentRecord = recordWithOldValue = undefined;
771 }
772 function recordRepresentsCurrentMutation(record) {
773 return record === recordWithOldValue || record === currentRecord;
774 }
775 function selectRecord(lastRecord, newRecord) {
776 if (lastRecord === newRecord) {
777 return lastRecord;
778 }if (recordWithOldValue && recordRepresentsCurrentMutation(lastRecord)) {
779 return recordWithOldValue;
780 }return null;
781 }
782 function Registration(observer, target, options) {
783 this.observer = observer;
784 this.target = target;
785 this.options = options;
786 this.transientObservedNodes = [];
787 }
788 Registration.prototype = {
789 enqueue: function enqueue(record) {
790 var records = this.observer.records_;
791 var length = records.length;
792 if (records.length > 0) {
793 var lastRecord = records[length - 1];
794 var recordToReplaceLast = selectRecord(lastRecord, record);
795 if (recordToReplaceLast) {
796 records[length - 1] = recordToReplaceLast;
797 return;
798 }
799 } else {
800 scheduleCallback(this.observer);
801 }
802 records[length] = record;
803 },
804 addListeners: function addListeners() {
805 this.addListeners_(this.target);
806 },
807 addListeners_: function addListeners_(node) {
808 var options = this.options;
809 if (options.attributes) node.addEventListener("DOMAttrModified", this, true);
810 if (options.characterData) node.addEventListener("DOMCharacterDataModified", this, true);
811 if (options.childList) node.addEventListener("DOMNodeInserted", this, true);
812 if (options.childList || options.subtree) node.addEventListener("DOMNodeRemoved", this, true);
813 },
814 removeListeners: function removeListeners() {
815 this.removeListeners_(this.target);
816 },
817 removeListeners_: function removeListeners_(node) {
818 var options = this.options;
819 if (options.attributes) node.removeEventListener("DOMAttrModified", this, true);
820 if (options.characterData) node.removeEventListener("DOMCharacterDataModified", this, true);
821 if (options.childList) node.removeEventListener("DOMNodeInserted", this, true);
822 if (options.childList || options.subtree) node.removeEventListener("DOMNodeRemoved", this, true);
823 },
824 addTransientObserver: function addTransientObserver(node) {
825 if (node === this.target) {
826 return;
827 }this.addListeners_(node);
828 this.transientObservedNodes.push(node);
829 var registrations = registrationsTable.get(node);
830 if (!registrations) registrationsTable.set(node, registrations = []);
831 registrations.push(this);
832 },
833 removeTransientObservers: function removeTransientObservers() {
834 var transientObservedNodes = this.transientObservedNodes;
835 this.transientObservedNodes = [];
836 transientObservedNodes.forEach(function (node) {
837 this.removeListeners_(node);
838 var registrations = registrationsTable.get(node);
839 for (var i = 0; i < registrations.length; i++) {
840 if (registrations[i] === this) {
841 registrations.splice(i, 1);
842 break;
843 }
844 }
845 }, this);
846 },
847 handleEvent: function handleEvent(e) {
848 e.stopImmediatePropagation();
849 switch (e.type) {
850 case "DOMAttrModified":
851 var name = e.attrName;
852 var namespace = e.relatedNode.namespaceURI;
853 var target = e.target;
854 var record = new getRecord("attributes", target);
855 record.attributeName = name;
856 record.attributeNamespace = namespace;
857 var oldValue = e.attrChange === MutationEvent.ADDITION ? null : e.prevValue;
858 forEachAncestorAndObserverEnqueueRecord(target, function (options) {
859 if (!options.attributes) return;
860 if (options.attributeFilter && options.attributeFilter.length && options.attributeFilter.indexOf(name) === -1 && options.attributeFilter.indexOf(namespace) === -1) {
861 return;
862 }
863 if (options.attributeOldValue) return getRecordWithOldValue(oldValue);
864 return record;
865 });
866 break;
867
868 case "DOMCharacterDataModified":
869 var target = e.target;
870 var record = getRecord("characterData", target);
871 var oldValue = e.prevValue;
872 forEachAncestorAndObserverEnqueueRecord(target, function (options) {
873 if (!options.characterData) return;
874 if (options.characterDataOldValue) return getRecordWithOldValue(oldValue);
875 return record;
876 });
877 break;
878
879 case "DOMNodeRemoved":
880 this.addTransientObserver(e.target);
881
882 case "DOMNodeInserted":
883 var changedNode = e.target;
884 var addedNodes, removedNodes;
885 if (e.type === "DOMNodeInserted") {
886 addedNodes = [changedNode];
887 removedNodes = [];
888 } else {
889 addedNodes = [];
890 removedNodes = [changedNode];
891 }
892 var previousSibling = changedNode.previousSibling;
893 var nextSibling = changedNode.nextSibling;
894 var record = getRecord("childList", e.target.parentNode);
895 record.addedNodes = addedNodes;
896 record.removedNodes = removedNodes;
897 record.previousSibling = previousSibling;
898 record.nextSibling = nextSibling;
899 forEachAncestorAndObserverEnqueueRecord(e.relatedNode, function (options) {
900 if (!options.childList) return;
901 return record;
902 });
903 }
904 clearRecords();
905 }
906 };
907 global.JsMutationObserver = JsMutationObserver;
908 if (!global.MutationObserver) {
909 global.MutationObserver = JsMutationObserver;
910 JsMutationObserver._isPolyfilled = true;
911 }
912 })(self);
913 })(window); // Atlassian: added IIFE
914 });
915
916 return module.exports;
917}).call(this);
918// node_modules/skatejs/lib/utils.js
919(typeof window === 'undefined' ? global : window).__c962c88861b22faa9e6b0ff498553ca3 = (function () {
920 var module = {
921 exports: {}
922 };
923 var exports = module.exports;
924 var defineDependencies = {
925 "module": module,
926 "exports": exports,
927 "./constants": __3ceacf009ef9ceb3c52ebb9324915170,
928 "./constants": __3ceacf009ef9ceb3c52ebb9324915170
929 };
930 var define = function defineReplacementWrapper(generatedModuleName) {
931 return function defineReplacement(name, deps, func) {
932 var root = (typeof window === 'undefined' ? global : window);
933 var defineGlobal = root.define;
934 var rval;
935 var type;
936
937 func = [func, deps, name].filter(function (cur) {
938 return typeof cur === 'function';
939 })[0];
940 deps = [deps, name, []].filter(Array.isArray)[0];
941 rval = func.apply(null, deps.map(function (value) {
942 return defineDependencies[value];
943 }));
944 type = typeof rval;
945
946 // Support existing AMD libs.
947 if (typeof defineGlobal === 'function') {
948 // Almond always expects a name so resolve one (#29).
949 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
950 }
951
952 // Some processors like Babel don't check to make sure that the module value
953 // is not a primitive before calling Object.defineProperty() on it. We ensure
954 // it is an instance so that it can.
955 if (type === 'string') {
956 rval = String(rval);
957 } else if (type === 'number') {
958 rval = Number(rval);
959 } else if (type === 'boolean') {
960 rval = Boolean(rval);
961 }
962
963 // Reset the exports to the defined module. This is how we convert AMD to
964 // CommonJS and ensures both can either co-exist, or be used separately. We
965 // only set it if it is not defined because there is no object representation
966 // of undefined, thus calling Object.defineProperty() on it would fail.
967 if (rval !== undefined) {
968 exports = module.exports = rval;
969 }
970 };
971 }("__c962c88861b22faa9e6b0ff498553ca3");
972 define.amd = true;
973
974 (function (factory) {
975 if (typeof define === "function" && define.amd) {
976 define(["exports", "./constants"], factory);
977 } else if (typeof exports !== "undefined") {
978 factory(exports, __3ceacf009ef9ceb3c52ebb9324915170);
979 }
980 })(function (exports, _constants) {
981
982 /**
983 * Checks {}.hasOwnProperty in a safe way.
984 *
985 * @param {Object} obj The object the property is on.
986 * @param {String} key The object key to check.
987 *
988 * @returns {Boolean}
989 */
990
991 exports.hasOwn = hasOwn;
992
993 /**
994 * Camel-cases the specified string.
995 *
996 * @param {String} str The string to camel-case.
997 *
998 * @returns {String}
999 */
1000 exports.camelCase = camelCase;
1001
1002 /**
1003 * Returns whether or not the source element contains the target element.
1004 * This is for browsers that don't support Element.prototype.contains on an
1005 * HTMLUnknownElement.
1006 *
1007 * @param {HTMLElement} source The source element.
1008 * @param {HTMLElement} target The target element.
1009 *
1010 * @returns {Boolean}
1011 */
1012 exports.elementContains = elementContains;
1013
1014 /**
1015 * Returns a function that will prevent more than one call in a single clock
1016 * tick.
1017 *
1018 * @param {Function} fn The function to call.
1019 *
1020 * @returns {Function}
1021 */
1022 exports.debounce = debounce;
1023
1024 /**
1025 * Returns whether or not the specified element has been selectively ignored.
1026 *
1027 * @param {Element} element The element to check and traverse up from.
1028 *
1029 * @returns {Boolean}
1030 */
1031 exports.getClosestIgnoredElement = getClosestIgnoredElement;
1032
1033 /**
1034 * Merges the second argument into the first.
1035 *
1036 * @param {Object} child The object to merge into.
1037 * @param {Object} parent The object to merge from.
1038 * @param {Boolean} overwrite Whether or not to overwrite properties on the child.
1039 *
1040 * @returns {Object} Returns the child object.
1041 */
1042 exports.inherit = inherit;
1043
1044 /**
1045 * Traverses an object checking hasOwnProperty.
1046 *
1047 * @param {Object} obj The object to traverse.
1048 * @param {Function} fn The function to call for each item in the object.
1049 *
1050 * @returns {undefined}
1051 */
1052 exports.objEach = objEach;
1053 exports.supportsNativeCustomElements = supportsNativeCustomElements;
1054 exports.isValidNativeCustomElementName = isValidNativeCustomElementName;
1055 Object.defineProperty(exports, "__esModule", {
1056 value: true
1057 });
1058
1059 var ATTR_IGNORE = _constants.ATTR_IGNORE;
1060 var elementPrototype = window.HTMLElement.prototype;
1061 exports.elementPrototype = elementPrototype;
1062 var elementPrototypeContains = elementPrototype.contains;
1063 function hasOwn(obj, key) {
1064 return Object.prototype.hasOwnProperty.call(obj, key);
1065 }
1066
1067 function camelCase(str) {
1068 return str.split(/-/g).map(function (str, index) {
1069 return index === 0 ? str : str[0].toUpperCase() + str.substring(1);
1070 }).join("");
1071 }
1072
1073 function elementContains(source, target) {
1074 // The document element does not have the contains method in IE.
1075 if (source === document && !source.contains) {
1076 return document.head.contains(target) || document.body.contains(target);
1077 }
1078
1079 return source.contains ? source.contains(target) : elementPrototypeContains.call(source, target);
1080 }
1081
1082 function debounce(fn) {
1083 var called = false;
1084
1085 return function () {
1086 if (!called) {
1087 called = true;
1088 setTimeout(function () {
1089 called = false;
1090 fn();
1091 }, 1);
1092 }
1093 };
1094 }
1095
1096 function getClosestIgnoredElement(element) {
1097 var parent = element;
1098
1099 // e.g. document doesn't have a function hasAttribute; no need to go further up
1100 while (parent instanceof Element) {
1101 if (parent.hasAttribute(ATTR_IGNORE)) {
1102 return parent;
1103 }
1104
1105 parent = parent.parentNode;
1106 }
1107 }
1108
1109 function inherit(child, parent, overwrite) {
1110 var names = Object.getOwnPropertyNames(parent);
1111 var namesLen = names.length;
1112
1113 for (var a = 0; a < namesLen; a++) {
1114 var name = names[a];
1115
1116 if (overwrite || child[name] === undefined) {
1117 var desc = Object.getOwnPropertyDescriptor(parent, name);
1118 var shouldDefineProps = desc.get || desc.set || !desc.writable || !desc.enumerable || !desc.configurable;
1119
1120 if (shouldDefineProps) {
1121 Object.defineProperty(child, name, desc);
1122 } else {
1123 child[name] = parent[name];
1124 }
1125 }
1126 }
1127
1128 return child;
1129 }
1130
1131 function objEach(obj, fn) {
1132 for (var a in obj) {
1133 if (hasOwn(obj, a)) {
1134 fn(obj[a], a);
1135 }
1136 }
1137 }
1138
1139 function supportsNativeCustomElements() {
1140 return typeof document.registerElement === "function";
1141 }
1142
1143 function isValidNativeCustomElementName(name) {
1144 return name.indexOf("-") > 0;
1145 }
1146 });
1147
1148 return module.exports;
1149}).call(this);
1150// node_modules/skatejs/lib/registry.js
1151(typeof window === 'undefined' ? global : window).__c4b6ad56719b8affc0c1c55ea177df52 = (function () {
1152 var module = {
1153 exports: {}
1154 };
1155 var exports = module.exports;
1156 var defineDependencies = {
1157 "module": module,
1158 "exports": exports,
1159 "./constants": __3ceacf009ef9ceb3c52ebb9324915170,
1160 "./globals": __df73b283f1d40e8f4912fb904e42aa12,
1161 "./utils": __c962c88861b22faa9e6b0ff498553ca3,
1162 "./constants": __3ceacf009ef9ceb3c52ebb9324915170,
1163 "./globals": __df73b283f1d40e8f4912fb904e42aa12,
1164 "./utils": __c962c88861b22faa9e6b0ff498553ca3
1165 };
1166 var define = function defineReplacementWrapper(generatedModuleName) {
1167 return function defineReplacement(name, deps, func) {
1168 var root = (typeof window === 'undefined' ? global : window);
1169 var defineGlobal = root.define;
1170 var rval;
1171 var type;
1172
1173 func = [func, deps, name].filter(function (cur) {
1174 return typeof cur === 'function';
1175 })[0];
1176 deps = [deps, name, []].filter(Array.isArray)[0];
1177 rval = func.apply(null, deps.map(function (value) {
1178 return defineDependencies[value];
1179 }));
1180 type = typeof rval;
1181
1182 // Support existing AMD libs.
1183 if (typeof defineGlobal === 'function') {
1184 // Almond always expects a name so resolve one (#29).
1185 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
1186 }
1187
1188 // Some processors like Babel don't check to make sure that the module value
1189 // is not a primitive before calling Object.defineProperty() on it. We ensure
1190 // it is an instance so that it can.
1191 if (type === 'string') {
1192 rval = String(rval);
1193 } else if (type === 'number') {
1194 rval = Number(rval);
1195 } else if (type === 'boolean') {
1196 rval = Boolean(rval);
1197 }
1198
1199 // Reset the exports to the defined module. This is how we convert AMD to
1200 // CommonJS and ensures both can either co-exist, or be used separately. We
1201 // only set it if it is not defined because there is no object representation
1202 // of undefined, thus calling Object.defineProperty() on it would fail.
1203 if (rval !== undefined) {
1204 exports = module.exports = rval;
1205 }
1206 };
1207 }("__c4b6ad56719b8affc0c1c55ea177df52");
1208 define.amd = true;
1209
1210 (function (factory) {
1211 if (typeof define === "function" && define.amd) {
1212 define(["exports", "module", "./constants", "./globals", "./utils"], factory);
1213 } else if (typeof exports !== "undefined" && typeof module !== "undefined") {
1214 factory(exports, module, __3ceacf009ef9ceb3c52ebb9324915170, __df73b283f1d40e8f4912fb904e42aa12, __c962c88861b22faa9e6b0ff498553ca3);
1215 }
1216 })(function (exports, module, _constants, _globals, _utils) {
1217
1218 var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
1219
1220 var TYPE_ATTRIBUTE = _constants.TYPE_ATTRIBUTE;
1221 var TYPE_CLASSNAME = _constants.TYPE_CLASSNAME;
1222 var TYPE_ELEMENT = _constants.TYPE_ELEMENT;
1223
1224 var globals = _interopRequire(_globals);
1225
1226 var hasOwn = _utils.hasOwn;
1227 var isValidNativeCustomElementName = _utils.isValidNativeCustomElementName;
1228 var supportsNativeCustomElements = _utils.supportsNativeCustomElements;
1229
1230 /**
1231 * Returns the class list for the specified element.
1232 *
1233 * @param {Element} element The element to get the class list for.
1234 *
1235 * @returns {ClassList | Array}
1236 */
1237 function getClassList(element) {
1238 var classList = element.classList;
1239
1240 if (classList) {
1241 return classList;
1242 }
1243
1244 var attrs = element.attributes;
1245
1246 return attrs["class"] && attrs["class"].nodeValue.split(/\s+/) || [];
1247 }
1248
1249 module.exports = {
1250 clear: function clear() {
1251 globals.registry = {};
1252 return this;
1253 },
1254
1255 get: function get(id) {
1256 return hasOwn(globals.registry, id) && globals.registry[id];
1257 },
1258
1259 getForElement: function getForElement(element) {
1260 var attrs = element.attributes;
1261 var attrsLen = attrs.length;
1262 var definitions = [];
1263 var isAttr = attrs.is;
1264 var isAttrValue = isAttr && (isAttr.value || isAttr.nodeValue);
1265
1266 // Using localName as fallback for edge cases when processing <object> tag that is used
1267 // as inteface to NPAPI plugin.
1268 var tag = (element.tagName || element.localName).toLowerCase();
1269 var isAttrOrTag = isAttrValue || tag;
1270 var definition;
1271 var tagToExtend;
1272
1273 if (this.isType(isAttrOrTag, TYPE_ELEMENT)) {
1274 definition = globals.registry[isAttrOrTag];
1275 tagToExtend = definition["extends"];
1276
1277 if (isAttrValue) {
1278 if (tag === tagToExtend) {
1279 definitions.push(definition);
1280 }
1281 } else if (!tagToExtend) {
1282 definitions.push(definition);
1283 }
1284 }
1285
1286 for (var a = 0; a < attrsLen; a++) {
1287 var attr = attrs[a].nodeName;
1288
1289 if (this.isType(attr, TYPE_ATTRIBUTE)) {
1290 definition = globals.registry[attr];
1291 tagToExtend = definition["extends"];
1292
1293 if (!tagToExtend || tag === tagToExtend) {
1294 definitions.push(definition);
1295 }
1296 }
1297 }
1298
1299 var classList = getClassList(element);
1300 var classListLen = classList.length;
1301
1302 for (var b = 0; b < classListLen; b++) {
1303 var className = classList[b];
1304
1305 if (this.isType(className, TYPE_CLASSNAME)) {
1306 definition = globals.registry[className];
1307 tagToExtend = definition["extends"];
1308
1309 if (!tagToExtend || tag === tagToExtend) {
1310 definitions.push(definition);
1311 }
1312 }
1313 }
1314
1315 return definitions;
1316 },
1317
1318 isType: function isType(id, type) {
1319 var def = this.get(id);
1320 return def && def.type === type;
1321 },
1322
1323 isNativeCustomElement: function isNativeCustomElement(id) {
1324 return supportsNativeCustomElements() && this.isType(id, TYPE_ELEMENT) && isValidNativeCustomElementName(id);
1325 },
1326
1327 set: function set(id, definition) {
1328 if (hasOwn(globals.registry, id)) {
1329 throw new Error("A component definition of type \"" + definition.type + "\" with the ID of \"" + id + "\" already exists.");
1330 }
1331
1332 globals.registry[id] = definition;
1333
1334 return this;
1335 }
1336 };
1337 });
1338
1339 return module.exports;
1340}).call(this);
1341// node_modules/skatejs/lib/lifecycle.js
1342(typeof window === 'undefined' ? global : window).__76ada509bc46d5c68cd543ddd8e839a4 = (function () {
1343 var module = {
1344 exports: {}
1345 };
1346 var exports = module.exports;
1347 var defineDependencies = {
1348 "module": module,
1349 "exports": exports,
1350 "./constants": __3ceacf009ef9ceb3c52ebb9324915170,
1351 "./data": __4666b4efa3069445b77e23d8419d0090,
1352 "./mutation-observer": __c91177d0507115b2c279ac28adb63576,
1353 "./registry": __c4b6ad56719b8affc0c1c55ea177df52,
1354 "./utils": __c962c88861b22faa9e6b0ff498553ca3,
1355 "./constants": __3ceacf009ef9ceb3c52ebb9324915170,
1356 "./data": __4666b4efa3069445b77e23d8419d0090,
1357 "./mutation-observer": __c91177d0507115b2c279ac28adb63576,
1358 "./registry": __c4b6ad56719b8affc0c1c55ea177df52,
1359 "./utils": __c962c88861b22faa9e6b0ff498553ca3
1360 };
1361 var define = function defineReplacementWrapper(generatedModuleName) {
1362 return function defineReplacement(name, deps, func) {
1363 var root = (typeof window === 'undefined' ? global : window);
1364 var defineGlobal = root.define;
1365 var rval;
1366 var type;
1367
1368 func = [func, deps, name].filter(function (cur) {
1369 return typeof cur === 'function';
1370 })[0];
1371 deps = [deps, name, []].filter(Array.isArray)[0];
1372 rval = func.apply(null, deps.map(function (value) {
1373 return defineDependencies[value];
1374 }));
1375 type = typeof rval;
1376
1377 // Support existing AMD libs.
1378 if (typeof defineGlobal === 'function') {
1379 // Almond always expects a name so resolve one (#29).
1380 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
1381 }
1382
1383 // Some processors like Babel don't check to make sure that the module value
1384 // is not a primitive before calling Object.defineProperty() on it. We ensure
1385 // it is an instance so that it can.
1386 if (type === 'string') {
1387 rval = String(rval);
1388 } else if (type === 'number') {
1389 rval = Number(rval);
1390 } else if (type === 'boolean') {
1391 rval = Boolean(rval);
1392 }
1393
1394 // Reset the exports to the defined module. This is how we convert AMD to
1395 // CommonJS and ensures both can either co-exist, or be used separately. We
1396 // only set it if it is not defined because there is no object representation
1397 // of undefined, thus calling Object.defineProperty() on it would fail.
1398 if (rval !== undefined) {
1399 exports = module.exports = rval;
1400 }
1401 };
1402 }("__76ada509bc46d5c68cd543ddd8e839a4");
1403 define.amd = true;
1404
1405 (function (factory) {
1406 if (typeof define === "function" && define.amd) {
1407 define(["exports", "./constants", "./data", "./mutation-observer", "./registry", "./utils"], factory);
1408 } else if (typeof exports !== "undefined") {
1409 factory(exports, __3ceacf009ef9ceb3c52ebb9324915170, __4666b4efa3069445b77e23d8419d0090, __c91177d0507115b2c279ac28adb63576, __c4b6ad56719b8affc0c1c55ea177df52, __c962c88861b22faa9e6b0ff498553ca3);
1410 }
1411 })(function (exports, _constants, _data, _mutationObserver, _registry, _utils) {
1412
1413 var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
1414
1415 Object.defineProperty(exports, "__esModule", {
1416 value: true
1417 });
1418
1419 var ATTR_IGNORE = _constants.ATTR_IGNORE;
1420
1421 var data = _interopRequire(_data);
1422
1423 var registry = _interopRequire(_registry);
1424
1425 var camelCase = _utils.camelCase;
1426 var elementContains = _utils.elementContains;
1427 var hasOwn = _utils.hasOwn;
1428 var inherit = _utils.inherit;
1429 var objEach = _utils.objEach;
1430 var Node = window.Node;
1431 //jshint ignore:line
1432 var elProto = window.HTMLElement.prototype;
1433 var nativeMatchesSelector = elProto.matches || elProto.msMatchesSelector || elProto.webkitMatchesSelector || elProto.mozMatchesSelector || elProto.oMatchesSelector;
1434 // Only IE9 has this msMatchesSelector bug, but best to detect it.
1435 var hasNativeMatchesSelectorDetattachedBug = !nativeMatchesSelector.call(document.createElement("div"), "div");
1436 var matchesSelector = function matchesSelector(element, selector) {
1437 if (hasNativeMatchesSelectorDetattachedBug) {
1438 var clone = element.cloneNode();
1439 document.createElement("div").appendChild(clone);
1440 return nativeMatchesSelector.call(clone, selector);
1441 }
1442 return nativeMatchesSelector.call(element, selector);
1443 };
1444
1445 // Edge has a bug where oldValue is sent as null instead of the true oldValue
1446 // when an element attribute is removed. Bug raised at
1447 // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/7711883/
1448 var needsAttributeOldValueCaching = /Edge/.test(navigator.userAgent);
1449
1450 /**
1451 * Parses an event definition and returns information about it.
1452 *
1453 * @param {String} e The event to parse.
1454 *
1455 * @returns {Object]}
1456 */
1457 function parseEvent(e) {
1458 var parts = e.split(" ");
1459 return {
1460 name: parts.shift(),
1461 delegate: parts.join(" ")
1462 };
1463 }
1464
1465 /**
1466 * Sets the defined attributes to their default values, if specified.
1467 *
1468 * @param {Element} target The web component element.
1469 * @param {Object} component The web component definition.
1470 *
1471 * @returns {undefined}
1472 */
1473 function initAttributes(target, component) {
1474 var componentAttributes = component.attributes;
1475
1476 if (typeof componentAttributes !== "object") {
1477 return;
1478 }
1479
1480 for (var attribute in componentAttributes) {
1481 if (hasOwn(componentAttributes, attribute) && hasOwn(componentAttributes[attribute], "value") && !target.hasAttribute(attribute)) {
1482 var value = componentAttributes[attribute].value;
1483 value = typeof value === "function" ? value(target) : value;
1484 target.setAttribute(attribute, value);
1485 }
1486 }
1487 }
1488
1489 /**
1490 * Defines a property that proxies the specified attribute.
1491 *
1492 * @param {Element} target The web component element.
1493 * @param {String} attribute The attribute name to proxy.
1494 *
1495 * @returns {undefined}
1496 */
1497 function defineAttributeProperty(target, attribute, property) {
1498 Object.defineProperty(target, property, {
1499 get: function get() {
1500 return this.getAttribute(attribute);
1501 },
1502 set: function set(value) {
1503 if (value === undefined) {
1504 this.removeAttribute(attribute);
1505 } else {
1506 this.setAttribute(attribute, value);
1507 }
1508 }
1509 });
1510 }
1511
1512 /**
1513 * Adds links from attributes to properties.
1514 *
1515 * @param {Element} target The web component element.
1516 * @param {Object} component The web component definition.
1517 *
1518 * @returns {undefined}
1519 */
1520 function addAttributeToPropertyLinks(target, component) {
1521 var componentAttributes = component.attributes;
1522
1523 if (typeof componentAttributes !== "object") {
1524 return;
1525 }
1526
1527 for (var attribute in componentAttributes) {
1528 var property = camelCase(attribute);
1529 if (hasOwn(componentAttributes, attribute) && !hasOwn(target, property)) {
1530 defineAttributeProperty(target, attribute, property);
1531 }
1532 }
1533 }
1534
1535 function triggerAttributeChanged(target, component, mutationData) {
1536 var callback;
1537 var type;
1538 var name = mutationData.name;
1539 var newValue = mutationData.newValue;
1540
1541 var cachedAttributeOldValues;
1542 if (needsAttributeOldValueCaching) {
1543 cachedAttributeOldValues = data(target, "cachedAttributeOldValues");
1544 }
1545
1546 // Read the old attribute value from cache if needed, otherwise use native oldValue
1547 var oldValue = needsAttributeOldValueCaching && hasOwn(cachedAttributeOldValues, name) ? cachedAttributeOldValues[name] : mutationData.oldValue;
1548
1549 var newValueIsString = typeof newValue === "string";
1550 var oldValueIsString = typeof oldValue === "string";
1551 var attrs = component.attributes;
1552 var specific = attrs && attrs[name];
1553
1554 if (!oldValueIsString && newValueIsString) {
1555 type = "created";
1556 } else if (oldValueIsString && newValueIsString) {
1557 type = "updated";
1558 } else if (oldValueIsString && !newValueIsString) {
1559 type = "removed";
1560 }
1561
1562 if (needsAttributeOldValueCaching) {
1563 if (type === "removed") {
1564 delete cachedAttributeOldValues[name];
1565 } else {
1566 cachedAttributeOldValues[name] = newValue;
1567 }
1568 }
1569
1570 if (specific && typeof specific[type] === "function") {
1571 callback = specific[type];
1572 } else if (specific && typeof specific.fallback === "function") {
1573 callback = specific.fallback;
1574 } else if (typeof specific === "function") {
1575 callback = specific;
1576 } else if (typeof attrs === "function") {
1577 callback = attrs;
1578 }
1579
1580 // Ensure values are null if undefined.
1581 newValue = newValue === undefined ? null : newValue;
1582 oldValue = oldValue === undefined ? null : oldValue;
1583
1584 // There may still not be a callback.
1585 if (callback) {
1586 callback(target, {
1587 type: type,
1588 name: name,
1589 newValue: newValue,
1590 oldValue: oldValue
1591 });
1592 }
1593 }
1594
1595 function triggerAttributesCreated(target, component) {
1596 var a;
1597 var attrs = target.attributes;
1598 var attrsCopy = [];
1599 var attrsLen = attrs.length;
1600
1601 for (a = 0; a < attrsLen; a++) {
1602 attrsCopy.push(attrs[a]);
1603 }
1604
1605 // In default web components, attribute changes aren't triggered for
1606 // attributes that already exist on an element when it is bound. This sucks
1607 // when you want to reuse and separate code for attributes away from your
1608 // lifecycle callbacks. Skate will initialise each attribute by calling the
1609 // created callback for the attributes that already exist on the element.
1610 for (a = 0; a < attrsLen; a++) {
1611 var attr = attrsCopy[a];
1612 triggerAttributeChanged(target, component, {
1613 name: attr.nodeName,
1614 newValue: attr.value || attr.nodeValue
1615 });
1616 }
1617 }
1618
1619 function addAttributeListeners(target, component) {
1620 var attrs = target.attributes;
1621
1622 if (!component.attributes || registry.isNativeCustomElement(component.id)) {
1623 return;
1624 }
1625
1626 var observer = new window.MutationObserver(function (mutations) {
1627 mutations.forEach(function (mutation) {
1628 var name = mutation.attributeName;
1629 var attr = attrs[name];
1630
1631 triggerAttributeChanged(target, component, {
1632 name: name,
1633 newValue: attr && (attr.value || attr.nodeValue),
1634 oldValue: mutation.oldValue
1635 });
1636 });
1637 });
1638
1639 observer.observe(target, {
1640 attributes: true,
1641 attributeOldValue: true
1642 });
1643 }
1644
1645 /**
1646 * Binds event listeners for the specified event handlers.
1647 *
1648 * @param {Element} target The component element.
1649 * @param {Object} component The component data.
1650 *
1651 * @returns {undefined}
1652 */
1653 function addEventListeners(target, component) {
1654 if (typeof component.events !== "object") {
1655 return;
1656 }
1657
1658 function makeHandler(handler, delegate) {
1659 return function (e) {
1660 // If we're not delegating, trigger directly on the component element.
1661 if (!delegate) {
1662 return handler(target, e, target);
1663 }
1664
1665 // If we're delegating, but the target doesn't match, then we've have
1666 // to go up the tree until we find a matching ancestor or stop at the
1667 // component element, or document. If a matching ancestor is found, the
1668 // handler is triggered on it.
1669 var current = e.target;
1670
1671 while (current && current !== document && current !== target.parentNode) {
1672 if (matchesSelector(current, delegate)) {
1673 return handler(target, e, current);
1674 }
1675
1676 current = current.parentNode;
1677 }
1678 };
1679 }
1680
1681 objEach(component.events, function (handler, name) {
1682 var evt = parseEvent(name);
1683 var useCapture = !!evt.delegate && (evt.name === "blur" || evt.name === "focus");
1684 target.addEventListener(evt.name, makeHandler(handler, evt.delegate), useCapture);
1685 });
1686 }
1687
1688 /**
1689 * Triggers the created lifecycle callback.
1690 *
1691 * @param {Element} target The component element.
1692 * @param {Object} component The component data.
1693 *
1694 * @returns {undefined}
1695 */
1696 function triggerCreated(target, component) {
1697 var targetData = data(target, component.id);
1698
1699 if (targetData.created) {
1700 return;
1701 }
1702
1703 targetData.created = true;
1704
1705 // TODO: This doesn't need to happen if using native.
1706 inherit(target, component.prototype, true);
1707
1708 // We use the unresolved / resolved attributes to flag whether or not the
1709 // element has been templated or not.
1710 if (component.template && !target.hasAttribute(component.resolvedAttribute)) {
1711 component.template(target);
1712 }
1713
1714 target.removeAttribute(component.unresolvedAttribute);
1715 target.setAttribute(component.resolvedAttribute, "");
1716 addEventListeners(target, component);
1717 addAttributeListeners(target, component);
1718 addAttributeToPropertyLinks(target, component);
1719 initAttributes(target, component);
1720 triggerAttributesCreated(target, component);
1721
1722 if (component.created) {
1723 component.created(target);
1724 }
1725 }
1726
1727 /**
1728 * Triggers the attached lifecycle callback.
1729 *
1730 * @param {Element} target The component element.
1731 * @param {Object} component The component data.
1732 *
1733 * @returns {undefined}
1734 */
1735 function triggerAttached(target, component) {
1736 var targetData = data(target, component.id);
1737
1738 if (targetData.attached) {
1739 return;
1740 }
1741
1742 if (!elementContains(document, target)) {
1743 return;
1744 }
1745
1746 targetData.attached = true;
1747
1748 if (component.attached) {
1749 component.attached(target);
1750 }
1751
1752 targetData.detached = false;
1753 }
1754
1755 /**
1756 * Triggers the detached lifecycle callback.
1757 *
1758 * @param {Element} target The component element.
1759 * @param {Object} component The component data.
1760 *
1761 * @returns {undefined}
1762 */
1763 function triggerDetached(target, component) {
1764 var targetData = data(target, component.id);
1765
1766 if (targetData.detached) {
1767 return;
1768 }
1769
1770 targetData.detached = true;
1771
1772 if (component.detached) {
1773 component.detached(target);
1774 }
1775
1776 targetData.attached = false;
1777 }
1778
1779 /**
1780 * Triggers the entire element lifecycle if it's not being ignored.
1781 *
1782 * @param {Element} target The component element.
1783 * @param {Object} component The component data.
1784 *
1785 * @returns {undefined}
1786 */
1787 function triggerLifecycle(target, component) {
1788 triggerCreated(target, component);
1789 triggerAttached(target, component);
1790 }
1791
1792 /**
1793 * Initialises a set of elements.
1794 *
1795 * @param {DOMNodeList | Array} elements A traversable set of elements.
1796 *
1797 * @returns {undefined}
1798 */
1799 function initElements(elements) {
1800 // [CATION] Don't cache elements length! Components initialization could append nodes
1801 // as siblings (see label's element behaviour for example) and this could lead to problems with
1802 // components placed at the end of processing childNodes because they will change they index
1803 // position and get out of cached value range.
1804 for (var a = 0; a < elements.length; a++) {
1805 var element = elements[a];
1806
1807 if (element.nodeType !== Node.ELEMENT_NODE || element.attributes[ATTR_IGNORE]) {
1808 continue;
1809 }
1810
1811 var currentNodeDefinitions = registry.getForElement(element);
1812 var currentNodeDefinitionsLength = currentNodeDefinitions.length;
1813
1814 for (var b = 0; b < currentNodeDefinitionsLength; b++) {
1815 triggerLifecycle(element, currentNodeDefinitions[b]);
1816 }
1817
1818 // When <object> tag is used to expose NPAPI api to js may have different behaviour then other
1819 // tags. One of those differences is that it's childNodes can be undefined.
1820 var elementChildNodes = element.childNodes || [];
1821 var elementChildNodesLen = elementChildNodes.length;
1822
1823 if (elementChildNodesLen) {
1824 initElements(elementChildNodes);
1825 }
1826 }
1827 }
1828
1829 /**
1830 * Triggers the remove lifecycle callback on all of the elements.
1831 *
1832 * @param {DOMNodeList} elements The elements to trigger the remove lifecycle
1833 * callback on.
1834 *
1835 * @returns {undefined}
1836 */
1837 function removeElements(elements) {
1838 // Don't cache `childNodes` length. For more info see description in `initElements` function.
1839 for (var a = 0; a < elements.length; a++) {
1840 var element = elements[a];
1841
1842 if (element.nodeType !== Node.ELEMENT_NODE) {
1843 continue;
1844 }
1845
1846 removeElements(element.childNodes);
1847
1848 var definitions = registry.getForElement(element);
1849 var definitionsLen = definitions.length;
1850
1851 for (var b = 0; b < definitionsLen; b++) {
1852 triggerDetached(element, definitions[b]);
1853 }
1854 }
1855 }
1856
1857 exports.initElements = initElements;
1858 exports.removeElements = removeElements;
1859 exports.triggerAttached = triggerAttached;
1860 exports.triggerAttributeChanged = triggerAttributeChanged;
1861 exports.triggerCreated = triggerCreated;
1862 exports.triggerDetached = triggerDetached;
1863 });
1864
1865 return module.exports;
1866}).call(this);
1867// node_modules/skatejs/lib/fix-ie-innerhtml.js
1868(typeof window === 'undefined' ? global : window).__576655637d4ea6523fc9a23f8a7b3b68 = (function () {
1869 var module = {
1870 exports: {}
1871 };
1872 var exports = module.exports;
1873 var defineDependencies = {
1874 "module": module,
1875 "exports": exports
1876 };
1877 var define = function defineReplacementWrapper(generatedModuleName) {
1878 return function defineReplacement(name, deps, func) {
1879 var root = (typeof window === 'undefined' ? global : window);
1880 var defineGlobal = root.define;
1881 var rval;
1882 var type;
1883
1884 func = [func, deps, name].filter(function (cur) {
1885 return typeof cur === 'function';
1886 })[0];
1887 deps = [deps, name, []].filter(Array.isArray)[0];
1888 rval = func.apply(null, deps.map(function (value) {
1889 return defineDependencies[value];
1890 }));
1891 type = typeof rval;
1892
1893 // Support existing AMD libs.
1894 if (typeof defineGlobal === 'function') {
1895 // Almond always expects a name so resolve one (#29).
1896 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
1897 }
1898
1899 // Some processors like Babel don't check to make sure that the module value
1900 // is not a primitive before calling Object.defineProperty() on it. We ensure
1901 // it is an instance so that it can.
1902 if (type === 'string') {
1903 rval = String(rval);
1904 } else if (type === 'number') {
1905 rval = Number(rval);
1906 } else if (type === 'boolean') {
1907 rval = Boolean(rval);
1908 }
1909
1910 // Reset the exports to the defined module. This is how we convert AMD to
1911 // CommonJS and ensures both can either co-exist, or be used separately. We
1912 // only set it if it is not defined because there is no object representation
1913 // of undefined, thus calling Object.defineProperty() on it would fail.
1914 if (rval !== undefined) {
1915 exports = module.exports = rval;
1916 }
1917 };
1918 }("__576655637d4ea6523fc9a23f8a7b3b68");
1919 define.amd = true;
1920
1921 (function (factory) {
1922 if (typeof define === "function" && define.amd) {
1923 define(["exports"], factory);
1924 } else if (typeof exports !== "undefined") {
1925 factory(exports);
1926 }
1927 })(function (exports) {
1928
1929 var isIeUntil10 = /MSIE/.test(navigator.userAgent);
1930 var isIe11 = /Trident/.test(navigator.userAgent);
1931 var isIe = isIeUntil10 || isIe11;
1932 var elementPrototype = window.HTMLElement.prototype;
1933
1934 // ! This walkTree method differs from the implementation in ../../utils/walk-tree
1935 // It invokes the callback only for the children, not the passed node and the second parameter to the callback is the parent node
1936 function walkTree(node, cb) {
1937 var childNodes = node.childNodes;
1938
1939 if (!childNodes) {
1940 return;
1941 }
1942
1943 var childNodesLen = childNodes.length;
1944
1945 for (var a = 0; a < childNodesLen; a++) {
1946 var childNode = childNodes[a];
1947 cb(childNode, node);
1948 walkTree(childNode, cb);
1949 }
1950 }
1951
1952 function fixInnerHTML() {
1953 var originalInnerHTML = Object.getOwnPropertyDescriptor(elementPrototype, "innerHTML");
1954
1955 var get = function get() {
1956 return originalInnerHTML.get.call(this);
1957 };
1958 get._hasBeenEnhanced = true;
1959
1960 // This redefines the innerHTML property so that we can ensure that events
1961 // are properly triggered.
1962 Object.defineProperty(elementPrototype, "innerHTML", {
1963 get: get,
1964 set: function set(html) {
1965 walkTree(this, function (node, parentNode) {
1966 var mutationEvent = document.createEvent("MutationEvent");
1967 mutationEvent.initMutationEvent("DOMNodeRemoved", true, false, parentNode, null, null, null, null);
1968 node.dispatchEvent(mutationEvent);
1969 });
1970 originalInnerHTML.set.call(this, html);
1971 }
1972 });
1973 }
1974
1975 if (isIe) {
1976 // IE 9-11
1977 var propertyDescriptor = Object.getOwnPropertyDescriptor(elementPrototype, "innerHTML");
1978 var hasBeenEnhanced = !!propertyDescriptor && propertyDescriptor.get._hasBeenEnhanced;
1979
1980 if (!hasBeenEnhanced) {
1981 if (isIe11) {
1982 // IE11's native MutationObserver needs some help as well :()
1983 window.MutationObserver = window.JsMutationObserver || window.MutationObserver;
1984 }
1985
1986 fixInnerHTML();
1987 }
1988 }
1989 });
1990
1991 return module.exports;
1992}).call(this);
1993// node_modules/skatejs/lib/document-observer.js
1994(typeof window === 'undefined' ? global : window).__3c8c6233f9ea85a9125bd2a1e04f063c = (function () {
1995 var module = {
1996 exports: {}
1997 };
1998 var exports = module.exports;
1999 var defineDependencies = {
2000 "module": module,
2001 "exports": exports,
2002 "./globals": __df73b283f1d40e8f4912fb904e42aa12,
2003 "./lifecycle": __76ada509bc46d5c68cd543ddd8e839a4,
2004 "./mutation-observer": __c91177d0507115b2c279ac28adb63576,
2005 "./fix-ie-innerhtml": __576655637d4ea6523fc9a23f8a7b3b68,
2006 "./utils": __c962c88861b22faa9e6b0ff498553ca3,
2007 "./globals": __df73b283f1d40e8f4912fb904e42aa12,
2008 "./lifecycle": __76ada509bc46d5c68cd543ddd8e839a4,
2009 "./mutation-observer": __c91177d0507115b2c279ac28adb63576,
2010 "./fix-ie-innerhtml": __576655637d4ea6523fc9a23f8a7b3b68,
2011 "./utils": __c962c88861b22faa9e6b0ff498553ca3
2012 };
2013 var define = function defineReplacementWrapper(generatedModuleName) {
2014 return function defineReplacement(name, deps, func) {
2015 var root = (typeof window === 'undefined' ? global : window);
2016 var defineGlobal = root.define;
2017 var rval;
2018 var type;
2019
2020 func = [func, deps, name].filter(function (cur) {
2021 return typeof cur === 'function';
2022 })[0];
2023 deps = [deps, name, []].filter(Array.isArray)[0];
2024 rval = func.apply(null, deps.map(function (value) {
2025 return defineDependencies[value];
2026 }));
2027 type = typeof rval;
2028
2029 // Support existing AMD libs.
2030 if (typeof defineGlobal === 'function') {
2031 // Almond always expects a name so resolve one (#29).
2032 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
2033 }
2034
2035 // Some processors like Babel don't check to make sure that the module value
2036 // is not a primitive before calling Object.defineProperty() on it. We ensure
2037 // it is an instance so that it can.
2038 if (type === 'string') {
2039 rval = String(rval);
2040 } else if (type === 'number') {
2041 rval = Number(rval);
2042 } else if (type === 'boolean') {
2043 rval = Boolean(rval);
2044 }
2045
2046 // Reset the exports to the defined module. This is how we convert AMD to
2047 // CommonJS and ensures both can either co-exist, or be used separately. We
2048 // only set it if it is not defined because there is no object representation
2049 // of undefined, thus calling Object.defineProperty() on it would fail.
2050 if (rval !== undefined) {
2051 exports = module.exports = rval;
2052 }
2053 };
2054 }("__3c8c6233f9ea85a9125bd2a1e04f063c");
2055 define.amd = true;
2056
2057 (function (factory) {
2058 if (typeof define === "function" && define.amd) {
2059 define(["exports", "module", "./globals", "./lifecycle", "./mutation-observer", "./fix-ie-innerhtml", "./utils"], factory);
2060 } else if (typeof exports !== "undefined" && typeof module !== "undefined") {
2061 factory(exports, module, __df73b283f1d40e8f4912fb904e42aa12, __76ada509bc46d5c68cd543ddd8e839a4, __c91177d0507115b2c279ac28adb63576, __576655637d4ea6523fc9a23f8a7b3b68, __c962c88861b22faa9e6b0ff498553ca3);
2062 }
2063 })(function (exports, module, _globals, _lifecycle, _mutationObserver, _fixIeInnerhtml, _utils) {
2064
2065 var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
2066
2067 var globals = _interopRequire(_globals);
2068
2069 var initElements = _lifecycle.initElements;
2070 var removeElements = _lifecycle.removeElements;
2071 var getClosestIgnoredElement = _utils.getClosestIgnoredElement;
2072
2073 /**
2074 * The document observer handler.
2075 *
2076 * @param {Array} mutations The mutations to handle.
2077 *
2078 * @returns {undefined}
2079 */
2080 function documentObserverHandler(mutations) {
2081 var mutationsLen = mutations.length;
2082
2083 for (var a = 0; a < mutationsLen; a++) {
2084 var mutation = mutations[a];
2085 var addedNodes = mutation.addedNodes;
2086 var removedNodes = mutation.removedNodes;
2087
2088 // Since siblings are batched together, we check the first node's parent
2089 // node to see if it is ignored. If it is then we don't process any added
2090 // nodes. This prevents having to check every node.
2091 if (addedNodes && addedNodes.length && !getClosestIgnoredElement(addedNodes[0].parentNode)) {
2092 initElements(addedNodes);
2093 }
2094
2095 // We can't check batched nodes here because they won't have a parent node.
2096 if (removedNodes && removedNodes.length) {
2097 removeElements(removedNodes);
2098 }
2099 }
2100 }
2101
2102 /**
2103 * Creates a new mutation observer for listening to Skate definitions for the
2104 * document.
2105 *
2106 * @param {Element} root The element to observe.
2107 *
2108 * @returns {MutationObserver}
2109 */
2110 function createDocumentObserver() {
2111 var observer = new window.MutationObserver(documentObserverHandler);
2112
2113 // Observe after the DOM content has loaded.
2114 observer.observe(document, {
2115 childList: true,
2116 subtree: true
2117 });
2118
2119 return observer;
2120 }
2121
2122 module.exports = {
2123 register: function register(fixIe) {
2124 // IE has issues with reporting removedNodes correctly. See the polyfill for
2125 // details. If we fix IE, we must also re-define the document observer.
2126 if (fixIe) {
2127 this.unregister();
2128 }
2129
2130 if (!globals.observer) {
2131 globals.observer = createDocumentObserver();
2132 }
2133
2134 return this;
2135 },
2136
2137 unregister: function unregister() {
2138 if (globals.observer) {
2139 globals.observer.disconnect();
2140 globals.observer = undefined;
2141 }
2142
2143 return this;
2144 }
2145 };
2146 });
2147
2148 return module.exports;
2149}).call(this);
2150// node_modules/skatejs/lib/skate.js
2151(typeof window === 'undefined' ? global : window).__612b714a7afa741ae272e3b4821d110b = (function () {
2152 var module = {
2153 exports: {}
2154 };
2155 var exports = module.exports;
2156 var defineDependencies = {
2157 "module": module,
2158 "exports": exports,
2159 "./constants": __3ceacf009ef9ceb3c52ebb9324915170,
2160 "./document-observer": __3c8c6233f9ea85a9125bd2a1e04f063c,
2161 "./lifecycle": __76ada509bc46d5c68cd543ddd8e839a4,
2162 "./registry": __c4b6ad56719b8affc0c1c55ea177df52,
2163 "./utils": __c962c88861b22faa9e6b0ff498553ca3,
2164 "./version": __15c28555b7ada36a99309d466d5cff55,
2165 "./constants": __3ceacf009ef9ceb3c52ebb9324915170,
2166 "./document-observer": __3c8c6233f9ea85a9125bd2a1e04f063c,
2167 "./lifecycle": __76ada509bc46d5c68cd543ddd8e839a4,
2168 "./registry": __c4b6ad56719b8affc0c1c55ea177df52,
2169 "./utils": __c962c88861b22faa9e6b0ff498553ca3,
2170 "./version": __15c28555b7ada36a99309d466d5cff55
2171 };
2172 var define = function defineReplacementWrapper(generatedModuleName) {
2173 return function defineReplacement(name, deps, func) {
2174 var root = (typeof window === 'undefined' ? global : window);
2175 var defineGlobal = root.define;
2176 var rval;
2177 var type;
2178
2179 func = [func, deps, name].filter(function (cur) {
2180 return typeof cur === 'function';
2181 })[0];
2182 deps = [deps, name, []].filter(Array.isArray)[0];
2183 rval = func.apply(null, deps.map(function (value) {
2184 return defineDependencies[value];
2185 }));
2186 type = typeof rval;
2187
2188 // Support existing AMD libs.
2189 if (typeof defineGlobal === 'function') {
2190 // Almond always expects a name so resolve one (#29).
2191 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
2192 }
2193
2194 // Some processors like Babel don't check to make sure that the module value
2195 // is not a primitive before calling Object.defineProperty() on it. We ensure
2196 // it is an instance so that it can.
2197 if (type === 'string') {
2198 rval = String(rval);
2199 } else if (type === 'number') {
2200 rval = Number(rval);
2201 } else if (type === 'boolean') {
2202 rval = Boolean(rval);
2203 }
2204
2205 // Reset the exports to the defined module. This is how we convert AMD to
2206 // CommonJS and ensures both can either co-exist, or be used separately. We
2207 // only set it if it is not defined because there is no object representation
2208 // of undefined, thus calling Object.defineProperty() on it would fail.
2209 if (rval !== undefined) {
2210 exports = module.exports = rval;
2211 }
2212 };
2213 }("__612b714a7afa741ae272e3b4821d110b");
2214 define.amd = true;
2215
2216 (function (factory) {
2217 if (typeof define === "function" && define.amd) {
2218 define(["exports", "module", "./constants", "./document-observer", "./lifecycle", "./registry", "./utils", "./version"], factory);
2219 } else if (typeof exports !== "undefined" && typeof module !== "undefined") {
2220 factory(exports, module, __3ceacf009ef9ceb3c52ebb9324915170, __3c8c6233f9ea85a9125bd2a1e04f063c, __76ada509bc46d5c68cd543ddd8e839a4, __c4b6ad56719b8affc0c1c55ea177df52, __c962c88861b22faa9e6b0ff498553ca3, __15c28555b7ada36a99309d466d5cff55);
2221 }
2222 })(function (exports, module, _constants, _documentObserver, _lifecycle, _registry, _utils, _version) {
2223
2224 var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
2225
2226 var TYPE_ATTRIBUTE = _constants.TYPE_ATTRIBUTE;
2227 var TYPE_CLASSNAME = _constants.TYPE_CLASSNAME;
2228 var TYPE_ELEMENT = _constants.TYPE_ELEMENT;
2229
2230 var documentObserver = _interopRequire(_documentObserver);
2231
2232 var triggerCreated = _lifecycle.triggerCreated;
2233 var triggerAttached = _lifecycle.triggerAttached;
2234 var triggerDetached = _lifecycle.triggerDetached;
2235 var triggerAttributeChanged = _lifecycle.triggerAttributeChanged;
2236 var initElements = _lifecycle.initElements;
2237
2238 var registry = _interopRequire(_registry);
2239
2240 var debounce = _utils.debounce;
2241 var inherit = _utils.inherit;
2242
2243 var version = _interopRequire(_version);
2244
2245 var HTMLElement = window.HTMLElement; //jshint ignore:line
2246
2247 // IE <= 10 can fire "interactive" too early (#243).
2248 var isOldIE = !!document.attachEvent; // attachEvent was removed in IE11.
2249
2250 function isReady() {
2251 if (isOldIE) {
2252 return document.readyState === "complete";
2253 } else {
2254 return document.readyState === "interactive" || document.readyState === "complete";
2255 }
2256 }
2257
2258 /**
2259 * Initialises all valid elements in the document. Ensures that it does not
2260 * happen more than once in the same execution, and that it happens after the DOM is ready.
2261 *
2262 * @returns {undefined}
2263 */
2264 var initDocument = debounce(function () {
2265 var initialiseSkateElementsOnDomLoad = function initialiseSkateElementsOnDomLoad() {
2266 initElements(document.documentElement.childNodes);
2267 };
2268 if (isReady()) {
2269 initialiseSkateElementsOnDomLoad();
2270 } else {
2271 if (isOldIE) {
2272 window.addEventListener("load", initialiseSkateElementsOnDomLoad);
2273 } else {
2274 document.addEventListener("DOMContentLoaded", initialiseSkateElementsOnDomLoad);
2275 }
2276 }
2277 });
2278
2279 /**
2280 * Creates a constructor for the specified definition.
2281 *
2282 * @param {Object} definition The definition information to use for generating the constructor.
2283 *
2284 * @returns {Function} The element constructor.
2285 */
2286 function makeElementConstructor(definition) {
2287 function CustomElement() {
2288 var element;
2289 var tagToExtend = definition["extends"];
2290 var definitionId = definition.id;
2291
2292 if (tagToExtend) {
2293 element = document.createElement(tagToExtend);
2294 element.setAttribute("is", definitionId);
2295 } else {
2296 element = document.createElement(definitionId);
2297 }
2298
2299 // Ensure the definition prototype is up to date with the element's
2300 // prototype. This ensures that overwriting the element prototype still
2301 // works.
2302 definition.prototype = CustomElement.prototype;
2303
2304 // If they use the constructor we don't have to wait until it's attached.
2305 triggerCreated(element, definition);
2306
2307 return element;
2308 }
2309
2310 // This allows modifications to the element prototype propagate to the
2311 // definition prototype.
2312 CustomElement.prototype = definition.prototype;
2313
2314 return CustomElement;
2315 }
2316
2317 // Public API
2318 // ----------
2319
2320 /**
2321 * Creates a listener for the specified definition.
2322 *
2323 * @param {String} id The ID of the definition.
2324 * @param {Object | Function} definition The definition definition.
2325 *
2326 * @returns {Function} Constructor that returns a custom element.
2327 */
2328 function skate(id, definition) {
2329 // Just in case the definition is shared, we duplicate it so that internal
2330 // modifications to the original aren't shared.
2331 definition = inherit({}, definition);
2332 definition = inherit(definition, skate.defaults);
2333 definition.id = id;
2334
2335 registry.set(id, definition);
2336
2337 if (registry.isNativeCustomElement(id)) {
2338 var elementPrototype = definition["extends"] ? document.createElement(definition["extends"]).constructor.prototype : HTMLElement.prototype;
2339
2340 if (!elementPrototype.isPrototypeOf(definition.prototype)) {
2341 definition.prototype = inherit(Object.create(elementPrototype), definition.prototype, true);
2342 }
2343
2344 var options = {
2345 prototype: inherit(definition.prototype, {
2346 createdCallback: function createdCallback() {
2347 triggerCreated(this, definition);
2348 },
2349 attachedCallback: function attachedCallback() {
2350 triggerAttached(this, definition);
2351 },
2352 detachedCallback: function detachedCallback() {
2353 triggerDetached(this, definition);
2354 },
2355 attributeChangedCallback: function attributeChangedCallback(name, oldValue, newValue) {
2356 triggerAttributeChanged(this, definition, {
2357 name: name,
2358 oldValue: oldValue,
2359 newValue: newValue
2360 });
2361 }
2362 })
2363 };
2364
2365 if (definition["extends"]) {
2366 options["extends"] = definition["extends"];
2367 }
2368
2369 return document.registerElement(id, options);
2370 }
2371
2372 initDocument();
2373 documentObserver.register(!!definition.detached);
2374
2375 if (registry.isType(id, TYPE_ELEMENT)) {
2376 return makeElementConstructor(definition);
2377 }
2378 }
2379
2380 /**
2381 * Synchronously initialises the specified element or elements and descendants.
2382 *
2383 * @param {Mixed} nodes The node, or nodes to initialise. Can be anything:
2384 * jQuery, DOMNodeList, DOMNode, selector etc.
2385 *
2386 * @returns {skate}
2387 */
2388 skate.init = function (nodes) {
2389 var nodesToUse = nodes;
2390
2391 if (!nodes) {
2392 return nodes;
2393 }
2394
2395 if (typeof nodes === "string") {
2396 nodesToUse = nodes = document.querySelectorAll(nodes);
2397 } else if (nodes instanceof HTMLElement) {
2398 nodesToUse = [nodes];
2399 }
2400
2401 initElements(nodesToUse);
2402
2403 return nodes;
2404 };
2405
2406 // Restriction type constants.
2407 skate.type = {
2408 ATTRIBUTE: TYPE_ATTRIBUTE,
2409 CLASSNAME: TYPE_CLASSNAME,
2410 ELEMENT: TYPE_ELEMENT
2411 };
2412
2413 // Makes checking the version easy when debugging.
2414 skate.version = version;
2415
2416 /**
2417 * The default options for a definition.
2418 *
2419 * @var {Object}
2420 */
2421 skate.defaults = {
2422 // Attribute lifecycle callback or callbacks.
2423 attributes: undefined,
2424
2425 // The events to manage the binding and unbinding of during the definition's
2426 // lifecycle.
2427 events: undefined,
2428
2429 // Restricts a particular definition to binding explicitly to an element with
2430 // a tag name that matches the specified value.
2431 "extends": undefined,
2432
2433 // The ID of the definition. This is automatically set in the `skate()`
2434 // function.
2435 id: "",
2436
2437 // Properties and methods to add to each element.
2438 prototype: {},
2439
2440 // The attribute name to add after calling the created() callback.
2441 resolvedAttribute: "resolved",
2442
2443 // The template to replace the content of the element with.
2444 template: undefined,
2445
2446 // The type of bindings to allow.
2447 type: TYPE_ELEMENT,
2448
2449 // The attribute name to remove after calling the created() callback.
2450 unresolvedAttribute: "unresolved"
2451 };
2452
2453 // Exporting
2454 // ---------
2455
2456 var previousSkate = window.skate;
2457 skate.noConflict = function () {
2458 window.skate = previousSkate;
2459 return skate;
2460 };
2461
2462 // Global
2463 window.skate = skate;
2464
2465 // ES6
2466 module.exports = skate;
2467 });
2468
2469 return module.exports;
2470}).call(this);
2471// node_modules/@atlassian/aui/src/js/aui/internal/skate.js
2472(typeof window === 'undefined' ? global : window).__c1ce1f1e3e613f564fc234ff043570f1 = (function () {
2473 var module = {
2474 exports: {}
2475 };
2476 var exports = module.exports;
2477
2478 'use strict';
2479
2480 Object.defineProperty(exports, "__esModule", {
2481 value: true
2482 });
2483
2484 var _skatejs = __612b714a7afa741ae272e3b4821d110b;
2485
2486 var _skatejs2 = _interopRequireDefault(_skatejs);
2487
2488 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
2489
2490 var auiSkate = _skatejs2.default.noConflict();
2491
2492 exports.default = auiSkate;
2493 module.exports = exports['default'];
2494
2495 return module.exports;
2496}).call(this);
2497// node_modules/skatejs-template-html/dist/template-html.js
2498(typeof window === 'undefined' ? global : window).__f52b7059926ab2bdcd0aee12b4bc782b = (function () {
2499 var module = {
2500 exports: {}
2501 };
2502 var exports = module.exports;
2503 var defineDependencies = {
2504 "module": module,
2505 "exports": exports
2506 };
2507 var define = function defineReplacementWrapper(generatedModuleName) {
2508 return function defineReplacement(name, deps, func) {
2509 var root = (typeof window === 'undefined' ? global : window);
2510 var defineGlobal = root.define;
2511 var rval;
2512 var type;
2513
2514 func = [func, deps, name].filter(function (cur) {
2515 return typeof cur === 'function';
2516 })[0];
2517 deps = [deps, name, []].filter(Array.isArray)[0];
2518 rval = func.apply(null, deps.map(function (value) {
2519 return defineDependencies[value];
2520 }));
2521 type = typeof rval;
2522
2523 // Support existing AMD libs.
2524 if (typeof defineGlobal === 'function') {
2525 // Almond always expects a name so resolve one (#29).
2526 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
2527 }
2528
2529 // Some processors like Babel don't check to make sure that the module value
2530 // is not a primitive before calling Object.defineProperty() on it. We ensure
2531 // it is an instance so that it can.
2532 if (type === 'string') {
2533 rval = String(rval);
2534 } else if (type === 'number') {
2535 rval = Number(rval);
2536 } else if (type === 'boolean') {
2537 rval = Boolean(rval);
2538 }
2539
2540 // Reset the exports to the defined module. This is how we convert AMD to
2541 // CommonJS and ensures both can either co-exist, or be used separately. We
2542 // only set it if it is not defined because there is no object representation
2543 // of undefined, thus calling Object.defineProperty() on it would fail.
2544 if (rval !== undefined) {
2545 exports = module.exports = rval;
2546 }
2547 };
2548 }("__f52b7059926ab2bdcd0aee12b4bc782b");
2549 define.amd = true;
2550
2551 (function () {
2552
2553 var DocumentFragment = window.DocumentFragment;
2554 var elProto = window.HTMLElement.prototype;
2555 var matchesSelector = (
2556 elProto.matches ||
2557 elProto.msMatchesSelector ||
2558 elProto.webkitMatchesSelector ||
2559 elProto.mozMatchesSelector ||
2560 elProto.oMatchesSelector
2561 );
2562
2563 function getData (element, name) {
2564 if (element.__SKATE_TEMPLATE_HTML_DATA) {
2565 return element.__SKATE_TEMPLATE_HTML_DATA[name];
2566 }
2567 }
2568
2569 function setData (element, name, value) {
2570 if (!element.__SKATE_TEMPLATE_HTML_DATA) {
2571 element.__SKATE_TEMPLATE_HTML_DATA = {};
2572 }
2573
2574 element.__SKATE_TEMPLATE_HTML_DATA[name] = value;
2575
2576 return element;
2577 }
2578
2579 function createFragmentFromString (domString) {
2580 var specialMap = {
2581 caption: 'table',
2582 dd: 'dl',
2583 dt: 'dl',
2584 li: 'ul',
2585 tbody: 'table',
2586 td: 'tr',
2587 thead: 'table',
2588 tr: 'tbody'
2589 };
2590
2591 var tag = domString.match(/\s*<([^\s>]+)/);
2592 var div = document.createElement(tag && specialMap[tag[1]] || 'div');
2593
2594 div.innerHTML = domString;
2595
2596 return createFragmentFromNodeList(div.childNodes);
2597 }
2598
2599 function createFragmentFromNodeList (nodeList) {
2600 var frag = document.createDocumentFragment();
2601
2602 while (nodeList && nodeList.length) {
2603 frag.appendChild(nodeList[0]);
2604 }
2605
2606 return frag;
2607 }
2608
2609 function getNodesBetween (startNode, endNode) {
2610 var nodes = [];
2611 var nextNode = startNode.nextSibling;
2612
2613 while (nextNode !== endNode) {
2614 nodes.push(nextNode);
2615 nextNode = nextNode.nextSibling;
2616 }
2617
2618 return nodes;
2619 }
2620
2621 function findChildrenMatchingSelector (sourceNode, selector) {
2622 if (selector) {
2623 var found = sourceNode.querySelectorAll(selector);
2624 var foundLength = found.length;
2625 var filtered = [];
2626
2627 for (var a = 0; a < foundLength; a++) {
2628 var node = found[a];
2629
2630 if (node.parentNode === sourceNode) {
2631 filtered.push(node);
2632 }
2633 }
2634
2635 return filtered;
2636 }
2637
2638 return [].slice.call(sourceNode.childNodes) || [];
2639 }
2640
2641 function htmlTemplateParentWrapper (element) {
2642 var contentNodes = getData(element, 'content');
2643 var contentNodesLen = contentNodes.length;
2644
2645 return {
2646 childNodes: {
2647 get: function () {
2648 var nodes = [];
2649
2650 for (var a = 0; a < contentNodesLen; a++) {
2651 var contentNode = contentNodes[a];
2652
2653 if (contentNode.isDefault) {
2654 continue;
2655 }
2656
2657 nodes = nodes.concat(getNodesBetween(contentNode.startNode, contentNode.endNode));
2658 }
2659
2660 return nodes;
2661 }
2662 },
2663
2664 firstChild: {
2665 get: function () {
2666 var childNodes = this.childNodes;
2667 return childNodes.length && childNodes[0] || null;
2668 }
2669 },
2670
2671 innerHTML: {
2672 get: function () {
2673 var html = '';
2674 var childNodes = this.childNodes;
2675 var childNodesLen = childNodes.length;
2676
2677 for (var a = 0; a < childNodesLen; a++) {
2678 var childNode = childNodes[a];
2679 html += childNode.outerHTML || childNode.textContent;
2680 }
2681
2682 return html;
2683 },
2684 set: function (html) {
2685 var targetFragment = createFragmentFromString(html);
2686
2687 for (var a = 0; a < contentNodesLen; a++) {
2688 var contentNode = contentNodes[a];
2689 var childNodes = getNodesBetween(contentNode.startNode, contentNode.endNode);
2690
2691 // Remove all nodes (including default content).
2692 for (var b = 0; b < childNodes.length; b++) {
2693 var childNode = childNodes[b];
2694 childNode.parentNode.removeChild(childNode);
2695 }
2696
2697 var foundNodes = findChildrenMatchingSelector(targetFragment, contentNode.selector);
2698
2699 // Add any matched nodes from the given HTML.
2700 for (var c = 0; c < foundNodes.length; c++) {
2701 contentNode.container.insertBefore(foundNodes[c], contentNode.endNode);
2702 }
2703
2704 // If no nodes were found, set the default content.
2705 if (foundNodes.length) {
2706 removeDefaultContent(contentNode);
2707 } else {
2708 addDefaultContent(contentNode);
2709 }
2710 }
2711 }
2712 },
2713
2714 lastChild: {
2715 get: function () {
2716 for (var a = contentNodesLen - 1; a > -1; a--) {
2717 var contentNode = contentNodes[a];
2718
2719 if (contentNode.isDefault) {
2720 continue;
2721 }
2722
2723 var childNodes = this.childNodes;
2724 var childNodesLen = childNodes.length;
2725
2726 return childNodes[childNodesLen - 1];
2727 }
2728
2729 return null;
2730 }
2731 },
2732
2733 outerHTML: {
2734 get: function () {
2735 var name = this.tagName.toLowerCase();
2736 var html = '<' + name;
2737 var attrs = this.attributes;
2738
2739 if (attrs) {
2740 var attrsLength = attrs.length;
2741
2742 for (var a = 0; a < attrsLength; a++) {
2743 var attr = attrs[a];
2744 html += ' ' + attr.nodeName + '="' + attr.nodeValue + '"';
2745 }
2746 }
2747
2748 html += '>';
2749 html += this.innerHTML;
2750 html += '</' + name + '>';
2751
2752 return html;
2753 }
2754 },
2755
2756 textContent: {
2757 get: function () {
2758 var textContent = '';
2759 var childNodes = this.childNodes;
2760 var childNodesLength = this.childNodes.length;
2761
2762 for (var a = 0; a < childNodesLength; a++) {
2763 textContent += childNodes[a].textContent;
2764 }
2765
2766 return textContent;
2767 },
2768 set: function (textContent) {
2769 var acceptsTextContent;
2770
2771 // Removes all nodes (including default content).
2772 this.innerHTML = '';
2773
2774 // Find the first content node without a selector.
2775 for (var a = 0; a < contentNodesLen; a++) {
2776 var contentNode = contentNodes[a];
2777
2778 if (!contentNode.selector) {
2779 acceptsTextContent = contentNode;
2780 break;
2781 }
2782 }
2783
2784 // There may be no content nodes that accept text content.
2785 if (acceptsTextContent) {
2786 if (textContent) {
2787 removeDefaultContent(acceptsTextContent);
2788 acceptsTextContent.container.insertBefore(document.createTextNode(textContent), acceptsTextContent.endNode);
2789 } else {
2790 addDefaultContent(acceptsTextContent);
2791 }
2792 }
2793 }
2794 },
2795
2796 appendChild: {
2797 value: function (node) {
2798 if (node instanceof DocumentFragment) {
2799 var fragChildNodes = node.childNodes;
2800
2801 [].slice.call(fragChildNodes).forEach(function (node) {
2802 this.appendChild(node);
2803 }.bind(this));
2804
2805 return this;
2806 }
2807
2808 for (var b = 0; b < contentNodesLen; b++) {
2809 var contentNode = contentNodes[b];
2810 var contentSelector = contentNode.selector;
2811
2812 if (!contentSelector || node instanceof window.HTMLElement && matchesSelector.call(node, contentSelector)) {
2813 removeDefaultContent(contentNode);
2814 contentNode.endNode.parentNode.insertBefore(node, contentNode.endNode);
2815 break;
2816 }
2817 }
2818
2819 return this;
2820 }
2821 },
2822
2823 insertAdjacentHTML: {
2824 value: function (where, html) {
2825 if (where === 'afterbegin') {
2826 this.insertBefore(createFragmentFromString(html), this.childNodes[0]);
2827 } else if (where === 'beforeend') {
2828 this.appendChild(createFragmentFromString(html));
2829 } else {
2830 element.insertAdjacentHTML(where, html);
2831 }
2832
2833 return this;
2834 }
2835 },
2836
2837 insertBefore: {
2838 value: function (node, referenceNode) {
2839 // If no reference node is supplied, we append. This also means that we
2840 // don't need to add / remove any default content because either there
2841 // aren't any nodes or appendChild will handle it.
2842 if (!referenceNode) {
2843 return this.appendChild(node);
2844 }
2845
2846 // Handle document fragments.
2847 if (node instanceof DocumentFragment) {
2848 var fragChildNodes = node.childNodes;
2849
2850 if (fragChildNodes) {
2851 var fragChildNodesLength = fragChildNodes.length;
2852
2853 for (var a = 0; a < fragChildNodesLength; a++) {
2854 this.insertBefore(fragChildNodes[a], referenceNode);
2855 }
2856 }
2857
2858 return this;
2859 }
2860
2861 var hasFoundReferenceNode = false;
2862
2863 // There's no reason to handle default content add / remove because:
2864 // 1. If no reference node is supplied, appendChild handles it.
2865 // 2. If a reference node is supplied, there already is content.
2866 // 3. If a reference node is invalid, an exception is thrown, but also
2867 // it's state would not change even if it wasn't.
2868 mainLoop:
2869 for (var b = 0; b < contentNodesLen; b++) {
2870 var contentNode = contentNodes[b];
2871 var betweenNodes = getNodesBetween(contentNode.startNode, contentNode.endNode);
2872 var betweenNodesLen = betweenNodes.length;
2873
2874 for (var c = 0; c < betweenNodesLen; c++) {
2875 var betweenNode = betweenNodes[c];
2876
2877 if (betweenNode === referenceNode) {
2878 hasFoundReferenceNode = true;
2879 }
2880
2881 if (hasFoundReferenceNode) {
2882 var selector = contentNode.selector;
2883
2884 if (!selector || matchesSelector.call(node, selector)) {
2885 betweenNode.parentNode.insertBefore(node, betweenNode);
2886 break mainLoop;
2887 }
2888 }
2889 }
2890 }
2891
2892 // If no reference node was found as a child node of the element we must
2893 // throw an error. This works for both no child nodes, or if the
2894 // reference wasn't found to be a child node.
2895 if (!hasFoundReferenceNode) {
2896 throw new Error('DOMException 8: The node before which the new node is to be inserted is not a child of this node.');
2897 }
2898
2899 return node;
2900 }
2901 },
2902
2903 removeChild: {
2904 value: function (childNode) {
2905 var removed = false;
2906
2907 for (var a = 0; a < contentNodesLen; a++) {
2908 var contentNode = contentNodes[a];
2909
2910 if (contentNode.container === childNode.parentNode) {
2911 contentNode.container.removeChild(childNode);
2912 removed = true;
2913 break;
2914 }
2915
2916 if (contentNode.startNode.nextSibling === contentNode.endNode) {
2917 addDefaultContent(contentNode);
2918 }
2919 }
2920
2921 if (!removed) {
2922 throw new Error('DOMException 8: The node in which you are trying to remove is not a child of this node.');
2923 }
2924
2925 return childNode;
2926 }
2927 },
2928
2929 replaceChild: {
2930 value: function (newChild, oldChild) {
2931 for (var a = 0; a < contentNodesLen; a++) {
2932 var contentNode = contentNodes[a];
2933
2934 if (contentNode.container === oldChild.parentNode) {
2935 contentNode.container.replaceChild(newChild, oldChild);
2936 break;
2937 }
2938 }
2939
2940 return this;
2941 }
2942 }
2943 };
2944 }
2945
2946 function addDefaultContent (content) {
2947 var nodes = content.defaultNodes;
2948 var nodesLen = nodes.length;
2949
2950 for (var a = 0; a < nodesLen; a++) {
2951 content.container.insertBefore(nodes[a], content.endNode);
2952 }
2953
2954 content.isDefault = true;
2955 }
2956
2957 function removeDefaultContent (content) {
2958 var nodes = content.defaultNodes;
2959 var nodesLen = nodes.length;
2960
2961 for (var a = 0; a < nodesLen; a++) {
2962 var node = nodes[a];
2963 node.parentNode.removeChild(node);
2964 }
2965
2966 content.isDefault = false;
2967 }
2968
2969 function createProxyProperty (node, name) {
2970 return {
2971 get: function () {
2972 var value = node[name];
2973
2974 if (typeof value === 'function') {
2975 return value.bind(node);
2976 }
2977
2978 return value;
2979 },
2980
2981 set: function (value) {
2982 node[name] = value;
2983 }
2984 };
2985 }
2986
2987 function wrapNodeWith (node, wrapper) {
2988 var wrapped = {};
2989
2990 for (var name in node) {
2991 var inWrapper = name in wrapper;
2992
2993 if (inWrapper) {
2994 Object.defineProperty(wrapped, name, wrapper[name]);
2995 } else {
2996 Object.defineProperty(wrapped, name, createProxyProperty(node, name));
2997 }
2998 }
2999
3000 return wrapped;
3001 }
3002
3003 function cacheContentData (node) {
3004 var contentNodes = node.getElementsByTagName('content');
3005 var contentNodesLen = contentNodes && contentNodes.length;
3006
3007 if (contentNodesLen) {
3008 var contentData = [];
3009
3010 while (contentNodes.length) {
3011 var contentNode = contentNodes[0];
3012 var parentNode = contentNode.parentNode;
3013 var selector = contentNode.getAttribute('select');
3014 var startNode = document.createComment(' content ');
3015 var endNode = document.createComment(' /content ');
3016
3017 contentData.push({
3018 container: parentNode,
3019 contentNode: contentNode,
3020 defaultNodes: [].slice.call(contentNode.childNodes),
3021 endNode: endNode,
3022 isDefault: true,
3023 selector: selector,
3024 startNode: startNode
3025 });
3026
3027 parentNode.replaceChild(endNode, contentNode);
3028 parentNode.insertBefore(startNode, endNode);
3029
3030 // Cache data in the comment that can be read if no content information
3031 // is cached. This allows seamless server-side rendering.
3032 startNode.textContent += JSON.stringify({
3033 defaultContent: contentNode.innerHTML,
3034 selector: selector
3035 }) + ' ';
3036 }
3037
3038 setData(node, 'content', contentData);
3039 }
3040 }
3041
3042
3043
3044 // Content Parser
3045 // --------------
3046
3047 function parseCommentNode (node) {
3048 var data;
3049 var matches = node.textContent.match(/^ (\/?)content (.*)/i);
3050
3051 if (matches) {
3052 if (matches[2]) {
3053 try {
3054 data = JSON.parse(matches[2]);
3055 } catch (e) {
3056 throw new Error('Unable to parse content comment data: "' + e + '" in "<!--' + node.textContent + '-->".');
3057 }
3058 }
3059
3060 return {
3061 data: data || {
3062 defaultContent: undefined,
3063 isDefault: undefined,
3064 selector: undefined
3065 },
3066 type: matches[1] ? 'close' : 'open'
3067 };
3068 }
3069 }
3070
3071 function parseNodeForContent (node) {
3072 var a;
3073 var childNodes = node.childNodes;
3074 var childNodesLen = childNodes.length;
3075 var contentDatas = [];
3076 var lastContentNode;
3077
3078 for (a = 0; a < childNodesLen; a++) {
3079 var childNode = childNodes[a];
3080
3081 if (childNode.nodeType === 8) {
3082 var contentInfo = parseCommentNode(childNode);
3083
3084 if (contentInfo) {
3085 if (contentInfo.type === 'open') {
3086 if (lastContentNode) {
3087 throw new Error('Cannot have an opening content placeholder after another content placeholder at the same level in the DOM tree: "' + childNode.textContent + '" in "' + childNode.parentNode.innerHTML + '".');
3088 }
3089
3090 lastContentNode = {
3091 container: childNode.parentNode,
3092 contentNode: childNode,
3093 defaultNodes: contentInfo.data.defaultContent && createFragmentFromString(contentInfo.data.defaultContent).childNodes || [],
3094 isDefault: contentInfo.data.isDefault,
3095 selector: contentInfo.data.selector,
3096 startNode: childNode
3097 };
3098 } else if (contentInfo.type === 'close') {
3099 if (!lastContentNode) {
3100 throw new Error('Unmatched closing content placeholder: "' + childNode.textContent + '" in "' + childNode.parentNode.innerHTML + '".');
3101 }
3102
3103 lastContentNode.endNode = childNode;
3104 contentDatas.push(lastContentNode);
3105 lastContentNode = undefined;
3106 }
3107 }
3108 } else {
3109 contentDatas = contentDatas.concat(parseNodeForContent(childNode));
3110 }
3111 }
3112
3113 return contentDatas;
3114 }
3115
3116
3117
3118 // Public API
3119 // ----------
3120
3121 function skateTemplateHtml () {
3122 var template = [].slice.call(arguments).join('');
3123
3124 return function (target) {
3125 var frag = createFragmentFromNodeList(target.childNodes);
3126
3127 target.innerHTML = template;
3128 cacheContentData(target);
3129
3130 if (frag.childNodes.length) {
3131 skateTemplateHtml.wrap(target).appendChild(frag);
3132 }
3133 };
3134 }
3135
3136 skateTemplateHtml.wrap = function (node) {
3137 if (!getData(node, 'content')) {
3138 setData(node, 'content', parseNodeForContent(node));
3139 }
3140
3141 return wrapNodeWith(node, htmlTemplateParentWrapper(node));
3142 };
3143
3144
3145
3146 // Exporting
3147 // ---------
3148
3149 // Global.
3150 window.skateTemplateHtml = skateTemplateHtml;
3151
3152 // AMD.
3153 if (typeof define === 'function') {
3154 define(function () {
3155 return skateTemplateHtml;
3156 });
3157 }
3158
3159 // CommonJS.
3160 if (typeof module === 'object') {
3161 module.exports = skateTemplateHtml;
3162 }
3163 })();
3164
3165
3166 return module.exports;
3167}).call(this);
3168// node_modules/@atlassian/aui/src/js/aui/internal/enforcer.js
3169(typeof window === 'undefined' ? global : window).__8339408c10b0a9052af9f3aad7b3a4e8 = (function () {
3170 var module = {
3171 exports: {}
3172 };
3173 var exports = module.exports;
3174
3175 'use strict';
3176
3177 Object.defineProperty(exports, "__esModule", {
3178 value: true
3179 });
3180
3181 var _log = __cf890abdf040e0993fb71f2f839bc972;
3182
3183 var logger = _interopRequireWildcard(_log);
3184
3185 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
3186
3187 function enforcer(element) {
3188
3189 function attributeExists(attributeName) {
3190 var errorMessage = attributeName + ' wasn\'t defined';
3191
3192 return satisfiesRules(function () {
3193 return element.hasAttribute(attributeName);
3194 }, errorMessage);
3195 }
3196
3197 function refersTo(attributeName) {
3198
3199 if (!attributeExists(attributeName, element)) {
3200 return false;
3201 }
3202
3203 var desiredId = element.getAttribute(attributeName);
3204 var errorMessage = 'an element with id set to "' + desiredId + '" was not found';
3205
3206 return satisfiesRules(function () {
3207 return document.getElementById(desiredId);
3208 }, errorMessage);
3209 }
3210
3211 function ariaControls() {
3212 return refersTo('aria-controls');
3213 }
3214
3215 function ariaOwns() {
3216 return refersTo('aria-owns');
3217 }
3218
3219 function satisfiesRules(predicate, message) {
3220 if (!predicate()) {
3221 if (element) {
3222 logger.error(message, element);
3223 } else {
3224 logger.error(message);
3225 }
3226 return false;
3227 }
3228 return true;
3229 }
3230
3231 return {
3232 attributeExists: attributeExists,
3233 refersTo: refersTo,
3234 satisfiesRules: satisfiesRules,
3235 ariaControls: ariaControls,
3236 ariaOwns: ariaOwns
3237 };
3238 }
3239
3240 exports.default = enforcer;
3241 module.exports = exports['default'];
3242
3243 return module.exports;
3244}).call(this);
3245// node_modules/fancy-file-input/dist/fancy-file-input.js
3246(typeof window === 'undefined' ? global : window).__e978d2e4e1d10e62ed13103fb5b406fc = (function () {
3247 var module = {
3248 exports: {}
3249 };
3250 var exports = module.exports;
3251 var defineDependencies = {
3252 "module": module,
3253 "exports": exports,
3254 "jquery": __307d3e18fd611f85395c67cddeb1fe24,
3255 "jquery": __307d3e18fd611f85395c67cddeb1fe24
3256 };
3257 var define = function defineReplacementWrapper(generatedModuleName) {
3258 return function defineReplacement(name, deps, func) {
3259 var root = (typeof window === 'undefined' ? global : window);
3260 var defineGlobal = root.define;
3261 var rval;
3262 var type;
3263
3264 func = [func, deps, name].filter(function (cur) {
3265 return typeof cur === 'function';
3266 })[0];
3267 deps = [deps, name, []].filter(Array.isArray)[0];
3268 rval = func.apply(null, deps.map(function (value) {
3269 return defineDependencies[value];
3270 }));
3271 type = typeof rval;
3272
3273 // Support existing AMD libs.
3274 if (typeof defineGlobal === 'function') {
3275 // Almond always expects a name so resolve one (#29).
3276 defineGlobal(typeof name === 'string' ? name : generatedModuleName, deps, func);
3277 }
3278
3279 // Some processors like Babel don't check to make sure that the module value
3280 // is not a primitive before calling Object.defineProperty() on it. We ensure
3281 // it is an instance so that it can.
3282 if (type === 'string') {
3283 rval = String(rval);
3284 } else if (type === 'number') {
3285 rval = Number(rval);
3286 } else if (type === 'boolean') {
3287 rval = Boolean(rval);
3288 }
3289
3290 // Reset the exports to the defined module. This is how we convert AMD to
3291 // CommonJS and ensures both can either co-exist, or be used separately. We
3292 // only set it if it is not defined because there is no object representation
3293 // of undefined, thus calling Object.defineProperty() on it would fail.
3294 if (rval !== undefined) {
3295 exports = module.exports = rval;
3296 }
3297 };
3298 }("__e978d2e4e1d10e62ed13103fb5b406fc");
3299 define.amd = true;
3300
3301 /*! jQuery Fancy File Input plugin - v1.0.0 - 2016-02-23
3302 * http://seancurtis.com/experiments/fancy-file-input/
3303 * Copyright (c) 2016 Atlassian Pty Ltd; Licensed http://www.apache.org/licenses/LICENSE-2.0 */
3304 (function (root, factory) {
3305 if (typeof define === 'function' && define.amd) {
3306 // AMD. Register as an anonymous module unless amdModuleId is set
3307 define(["jquery"], function (a0) {
3308 return (root['FancyFileInput'] = factory(a0));
3309 });
3310 } else if (typeof exports === 'object') {
3311 // Node. Does not work with strict CommonJS, but
3312 // only CommonJS-like environments that support module.exports,
3313 // like Node.
3314 module.exports = factory(__307d3e18fd611f85395c67cddeb1fe24);
3315 } else {
3316 root['FancyFileInput'] = factory(jQuery);
3317 }
3318 }(this, function ($) {
3319
3320 /**
3321 * --------------------------------------------------------------------
3322 * jQuery Fancy File Input plugin
3323 * Author: Atlassian Pty Ltd
3324 * Copyright © 2012 - 2016 Atlassian Pty Ltd. Licensed under the
3325 * Apache License, Version 2.0 (the "License"); you may not use this
3326 * file except in compliance with the License. You may obtain a copy
3327 * of the License at http://www.apache.org/licenses/LICENSE-2.0.
3328 * Unless required by applicable law or agreed to in writing, software
3329 * distributed under the License is distributed on an "AS IS" BASIS,
3330 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
3331 * implied. See the License for the specific language governing
3332 * permissions and limitations under the License.
3333 * --------------------------------------------------------------------
3334 */
3335
3336 /* jshint -W097 */
3337
3338 var fakePathRegex = /^.*[\\\/]/;
3339 var multipleFileTextRegex = /\{0\}/gi;
3340 var ie = (function() {
3341 var v = 3;
3342 var div = document.createElement( 'div' );
3343 var all = div.getElementsByTagName( 'i' );
3344
3345 do {
3346 div.innerHTML = '<!--[if gt IE ' + (++v) + ']><i></i><![endif]-->';
3347 } while (all[0]);
3348
3349 return v > 4 ? v : document.documentMode;
3350 }());
3351
3352 function FancyFileInput(el, options) {
3353 var instance = $(el).data('FancyFileInput');
3354 if (instance) {
3355 return instance;
3356 }
3357 options = $.extend({}, FancyFileInput.defaults, options);
3358 this.el = el;
3359 this.$el = $(el);
3360 this.$label = this.createLabel(options.buttonText);
3361 this._addLabelText();
3362 this.$clearButton = $('<button>', {
3363 text: (this.$label.attr('data-ffi-clearButtonText') || options.clearButtonText),
3364 'class': 'ffi-clear',
3365 type: 'button',
3366 'tabindex': '-1'
3367 });
3368 this.multipleFileTextPattern = this.$label.attr('data-ffi-multipleFileTextPattern') || options.multipleFileTextPattern;
3369 this._eventNamespace = '.ffi';
3370 this.CLASSES = {
3371 disabled: 'is-disabled',
3372 focused: 'is-focused',
3373 active: 'is-active',
3374 valid: 'is-valid',
3375 invalid: 'is-invalid'
3376 };
3377 this[this.isDisabled() ? 'disable' : 'enable']();
3378 this.isFocused = false;
3379 }
3380
3381 FancyFileInput.defaults = {
3382 buttonText: 'Browse\u2026',
3383 clearButtonText: 'Clear',
3384 multipleFileTextPattern: '{0} files'
3385 };
3386
3387 FancyFileInput.prototype._addLabelText = function attLabelText() {
3388 var $associatedLabel = $('label[for="' + this.el.id + '"]');
3389 if ($associatedLabel.length) {
3390 this.$el.attr('aria-label', $associatedLabel.text());
3391 }
3392 };
3393
3394 FancyFileInput.prototype.createLabel = function (buttonText) {
3395 var $label = this.$el.parent('.ffi[data-ffi-button-text]');
3396 if (!$label.length) {
3397 $label = this.$el.wrap($('<label>', { 'class': 'ffi', 'data-ffi-button-text': buttonText })).parent();
3398 }
3399 return $label;
3400 };
3401
3402 FancyFileInput.prototype.isDisabled = function () {
3403 return this.$el.is(':disabled');
3404 };
3405
3406 FancyFileInput.prototype.formatMultipleFileText = function (numFiles) {
3407 return this.multipleFileTextPattern.replace(multipleFileTextRegex, numFiles);
3408 };
3409
3410 FancyFileInput.prototype.bindEvents = function () {
3411 this.$el
3412 .on('invalid' + this._eventNamespace, $.proxy(this.checkValidity, this))
3413 .on('change' + this._eventNamespace, $.proxy(this.change, this))
3414 .on('keydown' + this._eventNamespace, $.proxy(this.keydown, this))
3415 .on('mousedown' + this._eventNamespace, $.proxy(this.mousedown, this))
3416 .on('mouseup' + this._eventNamespace, $.proxy(this.mouseup, this))
3417 .on('focus' + this._eventNamespace, $.proxy(this.focus, this))
3418 .on('blur' + this._eventNamespace, $.proxy(this.blur, this));
3419 this.$clearButton.on('click' + this._eventNamespace, $.proxy(this.clear, this));
3420 };
3421
3422 FancyFileInput.prototype.unbindEvents = function () {
3423 this.$el.off(this._eventNamespace);
3424 this.$clearButton.off(this._eventNamespace);
3425 };
3426
3427 FancyFileInput.prototype.fireEvent = function (event) {
3428 this.$el.trigger(event + this._eventNamespace);
3429 };
3430
3431 FancyFileInput.prototype.enable = function () {
3432 this.bindEvents();
3433 this.$el.prop('disabled', false);
3434 this.$label.removeClass(this.CLASSES.disabled);
3435 };
3436
3437 FancyFileInput.prototype.disable = function () {
3438 this.unbindEvents();
3439 this.$el.prop('disabled', true);
3440 this.$label.addClass(this.CLASSES.disabled);
3441 };
3442
3443 FancyFileInput.prototype.clear = function () {
3444 this.$el.wrap('<form>').closest('form').get(0).reset();
3445 this.$el.unwrap();
3446 this.el.value = '';
3447 this.change();
3448 return false;
3449 };
3450
3451 FancyFileInput.prototype.focus = function () {
3452 var instance = this;
3453
3454 this.$label.addClass(this.CLASSES.focused);
3455
3456 // toggle focus so that the cursor appears back in the field instead of on the button
3457 if (ie && !this.isFocused) {
3458 this.isFocused = true;
3459
3460 setTimeout(function() {
3461 instance.$el.blur();
3462 instance.$el.focus();
3463 }, 0);
3464 }
3465 };
3466
3467 FancyFileInput.prototype.blur = function () {
3468 if (!ie || !this.isFocused) {
3469 this.$label.removeClass(this.CLASSES.focused);
3470 this.isFocused = false;
3471 }
3472 };
3473
3474 FancyFileInput.prototype.mousedown = function () {
3475 this.$label.addClass(this.CLASSES.active);
3476 };
3477
3478 FancyFileInput.prototype.mouseup = function () {
3479 this.$label.removeClass(this.CLASSES.active);
3480 };
3481
3482 FancyFileInput.prototype.keydown = function (e) {
3483 var keyCode = e.which;
3484 var BACKSPACE = 8;
3485 var TAB = 9;
3486 var DELETE = 46;
3487
3488 // Add clear behaviour for all browsers
3489 if (keyCode === BACKSPACE || keyCode === DELETE) {
3490 this.clear();
3491 e.preventDefault();
3492 }
3493
3494 // This works around the IE double tab-stop - no events or blur/change occur when moving between
3495 // the field part of the input and the button part. This is dirty, but it works.
3496 if (ie && keyCode === TAB) {
3497 var instance = this;
3498
3499 this.isFocused = false;
3500 this.$el.prop('disabled',true);
3501
3502 setTimeout(function(){
3503 instance.$el.prop('disabled', false).blur();
3504 }, 0);
3505 }
3506 };
3507
3508 FancyFileInput.prototype.checkValidity = function () {
3509 if (!this.el.required) {
3510 return;
3511 }
3512 var isInvalid = this.$el.is(':invalid');
3513
3514 this.$label.toggleClass(this.CLASSES.invalid, isInvalid).toggleClass(this.CLASSES.valid, !isInvalid);
3515 };
3516
3517 FancyFileInput.prototype.change = function () {
3518 var files;
3519 var val = '';
3520
3521 this.checkValidity();
3522
3523 // multiple file selection
3524 if (this.el.multiple && this.el.files.length > 1) {
3525 files = this.formatMultipleFileText(this.el.files.length); // '5 files'
3526 } else {
3527 files = this.el.value; // 'README.txt'
3528 }
3529
3530 if (files.length) {
3531 val = files.replace(fakePathRegex, ''); // Strips off the C:\fakepath nonsense
3532 this.$clearButton.appendTo(this.$label);
3533 } else {
3534 this.$clearButton.detach();
3535 }
3536
3537 this.$el.focus();
3538 this.setFieldText(val);
3539 this.fireEvent('value-changed');
3540 };
3541
3542 FancyFileInput.prototype.setFieldText = function (text) {
3543 var dataAttribute = 'data-ffi-value';
3544 if (text.length) {
3545 this.$label.attr(dataAttribute, text);
3546 this.fireEvent('value-added');
3547 } else {
3548 this.$label.removeAttr(dataAttribute);
3549 this.fireEvent('value-cleared');
3550 }
3551 };
3552
3553 $.fn.fancyFileInput = function (options) {
3554 return this.each(function () {
3555 var ffi = new FancyFileInput(this, options);
3556 $(this).data('FancyFileInput', ffi);
3557 });
3558 };
3559
3560 return FancyFileInput;
3561
3562 }));
3563
3564
3565 return module.exports;
3566}).call(this);
3567// src/js/aui/fancy-file-input.js
3568(typeof window === 'undefined' ? global : window).__84e1fe9bfd01961fdb8386c0cdd32066 = (function () {
3569 var module = {
3570 exports: {}
3571 };
3572 var exports = module.exports;
3573
3574 /* AUI-4199: This puts the FFI object on the jQuery global for backwards compatibility. */
3575
3576 Object.defineProperty(exports, "__esModule", {
3577 value: true
3578 });
3579
3580 var _fancyFileInput = __e978d2e4e1d10e62ed13103fb5b406fc;
3581
3582 var _fancyFileInput2 = _interopRequireDefault(_fancyFileInput);
3583
3584 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
3585
3586 exports.default = _fancyFileInput2.default;
3587 module.exports = exports['default'];
3588
3589 return module.exports;
3590}).call(this);
3591// node_modules/@atlassian/aui/src/js/aui/params.js
3592(typeof window === 'undefined' ? global : window).__c9067396b725a0e50bb5247a7338561e = (function () {
3593 var module = {
3594 exports: {}
3595 };
3596 var exports = module.exports;
3597
3598 'use strict';
3599
3600 Object.defineProperty(exports, "__esModule", {
3601 value: true
3602 });
3603
3604 var _globalize = __4d02fe17b8e885a34493e34af3d145dd;
3605
3606 var _globalize2 = _interopRequireDefault(_globalize);
3607
3608 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
3609
3610 exports.default = (0, _globalize2.default)('params', {});
3611 module.exports = exports['default'];
3612
3613 return module.exports;
3614}).call(this);
3615// node_modules/@atlassian/aui/src/js/aui/populate-parameters.js
3616(typeof window === 'undefined' ? global : window).__0210cf71af3a1c7fcbb0f421af87d03c = (function () {
3617 var module = {
3618 exports: {}
3619 };
3620 var exports = module.exports;
3621
3622 'use strict';
3623
3624 Object.defineProperty(exports, "__esModule", {
3625 value: true
3626 });
3627
3628 var _jquery = __307d3e18fd611f85395c67cddeb1fe24;
3629
3630 var _jquery2 = _interopRequireDefault(_jquery);
3631
3632 var _globalize = __4d02fe17b8e885a34493e34af3d145dd;
3633
3634 var _globalize2 = _interopRequireDefault(_globalize);
3635
3636 var _params = __c9067396b725a0e50bb5247a7338561e;
3637
3638 var _params2 = _interopRequireDefault(_params);
3639
3640 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
3641
3642 function populateParameters(parameters) {
3643 if (!parameters) {
3644 parameters = _params2.default;
3645 }
3646
3647 (0, _jquery2.default)('.parameters input').each(function () {
3648 var value = this.value;
3649 var id = this.title || this.id;
3650
3651 if ((0, _jquery2.default)(this).hasClass('list')) {
3652 if (parameters[id]) {
3653 parameters[id].push(value);
3654 } else {
3655 parameters[id] = [value];
3656 }
3657 } else {
3658 parameters[id] = value.match(/^(tru|fals)e$/i) ? value.toLowerCase() === 'true' : value;
3659 }
3660 });
3661 }
3662
3663 (0, _globalize2.default)('populateParameters', populateParameters);
3664
3665 exports.default = populateParameters;
3666 module.exports = exports['default'];
3667
3668 return module.exports;
3669}).call(this);
3670// node_modules/@atlassian/aui/src/js/aui/version.js
3671(typeof window === 'undefined' ? global : window).__399d6bb24e6280e2241deb4e98d541ff = (function () {
3672 var module = {
3673 exports: {}
3674 };
3675 var exports = module.exports;
3676
3677 'use strict';
3678
3679 Object.defineProperty(exports, "__esModule", {
3680 value: true
3681 });
3682
3683 var _globalize = __4d02fe17b8e885a34493e34af3d145dd;
3684
3685 var _globalize2 = _interopRequireDefault(_globalize);
3686
3687 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
3688
3689 var version = '6.0.6';
3690
3691 (0, _globalize2.default)('version', version);
3692
3693 exports.default = version;
3694 module.exports = exports['default'];
3695
3696 return module.exports;
3697}).call(this);
3698// node_modules/@atlassian/aui/src/js/aui/setup.js
3699(typeof window === 'undefined' ? global : window).__9e53ace664f2009a19d8a8d4adf77670 = (function () {
3700 var module = {
3701 exports: {}
3702 };
3703 var exports = module.exports;
3704
3705 'use strict';
3706
3707 var _jquery = __307d3e18fd611f85395c67cddeb1fe24;
3708
3709 var _jquery2 = _interopRequireDefault(_jquery);
3710
3711 var _globalize = __4d02fe17b8e885a34493e34af3d145dd;
3712
3713 var _globalize2 = _interopRequireDefault(_globalize);
3714
3715 var _populateParameters = __0210cf71af3a1c7fcbb0f421af87d03c;
3716
3717 var _populateParameters2 = _interopRequireDefault(_populateParameters);
3718
3719 var _version = __399d6bb24e6280e2241deb4e98d541ff;
3720
3721 var _version2 = _interopRequireDefault(_version);
3722
3723 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
3724
3725 // Set the version.
3726 // Global setup that used to be in the main AJS namespace file.
3727
3728 (0, _jquery2.default)(function () {
3729 var $body = (0, _jquery2.default)('body');
3730
3731 if (!$body.data('auiVersion')) {
3732 $body.attr('data-aui-version', _version2.default);
3733 }
3734
3735 (0, _populateParameters2.default)();
3736 });
3737
3738 // Setting Traditional to handle our default param serialisation.
3739 // See http://api.jquery.com/jQuery.param/ for more information.
3740 _jquery2.default.ajaxSettings.traditional = true;
3741 (0, _globalize2.default)('$', _jquery2.default);
3742
3743 return module.exports;
3744}).call(this);
3745// node_modules/@atlassian/aui/src/js/aui.js
3746(typeof window === 'undefined' ? global : window).__2a3851548b439fef56cc0d18ab878624 = (function () {
3747 var module = {
3748 exports: {}
3749 };
3750 var exports = module.exports;
3751
3752 'use strict';
3753
3754 Object.defineProperty(exports, "__esModule", {
3755 value: true
3756 });
3757
3758 __cf890abdf040e0993fb71f2f839bc972;
3759
3760 __0210cf71af3a1c7fcbb0f421af87d03c;
3761
3762 __9e53ace664f2009a19d8a8d4adf77670;
3763
3764 exports.default = window.AJS;
3765 module.exports = exports['default'];
3766
3767 return module.exports;
3768}).call(this);
3769// src/js/aui.js
3770(typeof window === 'undefined' ? global : window).__926e147e38f62e0612bb8166764a9b91 = (function () {
3771 var module = {
3772 exports: {}
3773 };
3774 var exports = module.exports;
3775
3776 'use strict';
3777
3778 Object.defineProperty(exports, "__esModule", {
3779 value: true
3780 });
3781
3782 __84e1fe9bfd01961fdb8386c0cdd32066;
3783
3784 var _aui = __2a3851548b439fef56cc0d18ab878624;
3785
3786 var _aui2 = _interopRequireDefault(_aui);
3787
3788 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
3789
3790 // Fancy File Input is required by the refapp and assumed to be bundled in AUI.
3791 // It's exposed as a web resource in the plugin.
3792 // We might want to consider not bundling it.
3793 exports.default = _aui2.default;
3794 module.exports = exports['default'];
3795
3796 return module.exports;
3797}).call(this);