material_view_components 0.1.1

data/app/assets/builds/material_view_components/application.js

@@ -0,0 +1,1958 @@
+(() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
+  };
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // node_modules/@hotwired/stimulus/dist/stimulus.js
+  function extendEvent(event) {
+    if ("immediatePropagationStopped" in event) {
+      return event;
+    } else {
+      const { stopImmediatePropagation } = event;
+      return Object.assign(event, {
+        immediatePropagationStopped: false,
+        stopImmediatePropagation() {
+          this.immediatePropagationStopped = true;
+          stopImmediatePropagation.call(this);
+        }
+      });
+    }
+  }
+  function parseActionDescriptorString(descriptorString) {
+    const source = descriptorString.trim();
+    const matches = source.match(descriptorPattern) || [];
+    return {
+      eventTarget: parseEventTarget(matches[4]),
+      eventName: matches[2],
+      eventOptions: matches[9] ? parseEventOptions(matches[9]) : {},
+      identifier: matches[5],
+      methodName: matches[7]
+    };
+  }
+  function parseEventTarget(eventTargetName) {
+    if (eventTargetName == "window") {
+      return window;
+    } else if (eventTargetName == "document") {
+      return document;
+    }
+  }
+  function parseEventOptions(eventOptions) {
+    return eventOptions.split(":").reduce((options, token) => Object.assign(options, { [token.replace(/^!/, "")]: !/^!/.test(token) }), {});
+  }
+  function stringifyEventTarget(eventTarget) {
+    if (eventTarget == window) {
+      return "window";
+    } else if (eventTarget == document) {
+      return "document";
+    }
+  }
+  function camelize(value) {
+    return value.replace(/(?:[_-])([a-z0-9])/g, (_, char) => char.toUpperCase());
+  }
+  function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+  }
+  function dasherize(value) {
+    return value.replace(/([A-Z])/g, (_, char) => `-${char.toLowerCase()}`);
+  }
+  function tokenize(value) {
+    return value.match(/[^\s]+/g) || [];
+  }
+  function getDefaultEventNameForElement(element) {
+    const tagName = element.tagName.toLowerCase();
+    if (tagName in defaultEventNames) {
+      return defaultEventNames[tagName](element);
+    }
+  }
+  function error(message) {
+    throw new Error(message);
+  }
+  function typecast(value) {
+    try {
+      return JSON.parse(value);
+    } catch (o_O) {
+      return value;
+    }
+  }
+  function add(map, key, value) {
+    fetch(map, key).add(value);
+  }
+  function del(map, key, value) {
+    fetch(map, key).delete(value);
+    prune(map, key);
+  }
+  function fetch(map, key) {
+    let values = map.get(key);
+    if (!values) {
+      values = new Set();
+      map.set(key, values);
+    }
+    return values;
+  }
+  function prune(map, key) {
+    const values = map.get(key);
+    if (values != null && values.size == 0) {
+      map.delete(key);
+    }
+  }
+  function parseTokenString(tokenString, element, attributeName) {
+    return tokenString.trim().split(/\s+/).filter((content) => content.length).map((content, index) => ({ element, attributeName, content, index }));
+  }
+  function zip(left, right) {
+    const length = Math.max(left.length, right.length);
+    return Array.from({ length }, (_, index) => [left[index], right[index]]);
+  }
+  function tokensAreEqual(left, right) {
+    return left && right && left.index == right.index && left.content == right.content;
+  }
+  function readInheritableStaticArrayValues(constructor, propertyName) {
+    const ancestors = getAncestorsForConstructor(constructor);
+    return Array.from(ancestors.reduce((values, constructor2) => {
+      getOwnStaticArrayValues(constructor2, propertyName).forEach((name) => values.add(name));
+      return values;
+    }, new Set()));
+  }
+  function readInheritableStaticObjectPairs(constructor, propertyName) {
+    const ancestors = getAncestorsForConstructor(constructor);
+    return ancestors.reduce((pairs, constructor2) => {
+      pairs.push(...getOwnStaticObjectPairs(constructor2, propertyName));
+      return pairs;
+    }, []);
+  }
+  function getAncestorsForConstructor(constructor) {
+    const ancestors = [];
+    while (constructor) {
+      ancestors.push(constructor);
+      constructor = Object.getPrototypeOf(constructor);
+    }
+    return ancestors.reverse();
+  }
+  function getOwnStaticArrayValues(constructor, propertyName) {
+    const definition = constructor[propertyName];
+    return Array.isArray(definition) ? definition : [];
+  }
+  function getOwnStaticObjectPairs(constructor, propertyName) {
+    const definition = constructor[propertyName];
+    return definition ? Object.keys(definition).map((key) => [key, definition[key]]) : [];
+  }
+  function bless(constructor) {
+    return shadow(constructor, getBlessedProperties(constructor));
+  }
+  function shadow(constructor, properties) {
+    const shadowConstructor = extend(constructor);
+    const shadowProperties = getShadowProperties(constructor.prototype, properties);
+    Object.defineProperties(shadowConstructor.prototype, shadowProperties);
+    return shadowConstructor;
+  }
+  function getBlessedProperties(constructor) {
+    const blessings = readInheritableStaticArrayValues(constructor, "blessings");
+    return blessings.reduce((blessedProperties, blessing) => {
+      const properties = blessing(constructor);
+      for (const key in properties) {
+        const descriptor = blessedProperties[key] || {};
+        blessedProperties[key] = Object.assign(descriptor, properties[key]);
+      }
+      return blessedProperties;
+    }, {});
+  }
+  function getShadowProperties(prototype, properties) {
+    return getOwnKeys(properties).reduce((shadowProperties, key) => {
+      const descriptor = getShadowedDescriptor(prototype, properties, key);
+      if (descriptor) {
+        Object.assign(shadowProperties, { [key]: descriptor });
+      }
+      return shadowProperties;
+    }, {});
+  }
+  function getShadowedDescriptor(prototype, properties, key) {
+    const shadowingDescriptor = Object.getOwnPropertyDescriptor(prototype, key);
+    const shadowedByValue = shadowingDescriptor && "value" in shadowingDescriptor;
+    if (!shadowedByValue) {
+      const descriptor = Object.getOwnPropertyDescriptor(properties, key).value;
+      if (shadowingDescriptor) {
+        descriptor.get = shadowingDescriptor.get || descriptor.get;
+        descriptor.set = shadowingDescriptor.set || descriptor.set;
+      }
+      return descriptor;
+    }
+  }
+  function blessDefinition(definition) {
+    return {
+      identifier: definition.identifier,
+      controllerConstructor: bless(definition.controllerConstructor)
+    };
+  }
+  function attributeValueContainsToken(attributeName, token) {
+    return `[${attributeName}~="${token}"]`;
+  }
+  function domReady() {
+    return new Promise((resolve) => {
+      if (document.readyState == "loading") {
+        document.addEventListener("DOMContentLoaded", () => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+  function ClassPropertiesBlessing(constructor) {
+    const classes = readInheritableStaticArrayValues(constructor, "classes");
+    return classes.reduce((properties, classDefinition) => {
+      return Object.assign(properties, propertiesForClassDefinition(classDefinition));
+    }, {});
+  }
+  function propertiesForClassDefinition(key) {
+    return {
+      [`${key}Class`]: {
+        get() {
+          const { classes } = this;
+          if (classes.has(key)) {
+            return classes.get(key);
+          } else {
+            const attribute = classes.getAttributeName(key);
+            throw new Error(`Missing attribute "${attribute}"`);
+          }
+        }
+      },
+      [`${key}Classes`]: {
+        get() {
+          return this.classes.getAll(key);
+        }
+      },
+      [`has${capitalize(key)}Class`]: {
+        get() {
+          return this.classes.has(key);
+        }
+      }
+    };
+  }
+  function TargetPropertiesBlessing(constructor) {
+    const targets = readInheritableStaticArrayValues(constructor, "targets");
+    return targets.reduce((properties, targetDefinition) => {
+      return Object.assign(properties, propertiesForTargetDefinition(targetDefinition));
+    }, {});
+  }
+  function propertiesForTargetDefinition(name) {
+    return {
+      [`${name}Target`]: {
+        get() {
+          const target = this.targets.find(name);
+          if (target) {
+            return target;
+          } else {
+            throw new Error(`Missing target element "${name}" for "${this.identifier}" controller`);
+          }
+        }
+      },
+      [`${name}Targets`]: {
+        get() {
+          return this.targets.findAll(name);
+        }
+      },
+      [`has${capitalize(name)}Target`]: {
+        get() {
+          return this.targets.has(name);
+        }
+      }
+    };
+  }
+  function ValuePropertiesBlessing(constructor) {
+    const valueDefinitionPairs = readInheritableStaticObjectPairs(constructor, "values");
+    const propertyDescriptorMap = {
+      valueDescriptorMap: {
+        get() {
+          return valueDefinitionPairs.reduce((result, valueDefinitionPair) => {
+            const valueDescriptor = parseValueDefinitionPair(valueDefinitionPair);
+            const attributeName = this.data.getAttributeNameForKey(valueDescriptor.key);
+            return Object.assign(result, { [attributeName]: valueDescriptor });
+          }, {});
+        }
+      }
+    };
+    return valueDefinitionPairs.reduce((properties, valueDefinitionPair) => {
+      return Object.assign(properties, propertiesForValueDefinitionPair(valueDefinitionPair));
+    }, propertyDescriptorMap);
+  }
+  function propertiesForValueDefinitionPair(valueDefinitionPair) {
+    const definition = parseValueDefinitionPair(valueDefinitionPair);
+    const { key, name, reader: read, writer: write } = definition;
+    return {
+      [name]: {
+        get() {
+          const value = this.data.get(key);
+          if (value !== null) {
+            return read(value);
+          } else {
+            return definition.defaultValue;
+          }
+        },
+        set(value) {
+          if (value === void 0) {
+            this.data.delete(key);
+          } else {
+            this.data.set(key, write(value));
+          }
+        }
+      },
+      [`has${capitalize(name)}`]: {
+        get() {
+          return this.data.has(key) || definition.hasCustomDefaultValue;
+        }
+      }
+    };
+  }
+  function parseValueDefinitionPair([token, typeDefinition]) {
+    return valueDescriptorForTokenAndTypeDefinition(token, typeDefinition);
+  }
+  function parseValueTypeConstant(constant) {
+    switch (constant) {
+      case Array:
+        return "array";
+      case Boolean:
+        return "boolean";
+      case Number:
+        return "number";
+      case Object:
+        return "object";
+      case String:
+        return "string";
+    }
+  }
+  function parseValueTypeDefault(defaultValue) {
+    switch (typeof defaultValue) {
+      case "boolean":
+        return "boolean";
+      case "number":
+        return "number";
+      case "string":
+        return "string";
+    }
+    if (Array.isArray(defaultValue))
+      return "array";
+    if (Object.prototype.toString.call(defaultValue) === "[object Object]")
+      return "object";
+  }
+  function parseValueTypeObject(typeObject) {
+    const typeFromObject = parseValueTypeConstant(typeObject.type);
+    if (typeFromObject) {
+      const defaultValueType = parseValueTypeDefault(typeObject.default);
+      if (typeFromObject !== defaultValueType) {
+        throw new Error(`Type "${typeFromObject}" must match the type of the default value. Given default value: "${typeObject.default}" as "${defaultValueType}"`);
+      }
+      return typeFromObject;
+    }
+  }
+  function parseValueTypeDefinition(typeDefinition) {
+    const typeFromObject = parseValueTypeObject(typeDefinition);
+    const typeFromDefaultValue = parseValueTypeDefault(typeDefinition);
+    const typeFromConstant = parseValueTypeConstant(typeDefinition);
+    const type = typeFromObject || typeFromDefaultValue || typeFromConstant;
+    if (type)
+      return type;
+    throw new Error(`Unknown value type "${typeDefinition}"`);
+  }
+  function defaultValueForDefinition(typeDefinition) {
+    const constant = parseValueTypeConstant(typeDefinition);
+    if (constant)
+      return defaultValuesByType[constant];
+    const defaultValue = typeDefinition.default;
+    if (defaultValue !== void 0)
+      return defaultValue;
+    return typeDefinition;
+  }
+  function valueDescriptorForTokenAndTypeDefinition(token, typeDefinition) {
+    const key = `${dasherize(token)}-value`;
+    const type = parseValueTypeDefinition(typeDefinition);
+    return {
+      type,
+      key,
+      name: camelize(key),
+      get defaultValue() {
+        return defaultValueForDefinition(typeDefinition);
+      },
+      get hasCustomDefaultValue() {
+        return parseValueTypeDefault(typeDefinition) !== void 0;
+      },
+      reader: readers[type],
+      writer: writers[type] || writers.default
+    };
+  }
+  function writeJSON(value) {
+    return JSON.stringify(value);
+  }
+  function writeString(value) {
+    return `${value}`;
+  }
+  var EventListener, Dispatcher, descriptorPattern, Action, defaultEventNames, Binding, ElementObserver, AttributeObserver, StringMapObserver, Multimap, TokenListObserver, ValueListObserver, BindingObserver, ValueObserver, TargetObserver, Context, getOwnKeys, extend, Module, ClassMap, DataMap, Guide, TargetSet, Scope, ScopeObserver, Router, defaultSchema, Application, defaultValuesByType, readers, writers, Controller;
+  var init_stimulus = __esm({
+    "node_modules/@hotwired/stimulus/dist/stimulus.js"() {
+      EventListener = class {
+        constructor(eventTarget, eventName, eventOptions) {
+          this.eventTarget = eventTarget;
+          this.eventName = eventName;
+          this.eventOptions = eventOptions;
+          this.unorderedBindings = new Set();
+        }
+        connect() {
+          this.eventTarget.addEventListener(this.eventName, this, this.eventOptions);
+        }
+        disconnect() {
+          this.eventTarget.removeEventListener(this.eventName, this, this.eventOptions);
+        }
+        bindingConnected(binding) {
+          this.unorderedBindings.add(binding);
+        }
+        bindingDisconnected(binding) {
+          this.unorderedBindings.delete(binding);
+        }
+        handleEvent(event) {
+          const extendedEvent = extendEvent(event);
+          for (const binding of this.bindings) {
+            if (extendedEvent.immediatePropagationStopped) {
+              break;
+            } else {
+              binding.handleEvent(extendedEvent);
+            }
+          }
+        }
+        get bindings() {
+          return Array.from(this.unorderedBindings).sort((left, right) => {
+            const leftIndex = left.index, rightIndex = right.index;
+            return leftIndex < rightIndex ? -1 : leftIndex > rightIndex ? 1 : 0;
+          });
+        }
+      };
+      Dispatcher = class {
+        constructor(application2) {
+          this.application = application2;
+          this.eventListenerMaps = new Map();
+          this.started = false;
+        }
+        start() {
+          if (!this.started) {
+            this.started = true;
+            this.eventListeners.forEach((eventListener) => eventListener.connect());
+          }
+        }
+        stop() {
+          if (this.started) {
+            this.started = false;
+            this.eventListeners.forEach((eventListener) => eventListener.disconnect());
+          }
+        }
+        get eventListeners() {
+          return Array.from(this.eventListenerMaps.values()).reduce((listeners, map) => listeners.concat(Array.from(map.values())), []);
+        }
+        bindingConnected(binding) {
+          this.fetchEventListenerForBinding(binding).bindingConnected(binding);
+        }
+        bindingDisconnected(binding) {
+          this.fetchEventListenerForBinding(binding).bindingDisconnected(binding);
+        }
+        handleError(error2, message, detail = {}) {
+          this.application.handleError(error2, `Error ${message}`, detail);
+        }
+        fetchEventListenerForBinding(binding) {
+          const { eventTarget, eventName, eventOptions } = binding;
+          return this.fetchEventListener(eventTarget, eventName, eventOptions);
+        }
+        fetchEventListener(eventTarget, eventName, eventOptions) {
+          const eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);
+          const cacheKey = this.cacheKey(eventName, eventOptions);
+          let eventListener = eventListenerMap.get(cacheKey);
+          if (!eventListener) {
+            eventListener = this.createEventListener(eventTarget, eventName, eventOptions);
+            eventListenerMap.set(cacheKey, eventListener);
+          }
+          return eventListener;
+        }
+        createEventListener(eventTarget, eventName, eventOptions) {
+          const eventListener = new EventListener(eventTarget, eventName, eventOptions);
+          if (this.started) {
+            eventListener.connect();
+          }
+          return eventListener;
+        }
+        fetchEventListenerMapForEventTarget(eventTarget) {
+          let eventListenerMap = this.eventListenerMaps.get(eventTarget);
+          if (!eventListenerMap) {
+            eventListenerMap = new Map();
+            this.eventListenerMaps.set(eventTarget, eventListenerMap);
+          }
+          return eventListenerMap;
+        }
+        cacheKey(eventName, eventOptions) {
+          const parts = [eventName];
+          Object.keys(eventOptions).sort().forEach((key) => {
+            parts.push(`${eventOptions[key] ? "" : "!"}${key}`);
+          });
+          return parts.join(":");
+        }
+      };
+      descriptorPattern = /^((.+?)(@(window|document))?->)?(.+?)(#([^:]+?))(:(.+))?$/;
+      Action = class {
+        constructor(element, index, descriptor) {
+          this.element = element;
+          this.index = index;
+          this.eventTarget = descriptor.eventTarget || element;
+          this.eventName = descriptor.eventName || getDefaultEventNameForElement(element) || error("missing event name");
+          this.eventOptions = descriptor.eventOptions || {};
+          this.identifier = descriptor.identifier || error("missing identifier");
+          this.methodName = descriptor.methodName || error("missing method name");
+        }
+        static forToken(token) {
+          return new this(token.element, token.index, parseActionDescriptorString(token.content));
+        }
+        toString() {
+          const eventNameSuffix = this.eventTargetName ? `@${this.eventTargetName}` : "";
+          return `${this.eventName}${eventNameSuffix}->${this.identifier}#${this.methodName}`;
+        }
+        get params() {
+          if (this.eventTarget instanceof Element) {
+            return this.getParamsFromEventTargetAttributes(this.eventTarget);
+          } else {
+            return {};
+          }
+        }
+        getParamsFromEventTargetAttributes(eventTarget) {
+          const params = {};
+          const pattern = new RegExp(`^data-${this.identifier}-(.+)-param$`);
+          const attributes = Array.from(eventTarget.attributes);
+          attributes.forEach(({ name, value }) => {
+            const match = name.match(pattern);
+            const key = match && match[1];
+            if (key) {
+              Object.assign(params, { [camelize(key)]: typecast(value) });
+            }
+          });
+          return params;
+        }
+        get eventTargetName() {
+          return stringifyEventTarget(this.eventTarget);
+        }
+      };
+      defaultEventNames = {
+        "a": (e) => "click",
+        "button": (e) => "click",
+        "form": (e) => "submit",
+        "details": (e) => "toggle",
+        "input": (e) => e.getAttribute("type") == "submit" ? "click" : "input",
+        "select": (e) => "change",
+        "textarea": (e) => "input"
+      };
+      Binding = class {
+        constructor(context, action) {
+          this.context = context;
+          this.action = action;
+        }
+        get index() {
+          return this.action.index;
+        }
+        get eventTarget() {
+          return this.action.eventTarget;
+        }
+        get eventOptions() {
+          return this.action.eventOptions;
+        }
+        get identifier() {
+          return this.context.identifier;
+        }
+        handleEvent(event) {
+          if (this.willBeInvokedByEvent(event)) {
+            this.invokeWithEvent(event);
+          }
+        }
+        get eventName() {
+          return this.action.eventName;
+        }
+        get method() {
+          const method = this.controller[this.methodName];
+          if (typeof method == "function") {
+            return method;
+          }
+          throw new Error(`Action "${this.action}" references undefined method "${this.methodName}"`);
+        }
+        invokeWithEvent(event) {
+          const { target, currentTarget } = event;
+          try {
+            const { params } = this.action;
+            const actionEvent = Object.assign(event, { params });
+            this.method.call(this.controller, actionEvent);
+            this.context.logDebugActivity(this.methodName, { event, target, currentTarget, action: this.methodName });
+          } catch (error2) {
+            const { identifier, controller, element, index } = this;
+            const detail = { identifier, controller, element, index, event };
+            this.context.handleError(error2, `invoking action "${this.action}"`, detail);
+          }
+        }
+        willBeInvokedByEvent(event) {
+          const eventTarget = event.target;
+          if (this.element === eventTarget) {
+            return true;
+          } else if (eventTarget instanceof Element && this.element.contains(eventTarget)) {
+            return this.scope.containsElement(eventTarget);
+          } else {
+            return this.scope.containsElement(this.action.element);
+          }
+        }
+        get controller() {
+          return this.context.controller;
+        }
+        get methodName() {
+          return this.action.methodName;
+        }
+        get element() {
+          return this.scope.element;
+        }
+        get scope() {
+          return this.context.scope;
+        }
+      };
+      ElementObserver = class {
+        constructor(element, delegate) {
+          this.mutationObserverInit = { attributes: true, childList: true, subtree: true };
+          this.element = element;
+          this.started = false;
+          this.delegate = delegate;
+          this.elements = new Set();
+          this.mutationObserver = new MutationObserver((mutations) => this.processMutations(mutations));
+        }
+        start() {
+          if (!this.started) {
+            this.started = true;
+            this.mutationObserver.observe(this.element, this.mutationObserverInit);
+            this.refresh();
+          }
+        }
+        pause(callback) {
+          if (this.started) {
+            this.mutationObserver.disconnect();
+            this.started = false;
+          }
+          callback();
+          if (!this.started) {
+            this.mutationObserver.observe(this.element, this.mutationObserverInit);
+            this.started = true;
+          }
+        }
+        stop() {
+          if (this.started) {
+            this.mutationObserver.takeRecords();
+            this.mutationObserver.disconnect();
+            this.started = false;
+          }
+        }
+        refresh() {
+          if (this.started) {
+            const matches = new Set(this.matchElementsInTree());
+            for (const element of Array.from(this.elements)) {
+              if (!matches.has(element)) {
+                this.removeElement(element);
+              }
+            }
+            for (const element of Array.from(matches)) {
+              this.addElement(element);
+            }
+          }
+        }
+        processMutations(mutations) {
+          if (this.started) {
+            for (const mutation of mutations) {
+              this.processMutation(mutation);
+            }
+          }
+        }
+        processMutation(mutation) {
+          if (mutation.type == "attributes") {
+            this.processAttributeChange(mutation.target, mutation.attributeName);
+          } else if (mutation.type == "childList") {
+            this.processRemovedNodes(mutation.removedNodes);
+            this.processAddedNodes(mutation.addedNodes);
+          }
+        }
+        processAttributeChange(node, attributeName) {
+          const element = node;
+          if (this.elements.has(element)) {
+            if (this.delegate.elementAttributeChanged && this.matchElement(element)) {
+              this.delegate.elementAttributeChanged(element, attributeName);
+            } else {
+              this.removeElement(element);
+            }
+          } else if (this.matchElement(element)) {
+            this.addElement(element);
+          }
+        }
+        processRemovedNodes(nodes) {
+          for (const node of Array.from(nodes)) {
+            const element = this.elementFromNode(node);
+            if (element) {
+              this.processTree(element, this.removeElement);
+            }
+          }
+        }
+        processAddedNodes(nodes) {
+          for (const node of Array.from(nodes)) {
+            const element = this.elementFromNode(node);
+            if (element && this.elementIsActive(element)) {
+              this.processTree(element, this.addElement);
+            }
+          }
+        }
+        matchElement(element) {
+          return this.delegate.matchElement(element);
+        }
+        matchElementsInTree(tree = this.element) {
+          return this.delegate.matchElementsInTree(tree);
+        }
+        processTree(tree, processor) {
+          for (const element of this.matchElementsInTree(tree)) {
+            processor.call(this, element);
+          }
+        }
+        elementFromNode(node) {
+          if (node.nodeType == Node.ELEMENT_NODE) {
+            return node;
+          }
+        }
+        elementIsActive(element) {
+          if (element.isConnected != this.element.isConnected) {
+            return false;
+          } else {
+            return this.element.contains(element);
+          }
+        }
+        addElement(element) {
+          if (!this.elements.has(element)) {
+            if (this.elementIsActive(element)) {
+              this.elements.add(element);
+              if (this.delegate.elementMatched) {
+                this.delegate.elementMatched(element);
+              }
+            }
+          }
+        }
+        removeElement(element) {
+          if (this.elements.has(element)) {
+            this.elements.delete(element);
+            if (this.delegate.elementUnmatched) {
+              this.delegate.elementUnmatched(element);
+            }
+          }
+        }
+      };
+      AttributeObserver = class {
+        constructor(element, attributeName, delegate) {
+          this.attributeName = attributeName;
+          this.delegate = delegate;
+          this.elementObserver = new ElementObserver(element, this);
+        }
+        get element() {
+          return this.elementObserver.element;
+        }
+        get selector() {
+          return `[${this.attributeName}]`;
+        }
+        start() {
+          this.elementObserver.start();
+        }
+        pause(callback) {
+          this.elementObserver.pause(callback);
+        }
+        stop() {
+          this.elementObserver.stop();
+        }
+        refresh() {
+          this.elementObserver.refresh();
+        }
+        get started() {
+          return this.elementObserver.started;
+        }
+        matchElement(element) {
+          return element.hasAttribute(this.attributeName);
+        }
+        matchElementsInTree(tree) {
+          const match = this.matchElement(tree) ? [tree] : [];
+          const matches = Array.from(tree.querySelectorAll(this.selector));
+          return match.concat(matches);
+        }
+        elementMatched(element) {
+          if (this.delegate.elementMatchedAttribute) {
+            this.delegate.elementMatchedAttribute(element, this.attributeName);
+          }
+        }
+        elementUnmatched(element) {
+          if (this.delegate.elementUnmatchedAttribute) {
+            this.delegate.elementUnmatchedAttribute(element, this.attributeName);
+          }
+        }
+        elementAttributeChanged(element, attributeName) {
+          if (this.delegate.elementAttributeValueChanged && this.attributeName == attributeName) {
+            this.delegate.elementAttributeValueChanged(element, attributeName);
+          }
+        }
+      };
+      StringMapObserver = class {
+        constructor(element, delegate) {
+          this.element = element;
+          this.delegate = delegate;
+          this.started = false;
+          this.stringMap = new Map();
+          this.mutationObserver = new MutationObserver((mutations) => this.processMutations(mutations));
+        }
+        start() {
+          if (!this.started) {
+            this.started = true;
+            this.mutationObserver.observe(this.element, { attributes: true, attributeOldValue: true });
+            this.refresh();
+          }
+        }
+        stop() {
+          if (this.started) {
+            this.mutationObserver.takeRecords();
+            this.mutationObserver.disconnect();
+            this.started = false;
+          }
+        }
+        refresh() {
+          if (this.started) {
+            for (const attributeName of this.knownAttributeNames) {
+              this.refreshAttribute(attributeName, null);
+            }
+          }
+        }
+        processMutations(mutations) {
+          if (this.started) {
+            for (const mutation of mutations) {
+              this.processMutation(mutation);
+            }
+          }
+        }
+        processMutation(mutation) {
+          const attributeName = mutation.attributeName;
+          if (attributeName) {
+            this.refreshAttribute(attributeName, mutation.oldValue);
+          }
+        }
+        refreshAttribute(attributeName, oldValue) {
+          const key = this.delegate.getStringMapKeyForAttribute(attributeName);
+          if (key != null) {
+            if (!this.stringMap.has(attributeName)) {
+              this.stringMapKeyAdded(key, attributeName);
+            }
+            const value = this.element.getAttribute(attributeName);
+            if (this.stringMap.get(attributeName) != value) {
+              this.stringMapValueChanged(value, key, oldValue);
+            }
+            if (value == null) {
+              const oldValue2 = this.stringMap.get(attributeName);
+              this.stringMap.delete(attributeName);
+              if (oldValue2)
+                this.stringMapKeyRemoved(key, attributeName, oldValue2);
+            } else {
+              this.stringMap.set(attributeName, value);
+            }
+          }
+        }
+        stringMapKeyAdded(key, attributeName) {
+          if (this.delegate.stringMapKeyAdded) {
+            this.delegate.stringMapKeyAdded(key, attributeName);
+          }
+        }
+        stringMapValueChanged(value, key, oldValue) {
+          if (this.delegate.stringMapValueChanged) {
+            this.delegate.stringMapValueChanged(value, key, oldValue);
+          }
+        }
+        stringMapKeyRemoved(key, attributeName, oldValue) {
+          if (this.delegate.stringMapKeyRemoved) {
+            this.delegate.stringMapKeyRemoved(key, attributeName, oldValue);
+          }
+        }
+        get knownAttributeNames() {
+          return Array.from(new Set(this.currentAttributeNames.concat(this.recordedAttributeNames)));
+        }
+        get currentAttributeNames() {
+          return Array.from(this.element.attributes).map((attribute) => attribute.name);
+        }
+        get recordedAttributeNames() {
+          return Array.from(this.stringMap.keys());
+        }
+      };
+      Multimap = class {
+        constructor() {
+          this.valuesByKey = new Map();
+        }
+        get keys() {
+          return Array.from(this.valuesByKey.keys());
+        }
+        get values() {
+          const sets = Array.from(this.valuesByKey.values());
+          return sets.reduce((values, set) => values.concat(Array.from(set)), []);
+        }
+        get size() {
+          const sets = Array.from(this.valuesByKey.values());
+          return sets.reduce((size, set) => size + set.size, 0);
+        }
+        add(key, value) {
+          add(this.valuesByKey, key, value);
+        }
+        delete(key, value) {
+          del(this.valuesByKey, key, value);
+        }
+        has(key, value) {
+          const values = this.valuesByKey.get(key);
+          return values != null && values.has(value);
+        }
+        hasKey(key) {
+          return this.valuesByKey.has(key);
+        }
+        hasValue(value) {
+          const sets = Array.from(this.valuesByKey.values());
+          return sets.some((set) => set.has(value));
+        }
+        getValuesForKey(key) {
+          const values = this.valuesByKey.get(key);
+          return values ? Array.from(values) : [];
+        }
+        getKeysForValue(value) {
+          return Array.from(this.valuesByKey).filter(([key, values]) => values.has(value)).map(([key, values]) => key);
+        }
+      };
+      TokenListObserver = class {
+        constructor(element, attributeName, delegate) {
+          this.attributeObserver = new AttributeObserver(element, attributeName, this);
+          this.delegate = delegate;
+          this.tokensByElement = new Multimap();
+        }
+        get started() {
+          return this.attributeObserver.started;
+        }
+        start() {
+          this.attributeObserver.start();
+        }
+        pause(callback) {
+          this.attributeObserver.pause(callback);
+        }
+        stop() {
+          this.attributeObserver.stop();
+        }
+        refresh() {
+          this.attributeObserver.refresh();
+        }
+        get element() {
+          return this.attributeObserver.element;
+        }
+        get attributeName() {
+          return this.attributeObserver.attributeName;
+        }
+        elementMatchedAttribute(element) {
+          this.tokensMatched(this.readTokensForElement(element));
+        }
+        elementAttributeValueChanged(element) {
+          const [unmatchedTokens, matchedTokens] = this.refreshTokensForElement(element);
+          this.tokensUnmatched(unmatchedTokens);
+          this.tokensMatched(matchedTokens);
+        }
+        elementUnmatchedAttribute(element) {
+          this.tokensUnmatched(this.tokensByElement.getValuesForKey(element));
+        }
+        tokensMatched(tokens) {
+          tokens.forEach((token) => this.tokenMatched(token));
+        }
+        tokensUnmatched(tokens) {
+          tokens.forEach((token) => this.tokenUnmatched(token));
+        }
+        tokenMatched(token) {
+          this.delegate.tokenMatched(token);
+          this.tokensByElement.add(token.element, token);
+        }
+        tokenUnmatched(token) {
+          this.delegate.tokenUnmatched(token);
+          this.tokensByElement.delete(token.element, token);
+        }
+        refreshTokensForElement(element) {
+          const previousTokens = this.tokensByElement.getValuesForKey(element);
+          const currentTokens = this.readTokensForElement(element);
+          const firstDifferingIndex = zip(previousTokens, currentTokens).findIndex(([previousToken, currentToken]) => !tokensAreEqual(previousToken, currentToken));
+          if (firstDifferingIndex == -1) {
+            return [[], []];
+          } else {
+            return [previousTokens.slice(firstDifferingIndex), currentTokens.slice(firstDifferingIndex)];
+          }
+        }
+        readTokensForElement(element) {
+          const attributeName = this.attributeName;
+          const tokenString = element.getAttribute(attributeName) || "";
+          return parseTokenString(tokenString, element, attributeName);
+        }
+      };
+      ValueListObserver = class {
+        constructor(element, attributeName, delegate) {
+          this.tokenListObserver = new TokenListObserver(element, attributeName, this);
+          this.delegate = delegate;
+          this.parseResultsByToken = new WeakMap();
+          this.valuesByTokenByElement = new WeakMap();
+        }
+        get started() {
+          return this.tokenListObserver.started;
+        }
+        start() {
+          this.tokenListObserver.start();
+        }
+        stop() {
+          this.tokenListObserver.stop();
+        }
+        refresh() {
+          this.tokenListObserver.refresh();
+        }
+        get element() {
+          return this.tokenListObserver.element;
+        }
+        get attributeName() {
+          return this.tokenListObserver.attributeName;
+        }
+        tokenMatched(token) {
+          const { element } = token;
+          const { value } = this.fetchParseResultForToken(token);
+          if (value) {
+            this.fetchValuesByTokenForElement(element).set(token, value);
+            this.delegate.elementMatchedValue(element, value);
+          }
+        }
+        tokenUnmatched(token) {
+          const { element } = token;
+          const { value } = this.fetchParseResultForToken(token);
+          if (value) {
+            this.fetchValuesByTokenForElement(element).delete(token);
+            this.delegate.elementUnmatchedValue(element, value);
+          }
+        }
+        fetchParseResultForToken(token) {
+          let parseResult = this.parseResultsByToken.get(token);
+          if (!parseResult) {
+            parseResult = this.parseToken(token);
+            this.parseResultsByToken.set(token, parseResult);
+          }
+          return parseResult;
+        }
+        fetchValuesByTokenForElement(element) {
+          let valuesByToken = this.valuesByTokenByElement.get(element);
+          if (!valuesByToken) {
+            valuesByToken = new Map();
+            this.valuesByTokenByElement.set(element, valuesByToken);
+          }
+          return valuesByToken;
+        }
+        parseToken(token) {
+          try {
+            const value = this.delegate.parseValueForToken(token);
+            return { value };
+          } catch (error2) {
+            return { error: error2 };
+          }
+        }
+      };
+      BindingObserver = class {
+        constructor(context, delegate) {
+          this.context = context;
+          this.delegate = delegate;
+          this.bindingsByAction = new Map();
+        }
+        start() {
+          if (!this.valueListObserver) {
+            this.valueListObserver = new ValueListObserver(this.element, this.actionAttribute, this);
+            this.valueListObserver.start();
+          }
+        }
+        stop() {
+          if (this.valueListObserver) {
+            this.valueListObserver.stop();
+            delete this.valueListObserver;
+            this.disconnectAllActions();
+          }
+        }
+        get element() {
+          return this.context.element;
+        }
+        get identifier() {
+          return this.context.identifier;
+        }
+        get actionAttribute() {
+          return this.schema.actionAttribute;
+        }
+        get schema() {
+          return this.context.schema;
+        }
+        get bindings() {
+          return Array.from(this.bindingsByAction.values());
+        }
+        connectAction(action) {
+          const binding = new Binding(this.context, action);
+          this.bindingsByAction.set(action, binding);
+          this.delegate.bindingConnected(binding);
+        }
+        disconnectAction(action) {
+          const binding = this.bindingsByAction.get(action);
+          if (binding) {
+            this.bindingsByAction.delete(action);
+            this.delegate.bindingDisconnected(binding);
+          }
+        }
+        disconnectAllActions() {
+          this.bindings.forEach((binding) => this.delegate.bindingDisconnected(binding));
+          this.bindingsByAction.clear();
+        }
+        parseValueForToken(token) {
+          const action = Action.forToken(token);
+          if (action.identifier == this.identifier) {
+            return action;
+          }
+        }
+        elementMatchedValue(element, action) {
+          this.connectAction(action);
+        }
+        elementUnmatchedValue(element, action) {
+          this.disconnectAction(action);
+        }
+      };
+      ValueObserver = class {
+        constructor(context, receiver) {
+          this.context = context;
+          this.receiver = receiver;
+          this.stringMapObserver = new StringMapObserver(this.element, this);
+          this.valueDescriptorMap = this.controller.valueDescriptorMap;
+          this.invokeChangedCallbacksForDefaultValues();
+        }
+        start() {
+          this.stringMapObserver.start();
+        }
+        stop() {
+          this.stringMapObserver.stop();
+        }
+        get element() {
+          return this.context.element;
+        }
+        get controller() {
+          return this.context.controller;
+        }
+        getStringMapKeyForAttribute(attributeName) {
+          if (attributeName in this.valueDescriptorMap) {
+            return this.valueDescriptorMap[attributeName].name;
+          }
+        }
+        stringMapKeyAdded(key, attributeName) {
+          const descriptor = this.valueDescriptorMap[attributeName];
+          if (!this.hasValue(key)) {
+            this.invokeChangedCallback(key, descriptor.writer(this.receiver[key]), descriptor.writer(descriptor.defaultValue));
+          }
+        }
+        stringMapValueChanged(value, name, oldValue) {
+          const descriptor = this.valueDescriptorNameMap[name];
+          if (value === null)
+            return;
+          if (oldValue === null) {
+            oldValue = descriptor.writer(descriptor.defaultValue);
+          }
+          this.invokeChangedCallback(name, value, oldValue);
+        }
+        stringMapKeyRemoved(key, attributeName, oldValue) {
+          const descriptor = this.valueDescriptorNameMap[key];
+          if (this.hasValue(key)) {
+            this.invokeChangedCallback(key, descriptor.writer(this.receiver[key]), oldValue);
+          } else {
+            this.invokeChangedCallback(key, descriptor.writer(descriptor.defaultValue), oldValue);
+          }
+        }
+        invokeChangedCallbacksForDefaultValues() {
+          for (const { key, name, defaultValue, writer } of this.valueDescriptors) {
+            if (defaultValue != void 0 && !this.controller.data.has(key)) {
+              this.invokeChangedCallback(name, writer(defaultValue), void 0);
+            }
+          }
+        }
+        invokeChangedCallback(name, rawValue, rawOldValue) {
+          const changedMethodName = `${name}Changed`;
+          const changedMethod = this.receiver[changedMethodName];
+          if (typeof changedMethod == "function") {
+            const descriptor = this.valueDescriptorNameMap[name];
+            const value = descriptor.reader(rawValue);
+            let oldValue = rawOldValue;
+            if (rawOldValue) {
+              oldValue = descriptor.reader(rawOldValue);
+            }
+            changedMethod.call(this.receiver, value, oldValue);
+          }
+        }
+        get valueDescriptors() {
+          const { valueDescriptorMap } = this;
+          return Object.keys(valueDescriptorMap).map((key) => valueDescriptorMap[key]);
+        }
+        get valueDescriptorNameMap() {
+          const descriptors = {};
+          Object.keys(this.valueDescriptorMap).forEach((key) => {
+            const descriptor = this.valueDescriptorMap[key];
+            descriptors[descriptor.name] = descriptor;
+          });
+          return descriptors;
+        }
+        hasValue(attributeName) {
+          const descriptor = this.valueDescriptorNameMap[attributeName];
+          const hasMethodName = `has${capitalize(descriptor.name)}`;
+          return this.receiver[hasMethodName];
+        }
+      };
+      TargetObserver = class {
+        constructor(context, delegate) {
+          this.context = context;
+          this.delegate = delegate;
+          this.targetsByName = new Multimap();
+        }
+        start() {
+          if (!this.tokenListObserver) {
+            this.tokenListObserver = new TokenListObserver(this.element, this.attributeName, this);
+            this.tokenListObserver.start();
+          }
+        }
+        stop() {
+          if (this.tokenListObserver) {
+            this.disconnectAllTargets();
+            this.tokenListObserver.stop();
+            delete this.tokenListObserver;
+          }
+        }
+        tokenMatched({ element, content: name }) {
+          if (this.scope.containsElement(element)) {
+            this.connectTarget(element, name);
+          }
+        }
+        tokenUnmatched({ element, content: name }) {
+          this.disconnectTarget(element, name);
+        }
+        connectTarget(element, name) {
+          var _a;
+          if (!this.targetsByName.has(name, element)) {
+            this.targetsByName.add(name, element);
+            (_a = this.tokenListObserver) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.targetConnected(element, name));
+          }
+        }
+        disconnectTarget(element, name) {
+          var _a;
+          if (this.targetsByName.has(name, element)) {
+            this.targetsByName.delete(name, element);
+            (_a = this.tokenListObserver) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.targetDisconnected(element, name));
+          }
+        }
+        disconnectAllTargets() {
+          for (const name of this.targetsByName.keys) {
+            for (const element of this.targetsByName.getValuesForKey(name)) {
+              this.disconnectTarget(element, name);
+            }
+          }
+        }
+        get attributeName() {
+          return `data-${this.context.identifier}-target`;
+        }
+        get element() {
+          return this.context.element;
+        }
+        get scope() {
+          return this.context.scope;
+        }
+      };
+      Context = class {
+        constructor(module, scope) {
+          this.logDebugActivity = (functionName, detail = {}) => {
+            const { identifier, controller, element } = this;
+            detail = Object.assign({ identifier, controller, element }, detail);
+            this.application.logDebugActivity(this.identifier, functionName, detail);
+          };
+          this.module = module;
+          this.scope = scope;
+          this.controller = new module.controllerConstructor(this);
+          this.bindingObserver = new BindingObserver(this, this.dispatcher);
+          this.valueObserver = new ValueObserver(this, this.controller);
+          this.targetObserver = new TargetObserver(this, this);
+          try {
+            this.controller.initialize();
+            this.logDebugActivity("initialize");
+          } catch (error2) {
+            this.handleError(error2, "initializing controller");
+          }
+        }
+        connect() {
+          this.bindingObserver.start();
+          this.valueObserver.start();
+          this.targetObserver.start();
+          try {
+            this.controller.connect();
+            this.logDebugActivity("connect");
+          } catch (error2) {
+            this.handleError(error2, "connecting controller");
+          }
+        }
+        disconnect() {
+          try {
+            this.controller.disconnect();
+            this.logDebugActivity("disconnect");
+          } catch (error2) {
+            this.handleError(error2, "disconnecting controller");
+          }
+          this.targetObserver.stop();
+          this.valueObserver.stop();
+          this.bindingObserver.stop();
+        }
+        get application() {
+          return this.module.application;
+        }
+        get identifier() {
+          return this.module.identifier;
+        }
+        get schema() {
+          return this.application.schema;
+        }
+        get dispatcher() {
+          return this.application.dispatcher;
+        }
+        get element() {
+          return this.scope.element;
+        }
+        get parentElement() {
+          return this.element.parentElement;
+        }
+        handleError(error2, message, detail = {}) {
+          const { identifier, controller, element } = this;
+          detail = Object.assign({ identifier, controller, element }, detail);
+          this.application.handleError(error2, `Error ${message}`, detail);
+        }
+        targetConnected(element, name) {
+          this.invokeControllerMethod(`${name}TargetConnected`, element);
+        }
+        targetDisconnected(element, name) {
+          this.invokeControllerMethod(`${name}TargetDisconnected`, element);
+        }
+        invokeControllerMethod(methodName, ...args) {
+          const controller = this.controller;
+          if (typeof controller[methodName] == "function") {
+            controller[methodName](...args);
+          }
+        }
+      };
+      getOwnKeys = (() => {
+        if (typeof Object.getOwnPropertySymbols == "function") {
+          return (object) => [
+            ...Object.getOwnPropertyNames(object),
+            ...Object.getOwnPropertySymbols(object)
+          ];
+        } else {
+          return Object.getOwnPropertyNames;
+        }
+      })();
+      extend = (() => {
+        function extendWithReflect(constructor) {
+          function extended() {
+            return Reflect.construct(constructor, arguments, new.target);
+          }
+          extended.prototype = Object.create(constructor.prototype, {
+            constructor: { value: extended }
+          });
+          Reflect.setPrototypeOf(extended, constructor);
+          return extended;
+        }
+        function testReflectExtension() {
+          const a = function() {
+            this.a.call(this);
+          };
+          const b = extendWithReflect(a);
+          b.prototype.a = function() {
+          };
+          return new b();
+        }
+        try {
+          testReflectExtension();
+          return extendWithReflect;
+        } catch (error2) {
+          return (constructor) => class extended extends constructor {
+          };
+        }
+      })();
+      Module = class {
+        constructor(application2, definition) {
+          this.application = application2;
+          this.definition = blessDefinition(definition);
+          this.contextsByScope = new WeakMap();
+          this.connectedContexts = new Set();
+        }
+        get identifier() {
+          return this.definition.identifier;
+        }
+        get controllerConstructor() {
+          return this.definition.controllerConstructor;
+        }
+        get contexts() {
+          return Array.from(this.connectedContexts);
+        }
+        connectContextForScope(scope) {
+          const context = this.fetchContextForScope(scope);
+          this.connectedContexts.add(context);
+          context.connect();
+        }
+        disconnectContextForScope(scope) {
+          const context = this.contextsByScope.get(scope);
+          if (context) {
+            this.connectedContexts.delete(context);
+            context.disconnect();
+          }
+        }
+        fetchContextForScope(scope) {
+          let context = this.contextsByScope.get(scope);
+          if (!context) {
+            context = new Context(this, scope);
+            this.contextsByScope.set(scope, context);
+          }
+          return context;
+        }
+      };
+      ClassMap = class {
+        constructor(scope) {
+          this.scope = scope;
+        }
+        has(name) {
+          return this.data.has(this.getDataKey(name));
+        }
+        get(name) {
+          return this.getAll(name)[0];
+        }
+        getAll(name) {
+          const tokenString = this.data.get(this.getDataKey(name)) || "";
+          return tokenize(tokenString);
+        }
+        getAttributeName(name) {
+          return this.data.getAttributeNameForKey(this.getDataKey(name));
+        }
+        getDataKey(name) {
+          return `${name}-class`;
+        }
+        get data() {
+          return this.scope.data;
+        }
+      };
+      DataMap = class {
+        constructor(scope) {
+          this.scope = scope;
+        }
+        get element() {
+          return this.scope.element;
+        }
+        get identifier() {
+          return this.scope.identifier;
+        }
+        get(key) {
+          const name = this.getAttributeNameForKey(key);
+          return this.element.getAttribute(name);
+        }
+        set(key, value) {
+          const name = this.getAttributeNameForKey(key);
+          this.element.setAttribute(name, value);
+          return this.get(key);
+        }
+        has(key) {
+          const name = this.getAttributeNameForKey(key);
+          return this.element.hasAttribute(name);
+        }
+        delete(key) {
+          if (this.has(key)) {
+            const name = this.getAttributeNameForKey(key);
+            this.element.removeAttribute(name);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        getAttributeNameForKey(key) {
+          return `data-${this.identifier}-${dasherize(key)}`;
+        }
+      };
+      Guide = class {
+        constructor(logger) {
+          this.warnedKeysByObject = new WeakMap();
+          this.logger = logger;
+        }
+        warn(object, key, message) {
+          let warnedKeys = this.warnedKeysByObject.get(object);
+          if (!warnedKeys) {
+            warnedKeys = new Set();
+            this.warnedKeysByObject.set(object, warnedKeys);
+          }
+          if (!warnedKeys.has(key)) {
+            warnedKeys.add(key);
+            this.logger.warn(message, object);
+          }
+        }
+      };
+      TargetSet = class {
+        constructor(scope) {
+          this.scope = scope;
+        }
+        get element() {
+          return this.scope.element;
+        }
+        get identifier() {
+          return this.scope.identifier;
+        }
+        get schema() {
+          return this.scope.schema;
+        }
+        has(targetName) {
+          return this.find(targetName) != null;
+        }
+        find(...targetNames) {
+          return targetNames.reduce((target, targetName) => target || this.findTarget(targetName) || this.findLegacyTarget(targetName), void 0);
+        }
+        findAll(...targetNames) {
+          return targetNames.reduce((targets, targetName) => [
+            ...targets,
+            ...this.findAllTargets(targetName),
+            ...this.findAllLegacyTargets(targetName)
+          ], []);
+        }
+        findTarget(targetName) {
+          const selector = this.getSelectorForTargetName(targetName);
+          return this.scope.findElement(selector);
+        }
+        findAllTargets(targetName) {
+          const selector = this.getSelectorForTargetName(targetName);
+          return this.scope.findAllElements(selector);
+        }
+        getSelectorForTargetName(targetName) {
+          const attributeName = this.schema.targetAttributeForScope(this.identifier);
+          return attributeValueContainsToken(attributeName, targetName);
+        }
+        findLegacyTarget(targetName) {
+          const selector = this.getLegacySelectorForTargetName(targetName);
+          return this.deprecate(this.scope.findElement(selector), targetName);
+        }
+        findAllLegacyTargets(targetName) {
+          const selector = this.getLegacySelectorForTargetName(targetName);
+          return this.scope.findAllElements(selector).map((element) => this.deprecate(element, targetName));
+        }
+        getLegacySelectorForTargetName(targetName) {
+          const targetDescriptor = `${this.identifier}.${targetName}`;
+          return attributeValueContainsToken(this.schema.targetAttribute, targetDescriptor);
+        }
+        deprecate(element, targetName) {
+          if (element) {
+            const { identifier } = this;
+            const attributeName = this.schema.targetAttribute;
+            const revisedAttributeName = this.schema.targetAttributeForScope(identifier);
+            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.`);
+          }
+          return element;
+        }
+        get guide() {
+          return this.scope.guide;
+        }
+      };
+      Scope = class {
+        constructor(schema, element, identifier, logger) {
+          this.targets = new TargetSet(this);
+          this.classes = new ClassMap(this);
+          this.data = new DataMap(this);
+          this.containsElement = (element2) => {
+            return element2.closest(this.controllerSelector) === this.element;
+          };
+          this.schema = schema;
+          this.element = element;
+          this.identifier = identifier;
+          this.guide = new Guide(logger);
+        }
+        findElement(selector) {
+          return this.element.matches(selector) ? this.element : this.queryElements(selector).find(this.containsElement);
+        }
+        findAllElements(selector) {
+          return [
+            ...this.element.matches(selector) ? [this.element] : [],
+            ...this.queryElements(selector).filter(this.containsElement)
+          ];
+        }
+        queryElements(selector) {
+          return Array.from(this.element.querySelectorAll(selector));
+        }
+        get controllerSelector() {
+          return attributeValueContainsToken(this.schema.controllerAttribute, this.identifier);
+        }
+      };
+      ScopeObserver = class {
+        constructor(element, schema, delegate) {
+          this.element = element;
+          this.schema = schema;
+          this.delegate = delegate;
+          this.valueListObserver = new ValueListObserver(this.element, this.controllerAttribute, this);
+          this.scopesByIdentifierByElement = new WeakMap();
+          this.scopeReferenceCounts = new WeakMap();
+        }
+        start() {
+          this.valueListObserver.start();
+        }
+        stop() {
+          this.valueListObserver.stop();
+        }
+        get controllerAttribute() {
+          return this.schema.controllerAttribute;
+        }
+        parseValueForToken(token) {
+          const { element, content: identifier } = token;
+          const scopesByIdentifier = this.fetchScopesByIdentifierForElement(element);
+          let scope = scopesByIdentifier.get(identifier);
+          if (!scope) {
+            scope = this.delegate.createScopeForElementAndIdentifier(element, identifier);
+            scopesByIdentifier.set(identifier, scope);
+          }
+          return scope;
+        }
+        elementMatchedValue(element, value) {
+          const referenceCount = (this.scopeReferenceCounts.get(value) || 0) + 1;
+          this.scopeReferenceCounts.set(value, referenceCount);
+          if (referenceCount == 1) {
+            this.delegate.scopeConnected(value);
+          }
+        }
+        elementUnmatchedValue(element, value) {
+          const referenceCount = this.scopeReferenceCounts.get(value);
+          if (referenceCount) {
+            this.scopeReferenceCounts.set(value, referenceCount - 1);
+            if (referenceCount == 1) {
+              this.delegate.scopeDisconnected(value);
+            }
+          }
+        }
+        fetchScopesByIdentifierForElement(element) {
+          let scopesByIdentifier = this.scopesByIdentifierByElement.get(element);
+          if (!scopesByIdentifier) {
+            scopesByIdentifier = new Map();
+            this.scopesByIdentifierByElement.set(element, scopesByIdentifier);
+          }
+          return scopesByIdentifier;
+        }
+      };
+      Router = class {
+        constructor(application2) {
+          this.application = application2;
+          this.scopeObserver = new ScopeObserver(this.element, this.schema, this);
+          this.scopesByIdentifier = new Multimap();
+          this.modulesByIdentifier = new Map();
+        }
+        get element() {
+          return this.application.element;
+        }
+        get schema() {
+          return this.application.schema;
+        }
+        get logger() {
+          return this.application.logger;
+        }
+        get controllerAttribute() {
+          return this.schema.controllerAttribute;
+        }
+        get modules() {
+          return Array.from(this.modulesByIdentifier.values());
+        }
+        get contexts() {
+          return this.modules.reduce((contexts, module) => contexts.concat(module.contexts), []);
+        }
+        start() {
+          this.scopeObserver.start();
+        }
+        stop() {
+          this.scopeObserver.stop();
+        }
+        loadDefinition(definition) {
+          this.unloadIdentifier(definition.identifier);
+          const module = new Module(this.application, definition);
+          this.connectModule(module);
+        }
+        unloadIdentifier(identifier) {
+          const module = this.modulesByIdentifier.get(identifier);
+          if (module) {
+            this.disconnectModule(module);
+          }
+        }
+        getContextForElementAndIdentifier(element, identifier) {
+          const module = this.modulesByIdentifier.get(identifier);
+          if (module) {
+            return module.contexts.find((context) => context.element == element);
+          }
+        }
+        handleError(error2, message, detail) {
+          this.application.handleError(error2, message, detail);
+        }
+        createScopeForElementAndIdentifier(element, identifier) {
+          return new Scope(this.schema, element, identifier, this.logger);
+        }
+        scopeConnected(scope) {
+          this.scopesByIdentifier.add(scope.identifier, scope);
+          const module = this.modulesByIdentifier.get(scope.identifier);
+          if (module) {
+            module.connectContextForScope(scope);
+          }
+        }
+        scopeDisconnected(scope) {
+          this.scopesByIdentifier.delete(scope.identifier, scope);
+          const module = this.modulesByIdentifier.get(scope.identifier);
+          if (module) {
+            module.disconnectContextForScope(scope);
+          }
+        }
+        connectModule(module) {
+          this.modulesByIdentifier.set(module.identifier, module);
+          const scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);
+          scopes.forEach((scope) => module.connectContextForScope(scope));
+        }
+        disconnectModule(module) {
+          this.modulesByIdentifier.delete(module.identifier);
+          const scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);
+          scopes.forEach((scope) => module.disconnectContextForScope(scope));
+        }
+      };
+      defaultSchema = {
+        controllerAttribute: "data-controller",
+        actionAttribute: "data-action",
+        targetAttribute: "data-target",
+        targetAttributeForScope: (identifier) => `data-${identifier}-target`
+      };
+      Application = class {
+        constructor(element = document.documentElement, schema = defaultSchema) {
+          this.logger = console;
+          this.debug = false;
+          this.logDebugActivity = (identifier, functionName, detail = {}) => {
+            if (this.debug) {
+              this.logFormattedMessage(identifier, functionName, detail);
+            }
+          };
+          this.element = element;
+          this.schema = schema;
+          this.dispatcher = new Dispatcher(this);
+          this.router = new Router(this);
+        }
+        static start(element, schema) {
+          const application2 = new Application(element, schema);
+          application2.start();
+          return application2;
+        }
+        async start() {
+          await domReady();
+          this.logDebugActivity("application", "starting");
+          this.dispatcher.start();
+          this.router.start();
+          this.logDebugActivity("application", "start");
+        }
+        stop() {
+          this.logDebugActivity("application", "stopping");
+          this.dispatcher.stop();
+          this.router.stop();
+          this.logDebugActivity("application", "stop");
+        }
+        register(identifier, controllerConstructor) {
+          if (controllerConstructor.shouldLoad) {
+            this.load({ identifier, controllerConstructor });
+          }
+        }
+        load(head, ...rest) {
+          const definitions = Array.isArray(head) ? head : [head, ...rest];
+          definitions.forEach((definition) => this.router.loadDefinition(definition));
+        }
+        unload(head, ...rest) {
+          const identifiers = Array.isArray(head) ? head : [head, ...rest];
+          identifiers.forEach((identifier) => this.router.unloadIdentifier(identifier));
+        }
+        get controllers() {
+          return this.router.contexts.map((context) => context.controller);
+        }
+        getControllerForElementAndIdentifier(element, identifier) {
+          const context = this.router.getContextForElementAndIdentifier(element, identifier);
+          return context ? context.controller : null;
+        }
+        handleError(error2, message, detail) {
+          var _a;
+          this.logger.error(`%s
+
+%o
+
+%o`, message, error2, detail);
+          (_a = window.onerror) === null || _a === void 0 ? void 0 : _a.call(window, message, "", 0, 0, error2);
+        }
+        logFormattedMessage(identifier, functionName, detail = {}) {
+          detail = Object.assign({ application: this }, detail);
+          this.logger.groupCollapsed(`${identifier} #${functionName}`);
+          this.logger.log("details:", Object.assign({}, detail));
+          this.logger.groupEnd();
+        }
+      };
+      defaultValuesByType = {
+        get array() {
+          return [];
+        },
+        boolean: false,
+        number: 0,
+        get object() {
+          return {};
+        },
+        string: ""
+      };
+      readers = {
+        array(value) {
+          const array = JSON.parse(value);
+          if (!Array.isArray(array)) {
+            throw new TypeError("Expected array");
+          }
+          return array;
+        },
+        boolean(value) {
+          return !(value == "0" || value == "false");
+        },
+        number(value) {
+          return Number(value);
+        },
+        object(value) {
+          const object = JSON.parse(value);
+          if (object === null || typeof object != "object" || Array.isArray(object)) {
+            throw new TypeError("Expected object");
+          }
+          return object;
+        },
+        string(value) {
+          return value;
+        }
+      };
+      writers = {
+        default: writeString,
+        array: writeJSON,
+        object: writeJSON
+      };
+      Controller = class {
+        constructor(context) {
+          this.context = context;
+        }
+        static get shouldLoad() {
+          return true;
+        }
+        get application() {
+          return this.context.application;
+        }
+        get scope() {
+          return this.context.scope;
+        }
+        get element() {
+          return this.scope.element;
+        }
+        get identifier() {
+          return this.scope.identifier;
+        }
+        get targets() {
+          return this.scope.targets;
+        }
+        get classes() {
+          return this.scope.classes;
+        }
+        get data() {
+          return this.scope.data;
+        }
+        initialize() {
+        }
+        connect() {
+        }
+        disconnect() {
+        }
+        dispatch(eventName, { target = this.element, detail = {}, prefix = this.identifier, bubbles = true, cancelable = true } = {}) {
+          const type = prefix ? `${prefix}:${eventName}` : eventName;
+          const event = new CustomEvent(type, { detail, bubbles, cancelable });
+          target.dispatchEvent(event);
+          return event;
+        }
+      };
+      Controller.blessings = [ClassPropertiesBlessing, TargetPropertiesBlessing, ValuePropertiesBlessing];
+      Controller.targets = [];
+      Controller.values = {};
+    }
+  });
+
+  // app/components/material/button_component_controller.js
+  var button_component_controller_exports = {};
+  __export(button_component_controller_exports, {
+    default: () => button_component_controller_default
+  });
+  var button_component_controller_default;
+  var init_button_component_controller = __esm({
+    "app/components/material/button_component_controller.js"() {
+      init_stimulus();
+      button_component_controller_default = class extends Controller {
+        connect() {
+          console.log("Hello, Stimulus!", this.element);
+        }
+      };
+    }
+  });
+
+  // import-glob:../../components/**/*_controller.js
+  var controller_exports = {};
+  __export(controller_exports, {
+    default: () => controller_default,
+    filenames: () => filenames
+  });
+  var modules, controller_default, filenames;
+  var init_controller = __esm({
+    "import-glob:../../components/**/*_controller.js"() {
+      init_button_component_controller();
+      modules = [button_component_controller_exports];
+      controller_default = modules;
+      filenames = ["../../components/material/button_component_controller.js"];
+    }
+  });
+
+  // app/javascript/controllers/application.js
+  init_stimulus();
+
+  // app/javascript/controllers/helpers.js
+  var controllerNameFrom = (filename) => {
+    const pattern = /.*\/components\/((?:\w+\/)*)(\w+)_controller.js$/;
+    const controllerName = filename.replace(pattern, (_match, $1, $2) => {
+      const scope = $1.replaceAll("/", "--").replaceAll("_", "-");
+      const name = $2.replaceAll("_", "-");
+      return scope + name;
+    });
+    return controllerName;
+  };
+  var helpers_default = registerControllersFrom = (context) => {
+    const { default: componentControllers, filenames: filenames2 } = context;
+    for (let i = 0, len = componentControllers.length; i < len; i++) {
+      let componentController = componentControllers[i].default;
+      let filename = filenames2[i];
+      let name = controllerNameFrom(filename);
+      Stimulus.register(name, componentController);
+      console.log(name);
+    }
+  };
+
+  // app/javascript/controllers/application.js
+  var application = Application.start();
+  application.warnings = true;
+  application.debug = false;
+  window.Stimulus = application;
+  helpers_default((init_controller(), controller_exports));
+
+  // app/javascript/controllers/hello_controller.js
+  init_stimulus();
+  var hello_controller_default = class extends Controller {
+    connect() {
+      this.element.textContent = "Hello World!";
+    }
+  };
+
+  // app/javascript/controllers/index.js
+  application.register("hello", hello_controller_default);
+})();