https://www.engagement-global.de/build/app.js

4/***/ "./node_modules/@hotwired/stimulus/dist/stimulus.js":
5/*!**********************************************************!*\
6  !*** ./node_modules/@hotwired/stimulus/dist/stimulus.js ***!
7  \**********************************************************/
8/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
9
10"use strict";
11__webpack_require__.r(__webpack_exports__);
12/* harmony export */ __webpack_require__.d(__webpack_exports__, {
13/* harmony export */   Application: function() { return /* binding */ Application; },
14/* harmony export */   AttributeObserver: function() { return /* binding */ AttributeObserver; },
15/* harmony export */   Context: function() { return /* binding */ Context; },
16/* harmony export */   Controller: function() { return /* binding */ Controller; },
17/* harmony export */   ElementObserver: function() { return /* binding */ ElementObserver; },
18/* harmony export */   IndexedMultimap: function() { return /* binding */ IndexedMultimap; },
19/* harmony export */   Multimap: function() { return /* binding */ Multimap; },
20/* harmony export */   SelectorObserver: function() { return /* binding */ SelectorObserver; },
21/* harmony export */   StringMapObserver: function() { return /* binding */ StringMapObserver; },
22/* harmony export */   TokenListObserver: function() { return /* binding */ TokenListObserver; },
23/* harmony export */   ValueListObserver: function() { return /* binding */ ValueListObserver; },
24/* harmony export */   add: function() { return /* binding */ add; },
25/* harmony export */   defaultSchema: function() { return /* binding */ defaultSchema; },
26/* harmony export */   del: function() { return /* binding */ del; },
27/* harmony export */   fetch: function() { return /* binding */ fetch; },
28/* harmony export */   prune: function() { return /* binding */ prune; }
29/* harmony export */ });
30/*
31Stimulus 3.2.1
32Copyright © 2023 Basecamp, LLC
33 */
34class EventListener {
35    constructor(eventTarget, eventName, eventOptions) {
36        this.eventTarget = eventTarget;
37        this.eventName = eventName;
38        this.eventOptions = eventOptions;
39        this.unorderedBindings = new Set();
40    }
41    connect() {
42        this.eventTarget.addEventListener(this.eventName, this, this.eventOptions);
43    }
44    disconnect() {
45        this.eventTarget.removeEventListener(this.eventName, this, this.eventOptions);
46    }
47    bindingConnected(binding) {
48        this.unorderedBindings.add(binding);
49    }
50    bindingDisconnected(binding) {
51        this.unorderedBindings.delete(binding);
52    }
53    handleEvent(event) {
54        const extendedEvent = extendEvent(event);
55        for (const binding of this.bindings) {
56            if (extendedEvent.immediatePropagationStopped) {
57                break;
58            }
59            else {
60                binding.handleEvent(extendedEvent);
61            }
62        }
63    }
64    hasBindings() {
65        return this.unorderedBindings.size > 0;
66    }
67    get bindings() {
68        return Array.from(this.unorderedBindings).sort((left, right) => {
69            const leftIndex = left.index, rightIndex = right.index;
70            return leftIndex < rightIndex ? -1 : leftIndex > rightIndex ? 1 : 0;
71        });
72    }
73}
74function extendEvent(event) {
75    if ("immediatePropagationStopped" in event) {
76        return event;
77    }
78    else {
79        const { stopImmediatePropagation } = event;
80        return Object.assign(event, {
81            immediatePropagationStopped: false,
82            stopImmediatePropagation() {
83                this.immediatePropagationStopped = true;
84                stopImmediatePropagation.call(this);
85            },
86        });
87    }
88}
89
90class Dispatcher {
91    constructor(application) {
92        this.application = application;
93        this.eventListenerMaps = new Map();
94        this.started = false;
95    }
96    start() {
97        if (!this.started) {
98            this.started = true;
99            this.eventListeners.forEach((eventListener) => eventListener.connect());
100        }
101    }
102    stop() {
103        if (this.started) {
104            this.started = false;
105            this.eventListeners.forEach((eventListener) => eventListener.disconnect());
106        }
107    }
108    get eventListeners() {
109        return Array.from(this.eventListenerMaps.values()).reduce((listeners, map) => listeners.concat(Array.from(map.values())), []);
110    }
111    bindingConnected(binding) {
112        this.fetchEventListenerForBinding(binding).bindingConnected(binding);
113    }
114    bindingDisconnected(binding, clearEventListeners = false) {
115        this.fetchEventListenerForBinding(binding).bindingDisconnected(binding);
116        if (clearEventListeners)
117            this.clearEventListenersForBinding(binding);
118    }
119    handleError(error, message, detail = {}) {
120        this.application.handleError(error, `Error ${message}`, detail);
121    }
122    clearEventListenersForBinding(binding) {
123        const eventListener = this.fetchEventListenerForBinding(binding);
124        if (!eventListener.hasBindings()) {
125            eventListener.disconnect();
126            this.removeMappedEventListenerFor(binding);
127        }
128    }
129    removeMappedEventListenerFor(binding) {
130        const { eventTarget, eventName, eventOptions } = binding;
131        const eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);
132        const cacheKey = this.cacheKey(eventName, eventOptions);
133        eventListenerMap.delete(cacheKey);
134        if (eventListenerMap.size == 0)
135            this.eventListenerMaps.delete(eventTarget);
136    }
137    fetchEventListenerForBinding(binding) {
138        const { eventTarget, eventName, eventOptions } = binding;
139        return this.fetchEventListener(eventTarget, eventName, eventOptions);
140    }
141    fetchEventListener(eventTarget, eventName, eventOptions) {
142        const eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);
143        const cacheKey = this.cacheKey(eventName, eventOptions);
144        let eventListener = eventListenerMap.get(cacheKey);
145        if (!eventListener) {
146            eventListener = this.createEventListener(eventTarget, eventName, eventOptions);
147            eventListenerMap.set(cacheKey, eventListener);
148        }
149        return eventListener;
150    }
151    createEventListener(eventTarget, eventName, eventOptions) {
152        const eventListener = new EventListener(eventTarget, eventName, eventOptions);
153        if (this.started) {
154            eventListener.connect();
155        }
156        return eventListener;
157    }
158    fetchEventListenerMapForEventTarget(eventTarget) {
159        let eventListenerMap = this.eventListenerMaps.get(eventTarget);
160        if (!eventListenerMap) {
161            eventListenerMap = new Map();
162            this.eventListenerMaps.set(eventTarget, eventListenerMap);
163        }
164        return eventListenerMap;
165    }
166    cacheKey(eventName, eventOptions) {
167        const parts = [eventName];
168        Object.keys(eventOptions)
169            .sort()
170            .forEach((key) => {
171            parts.push(`${eventOptions[key] ? "" : "!"}${key}`);
172        });
173        return parts.join(":");
174    }
175}
176
177const defaultActionDescriptorFilters = {
178    stop({ event, value }) {
179        if (value)
180            event.stopPropagation();
181        return true;
182    },
183    prevent({ event, value }) {
184        if (value)
185            event.preventDefault();
186        return true;
187    },
188    self({ event, value, element }) {
189        if (value) {
190            return element === event.target;
191        }
192        else {
193            return true;
194        }
195    },
196};
197const descriptorPattern = /^(?:(?:([^.]+?)\+)?(.+?)(?:\.(.+?))?(?:@(window|document))?->)?(.+?)(?:#([^:]+?))(?::(.+))?$/;
198function parseActionDescriptorString(descriptorString) {
199    const source = descriptorString.trim();
200    const matches = source.match(descriptorPattern) || [];
201    let eventName = matches[2];
202    let keyFilter = matches[3];
203    if (keyFilter && !["keydown", "keyup", "keypress"].includes(eventName)) {
204        eventName += `.${keyFilter}`;
205        keyFilter = "";
206    }
207    return {
208        eventTarget: parseEventTarget(matches[4]),
209        eventName,
210        eventOptions: matches[7] ? parseEventOptions(matches[7]) : {},
211        identifier: matches[5],
212        methodName: matches[6],
213        keyFilter: matches[1] || keyFilter,
214    };
215}
216function parseEventTarget(eventTargetName) {
217    if (eventTargetName == "window") {
218        return window;
219    }
220    else if (eventTargetName == "document") {
221        return document;
222    }
223}
224function parseEventOptions(eventOptions) {
225    return eventOptions
226        .split(":")
227        .reduce((options, token) => Object.assign(options, { [token.replace(/^!/, "")]: !/^!/.test(token) }), {});
228}
229function stringifyEventTarget(eventTarget) {
230    if (eventTarget == window) {
231        return "window";
232    }
233    else if (eventTarget == document) {
234        return "document";
235    }
236}
237
238function camelize(value) {
239    return value.replace(/(?:[_-])([a-z0-9])/g, (_, char) => char.toUpperCase());
240}
241function namespaceCamelize(value) {
242    return camelize(value.replace(/--/g, "-").replace(/__/g, "_"));
243}
244function capitalize(value) {
245    return value.charAt(0).toUpperCase() + value.slice(1);
246}
247function dasherize(value) {
248    return value.replace(/([A-Z])/g, (_, char) => `-${char.toLowerCase()}`);
249}
250function tokenize(value) {
251    return value.match(/[^\s]+/g) || [];
252}
253
254function isSomething(object) {
255    return object !== null && object !== undefined;
256}
257function hasProperty(object, property) {
258    return Object.prototype.hasOwnProperty.call(object, property);
259}
260
261const allModifiers = ["meta", "ctrl", "alt", "shift"];
262class Action {
263    constructor(element, index, descriptor, schema) {
264        this.element = element;
265        this.index = index;
266        this.eventTarget = descriptor.eventTarget || element;
267        this.eventName = descriptor.eventName || getDefaultEventNameForElement(element) || error("missing event name");
268        this.eventOptions = descriptor.eventOptions || {};
269        this.identifier = descriptor.identifier || error("missing identifier");
270        this.methodName = descriptor.methodName || error("missing method name");
271        this.keyFilter = descriptor.keyFilter || "";
272        this.schema = schema;
273    }
274    static forToken(token, schema) {
275        return new this(token.element, token.index, parseActionDescriptorString(token.content), schema);
276    }
277    toString() {
278        const eventFilter = this.keyFilter ? `.${this.keyFilter}` : "";
279        const eventTarget = this.eventTargetName ? `@${this.eventTargetName}` : "";
280        return `${this.eventName}${eventFilter}${eventTarget}->${this.identifier}#${this.methodName}`;
281    }
282    shouldIgnoreKeyboardEvent(event) {
283        if (!this.keyFilter) {
284            return false;
285        }
286        const filters = this.keyFilter.split("+");
287        if (this.keyFilterDissatisfied(event, filters)) {
288            return true;
289        }
290        const standardFilter = filters.filter((key) => !allModifiers.includes(key))[0];
291        if (!standardFilter) {
292            return false;
293        }
294        if (!hasProperty(this.keyMappings, standardFilter)) {
295            error(`contains unknown key filter: ${this.keyFilter}`);
296        }
297        return this.keyMappings[standardFilter].toLowerCase() !== event.key.toLowerCase();
298    }
299    shouldIgnoreMouseEvent(event) {
300        if (!this.keyFilter) {
301            return false;
302        }
303        const filters = [this.keyFilter];
304        if (this.keyFilterDissatisfied(event, filters)) {
305            return true;
306        }
307        return false;
308    }
309    get params() {
310        const params = {};
311        const pattern = new RegExp(`^data-${this.identifier}-(.+)-param$`, "i");
312        for (const { name, value } of Array.from(this.element.attributes)) {
313            const match = name.match(pattern);
314            const key = match && match[1];
315            if (key) {
316                params[camelize(key)] = typecast(value);
317            }
318        }
319        return params;
320    }
321    get eventTargetName() {
322        return stringifyEventTarget(this.eventTarget);
323    }
324    get keyMappings() {
325        return this.schema.keyMappings;
326    }
327    keyFilterDissatisfied(event, filters) {
328        const [meta, ctrl, alt, shift] = allModifiers.map((modifier) => filters.includes(modifier));
329        return event.metaKey !== meta || event.ctrlKey !== ctrl || event.altKey !== alt || event.shiftKey !== shift;
330    }
331}
332const defaultEventNames = {
333    a: () => "click",
334    button: () => "click",
335    form: () => "submit",
336    details: () => "toggle",
337    input: (e) => (e.getAttribute("type") == "submit" ? "click" : "input"),
338    select: () => "change",
339    textarea: () => "input",
340};
341function getDefaultEventNameForElement(element) {
342    const tagName = element.tagName.toLowerCase();
343    if (tagName in defaultEventNames) {
344        return defaultEventNames[tagName](element);
345    }
346}
347function error(message) {
348    throw new Error(message);
349}
350function typecast(value) {
351    try {
352        return JSON.parse(value);
353    }
354    catch (o_O) {
355        return value;
356    }
357}
358
359class Binding {
360    constructor(context, action) {
361        this.context = context;
362        this.action = action;
363    }
364    get index() {
365        return this.action.index;
366    }
367    get eventTarget() {
368        return this.action.eventTarget;
369    }
370    get eventOptions() {
371        return this.action.eventOptions;
372    }
373    get identifier() {
374        return this.context.identifier;
375    }
376    handleEvent(event) {
377        const actionEvent = this.prepareActionEvent(event);
378        if (this.willBeInvokedByEvent(event) && this.applyEventModifiers(actionEvent)) {
379            this.invokeWithEvent(actionEvent);
380        }
381    }
382    get eventName() {
383        return this.action.eventName;
384    }
385    get method() {
386        const method = this.controller[this.methodName];
387        if (typeof method == "function") {
388            return method;
389        }
390        throw new Error(`Action "${this.action}" references undefined method "${this.methodName}"`);
391    }
392    applyEventModifiers(event) {
393        const { element } = this.action;
394        const { actionDescriptorFilters } = this.context.application;
395        const { controller } = this.context;
396        let passes = true;
397        for (const [name, value] of Object.entries(this.eventOptions)) {
398            if (name in actionDescriptorFilters) {
399                const filter = actionDescriptorFilters[name];
400                passes = passes && filter({ name, value, event, element, controller });
401            }
402            else {
403                continue;
404            }
405        }
406        return passes;
407    }
408    prepareActionEvent(event) {
409        return Object.assign(event, { params: this.action.params });
410    }
411    invokeWithEvent(event) {
412        const { target, currentTarget } = event;
413        try {
414            this.method.call(this.controller, event);
415            this.context.logDebugActivity(this.methodName, { event, target, currentTarget, action: this.methodName });
416        }
417        catch (error) {
418            const { identifier, controller, element, index } = this;
419            const detail = { identifier, controller, element, index, event };
420            this.context.handleError(error, `invoking action "${this.action}"`, detail);
421        }
422    }
423    willBeInvokedByEvent(event) {
424        const eventTarget = event.target;
425        if (event instanceof KeyboardEvent && this.action.shouldIgnoreKeyboardEvent(event)) {
426            return false;
427        }
428        if (event instanceof MouseEvent && this.action.shouldIgnoreMouseEvent(event)) {
429            return false;
430        }
431        if (this.element === eventTarget) {
432            return true;
433        }
434        else if (eventTarget instanceof Element && this.element.contains(eventTarget)) {
435            return this.scope.containsElement(eventTarget);
436        }
437        else {
438            return this.scope.containsElement(this.action.element);
439        }
440    }
441    get controller() {
442        return this.context.controller;
443    }
444    get methodName() {
445        return this.action.methodName;
446    }
447    get element() {
448        return this.scope.element;
449    }
450    get scope() {
451        return this.context.scope;
452    }
453}
454
455class ElementObserver {
456    constructor(element, delegate) {
457        this.mutationObserverInit = { attributes: true, childList: true, subtree: true };
458        this.element = element;
459        this.started = false;
460        this.delegate = delegate;
461        this.elements = new Set();
462        this.mutationObserver = new MutationObserver((mutations) => this.processMutations(mutations));
463    }
464    start() {
465        if (!this.started) {
466            this.started = true;
467            this.mutationObserver.observe(this.element, this.mutationObserverInit);
468            this.refresh();
469        }
470    }
471    pause(callback) {
472        if (this.started) {
473            this.mutationObserver.disconnect();
474            this.started = false;
475        }
476        callback();
477        if (!this.started) {
478            this.mutationObserver.observe(this.element, this.mutationObserverInit);
479            this.started = true;
480        }
481    }
482    stop() {
483        if (this.started) {
484            this.mutationObserver.takeRecords();
485            this.mutationObserver.disconnect();
486            this.started = false;
487        }
488    }
489    refresh() {
490        if (this.started) {
491            const matches = new Set(this.matchElementsInTree());
492            for (const element of Array.from(this.elements)) {
493                if (!matches.has(element)) {
494                    this.removeElement(element);
495                }
496            }
497            for (const element of Array.from(matches)) {
498                this.addElement(element);
499            }
500        }
501    }
502    processMutations(mutations) {
503        if (this.started) {
504            for (const mutation of mutations) {
505                this.processMutation(mutation);
506            }
507        }
508    }
509    processMutation(mutation) {
510        if (mutation.type == "attributes") {
511            this.processAttributeChange(mutation.target, mutation.attributeName);
512        }
513        else if (mutation.type == "childList") {
514            this.processRemovedNodes(mutation.removedNodes);
515            this.processAddedNodes(mutation.addedNodes);
516        }
517    }
518    processAttributeChange(element, attributeName) {
519        if (this.elements.has(element)) {
520            if (this.delegate.elementAttributeChanged && this.matchElement(element)) {
521                this.delegate.elementAttributeChanged(element, attributeName);
522            }
523            else {
524                this.removeElement(element);
525            }
526        }
527        else if (this.matchElement(element)) {
528            this.addElement(element);
529        }
530    }
531    processRemovedNodes(nodes) {
532        for (const node of Array.from(nodes)) {
533            const element = this.elementFromNode(node);
534            if (element) {
535                this.processTree(element, this.removeElement);
536            }
537        }
538    }
539    processAddedNodes(nodes) {
540        for (const node of Array.from(nodes)) {
541            const element = this.elementFromNode(node);
542            if (element && this.elementIsActive(element)) {
543                this.processTree(element, this.addElement);
544            }
545        }
546    }
547    matchElement(element) {
548        return this.delegate.matchElement(element);
549    }
550    matchElementsInTree(tree = this.element) {
551        return this.delegate.matchElementsInTree(tree);
552    }
553    processTree(tree, processor) {
554        for (const element of this.matchElementsInTree(tree)) {
555            processor.call(this, element);
556        }
557    }
558    elementFromNode(node) {
559        if (node.nodeType == Node.ELEMENT_NODE) {
560            return node;
561        }
562    }
563    elementIsActive(element) {
564        if (element.isConnected != this.element.isConnected) {
565            return false;
566        }
567        else {
568            return this.element.contains(element);
569        }
570    }
571    addElement(element) {
572        if (!this.elements.has(element)) {
573            if (this.elementIsActive(element)) {
574                this.elements.add(element);
575                if (this.delegate.elementMatched) {
576                    this.delegate.elementMatched(element);
577                }
578            }
579        }
580    }
581    removeElement(element) {
582        if (this.elements.has(element)) {
583            this.elements.delete(element);
584            if (this.delegate.elementUnmatched) {
585                this.delegate.elementUnmatched(element);
586            }
587        }
588    }
589}
590
591class AttributeObserver {
592    constructor(element, attributeName, delegate) {
593        this.attributeName = attributeName;
594        this.delegate = delegate;
595        this.elementObserver = new ElementObserver(element, this);
596    }
597    get element() {
598        return this.elementObserver.element;
599    }
600    get selector() {
601        return `[${this.attributeName}]`;
602    }
603    start() {
604        this.elementObserver.start();
605    }
606    pause(callback) {
607        this.elementObserver.pause(callback);
608    }
609    stop() {
610        this.elementObserver.stop();
611    }
612    refresh() {
613        this.elementObserver.refresh();
614    }
615    get started() {
616        return this.elementObserver.started;
617    }
618    matchElement(element) {
619        return element.hasAttribute(this.attributeName);
620    }
621    matchElementsInTree(tree) {
622        const match = this.matchElement(tree) ? [tree] : [];
623        const matches = Array.from(tree.querySelectorAll(this.selector));
624        return match.concat(matches);
625    }
626    elementMatched(element) {
627        if (this.delegate.elementMatchedAttribute) {
628            this.delegate.elementMatchedAttribute(element, this.attributeName);
629        }
630    }
631    elementUnmatched(element) {
632        if (this.delegate.elementUnmatchedAttribute) {
633            this.delegate.elementUnmatchedAttribute(element, this.attributeName);
634        }
635    }
636    elementAttributeChanged(element, attributeName) {
637        if (this.delegate.elementAttributeValueChanged && this.attributeName == attributeName) {
638            this.delegate.elementAttributeValueChanged(element, attributeName);
639        }
640    }
641}
642
643function add(map, key, value) {
644    fetch(map, key).add(value);
645}
646function del(map, key, value) {
647    fetch(map, key).delete(value);
648    prune(map, key);
649}
650function fetch(map, key) {
651    let values = map.get(key);
652    if (!values) {
653        values = new Set();
654        map.set(key, values);
655    }
656    return values;
657}
658function prune(map, key) {
659    const values = map.get(key);
660    if (values != null && values.size == 0) {
661        map.delete(key);
662    }
663}
664
665class Multimap {
666    constructor() {
667        this.valuesByKey = new Map();
668    }
669    get keys() {
670        return Array.from(this.valuesByKey.keys());
671    }
672    get values() {
673        const sets = Array.from(this.valuesByKey.values());
674        return sets.reduce((values, set) => values.concat(Array.from(set)), []);
675    }
676    get size() {
677        const sets = Array.from(this.valuesByKey.values());
678        return sets.reduce((size, set) => size + set.size, 0);
679    }
680    add(key, value) {
681        add(this.valuesByKey, key, value);
682    }
683    delete(key, value) {
684        del(this.valuesByKey, key, value);
685    }
686    has(key, value) {
687        const values = this.valuesByKey.get(key);
688        return values != null && values.has(value);
689    }
690    hasKey(key) {
691        return this.valuesByKey.has(key);
692    }
693    hasValue(value) {
694        const sets = Array.from(this.valuesByKey.values());
695        return sets.some((set) => set.has(value));
696    }
697    getValuesForKey(key) {
698        const values = this.valuesByKey.get(key);
699        return values ? Array.from(values) : [];
700    }
701    getKeysForValue(value) {
702        return Array.from(this.valuesByKey)
703            .filter(([_key, values]) => values.has(value))
704            .map(([key, _values]) => key);
705    }
706}
707
708class IndexedMultimap extends Multimap {
709    constructor() {
710        super();
711        this.keysByValue = new Map();
712    }
713    get values() {
714        return Array.from(this.keysByValue.keys());
715    }
716    add(key, value) {
717        super.add(key, value);
718        add(this.keysByValue, value, key);
719    }
720    delete(key, value) {
721        super.delete(key, value);
722        del(this.keysByValue, value, key);
723    }
724    hasValue(value) {
725        return this.keysByValue.has(value);
726    }
727    getKeysForValue(value) {
728        const set = this.keysByValue.get(value);
729        return set ? Array.from(set) : [];
730    }
731}
732
733class SelectorObserver {
734    constructor(element, selector, delegate, details) {
735        this._selector = selector;
736        this.details = details;
737        this.elementObserver = new ElementObserver(element, this);
738        this.delegate = delegate;
739        this.matchesByElement = new Multimap();
740    }
741    get started() {
742        return this.elementObserver.started;
743    }
744    get selector() {
745        return this._selector;
746    }
747    set selector(selector) {
748        this._selector = selector;
749        this.refresh();
750    }
751    start() {
752        this.elementObserver.start();
753    }
754    pause(callback) {
755        this.elementObserver.pause(callback);
756    }
757    stop() {
758        this.elementObserver.stop();
759    }
760    refresh() {
761        this.elementObserver.refresh();
762    }
763    get element() {
764        return this.elementObserver.element;
765    }
766    matchElement(element) {
767        const { selector } = this;
768        if (selector) {
769            const matches = element.matches(selector);
770            if (this.delegate.selectorMatchElement) {
771                return matches && this.delegate.selectorMatchElement(element, this.details);
772            }
773            return matches;
774        }
775        else {
776            return false;
777        }
778    }
779    matchElementsInTree(tree) {
780        const { selector } = this;
781        if (selector) {
782            const match = this.matchElement(tree) ? [tree] : [];
783            const matches = Array.from(tree.querySelectorAll(selector)).filter((match) => this.matchElement(match));
784            return match.concat(matches);
785        }
786        else {
787            return [];
788        }
789    }
790    elementMatched(element) {
791        const { selector } = this;
792        if (selector) {
793            this.selectorMatched(element, selector);
794        }
795    }
796    elementUnmatched(element) {
797        const selectors = this.matchesByElement.getKeysForValue(element);
798        for (const selector of selectors) {
799            this.selectorUnmatched(element, selector);
800        }
801    }
802    elementAttributeChanged(element, _attributeName) {
803        const { selector } = this;
804        if (selector) {
805            const matches = this.matchElement(element);
806            const matchedBefore = this.matchesByElement.has(selector, element);
807            if (matches && !matchedBefore) {
808                this.selectorMatched(element, selector);
809            }
810            else if (!matches && matchedBefore) {
811                this.selectorUnmatched(element, selector);
812            }
813        }
814    }
815    selectorMatched(element, selector) {
816        this.delegate.selectorMatched(element, selector, this.details);
817        this.matchesByElement.add(selector, element);
818    }
819    selectorUnmatched(element, selector) {
820        this.delegate.selectorUnmatched(element, selector, this.details);
821        this.matchesByElement.delete(selector, element);
822    }
823}
824
825class StringMapObserver {
826    constructor(element, delegate) {
827        this.element = element;
828        this.delegate = delegate;
829        this.started = false;
830        this.stringMap = new Map();
831        this.mutationObserver = new MutationObserver((mutations) => this.processMutations(mutations));
832    }
833    start() {
834        if (!this.started) {
835            this.started = true;
836            this.mutationObserver.observe(this.element, { attributes: true, attributeOldValue: true });
837            this.refresh();
838        }
839    }
840    stop() {
841        if (this.started) {
842            this.mutationObserver.takeRecords();
843            this.mutationObserver.disconnect();
844            this.started = false;
845        }
846    }
847    refresh() {
848        if (this.started) {
849            for (const attributeName of this.knownAttributeNames) {
850                this.refreshAttribute(attributeName, null);
851            }
852        }
853    }
854    processMutations(mutations) {
855        if (this.started) {
856            for (const mutation of mutations) {
857                this.processMutation(mutation);
858            }
859        }
860    }
861    processMutation(mutation) {
862        const attributeName = mutation.attributeName;
863        if (attributeName) {
864            this.refreshAttribute(attributeName, mutation.oldValue);
865        }
866    }
867    refreshAttribute(attributeName, oldValue) {
868        const key = this.delegate.getStringMapKeyForAttribute(attributeName);
869        if (key != null) {
870            if (!this.stringMap.has(attributeName)) {
871                this.stringMapKeyAdded(key, attributeName);
872            }
873            const value = this.element.getAttribute(attributeName);
874            if (this.stringMap.get(attributeName) != value) {
875                this.stringMapValueChanged(value, key, oldValue);
876            }
877            if (value == null) {
878                const oldValue = this.stringMap.get(attributeName);
879                this.stringMap.delete(attributeName);
880                if (oldValue)
881                    this.stringMapKeyRemoved(key, attributeName, oldValue);
882            }
883            else {
884                this.stringMap.set(attributeName, value);
885            }
886        }
887    }
888    stringMapKeyAdded(key, attributeName) {
889        if (this.delegate.stringMapKeyAdded) {
890            this.delegate.stringMapKeyAdded(key, attributeName);
891        }
892    }
893    stringMapValueChanged(value, key, oldValue) {
894        if (this.delegate.stringMapValueChanged) {
895            this.delegate.stringMapValueChanged(value, key, oldValue);
896        }
897    }
898    stringMapKeyRemoved(key, attributeName, oldValue) {
899        if (this.delegate.stringMapKeyRemoved) {
900            this.delegate.stringMapKeyRemoved(key, attributeName, oldValue);
901        }
902    }
903    get knownAttributeNames() {
904        return Array.from(new Set(this.currentAttributeNames.concat(this.recordedAttributeNames)));
905    }
906    get currentAttributeNames() {
907        return Array.from(this.element.attributes).map((attribute) => attribute.name);
908    }
909    get recordedAttributeNames() {
910        return Array.from(this.stringMap.keys());
911    }
912}
913
914class TokenListObserver {
915    constructor(element, attributeName, delegate) {
916        this.attributeObserver = new AttributeObserver(element, attributeName, this);
917        this.delegate = delegate;
918        this.tokensByElement = new Multimap();
919    }
920    get started() {
921        return this.attributeObserver.started;
922    }
923    start() {
924        this.attributeObserver.start();
925    }
926    pause(callback) {
927        this.attributeObserver.pause(callback);
928    }
929    stop() {
930        this.attributeObserver.stop();
931    }
932    refresh() {
933        this.attributeObserver.refresh();
934    }
935    get element() {
936        return this.attributeObserver.element;
937    }
938    get attributeName() {
939        return this.attributeObserver.attributeName;
940    }
941    elementMatchedAttribute(element) {
942        this.tokensMatched(this.readTokensForElement(element));
943    }
944    elementAttributeValueChanged(element) {
945        const [unmatchedTokens, matchedTokens] = this.refreshTokensForElement(element);
946        this.tokensUnmatched(unmatchedTokens);
947        this.tokensMatched(matchedTokens);
948    }
949    elementUnmatchedAttribute(element) {
950        this.tokensUnmatched(this.tokensByElement.getValuesForKey(element));
951    }
952    tokensMatched(tokens) {
953        tokens.forEach((token) => this.tokenMatched(token));
954    }
955    tokensUnmatched(tokens) {
956        tokens.forEach((token) => this.tokenUnmatched(token));
957    }
958    tokenMatched(token) {
959        this.delegate.tokenMatched(token);
960        this.tokensByElement.add(token.element, token);
961    }
962    tokenUnmatched(token) {
963        this.delegate.tokenUnmatched(token);
964        this.tokensByElement.delete(token.element, token);
965    }
966    refreshTokensForElement(element) {
967        const previousTokens = this.tokensByElement.getValuesForKey(element);
968        const currentTokens = this.readTokensForElement(element);
969        const firstDifferingIndex = zip(previousTokens, currentTokens).findIndex(([previousToken, currentToken]) => !tokensAreEqual(previousToken, currentToken));
970        if (firstDifferingIndex == -1) {
971            return [[], []];
972        }
973        else {
974            return [previousTokens.slice(firstDifferingIndex), currentTokens.slice(firstDifferingIndex)];
975        }
976    }
977    readTokensForElement(element) {
978        const attributeName = this.attributeName;
979        const tokenString = element.getAttribute(attributeName) || "";
980        return parseTokenString(tokenString, element, attributeName);
981    }
982}
983function parseTokenString(tokenString, element, attributeName) {
984    return tokenString
985        .trim()
986        .split(/\s+/)
987        .filter((content) => content.length)
988        .map((content, index) => ({ element, attributeName, content, index }));
989}
990function zip(left, right) {
991    const length = Math.max(left.length, right.length);
992    return Array.from({ length }, (_, index) => [left[index], right[index]]);
993}
994function tokensAreEqual(left, right) {
995    return left && right && left.index == right.index && left.content == right.content;
996}
997
998class ValueListObserver {
999    constructor(element, attributeName, delegate) {
1000        this.tokenListObserver = new TokenListObserver(element, attributeName, this);
1001        this.delegate = delegate;
1002        this.parseResultsByToken = new WeakMap();
1003        this.valuesByTokenByElement = new WeakMap();
1004    }
1005    get started() {
1006        return this.tokenListObserver.started;
1007    }
1008    start() {
1009        this.tokenListObserver.start();
1010    }
1011    stop() {
1012        this.tokenListObserver.stop();
1013    }
1014    refresh() {
1015        this.tokenListObserver.refresh();
1016    }
1017    get element() {
1018        return this.tokenListObserver.element;
1019    }
1020    get attributeName() {
1021        return this.tokenListObserver.attributeName;
1022    }
1023    tokenMatched(token) {
1024        const { element } = token;
1025        const { value } = this.fetchParseResultForToken(token);
1026        if (value) {
1027            this.fetchValuesByTokenForElement(element).set(token, value);
1028            this.delegate.elementMatchedValue(element, value);
1029        }
1030    }
1031    tokenUnmatched(token) {
1032        const { element } = token;
1033        const { value } = this.fetchParseResultForToken(token);
1034        if (value) {
1035            this.fetchValuesByTokenForElement(element).delete(token);
1036            this.delegate.elementUnmatchedValue(element, value);
1037        }
1038    }
1039    fetchParseResultForToken(token) {
1040        let parseResult = this.parseResultsByToken.get(token);
1041        if (!parseResult) {
1042            parseResult = this.parseToken(token);
1043            this.parseResultsByToken.set(token, parseResult);
1044        }
1045        return parseResult;
1046    }
1047    fetchValuesByTokenForElement(element) {
1048        let valuesByToken = this.valuesByTokenByElement.get(element);
1049        if (!valuesByToken) {
1050            valuesByToken = new Map();
1051            this.valuesByTokenByElement.set(element, valuesByToken);
1052        }
1053        return valuesByToken;
1054    }
1055    parseToken(token) {
1056        try {
1057            const value = this.delegate.parseValueForToken(token);
1058            return { value };
1059        }
1060        catch (error) {
1061            return { error };
1062        }
1063    }
1064}
1065
1066class BindingObserver {
1067    constructor(context, delegate) {
1068        this.context = context;
1069        this.delegate = delegate;
1070        this.bindingsByAction = new Map();
1071    }
1072    start() {
1073        if (!this.valueListObserver) {
1074            this.valueListObserver = new ValueListObserver(this.element, this.actionAttribute, this);
1075            this.valueListObserver.start();
1076        }
1077    }
1078    stop() {
1079        if (this.valueListObserver) {
1080            this.valueListObserver.stop();
1081            delete this.valueListObserver;
1082            this.disconnectAllActions();
1083        }
1084    }
1085    get element() {
1086        return this.context.element;
1087    }
1088    get identifier() {
1089        return this.context.identifier;
1090    }
1091    get actionAttribute() {
1092        return this.schema.actionAttribute;
1093    }
1094    get schema() {
1095        return this.context.schema;
1096    }
1097    get bindings() {
1098        return Array.from(this.bindingsByAction.values());
1099    }
1100    connectAction(action) {
1101        const binding = new Binding(this.context, action);
1102        this.bindingsByAction.set(action, binding);
1103        this.delegate.bindingConnected(binding);
1104    }
1105    disconnectAction(action) {
1106        const binding = this.bindingsByAction.get(action);
1107        if (binding) {
1108            this.bindingsByAction.delete(action);
1109            this.delegate.bindingDisconnected(binding);
1110        }
1111    }
1112    disconnectAllActions() {
1113        this.bindings.forEach((binding) => this.delegate.bindingDisconnected(binding, true));
1114        this.bindingsByAction.clear();
1115    }
1116    parseValueForToken(token) {
1117        const action = Action.forToken(token, this.schema);
1118        if (action.identifier == this.identifier) {
1119            return action;
1120        }
1121    }
1122    elementMatchedValue(element, action) {
1123        this.connectAction(action);
1124    }
1125    elementUnmatchedValue(element, action) {
1126        this.disconnectAction(action);
1127    }
1128}
1129
1130class ValueObserver {
1131    constructor(context, receiver) {
1132        this.context = context;
1133        this.receiver = receiver;
1134        this.stringMapObserver = new StringMapObserver(this.element, this);
1135        this.valueDescriptorMap = this.controller.valueDescriptorMap;
1136    }
1137    start() {
1138        this.stringMapObserver.start();
1139        this.invokeChangedCallbacksForDefaultValues();
1140    }
1141    stop() {
1142        this.stringMapObserver.stop();
1143    }
1144    get element() {
1145        return this.context.element;
1146    }
1147    get controller() {
1148        return this.context.controller;
1149    }
1150    getStringMapKeyForAttribute(attributeName) {
1151        if (attributeName in this.valueDescriptorMap) {
1152            return this.valueDescriptorMap[attributeName].name;
1153        }
1154    }
1155    stringMapKeyAdded(key, attributeName) {
1156        const descriptor = this.valueDescriptorMap[attributeName];
1157        if (!this.hasValue(key)) {
1158            this.invokeChangedCallback(key, descriptor.writer(this.receiver[key]), descriptor.writer(descriptor.defaultValue));
1159        }
1160    }
1161    stringMapValueChanged(value, name, oldValue) {
1162        const descriptor = this.valueDescriptorNameMap[name];
1163        if (value === null)
1164            return;
1165        if (oldValue === null) {
1166            oldValue = descriptor.writer(descriptor.defaultValue);
1167        }
1168        this.invokeChangedCallback(name, value, oldValue);
1169    }
1170    stringMapKeyRemoved(key, attributeName, oldValue) {
1171        const descriptor = this.valueDescriptorNameMap[key];
1172        if (this.hasValue(key)) {
1173            this.invokeChangedCallback(key, descriptor.writer(this.receiver[key]), oldValue);
1174        }
1175        else {
1176            this.invokeChangedCallback(key, descriptor.writer(descriptor.defaultValue), oldValue);
1177        }
1178    }
1179    invokeChangedCallbacksForDefaultValues() {
1180        for (const { key, name, defaultValue, writer } of this.valueDescriptors) {
1181            if (defaultValue != undefined && !this.controller.data.has(key)) {
1182                this.invokeChangedCallback(name, writer(defaultValue), undefined);
1183            }
1184        }
1185    }
1186    invokeChangedCallback(name, rawValue, rawOldValue) {
1187        const changedMethodName = `${name}Changed`;
1188        const changedMethod = this.receiver[changedMethodName];
1189        if (typeof changedMethod == "function") {
1190            const descriptor = this.valueDescriptorNameMap[name];
1191            try {
1192                const value = descriptor.reader(rawValue);
1193                let oldValue = rawOldValue;
1194                if (rawOldValue) {
1195                    oldValue = descriptor.reader(rawOldValue);
1196                }
1197                changedMethod.call(this.receiver, value, oldValue);
1198            }
1199            catch (error) {
1200                if (error instanceof TypeError) {
1201                    error.message = `Stimulus Value "${this.context.identifier}.${descriptor.name}" - ${error.message}`;
1202                }
1203                throw error;
1204            }
1205        }
1206    }
1207    get valueDescriptors() {
1208        const { valueDescriptorMap } = this;
1209        return Object.keys(valueDescriptorMap).map((key) => valueDescriptorMap[key]);
1210    }
1211    get valueDescriptorNameMap() {
1212        const descriptors = {};
1213        Object.keys(this.valueDescriptorMap).forEach((key) => {
1214            const descriptor = this.valueDescriptorMap[key];
1215            descriptors[descriptor.name] = descriptor;
1216        });
1217        return descriptors;
1218    }
1219    hasValue(attributeName) {
1220        const descriptor = this.valueDescriptorNameMap[attributeName];
1221        const hasMethodName = `has${capitalize(descriptor.name)}`;
1222        return this.receiver[hasMethodName];
1223    }
1224}
1225
1226class TargetObserver {
1227    constructor(context, delegate) {
1228        this.context = context;
1229        this.delegate = delegate;
1230        this.targetsByName = new Multimap();
1231    }
1232    start() {
1233        if (!this.tokenListObserver) {
1234            this.tokenListObserver = new TokenListObserver(this.element, this.attributeName, this);
1235            this.tokenListObserver.start();
1236        }
1237    }
1238    stop() {
1239        if (this.tokenListObserver) {
1240            this.disconnectAllTargets();
1241            this.tokenListObserver.stop();
1242            delete this.tokenListObserver;
1243        }
1244    }
1245    tokenMatched({ element, content: name }) {
1246        if (this.scope.containsElement(element)) {
1247            this.connectTarget(element, name);
1248        }
1249    }
1250    tokenUnmatched({ element, content: name }) {
1251        this.disconnectTarget(element, name);
1252    }
1253    connectTarget(element, name) {
1254        var _a;
1255        if (!this.targetsByName.has(name, element)) {
1256            this.targetsByName.add(name, element);
1257            (_a = this.tokenListObserver) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.targetConnected(element, name));
1258        }
1259    }
1260    disconnectTarget(element, name) {
1261        var _a;
1262        if (this.targetsByName.has(name, element)) {
1263            this.targetsByName.delete(name, element);
1264            (_a = this.tokenListObserver) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.targetDisconnected(element, name));
1265        }
1266    }
1267    disconnectAllTargets() {
1268        for (const name of this.targetsByName.keys) {
1269            for (const element of this.targetsByName.getValuesForKey(name)) {
1270                this.disconnectTarget(element, name);
1271            }
1272        }
1273    }
1274    get attributeName() {
1275        return `data-${this.context.identifier}-target`;
1276    }
1277    get element() {
1278        return this.context.element;
1279    }
1280    get scope() {
1281        return this.context.scope;
1282    }
1283}
1284
1285function readInheritableStaticArrayValues(constructor, propertyName) {
1286    const ancestors = getAncestorsForConstructor(constructor);
1287    return Array.from(ancestors.reduce((values, constructor) => {
1288        getOwnStaticArrayValues(constructor, propertyName).forEach((name) => values.add(name));
1289        return values;
1290    }, new Set()));
1291}
1292function readInheritableStaticObjectPairs(constructor, propertyName) {
1293    const ancestors = getAncestorsForConstructor(constructor);
1294    return ancestors.reduce((pairs, constructor) => {
1295        pairs.push(...getOwnStaticObjectPairs(constructor, propertyName));
1296        return pairs;
1297    }, []);
1298}
1299function getAncestorsForConstructor(constructor) {
1300    const ancestors = [];
1301    while (constructor) {
1302        ancestors.push(constructor);
1303        constructor = Object.getPrototypeOf(constructor);
1304    }
1305    return ancestors.reverse();
1306}
1307function getOwnStaticArrayValues(constructor, propertyName) {
1308    const definition = constructor[propertyName];
1309    return Array.isArray(definition) ? definition : [];
1310}
1311function getOwnStaticObjectPairs(constructor, propertyName) {
1312    const definition = constructor[propertyName];
1313    return definition ? Object.keys(definition).map((key) => [key, definition[key]]) : [];
1314}
1315
1316class OutletObserver {
1317    constructor(context, delegate) {
1318        this.started = false;
1319        this.context = context;
1320        this.delegate = delegate;
1321        this.outletsByName = new Multimap();
1322        this.outletElementsByName = new Multimap();
1323        this.selectorObserverMap = new Map();
1324        this.attributeObserverMap = new Map();
1325    }
1326    start() {
1327        if (!this.started) {
1328            this.outletDefinitions.forEach((outletName) => {
1329                this.setupSelectorObserverForOutlet(outletName);
1330                this.setupAttributeObserverForOutlet(outletName);
1331            });
1332            this.started = true;
1333            this.dependentContexts.forEach((context) => context.refresh());
1334        }
1335    }
1336    refresh() {
1337        this.selectorObserverMap.forEach((observer) => observer.refresh());
1338        this.attributeObserverMap.forEach((observer) => observer.refresh());
1339    }
1340    stop() {
1341        if (this.started) {
1342            this.started = false;
1343            this.disconnectAllOutlets();
1344            this.stopSelectorObservers();
1345            this.stopAttributeObservers();
1346        }
1347    }
1348    stopSelectorObservers() {
1349        if (this.selectorObserverMap.size > 0) {
1350            this.selectorObserverMap.forEach((observer) => observer.stop());
1351            this.selectorObserverMap.clear();
1352        }
1353    }
1354    stopAttributeObservers() {
1355        if (this.attributeObserverMap.size > 0) {
1356            this.attributeObserverMap.forEach((observer) => observer.stop());
1357            this.attributeObserverMap.clear();
1358        }
1359    }
1360    selectorMatched(element, _selector, { outletName }) {
1361        const outlet = this.getOutlet(element, outletName);
1362        if (outlet) {
1363            this.connectOutlet(outlet, element, outletName);
1364        }
1365    }
1366    selectorUnmatched(element, _selector, { outletName }) {
1367        const outlet = this.getOutletFromMap(element, outletName);
1368        if (outlet) {
1369            this.disconnectOutlet(outlet, element, outletName);
1370        }
1371    }
1372    selectorMatchElement(element, { outletName }) {
1373        const selector = this.selector(outletName);
1374        const hasOutlet = this.hasOutlet(element, outletName);
1375        const hasOutletController = element.matches(`[${this.schema.controllerAttribute}~=${outletName}]`);
1376        if (selector) {
1377            return hasOutlet && hasOutletController && element.matches(selector);
1378        }
1379        else {
1380            return false;
1381        }
1382    }
1383    elementMatchedAttribute(_element, attributeName) {
1384        const outletName = this.getOutletNameFromOutletAttributeName(attributeName);
1385        if (outletName) {
1386            this.updateSelectorObserverForOutlet(outletName);
1387        }
1388    }
1389    elementAttributeValueChanged(_element, attributeName) {
1390        const outletName = this.getOutletNameFromOutletAttributeName(attributeName);
1391        if (outletName) {
1392            this.updateSelectorObserverForOutlet(outletName);
1393        }
1394    }
1395    elementUnmatchedAttribute(_element, attributeName) {
1396        const outletName = this.getOutletNameFromOutletAttributeName(attributeName);
1397        if (outletName) {
1398            this.updateSelectorObserverForOutlet(outletName);
1399        }
1400    }
1401    connectOutlet(outlet, element, outletName) {
1402        var _a;
1403        if (!this.outletElementsByName.has(outletName, element)) {
1404            this.outletsByName.add(outletName, outlet);
1405            this.outletElementsByName.add(outletName, element);
1406            (_a = this.selectorObserverMap.get(outletName)) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.outletConnected(outlet, element, outletName));
1407        }
1408    }
1409    disconnectOutlet(outlet, element, outletName) {
1410        var _a;
1411        if (this.outletElementsByName.has(outletName, element)) {
1412            this.outletsByName.delete(outletName, outlet);
1413            this.outletElementsByName.delete(outletName, element);
1414            (_a = this.selectorObserverMap
1415                .get(outletName)) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.outletDisconnected(outlet, element, outletName));
1416        }
1417    }
1418    disconnectAllOutlets() {
1419        for (const outletName of this.outletElementsByName.keys) {
1420            for (const element of this.outletElementsByName.getValuesForKey(outletName)) {
1421                for (const outlet of this.outletsByName.getValuesForKey(outletName)) {
1422                    this.disconnectOutlet(outlet, element, outletName);
1423                }
1424            }
1425        }
1426    }
1427    updateSelectorObserverForOutlet(outletName) {
1428        const observer = this.selectorObserverMap.get(outletName);
1429        if (observer) {
1430            observer.selector = this.selector(outletName);
1431        }
1432    }
1433    setupSelectorObserverForOutlet(outletName) {
1434        const selector = this.selector(outletName);
1435        const selectorObserver = new SelectorObserver(document.body, selector, this, { outletName });
1436        this.selectorObserverMap.set(outletName, selectorObserver);
1437        selectorObserver.start();
1438    }
1439    setupAttributeObserverForOutlet(outletName) {
1440        const attributeName = this.attributeNameForOutletName(outletName);
1441        const attributeObserver = new AttributeObserver(this.scope.element, attributeName, this);
1442        this.attributeObserverMap.set(outletName, attributeObserver);
1443        attributeObserver.start();
1444    }
1445    selector(outletName) {
1446        return this.scope.outlets.getSelectorForOutletName(outletName);
1447    }
1448    attributeNameForOutletName(outletName) {
1449        return this.scope.schema.outletAttributeForScope(this.identifier, outletName);
1450    }
1451    getOutletNameFromOutletAttributeName(attributeName) {
1452        return this.outletDefinitions.find((outletName) => this.attributeNameForOutletName(outletName) === attributeName);
1453    }
1454    get outletDependencies() {
1455        const dependencies = new Multimap();
1456        this.router.modules.forEach((module) => {
1457            const constructor = module.definition.controllerConstructor;
1458            const outlets = readInheritableStaticArrayValues(constructor, "outlets");
1459            outlets.forEach((outlet) => dependencies.add(outlet, module.identifier));
1460        });
1461        return dependencies;
1462    }
1463    get outletDefinitions() {
1464        return this.outletDependencies.getKeysForValue(this.identifier);
1465    }
1466    get dependentControllerIdentifiers() {
1467        return this.outletDependencies.getValuesForKey(this.identifier);
1468    }
1469    get dependentContexts() {
1470        const identifiers = this.dependentControllerIdentifiers;
1471        return this.router.contexts.filter((context) => identifiers.includes(context.identifier));
1472    }
1473    hasOutlet(element, outletName) {
1474        return !!this.getOutlet(element, outletName) || !!this.getOutletFromMap(element, outletName);
1475    }
1476    getOutlet(element, outletName) {
1477        return this.application.getControllerForElementAndIdentifier(element, outletName);
1478    }
1479    getOutletFromMap(element, outletName) {
1480        return this.outletsByName.getValuesForKey(outletName).find((outlet) => outlet.element === element);
1481    }
1482    get scope() {
1483        return this.context.scope;
1484    }
1485    get schema() {
1486        return this.context.schema;
1487    }
1488    get identifier() {
1489        return this.context.identifier;
1490    }
1491    get application() {
1492        return this.context.application;
1493    }
1494    get router() {
1495        return this.application.router;
1496    }
1497}
1498
1499class Context {
1500    constructor(module, scope) {
1501        this.logDebugActivity = (functionName, detail = {}) => {
1502            const { identifier, controller, element } = this;
1503            detail = Object.assign({ identifier, controller, element }, detail);
1504            this.application.logDebugActivity(this.identifier, functionName, detail);
1505        };
1506        this.module = module;
1507        this.scope = scope;
1508        this.controller = new module.controllerConstructor(this);
1509        this.bindingObserver = new BindingObserver(this, this.dispatcher);
1510        this.valueObserver = new ValueObserver(this, this.controller);
1511        this.targetObserver = new TargetObserver(this, this);
1512        this.outletObserver = new OutletObserver(this, this);
1513        try {
1514            this.controller.initialize();
1515            this.logDebugActivity("initialize");
1516        }
1517        catch (error) {
1518            this.handleError(error, "initializing controller");
1519        }
1520    }
1521    connect() {
1522        this.bindingObserver.start();
1523        this.valueObserver.start();
1524        this.targetObserver.start();
1525        this.outletObserver.start();
1526        try {
1527            this.controller.connect();
1528            this.logDebugActivity("connect");
1529        }
1530        catch (error) {
1531            this.handleError(error, "connecting controller");
1532        }
1533    }
1534    refresh() {
1535        this.outletObserver.refresh();
1536    }
1537    disconnect() {
1538        try {
1539            this.controller.disconnect();
1540            this.logDebugActivity("disconnect");
1541        }
1542        catch (error) {
1543            this.handleError(error, "disconnecting controller");
1544        }
1545        this.outletObserver.stop();
1546        this.targetObserver.stop();
1547        this.valueObserver.stop();
1548        this.bindingObserver.stop();
1549    }
1550    get application() {
1551        return this.module.application;
1552    }
1553    get identifier() {
1554        return this.module.identifier;
1555    }
1556    get schema() {
1557        return this.application.schema;
1558    }
1559    get dispatcher() {
1560        return this.application.dispatcher;
1561    }
1562    get element() {
1563        return this.scope.element;
1564    }
1565    get parentElement() {
1566        return this.element.parentElement;
1567    }
1568    handleError(error, message, detail = {}) {
1569        const { identifier, controller, element } = this;
1570        detail = Object.assign({ identifier, controller, element }, detail);
1571        this.application.handleError(error, `Error ${message}`, detail);
1572    }
1573    targetConnected(element, name) {
1574        this.invokeControllerMethod(`${name}TargetConnected`, element);
1575    }
1576    targetDisconnected(element, name) {
1577        this.invokeControllerMethod(`${name}TargetDisconnected`, element);
1578    }
1579    outletConnected(outlet, element, name) {
1580        this.invokeControllerMethod(`${namespaceCamelize(name)}OutletConnected`, outlet, element);
1581    }
1582    outletDisconnected(outlet, element, name) {
1583        this.invokeControllerMethod(`${namespaceCamelize(name)}OutletDisconnected`, outlet, element);
1584    }
1585    invokeControllerMethod(methodName, ...args) {
1586        const controller = this.controller;
1587        if (typeof controller[methodName] == "function") {
1588            controller[methodName](...args);
1589        }
1590    }
1591}
1592
1593function bless(constructor) {
1594    return shadow(constructor, getBlessedProperties(constructor));
1595}
1596function shadow(constructor, properties) {
1597    const shadowConstructor = extend(constructor);
1598    const shadowProperties = getShadowProperties(constructor.prototype, properties);
1599    Object.defineProperties(shadowConstructor.prototype, shadowProperties);
1600    return shadowConstructor;
1601}
1602function getBlessedProperties(constructor) {
1603    const blessings = readInheritableStaticArrayValues(constructor, "blessings");
1604    return blessings.reduce((blessedProperties, blessing) => {
1605        const properties = blessing(constructor);
1606        for (const key in properties) {
1607            const descriptor = blessedProperties[key] || {};
1608            blessedProperties[key] = Object.assign(descriptor, properties[key]);
1609        }
1610        return blessedProperties;
1611    }, {});
1612}
1613function getShadowProperties(prototype, properties) {
1614    return getOwnKeys(properties).reduce((shadowProperties, key) => {
1615        const descriptor = getShadowedDescriptor(prototype, properties, key);
1616        if (descriptor) {
1617            Object.assign(shadowProperties, { [key]: descriptor });
1618        }
1619        return shadowProperties;
1620    }, {});
1621}
1622function getShadowedDescriptor(prototype, properties, key) {
1623    const shadowingDescriptor = Object.getOwnPropertyDescriptor(prototype, key);
1624    const shadowedByValue = shadowingDescriptor && "value" in shadowingDescriptor;
1625    if (!shadowedByValue) {
1626        const descriptor = Object.getOwnPropertyDescriptor(properties, key).value;
1627        if (shadowingDescriptor) {
1628            descriptor.get = shadowingDescriptor.get || descriptor.get;
1629            descriptor.set = shadowingDescriptor.set || descriptor.set;
1630        }
1631        return descriptor;
1632    }
1633}
1634const getOwnKeys = (() => {
1635    if (typeof Object.getOwnPropertySymbols == "function") {
1636        return (object) => [...Object.getOwnPropertyNames(object), ...Object.getOwnPropertySymbols(object)];
1637    }
1638    else {
1639        return Object.getOwnPropertyNames;
1640    }
1641})();
1642const extend = (() => {
1643    function extendWithReflect(constructor) {
1644        function extended() {
1645            return Reflect.construct(constructor, arguments, new.target);
1646        }
1647        extended.prototype = Object.create(constructor.prototype, {
1648            constructor: { value: extended },
1649        });
1650        Reflect.setPrototypeOf(extended, constructor);
1651        return extended;
1652    }
1653    function testReflectExtension() {
1654        const a = function () {
1655            this.a.call(this);
1656        };
1657        const b = extendWithReflect(a);
1658        b.prototype.a = function () { };
1659        return new b();
1660    }
1661    try {
1662        testReflectExtension();
1663        return extendWithReflect;
1664    }
1665    catch (error) {
1666        return (constructor) => class extended extends constructor {
1667        };
1668    }
1669})();
1670
1671function blessDefinition(definition) {
1672    return {
1673        identifier: definition.identifier,
1674        controllerConstructor: bless(definition.controllerConstructor),
1675    };
1676}
1677
1678class Module {
1679    constructor(application, definition) {
1680        this.application = application;
1681        this.definition = blessDefinition(definition);
1682        this.contextsByScope = new WeakMap();
1683        this.connectedContexts = new Set();
1684    }
1685    get identifier() {
1686        return this.definition.identifier;
1687    }
1688    get controllerConstructor() {
1689        return this.definition.controllerConstructor;
1690    }
1691    get contexts() {
1692        return Array.from(this.connectedContexts);
1693    }
1694    connectContextForScope(scope) {
1695        const context = this.fetchContextForScope(scope);
1696        this.connectedContexts.add(context);
1697        context.connect();
1698    }
1699    disconnectContextForScope(scope) {
1700        const context = this.contextsByScope.get(scope);
1701        if (context) {
1702            this.connectedContexts.delete(context);
1703            context.disconnect();
1704        }
1705    }
1706    fetchContextForScope(scope) {
1707        let context = this.contextsByScope.get(scope);
1708        if (!context) {
1709            context = new Context(this, scope);
1710            this.contextsByScope.set(scope, context);
1711        }
1712        return context;
1713    }
1714}
1715
1716class ClassMap {
1717    constructor(scope) {
1718        this.scope = scope;
1719    }
1720    has(name) {
1721        return this.data.has(this.getDataKey(name));
1722    }
1723    get(name) {
1724        return this.getAll(name)[0];
1725    }
1726    getAll(name) {
1727        const tokenString = this.data.get(this.getDataKey(name)) || "";
1728        return tokenize(tokenString);
1729    }
1730    getAttributeName(name) {
1731        return this.data.getAttributeNameForKey(this.getDataKey(name));
1732    }
1733    getDataKey(name) {
1734        return `${name}-class`;
1735    }
1736    get data() {
1737        return this.scope.data;
1738    }
1739}
1740
1741class DataMap {
1742    constructor(scope) {
1743        this.scope = scope;
1744    }
1745    get element() {
1746        return this.scope.element;
1747    }
1748    get identifier() {
1749        return this.scope.identifier;
1750    }
1751    get(key) {
1752        const name = this.getAttributeNameForKey(key);
1753        return this.element.getAttribute(name);
1754    }
1755    set(key, value) {
1756        const name = this.getAttributeNameForKey(key);
1757        this.element.setAttribute(name, value);
1758        return this.get(key);
1759    }
1760    has(key) {
1761        const name = this.getAttributeNameForKey(key);
1762        return this.element.hasAttribute(name);
1763    }
1764    delete(key) {
1765        if (this.has(key)) {
1766            const name = this.getAttributeNameForKey(key);
1767            this.element.removeAttribute(name);
1768            return true;
1769        }
1770        else {
1771            return false;
1772        }
1773    }
1774    getAttributeNameForKey(key) {
1775        return `data-${this.identifier}-${dasherize(key)}`;
1776    }
1777}
1778
1779class Guide {
1780    constructor(logger) {
1781        this.warnedKeysByObject = new WeakMap();
1782        this.logger = logger;
1783    }
1784    warn(object, key, message) {
1785        let warnedKeys = this.warnedKeysByObject.get(object);
1786        if (!warnedKeys) {
1787            warnedKeys = new Set();
1788            this.warnedKeysByObject.set(object, warnedKeys);
1789        }
1790        if (!warnedKeys.has(key)) {
1791            warnedKeys.add(key);
1792            this.logger.warn(message, object);
1793        }
1794    }
1795}
1796
1797function attributeValueContainsToken(attributeName, token) {
1798    return `[${attributeName}~="${token}"]`;
1799}
1800
1801class TargetSet {
1802    constructor(scope) {
1803        this.scope = scope;
1804    }
1805    get element() {
1806        return this.scope.element;
1807    }
1808    get identifier() {
1809        return this.scope.identifier;
1810    }
1811    get schema() {
1812        return this.scope.schema;
1813    }
1814    has(targetName) {
1815        return this.find(targetName) != null;
1816    }
1817    find(...targetNames) {
1818        return targetNames.reduce((target, targetName) => target || this.findTarget(targetName) || this.findLegacyTarget(targetName), undefined);
1819    }
1820    findAll(...targetNames) {
1821        return targetNames.reduce((targets, targetName) => [
1822            ...targets,
1823            ...this.findAllTargets(targetName),
1824            ...this.findAllLegacyTargets(targetName),
1825        ], []);
1826    }
1827    findTarget(targetName) {
1828        const selector = this.getSelectorForTargetName(targetName);
1829        return this.scope.findElement(selector);
1830    }
1831    findAllTargets(targetName) {
1832        const selector = this.getSelectorForTargetName(targetName);
1833        return this.scope.findAllElements(selector);
1834    }
1835    getSelectorForTargetName(targetName) {
1836        const attributeName = this.schema.targetAttributeForScope(this.identifier);
1837        return attributeValueContainsToken(attributeName, targetName);
1838    }
1839    findLegacyTarget(targetName) {
1840        const selector = this.getLegacySelectorForTargetName(targetName);
1841        return this.deprecate(this.scope.findElement(selector), targetName);
1842    }
1843    findAllLegacyTargets(targetName) {
1844        const selector = this.getLegacySelectorForTargetName(targetName);
1845        return this.scope.findAllElements(selector).map((element) => this.deprecate(element, targetName));
1846    }
1847    getLegacySelectorForTargetName(targetName) {
1848        const targetDescriptor = `${this.identifier}.${targetName}`;
1849        return attributeValueContainsToken(this.schema.targetAttribute, targetDescriptor);
1850    }
1851    deprecate(element, targetName) {
1852        if (element) {
1853            const { identifier } = this;
1854            const attributeName = this.schema.targetAttribute;
1855            const revisedAttributeName = this.schema.targetAttributeForScope(identifier);
1856            this.guide.warn(element, `target:${targetName}`, `Please replace ${attributeName}="${identifier}.${targetName}" with ${revisedAttributeName}="${targetName}". ` +
1857                `The ${attributeName} attribute is deprecated and will be removed in a future version of Stimulus.`);
1858        }
1859        return element;
1860    }
1861    get guide() {
1862        return this.scope.guide;
1863    }
1864}
1865
1866class OutletSet {
1867    constructor(scope, controllerElement) {
1868        this.scope = scope;
1869        this.controllerElement = controllerElement;
1870    }
1871    get element() {
1872        return this.scope.element;
1873    }
1874    get identifier() {
1875        return this.scope.identifier;
1876    }
1877    get schema() {
1878        return this.scope.schema;
1879    }
1880    has(outletName) {
1881        return this.find(outletName) != null;
1882    }
1883    find(...outletNames) {
1884        return outletNames.reduce((outlet, outletName) => outlet || this.findOutlet(outletName), undefined);
1885    }
1886    findAll(...outletNames) {
1887        return outletNames.reduce((outlets, outletName) => [...outlets, ...this.findAllOutlets(outletName)], []);
1888    }
1889    getSelectorForOutletName(outletName) {
1890        const attributeName = this.schema.outletAttributeForScope(this.identifier, outletName);
1891        return this.controllerElement.getAttribute(attributeName);
1892    }
1893    findOutlet(outletName) {
1894        const selector = this.getSelectorForOutletName(outletName);
1895        if (selector)
1896            return this.findElement(selector, outletName);
1897    }
1898    findAllOutlets(outletName) {
1899        const selector = this.getSelectorForOutletName(outletName);
1900        return selector ? this.findAllElements(selector, outletName) : [];
1901    }
1902    findElement(selector, outletName) {
1903        const elements = this.scope.queryElements(selector);
1904        return elements.filter((element) => this.matchesElement(element, selector, outletName))[0];
1905    }
1906    findAllElements(selector, outletName) {
1907        const elements = this.scope.queryElements(selector);
1908        return elements.filter((element) => this.matchesElement(element, selector, outletName));
1909    }
1910    matchesElement(element, selector, outletName) {
1911        const controllerAttribute = element.getAttribute(this.scope.schema.controllerAttribute) || "";
1912        return element.matches(selector) && controllerAttribute.split(" ").includes(outletName);
1913    }
1914}
1915
1916class Scope {
1917    constructor(schema, element, identifier, logger) {
1918        this.targets = new TargetSet(this);
1919        this.classes = new ClassMap(this);
1920        this.data = new DataMap(this);
1921        this.containsElement = (element) => {
1922            return element.closest(this.controllerSelector) === this.element;
1923        };
1924        this.schema = schema;
1925        this.element = element;
1926        this.identifier = identifier;
1927        this.guide = new Guide(logger);
1928        this.outlets = new OutletSet(this.documentScope, element);
1929    }
1930    findElement(selector) {
1931        return this.element.matches(selector) ? this.element : this.queryElements(selector).find(this.containsElement);
1932    }
1933    findAllElements(selector) {
1934        return [
1935            ...(this.element.matches(selector) ? [this.element] : []),
1936            ...this.queryElements(selector).filter(this.containsElement),
1937        ];
1938    }
1939    queryElements(selector) {
1940        return Array.from(this.element.querySelectorAll(selector));
1941    }
1942    get controllerSelector() {
1943        return attributeValueContainsToken(this.schema.controllerAttribute, this.identifier);
1944    }
1945    get isDocumentScope() {
1946        return this.element === document.documentElement;
1947    }
1948    get documentScope() {
1949        return this.isDocumentScope
1950            ? this
1951            : new Scope(this.schema, document.documentElement, this.identifier, this.guide.logger);
1952    }
1953}
1954
1955class ScopeObserver {
1956    constructor(element, schema, delegate) {
1957        this.element = element;
1958        this.schema = schema;
1959        this.delegate = delegate;
1960        this.valueListObserver = new ValueListObserver(this.element, this.controllerAttribute, this);
1961        this.scopesByIdentifierByElement = new WeakMap();
1962        this.scopeReferenceCounts = new WeakMap();
1963    }
1964    start() {
1965        this.valueListObserver.start();
1966    }
1967    stop() {
1968        this.valueListObserver.stop();
1969    }
1970    get controllerAttribute() {
1971        return this.schema.controllerAttribute;
1972    }
1973    parseValueForToken(token) {
1974        const { element, content: identifier } = token;
1975        return this.parseValueForElementAndIdentifier(element, identifier);
1976    }
1977    parseValueForElementAndIdentifier(element, identifier) {
1978        const scopesByIdentifier = this.fetchScopesByIdentifierForElement(element);
1979        let scope = scopesByIdentifier.get(identifier);
1980        if (!scope) {
1981            scope = this.delegate.createScopeForElementAndIdentifier(element, identifier);
1982            scopesByIdentifier.set(identifier, scope);
1983        }
1984        return scope;
1985    }
1986    elementMatchedValue(element, value) {
1987        const referenceCount = (this.scopeReferenceCounts.get(value) || 0) + 1;
1988        this.scopeReferenceCounts.set(value, referenceCount);
1989        if (referenceCount == 1) {
1990            this.delegate.scopeConnected(value);
1991        }
1992    }
1993    elementUnmatchedValue(element, value) {
1994        const referenceCount = this.scopeReferenceCounts.get(value);
1995        if (referenceCount) {
1996            this.scopeReferenceCounts.set(value, referenceCount - 1);
1997            if (referenceCount == 1) {
1998                this.delegate.scopeDisconnected(value);
1999            }
2000        }
2001    }
2002    fetchScopesByIdentifierForElement(element) {
2003        let scopesByIdentifier = this.scopesByIdentifierByElement.get(element);
2004        if (!scopesByIdentifier) {
2005            scopesByIdentifier = new Map();
2006            this.scopesByIdentifierByElement.set(element, scopesByIdentifier);
2007        }
2008        return scopesByIdentifier;
2009    }
2010}
2011
2012class Router {
2013    constructor(application) {
2014        this.application = application;
2015        this.scopeObserver = new ScopeObserver(this.element, this.schema, this);
2016        this.scopesByIdentifier = new Multimap();
2017        this.modulesByIdentifier = new Map();
2018    }
2019    get element() {
2020        return this.application.element;
2021    }
2022    get schema() {
2023        return this.application.schema;
2024    }
2025    get logger() {
2026        return this.application.logger;
2027    }
2028    get controllerAttribute() {
2029        return this.schema.controllerAttribute;
2030    }
2031    get modules() {
2032        return Array.from(this.modulesByIdentifier.values());
2033    }
2034    get contexts() {
2035        return this.modules.reduce((contexts, module) => contexts.concat(module.contexts), []);
2036    }
2037    start() {
2038        this.scopeObserver.start();
2039    }
2040    stop() {
2041        this.scopeObserver.stop();
2042    }
2043    loadDefinition(definition) {
2044        this.unloadIdentifier(definition.identifier);
2045        const module = new Module(this.application, definition);
2046        this.connectModule(module);
2047        const afterLoad = definition.controllerConstructor.afterLoad;
2048        if (afterLoad) {
2049            afterLoad.call(definition.controllerConstructor, definition.identifier, this.application);
2050        }
2051    }
2052    unloadIdentifier(identifier) {
2053        const module = this.modulesByIdentifier.get(identifier);
2054        if (module) {
2055            this.disconnectModule(module);
2056        }
2057    }
2058    getContextForElementAndIdentifier(element, identifier) {
2059        const module = this.modulesByIdentifier.get(identifier);
2060        if (module) {
2061            return module.contexts.find((context) => context.element == element);
2062        }
2063    }
2064    proposeToConnectScopeForElementAndIdentifier(element, identifier) {
2065        const scope = this.scopeObserver.parseValueForElementAndIdentifier(element, identifier);
2066        if (scope) {
2067            this.scopeObserver.elementMatchedValue(scope.element, scope);
2068        }
2069        else {
2070            console.error(`Couldn't find or create scope for identifier: "${identifier}" and element:`, element);
2071        }
2072    }
2073    handleError(error, message, detail) {
2074        this.application.handleError(error, message, detail);
2075    }
2076    createScopeForElementAndIdentifier(element, identifier) {
2077        return new Scope(this.schema, element, identifier, this.logger);
2078    }
2079    scopeConnected(scope) {
2080        this.scopesByIdentifier.add(scope.identifier, scope);
2081        const module = this.modulesByIdentifier.get(scope.identifier);
2082        if (module) {
2083            module.connectContextForScope(scope);
2084        }
2085    }
2086    scopeDisconnected(scope) {
2087        this.scopesByIdentifier.delete(scope.identifier, scope);
2088        const module = this.modulesByIdentifier.get(scope.identifier);
2089        if (module) {
2090            module.disconnectContextForScope(scope);
2091        }
2092    }
2093    connectModule(module) {
2094        this.modulesByIdentifier.set(module.identifier, module);
2095        const scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);
2096        scopes.forEach((scope) => module.connectContextForScope(scope));
2097    }
2098    disconnectModule(module) {
2099        this.modulesByIdentifier.delete(module.identifier);
2100        const scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);
2101        scopes.forEach((scope) => module.disconnectContextForScope(scope));
2102    }
2103}
2104
2105const defaultSchema = {
2106    controllerAttribute: "data-controller",
2107    actionAttribute: "data-action",
2108    targetAttribute: "data-target",
2109    targetAttributeForScope: (identifier) => `data-${identifier}-target`,
2110    outletAttributeForScope: (identifier, outlet) => `data-${identifier}-${outlet}-outlet`,
2111    keyMappings: Object.assign(Object.assign({ enter: "Enter", tab: "Tab", esc: "Escape", space: " ", up: "ArrowUp", down: "ArrowDown", left: "ArrowLeft", right: "ArrowRight", home: "Home", end: "End", page_up: "PageUp", page_down: "PageDown" }, objectFromEntries("abcdefghijklmnopqrstuvwxyz".split("").map((c) => [c, c]))), objectFromEntries("0123456789".split("").map((n) => [n, n]))),
2112};
2113function objectFromEntries(array) {
2114    return array.reduce((memo, [k, v]) => (Object.assign(Object.assign({}, memo), { [k]: v })), {});
2115}
2116
2117class Application {
2118    constructor(element = document.documentElement, schema = defaultSchema) {
2119        this.logger = console;
2120        this.debug = false;
2121        this.logDebugActivity = (identifier, functionName, detail = {}) => {
2122            if (this.debug) {
2123                this.logFormattedMessage(identifier, functionName, detail);
2124            }
2125        };
2126        this.element = element;
2127        this.schema = schema;
2128        this.dispatcher = new Dispatcher(this);
2129        this.router = new Router(this);
2130        this.actionDescriptorFilters = Object.assign({}, defaultActionDescriptorFilters);
2131    }
2132    static start(element, schema) {
2133        const application = new this(element, schema);
2134        application.start();
2135        return application;
2136    }
2137    async start() {
2138        await domReady();
2139        this.logDebugActivity("application", "starting");
2140        this.dispatcher.start();
2141        this.router.start();
2142        this.logDebugActivity("application", "start");
2143    }
2144    stop() {
2145        this.logDebugActivity("application", "stopping");
2146        this.dispatcher.stop();
2147        this.router.stop();
2148        this.logDebugActivity("application", "stop");
2149    }
2150    register(identifier, controllerConstructor) {
2151        this.load({ identifier, controllerConstructor });
2152    }
2153    registerActionOption(name, filter) {
2154        this.actionDescriptorFilters[name] = filter;
2155    }
2156    load(head, ...rest) {
2157        const definitions = Array.isArray(head) ? head : [head, ...rest];
2158        definitions.forEach((definition) => {
2159            if (definition.controllerConstructor.shouldLoad) {
2160                this.router.loadDefinition(definition);
2161            }
2162        });
2163    }
2164    unload(head, ...rest) {
2165        const identifiers = Array.isArray(head) ? head : [head, ...rest];
2166        identifiers.forEach((identifier) => this.router.unloadIdentifier(identifier));
2167    }
2168    get controllers() {
2169        return this.router.contexts.map((context) => context.controller);
2170    }
2171    getControllerForElementAndIdentifier(element, identifier) {
2172        const context = this.router.getContextForElementAndIdentifier(element, identifier);
2173        return context ? context.controller : null;
2174    }
2175    handleError(error, message, detail) {
2176        var _a;
2177        this.logger.error(`%s\n\n%o\n\n%o`, message, error, detail);
2178        (_a = window.onerror) === null || _a === void 0 ? void 0 : _a.call(window, message, "", 0, 0, error);
2179    }
2180    logFormattedMessage(identifier, functionName, detail = {}) {
2181        detail = Object.assign({ application: this }, detail);
2182        this.logger.groupCollapsed(`${identifier} #${functionName}`);
2183        this.logger.log("details:", Object.assign({}, detail));
2184        this.logger.groupEnd();
2185    }
2186}
2187function domReady() {
2188    return new Promise((resolve) => {
2189        if (document.readyState == "loading") {
2190            document.addEventListener("DOMContentLoaded", () => resolve());
2191        }
2192        else {
2193            resolve();
2194        }
2195    });
2196}
2197
2198function ClassPropertiesBlessing(constructor) {
2199    const classes = readInheritableStaticArrayValues(constructor, "classes");
2200    return classes.reduce((properties, classDefinition) => {
2201        return Object.assign(properties, propertiesForClassDefinition(classDefinition));
2202    }, {});
2203}
2204function propertiesForClassDefinition(key) {
2205    return {
2206        [`${key}Class`]: {
2207            get() {
2208                const { classes } = this;
2209                if (classes.has(key)) {
2210                    return classes.get(key);
2211                }
2212                else {
2213                    const attribute = classes.getAttributeName(key);
2214                    throw new Error(`Missing attribute "${attribute}"`);
2215                }
2216            },
2217        },
2218        [`${key}Classes`]: {
2219            get() {
2220                return this.classes.getAll(key);
2221            },
2222        },
2223        [`has${capitalize(key)}Class`]: {
2224            get() {
2225                return this.classes.has(key);
2226            },
2227        },
2228    };
2229}
2230
2231function OutletPropertiesBlessing(constructor) {
2232    const outlets = readInheritableStaticArrayValues(constructor, "outlets");
2233    return outlets.reduce((properties, outletDefinition) => {
2234        return Object.assign(properties, propertiesForOutletDefinition(outletDefinition));
2235    }, {});
2236}
2237function getOutletController(controller, element, identifier) {
2238    return controller.application.getControllerForElementAndIdentifier(element, identifier);
2239}
2240function getControllerAndEnsureConnectedScope(controller, element, outletName) {
2241    let outletController = getOutletController(controller, element, outletName);
2242    if (outletController)
2243        return outletController;
2244    controller.application.router.proposeToConnectScopeForElementAndIdentifier(element, outletName);
2245    outletController = getOutletController(controller, element, outletName);
2246    if (outletController)
2247        return outletController;
2248}
2249function propertiesForOutletDefinition(name) {
2250    const camelizedName = namespaceCamelize(name);
2251    return {
2252        [`${camelizedName}Outlet`]: {
2253            get() {
2254                const outletElement = this.outlets.find(name);
2255                const selector = this.outlets.getSelectorForOutletName(name);
2256                if (outletElement) {
2257                    const outletController = getControllerAndEnsureConnectedScope(this, outletElement, name);
2258                    if (outletController)
2259                        return outletController;
2260                    throw new Error(`The provided outlet element is missing an outlet controller "${name}" instance for host controller "${this.identifier}"`);
2261                }
2262                throw new Error(`Missing outlet element "${name}" for host controller "${this.identifier}". Stimulus couldn't find a matching outlet element using selector "${selector}".`);
2263            },
2264        },
2265        [`${camelizedName}Outlets`]: {
2266            get() {
2267                const outlets = this.outlets.findAll(name);
2268                if (outlets.length > 0) {
2269                    return outlets
2270                        .map((outletElement) => {
2271                        const outletController = getControllerAndEnsureConnectedScope(this, outletElement, name);
2272                        if (outletController)
2273                            return outletController;
2274                        console.warn(`The provided outlet element is missing an outlet controller "${name}" instance for host controller "${this.identifier}"`, outletElement);
2275                    })
2276                        .filter((controller) => controller);
2277                }
2278                return [];
2279            },
2280        },
2281        [`${camelizedName}OutletElement`]: {
2282            get() {
2283                const outletElement = this.outlets.find(name);
2284                const selector = this.outlets.getSelectorForOutletName(name);
2285                if (outletElement) {
2286                    return outletElement;
2287                }
2288                else {
2289                    throw new Error(`Missing outlet element "${name}" for host controller "${this.identifier}". Stimulus couldn't find a matching outlet element using selector "${selector}".`);
2290                }
2291            },
2292        },
2293        [`${camelizedName}OutletElements`]: {
2294            get() {
2295                return this.outlets.findAll(name);
2296            },
2297        },
2298        [`has${capitalize(camelizedName)}Outlet`]: {
2299            get() {
2300                return this.outlets.has(name);
2301            },
2302        },
2303    };
2304}
2305
2306function TargetPropertiesBlessing(constructor) {
2307    const targets = readInheritableStaticArrayValues(constructor, "targets");
2308    return targets.reduce((properties, targetDefinition) => {
2309        return Object.assign(properties, propertiesForTargetDefinition(targetDefinition));
2310    }, {});
2311}
2312function propertiesForTargetDefinition(name) {
2313    return {
2314        [`${name}Target`]: {
2315            get() {
2316                const target = this.targets.find(name);
2317                if (target) {
2318                    return target;
2319                }
2320                else {
2321                    throw new Error(`Missing target element "${name}" for "${this.identifier}" controller`);
2322                }
2323            },
2324        },
2325        [`${name}Targets`]: {
2326            get() {
2327                return this.targets.findAll(name);
2328            },
2329        },
2330        [`has${capitalize(name)}Target`]: {
2331            get() {
2332                return this.targets.has(name);
2333            },
2334        },
2335    };
2336}
2337
2338function ValuePropertiesBlessing(constructor) {
2339    const valueDefinitionPairs = readInheritableStaticObjectPairs(constructor, "values");
2340    const propertyDescriptorMap = {
2341        valueDescriptorMap: {
2342            get() {
2343                return valueDefinitionPairs.reduce((result, valueDefinitionPair) => {
2344                    const valueDescriptor = parseValueDefinitionPair(valueDefinitionPair, this.identifier);
2345                    const attributeName = this.data.getAttributeNameForKey(valueDescriptor.key);
2346                    return Object.assign(result, { [attributeName]: valueDescriptor });
2347                }, {});
2348            },
2349        },
2350    };
2351    return valueDefinitionPairs.reduce((properties, valueDefinitionPair) => {
2352        return Object.assign(properties, propertiesForValueDefinitionPair(valueDefinitionPair));
2353    }, propertyDescriptorMap);
2354}
2355function propertiesForValueDefinitionPair(valueDefinitionPair, controller) {
2356    const definition = parseValueDefinitionPair(valueDefinitionPair, controller);
2357    const { key, name, reader: read, writer: write } = definition;
2358    return {
2359        [name]: {
2360            get() {
2361                const value = this.data.get(key);
2362                if (value !== null) {
2363                    return read(value);
2364                }
2365                else {
2366                    return definition.defaultValue;
2367                }
2368            },
2369            set(value) {
2370                if (value === undefined) {
2371                    this.data.delete(key);
2372                }
2373                else {
2374                    this.data.set(key, write(value));
2375                }
2376            },
2377        },
2378        [`has${capitalize(name)}`]: {
2379            get() {
2380                return this.data.has(key) || definition.hasCustomDefaultValue;
2381            },
2382        },
2383    };
2384}
2385function parseValueDefinitionPair([token, typeDefinition], controller) {
2386    return valueDescriptorForTokenAndTypeDefinition({
2387        controller,
2388        token,
2389        typeDefinition,
2390    });
2391}
2392function parseValueTypeConstant(constant) {
2393    switch (constant) {
2394        case Array:
2395            return "array";
2396        case Boolean:
2397            return "boolean";
2398        case Number:
2399            return "number";
2400        case Object:
2401            return "object";
2402        case String:
2403            return "string";
2404    }
2405}
2406function parseValueTypeDefault(defaultValue) {
2407    switch (typeof defaultValue) {
2408        case "boolean":
2409            return "boolean";
2410        case "number":
2411            return "number";
2412        case "string":
2413            return "string";
2414    }
2415    if (Array.isArray(defaultValue))
2416        return "array";
2417    if (Object.prototype.toString.call(defaultValue) === "[object Object]")
2418        return "object";
2419}
2420function parseValueTypeObject(payload) {
2421    const { controller, token, typeObject } = payload;
2422    const hasType = isSomething(typeObject.type);
2423    const hasDefault = isSomething(typeObject.default);
2424    const fullObject = hasType && hasDefault;
2425    const onlyType = hasType && !hasDefault;
2426    const onlyDefault = !hasType && hasDefault;
2427    const typeFromObject = parseValueTypeConstant(typeObject.type);
2428    const typeFromDefaultValue = parseValueTypeDefault(payload.typeObject.default);
2429    if (onlyType)
2430        return typeFromObject;
2431    if (onlyDefault)
2432        return typeFromDefaultValue;
2433    if (typeFromObject !== typeFromDefaultValue) {
2434        const propertyPath = controller ? `${controller}.${token}` : token;
2435        throw new Error(`The specified default value for the Stimulus Value "${propertyPath}" must match the defined type "${typeFromObject}". The provided default value of "${typeObject.default}" is of type "${typeFromDefaultValue}".`);
2436    }
2437    if (fullObject)
2438        return typeFromObject;
2439}
2440function parseValueTypeDefinition(payload) {
2441    const { controller, token, typeDefinition } = payload;
2442    const typeObject = { controller, token, typeObject: typeDefinition };
2443    const typeFromObject = parseValueTypeObject(typeObject);
2444    const typeFromDefaultValue = parseValueTypeDefault(typeDefinition);
2445    const typeFromConstant = parseValueTypeConstant(typeDefinition);
2446    const type = typeFromObject || typeFromDefaultValue || typeFromConstant;
2447    if (type)
2448        return type;
2449    const propertyPath = controller ? `${controller}.${typeDefinition}` : token;
2450    throw new Error(`Unknown value type "${propertyPath}" for "${token}" value`);
2451}
2452function defaultValueForDefinition(typeDefinition) {
2453    const constant = parseValueTypeConstant(typeDefinition);
2454    if (constant)
2455        return defaultValuesByType[constant];
2456    const hasDefault = hasProperty(typeDefinition, "default");
2457    const hasType = hasProperty(typeDefinition, "type");
2458    const typeObject = typeDefinition;
2459    if (hasDefault)
2460        return typeObject.default;
2461    if (hasType) {
2462        const { type } = typeObject;
2463        const constantFromType = parseValueTypeConstant(type);
2464        if (constantFromType)
2465            return defaultValuesByType[constantFromType];
2466    }
2467    return typeDefinition;
2468}
2469function valueDescriptorForTokenAndTypeDefinition(payload) {
2470    const { token, typeDefinition } = payload;
2471    const key = `${dasherize(token)}-value`;
2472    const type = parseValueTypeDefinition(payload);
2473    return {
2474        type,
2475        key,
2476        name: camelize(key),
2477        get defaultValue() {
2478            return defaultValueForDefinition(typeDefinition);
2479        },
2480        get hasCustomDefaultValue() {
2481            return parseValueTypeDefault(typeDefinition) !== undefined;
2482        },
2483        reader: readers[type],
2484        writer: writers[type] || writers.default,
2485    };
2486}
2487const defaultValuesByType = {
2488    get array() {
2489        return [];
2490    },
2491    boolean: false,
2492    number: 0,
2493    get object() {
2494        return {};
2495    },
2496    string: "",
2497};
2498const readers = {
2499    array(value) {
2500        const array = JSON.parse(value);
2501        if (!Array.isArray(array)) {
2502            throw new TypeError(`expected value of type "array" but instead got value "${value}" of type "${parseValueTypeDefault(array)}"`);
2503        }
2504        return array;
2505    },
2506    boolean(value) {
2507        return !(value == "0" || String(value).toLowerCase() == "false");
2508    },
2509    number(value) {
2510        return Number(value.replace(/_/g, ""));
2511    },
2512    object(value) {
2513        const object = JSON.parse(value);
2514        if (object === null || typeof object != "object" || Array.isArray(object)) {
2515            throw new TypeError(`expected value of type "object" but instead got value "${value}" of type "${parseValueTypeDefault(object)}"`);
2516        }
2517        return object;
2518    },
2519    string(value) {
2520        return value;
2521    },
2522};
2523const writers = {
2524    default: writeString,
2525    array: writeJSON,
2526    object: writeJSON,
2527};
2528function writeJSON(value) {
2529    return JSON.stringify(value);
2530}
2531function writeString(value) {
2532    return `${value}`;
2533}
2534
2535class Controller {
2536    constructor(context) {
2537        this.context = context;
2538    }
2539    static get shouldLoad() {
2540        return true;
2541    }
2542    static afterLoad(_identifier, _application) {
2543        return;
2544    }
2545    get application() {
2546        return this.context.application;
2547    }
2548    get scope() {
2549        return this.context.scope;
2550    }
2551    get element() {
2552        return this.scope.element;
2553    }
2554    get identifier() {
2555        return this.scope.identifier;
2556    }
2557    get targets() {
2558        return this.scope.targets;
2559    }
2560    get outlets() {
2561        return this.scope.outlets;
2562    }
2563    get classes() {
2564        return this.scope.classes;
2565    }
2566    get data() {
2567        return this.scope.data;
2568    }
2569    initialize() {
2570    }
2571    connect() {
2572    }
2573    disconnect() {
2574    }
2575    dispatch(eventName, { target = this.element, detail = {}, prefix = this.identifier, bubbles = true, cancelable = true, } = {}) {
2576        const type = prefix ? `${prefix}:${eventName}` : eventName;
2577        const event = new CustomEvent(type, { detail, bubbles, cancelable });
2578        target.dispatchEvent(event);
2579        return event;
2580    }
2581}
2582Controller.blessings = [
2583    ClassPropertiesBlessing,
2584    TargetPropertiesBlessing,
2585    ValuePropertiesBlessing,
2586    OutletPropertiesBlessing,
2587];
2588Controller.targets = [];
2589Controller.outlets = [];
2590Controller.values = {};
2591
2592
2593
2594
2595/***/ }),
2596

