https://www.rankia.co/assets/notificaciones-89b82178.js

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