2597/***/ "./node_modules/@popperjs/core/lib/createPopper.js":
2598/*!*********************************************************!*\
2599  !*** ./node_modules/@popperjs/core/lib/createPopper.js ***!
2600  \*********************************************************/
2601/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
2602
2603"use strict";
2604__webpack_require__.r(__webpack_exports__);
2605/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2606/* harmony export */   createPopper: function() { return /* binding */ createPopper; },
2607/* harmony export */   detectOverflow: function() { return /* reexport safe */ _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_8__["default"]; },
2608/* harmony export */   popperGenerator: function() { return /* binding */ popperGenerator; }
2609/* harmony export */ });
2610/* harmony import */ var _dom_utils_getCompositeRect_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./dom-utils/getCompositeRect.js */ "./node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js");
2611/* harmony import */ var _dom_utils_getLayoutRect_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./dom-utils/getLayoutRect.js */ "./node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js");
2612/* harmony import */ var _dom_utils_listScrollParents_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./dom-utils/listScrollParents.js */ "./node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js");
2613/* harmony import */ var _dom_utils_getOffsetParent_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./dom-utils/getOffsetParent.js */ "./node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js");
2614/* harmony import */ var _utils_orderModifiers_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils/orderModifiers.js */ "./node_modules/@popperjs/core/lib/utils/orderModifiers.js");
2615/* harmony import */ var _utils_debounce_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./utils/debounce.js */ "./node_modules/@popperjs/core/lib/utils/debounce.js");
2616/* harmony import */ var _utils_mergeByName_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./utils/mergeByName.js */ "./node_modules/@popperjs/core/lib/utils/mergeByName.js");
2617/* harmony import */ var _utils_detectOverflow_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./utils/detectOverflow.js */ "./node_modules/@popperjs/core/lib/utils/detectOverflow.js");
2618/* harmony import */ var _dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./dom-utils/instanceOf.js */ "./node_modules/@popperjs/core/lib/dom-utils/instanceOf.js");
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628var DEFAULT_OPTIONS = {
2629  placement: 'bottom',
2630  modifiers: [],
2631  strategy: 'absolute'
2632};
2633
2634function areValidElements() {
2635  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
2636    args[_key] = arguments[_key];
2637  }
2638
2639  return !args.some(function (element) {
2640    return !(element && typeof element.getBoundingClientRect === 'function');
2641  });
2642}
2643
2644function popperGenerator(generatorOptions) {
2645  if (generatorOptions === void 0) {
2646    generatorOptions = {};
2647  }
2648
2649  var _generatorOptions = generatorOptions,
2650      _generatorOptions$def = _generatorOptions.defaultModifiers,
2651      defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,
2652      _generatorOptions$def2 = _generatorOptions.defaultOptions,
2653      defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
2654  return function createPopper(reference, popper, options) {
2655    if (options === void 0) {
2656      options = defaultOptions;
2657    }
2658
2659    var state = {
2660      placement: 'bottom',
2661      orderedModifiers: [],
2662      options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
2663      modifiersData: {},
2664      elements: {
2665        reference: reference,
2666        popper: popper
2667      },
2668      attributes: {},
2669      styles: {}
2670    };
2671    var effectCleanupFns = [];
2672    var isDestroyed = false;
2673    var instance = {
2674      state: state,
2675      setOptions: function setOptions(setOptionsAction) {
2676        var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction;
2677        cleanupModifierEffects();
2678        state.options = Object.assign({}, defaultOptions, state.options, options);
2679        state.scrollParents = {
2680          reference: (0,_dom_utils_instanceOf_js__WEBPACK_IMPORTED_MODULE_0__.isElement)(reference) ? (0,_dom_utils_listScrollParents_js__WEBPACK_IMPORTED_MODULE_1__["default"])(reference) : reference.contextElement ? (0,_dom_utils_listScrollParents_js__WEBPACK_IMPORTED_MODULE_1__["default"])(reference.contextElement) : [],
2681          popper: (0,_dom_utils_listScrollParents_js__WEBPACK_IMPORTED_MODULE_1__["default"])(popper)
2682        }; // Orders the modifiers based on their dependencies and `phase`
2683        // properties
2684
2685        var orderedModifiers = (0,_utils_orderModifiers_js__WEBPACK_IMPORTED_MODULE_2__["default"])((0,_utils_mergeByName_js__WEBPACK_IMPORTED_MODULE_3__["default"])([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers
2686
2687        state.orderedModifiers = orderedModifiers.filter(function (m) {
2688          return m.enabled;
2689        });
2690        runModifierEffects();
2691        return instance.update();
2692      },
2693      // Sync update – it will always be executed, even if not necessary. This
2694      // is useful for low frequency updates where sync behavior simplifies the
2695      // logic.
2696      // For high frequency updates (e.g. `resize` and `scroll` events), always
2697      // prefer the async Popper#update method
2698      forceUpdate: function forceUpdate() {
2699        if (isDestroyed) {
2700          return;
2701        }
2702
2703        var _state$elements = state.elements,
2704            reference = _state$elements.reference,
2705            popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements
2706        // anymore
2707
2708        if (!areValidElements(reference, popper)) {
2709          return;
2710        } // Store the reference and popper rects to be read by modifiers
2711
2712
2713        state.rects = {
2714          reference: (0,_dom_utils_getCompositeRect_js__WEBPACK_IMPORTED_MODULE_4__["default"])(reference, (0,_dom_utils_getOffsetParent_js__WEBPACK_IMPORTED_MODULE_5__["default"])(popper), state.options.strategy === 'fixed'),
2715          popper: (0,_dom_utils_getLayoutRect_js__WEBPACK_IMPORTED_MODULE_6__["default"])(popper)
2716        }; // Modifiers have the ability to reset the current update cycle. The
2717        // most common use case for this is the `flip` modifier changing the
2718        // placement, which then needs to re-run all the modifiers, because the
2719        // logic was previously ran for the previous placement and is therefore
2720        // stale/incorrect
2721
2722        state.reset = false;
2723        state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier
2724        // is filled with the initial data specified by the modifier. This means
2725        // it doesn't persist and is fresh on each update.
2726        // To ensure persistent data, use `${name}#persistent`
2727
2728        state.orderedModifiers.forEach(function (modifier) {
2729          return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
2730        });
2731
2732        for (var index = 0; index < state.orderedModifiers.length; index++) {
2733          if (state.reset === true) {
2734            state.reset = false;
2735            index = -1;
2736            continue;
2737          }
2738
2739          var _state$orderedModifie = state.orderedModifiers[index],
2740              fn = _state$orderedModifie.fn,
2741              _state$orderedModifie2 = _state$orderedModifie.options,
2742              _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,
2743              name = _state$orderedModifie.name;
2744
2745          if (typeof fn === 'function') {
2746            state = fn({
2747              state: state,
2748              options: _options,
2749              name: name,
2750              instance: instance
2751            }) || state;
2752          }
2753        }
2754      },
2755      // Async and optimistically optimized update – it will not be executed if
2756      // not necessary (debounced to run at most once-per-tick)
2757      update: (0,_utils_debounce_js__WEBPACK_IMPORTED_MODULE_7__["default"])(function () {
2758        return new Promise(function (resolve) {
2759          instance.forceUpdate();
2760          resolve(state);
2761        });
2762      }),
2763      destroy: function destroy() {
2764        cleanupModifierEffects();
2765        isDestroyed = true;
2766      }
2767    };
2768
2769    if (!areValidElements(reference, popper)) {
2770      return instance;
2771    }
2772
2773    instance.setOptions(options).then(function (state) {
2774      if (!isDestroyed && options.onFirstUpdate) {
2775        options.onFirstUpdate(state);
2776      }
2777    }); // Modifiers have the ability to execute arbitrary code before the first
2778    // update cycle runs. They will be executed in the same order as the update
2779    // cycle. This is useful when a modifier adds some persistent data that
2780    // other modifiers need to use, but the modifier is run after the dependent
2781    // one.
2782
2783    function runModifierEffects() {
2784      state.orderedModifiers.forEach(function (_ref) {
2785        var name = _ref.name,
2786            _ref$options = _ref.options,
2787            options = _ref$options === void 0 ? {} : _ref$options,
2788            effect = _ref.effect;
2789
2790        if (typeof effect === 'function') {
2791          var cleanupFn = effect({
2792            state: state,
2793            name: name,
2794            instance: instance,
2795            options: options
2796          });
2797
2798          var noopFn = function noopFn() {};
2799
2800          effectCleanupFns.push(cleanupFn || noopFn);
2801        }
2802      });
2803    }
2804
2805    function cleanupModifierEffects() {
2806      effectCleanupFns.forEach(function (fn) {
2807        return fn();
2808      });
2809      effectCleanupFns = [];
2810    }
2811
2812    return instance;
2813  };
2814}
2815var createPopper = /*#__PURE__*/popperGenerator(); // eslint-disable-next-line import/no-unused-modules
2816
2817
2818
2819/***/ }),
2820