{"version":3,"file":"gohire_entry.js","mappings":"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","sources":["webpack://onecowork/./node_modules/@hotwired/stimulus/dist/stimulus.js","webpack://onecowork/./app/javascript/gohire_entry.js","webpack://onecowork/./app/javascript/controllers/gohire_controller.js"],"sourcesContent":["/*\nStimulus 3.2.1\nCopyright © 2023 Basecamp, LLC\n */\nclass EventListener {\n    constructor(eventTarget, eventName, eventOptions) {\n        this.eventTarget = eventTarget;\n        this.eventName = eventName;\n        this.eventOptions = eventOptions;\n        this.unorderedBindings = new Set();\n    }\n    connect() {\n        this.eventTarget.addEventListener(this.eventName, this, this.eventOptions);\n    }\n    disconnect() {\n        this.eventTarget.removeEventListener(this.eventName, this, this.eventOptions);\n    }\n    bindingConnected(binding) {\n        this.unorderedBindings.add(binding);\n    }\n    bindingDisconnected(binding) {\n        this.unorderedBindings.delete(binding);\n    }\n    handleEvent(event) {\n        const extendedEvent = extendEvent(event);\n        for (const binding of this.bindings) {\n            if (extendedEvent.immediatePropagationStopped) {\n                break;\n            }\n            else {\n                binding.handleEvent(extendedEvent);\n            }\n        }\n    }\n    hasBindings() {\n        return this.unorderedBindings.size > 0;\n    }\n    get bindings() {\n        return Array.from(this.unorderedBindings).sort((left, right) => {\n            const leftIndex = left.index, rightIndex = right.index;\n            return leftIndex < rightIndex ? -1 : leftIndex > rightIndex ? 1 : 0;\n        });\n    }\n}\nfunction extendEvent(event) {\n    if (\"immediatePropagationStopped\" in event) {\n        return event;\n    }\n    else {\n        const { stopImmediatePropagation } = event;\n        return Object.assign(event, {\n            immediatePropagationStopped: false,\n            stopImmediatePropagation() {\n                this.immediatePropagationStopped = true;\n                stopImmediatePropagation.call(this);\n            },\n        });\n    }\n}\n\nclass Dispatcher {\n    constructor(application) {\n        this.application = application;\n        this.eventListenerMaps = new Map();\n        this.started = false;\n    }\n    start() {\n        if (!this.started) {\n            this.started = true;\n            this.eventListeners.forEach((eventListener) => eventListener.connect());\n        }\n    }\n    stop() {\n        if (this.started) {\n            this.started = false;\n            this.eventListeners.forEach((eventListener) => eventListener.disconnect());\n        }\n    }\n    get eventListeners() {\n        return Array.from(this.eventListenerMaps.values()).reduce((listeners, map) => listeners.concat(Array.from(map.values())), []);\n    }\n    bindingConnected(binding) {\n        this.fetchEventListenerForBinding(binding).bindingConnected(binding);\n    }\n    bindingDisconnected(binding, clearEventListeners = false) {\n        this.fetchEventListenerForBinding(binding).bindingDisconnected(binding);\n        if (clearEventListeners)\n            this.clearEventListenersForBinding(binding);\n    }\n    handleError(error, message, detail = {}) {\n        this.application.handleError(error, `Error ${message}`, detail);\n    }\n    clearEventListenersForBinding(binding) {\n        const eventListener = this.fetchEventListenerForBinding(binding);\n        if (!eventListener.hasBindings()) {\n            eventListener.disconnect();\n            this.removeMappedEventListenerFor(binding);\n        }\n    }\n    removeMappedEventListenerFor(binding) {\n        const { eventTarget, eventName, eventOptions } = binding;\n        const eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);\n        const cacheKey = this.cacheKey(eventName, eventOptions);\n        eventListenerMap.delete(cacheKey);\n        if (eventListenerMap.size == 0)\n            this.eventListenerMaps.delete(eventTarget);\n    }\n    fetchEventListenerForBinding(binding) {\n        const { eventTarget, eventName, eventOptions } = binding;\n        return this.fetchEventListener(eventTarget, eventName, eventOptions);\n    }\n    fetchEventListener(eventTarget, eventName, eventOptions) {\n        const eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);\n        const cacheKey = this.cacheKey(eventName, eventOptions);\n        let eventListener = eventListenerMap.get(cacheKey);\n        if (!eventListener) {\n            eventListener = this.createEventListener(eventTarget, eventName, eventOptions);\n            eventListenerMap.set(cacheKey, eventListener);\n        }\n        return eventListener;\n    }\n    createEventListener(eventTarget, eventName, eventOptions) {\n        const eventListener = new EventListener(eventTarget, eventName, eventOptions);\n        if (this.started) {\n            eventListener.connect();\n        }\n        return eventListener;\n    }\n    fetchEventListenerMapForEventTarget(eventTarget) {\n        let eventListenerMap = this.eventListenerMaps.get(eventTarget);\n        if (!eventListenerMap) {\n            eventListenerMap = new Map();\n            this.eventListenerMaps.set(eventTarget, eventListenerMap);\n        }\n        return eventListenerMap;\n    }\n    cacheKey(eventName, eventOptions) {\n        const parts = [eventName];\n        Object.keys(eventOptions)\n            .sort()\n            .forEach((key) => {\n            parts.push(`${eventOptions[key] ? \"\" : \"!\"}${key}`);\n        });\n        return parts.join(\":\");\n    }\n}\n\nconst defaultActionDescriptorFilters = {\n    stop({ event, value }) {\n        if (value)\n            event.stopPropagation();\n        return true;\n    },\n    prevent({ event, value }) {\n        if (value)\n            event.preventDefault();\n        return true;\n    },\n    self({ event, value, element }) {\n        if (value) {\n            return element === event.target;\n        }\n        else {\n            return true;\n        }\n    },\n};\nconst descriptorPattern = /^(?:(?:([^.]+?)\\+)?(.+?)(?:\\.(.+?))?(?:@(window|document))?->)?(.+?)(?:#([^:]+?))(?::(.+))?$/;\nfunction parseActionDescriptorString(descriptorString) {\n    const source = descriptorString.trim();\n    const matches = source.match(descriptorPattern) || [];\n    let eventName = matches[2];\n    let keyFilter = matches[3];\n    if (keyFilter && ![\"keydown\", \"keyup\", \"keypress\"].includes(eventName)) {\n        eventName += `.${keyFilter}`;\n        keyFilter = \"\";\n    }\n    return {\n        eventTarget: parseEventTarget(matches[4]),\n        eventName,\n        eventOptions: matches[7] ? parseEventOptions(matches[7]) : {},\n        identifier: matches[5],\n        methodName: matches[6],\n        keyFilter: matches[1] || keyFilter,\n    };\n}\nfunction parseEventTarget(eventTargetName) {\n    if (eventTargetName == \"window\") {\n        return window;\n    }\n    else if (eventTargetName == \"document\") {\n        return document;\n    }\n}\nfunction parseEventOptions(eventOptions) {\n    return eventOptions\n        .split(\":\")\n        .reduce((options, token) => Object.assign(options, { [token.replace(/^!/, \"\")]: !/^!/.test(token) }), {});\n}\nfunction stringifyEventTarget(eventTarget) {\n    if (eventTarget == window) {\n        return \"window\";\n    }\n    else if (eventTarget == document) {\n        return \"document\";\n    }\n}\n\nfunction camelize(value) {\n    return value.replace(/(?:[_-])([a-z0-9])/g, (_, char) => char.toUpperCase());\n}\nfunction namespaceCamelize(value) {\n    return camelize(value.replace(/--/g, \"-\").replace(/__/g, \"_\"));\n}\nfunction capitalize(value) {\n    return value.charAt(0).toUpperCase() + value.slice(1);\n}\nfunction dasherize(value) {\n    return value.replace(/([A-Z])/g, (_, char) => `-${char.toLowerCase()}`);\n}\nfunction tokenize(value) {\n    return value.match(/[^\\s]+/g) || [];\n}\n\nfunction isSomething(object) {\n    return object !== null && object !== undefined;\n}\nfunction hasProperty(object, property) {\n    return Object.prototype.hasOwnProperty.call(object, property);\n}\n\nconst allModifiers = [\"meta\", \"ctrl\", \"alt\", \"shift\"];\nclass Action {\n    constructor(element, index, descriptor, schema) {\n        this.element = element;\n        this.index = index;\n        this.eventTarget = descriptor.eventTarget || element;\n        this.eventName = descriptor.eventName || getDefaultEventNameForElement(element) || error(\"missing event name\");\n        this.eventOptions = descriptor.eventOptions || {};\n        this.identifier = descriptor.identifier || error(\"missing identifier\");\n        this.methodName = descriptor.methodName || error(\"missing method name\");\n        this.keyFilter = descriptor.keyFilter || \"\";\n        this.schema = schema;\n    }\n    static forToken(token, schema) {\n        return new this(token.element, token.index, parseActionDescriptorString(token.content), schema);\n    }\n    toString() {\n        const eventFilter = this.keyFilter ? `.${this.keyFilter}` : \"\";\n        const eventTarget = this.eventTargetName ? `@${this.eventTargetName}` : \"\";\n        return `${this.eventName}${eventFilter}${eventTarget}->${this.identifier}#${this.methodName}`;\n    }\n    shouldIgnoreKeyboardEvent(event) {\n        if (!this.keyFilter) {\n            return false;\n        }\n        const filters = this.keyFilter.split(\"+\");\n        if (this.keyFilterDissatisfied(event, filters)) {\n            return true;\n        }\n        const standardFilter = filters.filter((key) => !allModifiers.includes(key))[0];\n        if (!standardFilter) {\n            return false;\n        }\n        if (!hasProperty(this.keyMappings, standardFilter)) {\n            error(`contains unknown key filter: ${this.keyFilter}`);\n        }\n        return this.keyMappings[standardFilter].toLowerCase() !== event.key.toLowerCase();\n    }\n    shouldIgnoreMouseEvent(event) {\n        if (!this.keyFilter) {\n            return false;\n        }\n        const filters = [this.keyFilter];\n        if (this.keyFilterDissatisfied(event, filters)) {\n            return true;\n        }\n        return false;\n    }\n    get params() {\n        const params = {};\n        const pattern = new RegExp(`^data-${this.identifier}-(.+)-param$`, \"i\");\n        for (const { name, value } of Array.from(this.element.attributes)) {\n            const match = name.match(pattern);\n            const key = match && match[1];\n            if (key) {\n                params[camelize(key)] = typecast(value);\n            }\n        }\n        return params;\n    }\n    get eventTargetName() {\n        return stringifyEventTarget(this.eventTarget);\n    }\n    get keyMappings() {\n        return this.schema.keyMappings;\n    }\n    keyFilterDissatisfied(event, filters) {\n        const [meta, ctrl, alt, shift] = allModifiers.map((modifier) => filters.includes(modifier));\n        return event.metaKey !== meta || event.ctrlKey !== ctrl || event.altKey !== alt || event.shiftKey !== shift;\n    }\n}\nconst defaultEventNames = {\n    a: () => \"click\",\n    button: () => \"click\",\n    form: () => \"submit\",\n    details: () => \"toggle\",\n    input: (e) => (e.getAttribute(\"type\") == \"submit\" ? \"click\" : \"input\"),\n    select: () => \"change\",\n    textarea: () => \"input\",\n};\nfunction getDefaultEventNameForElement(element) {\n    const tagName = element.tagName.toLowerCase();\n    if (tagName in defaultEventNames) {\n        return defaultEventNames[tagName](element);\n    }\n}\nfunction error(message) {\n    throw new Error(message);\n}\nfunction typecast(value) {\n    try {\n        return JSON.parse(value);\n    }\n    catch (o_O) {\n        return value;\n    }\n}\n\nclass Binding {\n    constructor(context, action) {\n        this.context = context;\n        this.action = action;\n    }\n    get index() {\n        return this.action.index;\n    }\n    get eventTarget() {\n        return this.action.eventTarget;\n    }\n    get eventOptions() {\n        return this.action.eventOptions;\n    }\n    get identifier() {\n        return this.context.identifier;\n    }\n    handleEvent(event) {\n        const actionEvent = this.prepareActionEvent(event);\n        if (this.willBeInvokedByEvent(event) && this.applyEventModifiers(actionEvent)) {\n            this.invokeWithEvent(actionEvent);\n        }\n    }\n    get eventName() {\n        return this.action.eventName;\n    }\n    get method() {\n        const method = this.controller[this.methodName];\n        if (typeof method == \"function\") {\n            return method;\n        }\n        throw new Error(`Action \"${this.action}\" references undefined method \"${this.methodName}\"`);\n    }\n    applyEventModifiers(event) {\n        const { element } = this.action;\n        const { actionDescriptorFilters } = this.context.application;\n        const { controller } = this.context;\n        let passes = true;\n        for (const [name, value] of Object.entries(this.eventOptions)) {\n            if (name in actionDescriptorFilters) {\n                const filter = actionDescriptorFilters[name];\n                passes = passes && filter({ name, value, event, element, controller });\n            }\n            else {\n                continue;\n            }\n        }\n        return passes;\n    }\n    prepareActionEvent(event) {\n        return Object.assign(event, { params: this.action.params });\n    }\n    invokeWithEvent(event) {\n        const { target, currentTarget } = event;\n        try {\n            this.method.call(this.controller, event);\n            this.context.logDebugActivity(this.methodName, { event, target, currentTarget, action: this.methodName });\n        }\n        catch (error) {\n            const { identifier, controller, element, index } = this;\n            const detail = { identifier, controller, element, index, event };\n            this.context.handleError(error, `invoking action \"${this.action}\"`, detail);\n        }\n    }\n    willBeInvokedByEvent(event) {\n        const eventTarget = event.target;\n        if (event instanceof KeyboardEvent && this.action.shouldIgnoreKeyboardEvent(event)) {\n            return false;\n        }\n        if (event instanceof MouseEvent && this.action.shouldIgnoreMouseEvent(event)) {\n            return false;\n        }\n        if (this.element === eventTarget) {\n            return true;\n        }\n        else if (eventTarget instanceof Element && this.element.contains(eventTarget)) {\n            return this.scope.containsElement(eventTarget);\n        }\n        else {\n            return this.scope.containsElement(this.action.element);\n        }\n    }\n    get controller() {\n        return this.context.controller;\n    }\n    get methodName() {\n        return this.action.methodName;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get scope() {\n        return this.context.scope;\n    }\n}\n\nclass ElementObserver {\n    constructor(element, delegate) {\n        this.mutationObserverInit = { attributes: true, childList: true, subtree: true };\n        this.element = element;\n        this.started = false;\n        this.delegate = delegate;\n        this.elements = new Set();\n        this.mutationObserver = new MutationObserver((mutations) => this.processMutations(mutations));\n    }\n    start() {\n        if (!this.started) {\n            this.started = true;\n            this.mutationObserver.observe(this.element, this.mutationObserverInit);\n            this.refresh();\n        }\n    }\n    pause(callback) {\n        if (this.started) {\n            this.mutationObserver.disconnect();\n            this.started = false;\n        }\n        callback();\n        if (!this.started) {\n            this.mutationObserver.observe(this.element, this.mutationObserverInit);\n            this.started = true;\n        }\n    }\n    stop() {\n        if (this.started) {\n            this.mutationObserver.takeRecords();\n            this.mutationObserver.disconnect();\n            this.started = false;\n        }\n    }\n    refresh() {\n        if (this.started) {\n            const matches = new Set(this.matchElementsInTree());\n            for (const element of Array.from(this.elements)) {\n                if (!matches.has(element)) {\n                    this.removeElement(element);\n                }\n            }\n            for (const element of Array.from(matches)) {\n                this.addElement(element);\n            }\n        }\n    }\n    processMutations(mutations) {\n        if (this.started) {\n            for (const mutation of mutations) {\n                this.processMutation(mutation);\n            }\n        }\n    }\n    processMutation(mutation) {\n        if (mutation.type == \"attributes\") {\n            this.processAttributeChange(mutation.target, mutation.attributeName);\n        }\n        else if (mutation.type == \"childList\") {\n            this.processRemovedNodes(mutation.removedNodes);\n            this.processAddedNodes(mutation.addedNodes);\n        }\n    }\n    processAttributeChange(element, attributeName) {\n        if (this.elements.has(element)) {\n            if (this.delegate.elementAttributeChanged && this.matchElement(element)) {\n                this.delegate.elementAttributeChanged(element, attributeName);\n            }\n            else {\n                this.removeElement(element);\n            }\n        }\n        else if (this.matchElement(element)) {\n            this.addElement(element);\n        }\n    }\n    processRemovedNodes(nodes) {\n        for (const node of Array.from(nodes)) {\n            const element = this.elementFromNode(node);\n            if (element) {\n                this.processTree(element, this.removeElement);\n            }\n        }\n    }\n    processAddedNodes(nodes) {\n        for (const node of Array.from(nodes)) {\n            const element = this.elementFromNode(node);\n            if (element && this.elementIsActive(element)) {\n                this.processTree(element, this.addElement);\n            }\n        }\n    }\n    matchElement(element) {\n        return this.delegate.matchElement(element);\n    }\n    matchElementsInTree(tree = this.element) {\n        return this.delegate.matchElementsInTree(tree);\n    }\n    processTree(tree, processor) {\n        for (const element of this.matchElementsInTree(tree)) {\n            processor.call(this, element);\n        }\n    }\n    elementFromNode(node) {\n        if (node.nodeType == Node.ELEMENT_NODE) {\n            return node;\n        }\n    }\n    elementIsActive(element) {\n        if (element.isConnected != this.element.isConnected) {\n            return false;\n        }\n        else {\n            return this.element.contains(element);\n        }\n    }\n    addElement(element) {\n        if (!this.elements.has(element)) {\n            if (this.elementIsActive(element)) {\n                this.elements.add(element);\n                if (this.delegate.elementMatched) {\n                    this.delegate.elementMatched(element);\n                }\n            }\n        }\n    }\n    removeElement(element) {\n        if (this.elements.has(element)) {\n            this.elements.delete(element);\n            if (this.delegate.elementUnmatched) {\n                this.delegate.elementUnmatched(element);\n            }\n        }\n    }\n}\n\nclass AttributeObserver {\n    constructor(element, attributeName, delegate) {\n        this.attributeName = attributeName;\n        this.delegate = delegate;\n        this.elementObserver = new ElementObserver(element, this);\n    }\n    get element() {\n        return this.elementObserver.element;\n    }\n    get selector() {\n        return `[${this.attributeName}]`;\n    }\n    start() {\n        this.elementObserver.start();\n    }\n    pause(callback) {\n        this.elementObserver.pause(callback);\n    }\n    stop() {\n        this.elementObserver.stop();\n    }\n    refresh() {\n        this.elementObserver.refresh();\n    }\n    get started() {\n        return this.elementObserver.started;\n    }\n    matchElement(element) {\n        return element.hasAttribute(this.attributeName);\n    }\n    matchElementsInTree(tree) {\n        const match = this.matchElement(tree) ? [tree] : [];\n        const matches = Array.from(tree.querySelectorAll(this.selector));\n        return match.concat(matches);\n    }\n    elementMatched(element) {\n        if (this.delegate.elementMatchedAttribute) {\n            this.delegate.elementMatchedAttribute(element, this.attributeName);\n        }\n    }\n    elementUnmatched(element) {\n        if (this.delegate.elementUnmatchedAttribute) {\n            this.delegate.elementUnmatchedAttribute(element, this.attributeName);\n        }\n    }\n    elementAttributeChanged(element, attributeName) {\n        if (this.delegate.elementAttributeValueChanged && this.attributeName == attributeName) {\n            this.delegate.elementAttributeValueChanged(element, attributeName);\n        }\n    }\n}\n\nfunction add(map, key, value) {\n    fetch(map, key).add(value);\n}\nfunction del(map, key, value) {\n    fetch(map, key).delete(value);\n    prune(map, key);\n}\nfunction fetch(map, key) {\n    let values = map.get(key);\n    if (!values) {\n        values = new Set();\n        map.set(key, values);\n    }\n    return values;\n}\nfunction prune(map, key) {\n    const values = map.get(key);\n    if (values != null && values.size == 0) {\n        map.delete(key);\n    }\n}\n\nclass Multimap {\n    constructor() {\n        this.valuesByKey = new Map();\n    }\n    get keys() {\n        return Array.from(this.valuesByKey.keys());\n    }\n    get values() {\n        const sets = Array.from(this.valuesByKey.values());\n        return sets.reduce((values, set) => values.concat(Array.from(set)), []);\n    }\n    get size() {\n        const sets = Array.from(this.valuesByKey.values());\n        return sets.reduce((size, set) => size + set.size, 0);\n    }\n    add(key, value) {\n        add(this.valuesByKey, key, value);\n    }\n    delete(key, value) {\n        del(this.valuesByKey, key, value);\n    }\n    has(key, value) {\n        const values = this.valuesByKey.get(key);\n        return values != null && values.has(value);\n    }\n    hasKey(key) {\n        return this.valuesByKey.has(key);\n    }\n    hasValue(value) {\n        const sets = Array.from(this.valuesByKey.values());\n        return sets.some((set) => set.has(value));\n    }\n    getValuesForKey(key) {\n        const values = this.valuesByKey.get(key);\n        return values ? Array.from(values) : [];\n    }\n    getKeysForValue(value) {\n        return Array.from(this.valuesByKey)\n            .filter(([_key, values]) => values.has(value))\n            .map(([key, _values]) => key);\n    }\n}\n\nclass IndexedMultimap extends Multimap {\n    constructor() {\n        super();\n        this.keysByValue = new Map();\n    }\n    get values() {\n        return Array.from(this.keysByValue.keys());\n    }\n    add(key, value) {\n        super.add(key, value);\n        add(this.keysByValue, value, key);\n    }\n    delete(key, value) {\n        super.delete(key, value);\n        del(this.keysByValue, value, key);\n    }\n    hasValue(value) {\n        return this.keysByValue.has(value);\n    }\n    getKeysForValue(value) {\n        const set = this.keysByValue.get(value);\n        return set ? Array.from(set) : [];\n    }\n}\n\nclass SelectorObserver {\n    constructor(element, selector, delegate, details) {\n        this._selector = selector;\n        this.details = details;\n        this.elementObserver = new ElementObserver(element, this);\n        this.delegate = delegate;\n        this.matchesByElement = new Multimap();\n    }\n    get started() {\n        return this.elementObserver.started;\n    }\n    get selector() {\n        return this._selector;\n    }\n    set selector(selector) {\n        this._selector = selector;\n        this.refresh();\n    }\n    start() {\n        this.elementObserver.start();\n    }\n    pause(callback) {\n        this.elementObserver.pause(callback);\n    }\n    stop() {\n        this.elementObserver.stop();\n    }\n    refresh() {\n        this.elementObserver.refresh();\n    }\n    get element() {\n        return this.elementObserver.element;\n    }\n    matchElement(element) {\n        const { selector } = this;\n        if (selector) {\n            const matches = element.matches(selector);\n            if (this.delegate.selectorMatchElement) {\n                return matches && this.delegate.selectorMatchElement(element, this.details);\n            }\n            return matches;\n        }\n        else {\n            return false;\n        }\n    }\n    matchElementsInTree(tree) {\n        const { selector } = this;\n        if (selector) {\n            const match = this.matchElement(tree) ? [tree] : [];\n            const matches = Array.from(tree.querySelectorAll(selector)).filter((match) => this.matchElement(match));\n            return match.concat(matches);\n        }\n        else {\n            return [];\n        }\n    }\n    elementMatched(element) {\n        const { selector } = this;\n        if (selector) {\n            this.selectorMatched(element, selector);\n        }\n    }\n    elementUnmatched(element) {\n        const selectors = this.matchesByElement.getKeysForValue(element);\n        for (const selector of selectors) {\n            this.selectorUnmatched(element, selector);\n        }\n    }\n    elementAttributeChanged(element, _attributeName) {\n        const { selector } = this;\n        if (selector) {\n            const matches = this.matchElement(element);\n            const matchedBefore = this.matchesByElement.has(selector, element);\n            if (matches && !matchedBefore) {\n                this.selectorMatched(element, selector);\n            }\n            else if (!matches && matchedBefore) {\n                this.selectorUnmatched(element, selector);\n            }\n        }\n    }\n    selectorMatched(element, selector) {\n        this.delegate.selectorMatched(element, selector, this.details);\n        this.matchesByElement.add(selector, element);\n    }\n    selectorUnmatched(element, selector) {\n        this.delegate.selectorUnmatched(element, selector, this.details);\n        this.matchesByElement.delete(selector, element);\n    }\n}\n\nclass StringMapObserver {\n    constructor(element, delegate) {\n        this.element = element;\n        this.delegate = delegate;\n        this.started = false;\n        this.stringMap = new Map();\n        this.mutationObserver = new MutationObserver((mutations) => this.processMutations(mutations));\n    }\n    start() {\n        if (!this.started) {\n            this.started = true;\n            this.mutationObserver.observe(this.element, { attributes: true, attributeOldValue: true });\n            this.refresh();\n        }\n    }\n    stop() {\n        if (this.started) {\n            this.mutationObserver.takeRecords();\n            this.mutationObserver.disconnect();\n            this.started = false;\n        }\n    }\n    refresh() {\n        if (this.started) {\n            for (const attributeName of this.knownAttributeNames) {\n                this.refreshAttribute(attributeName, null);\n            }\n        }\n    }\n    processMutations(mutations) {\n        if (this.started) {\n            for (const mutation of mutations) {\n                this.processMutation(mutation);\n            }\n        }\n    }\n    processMutation(mutation) {\n        const attributeName = mutation.attributeName;\n        if (attributeName) {\n            this.refreshAttribute(attributeName, mutation.oldValue);\n        }\n    }\n    refreshAttribute(attributeName, oldValue) {\n        const key = this.delegate.getStringMapKeyForAttribute(attributeName);\n        if (key != null) {\n            if (!this.stringMap.has(attributeName)) {\n                this.stringMapKeyAdded(key, attributeName);\n            }\n            const value = this.element.getAttribute(attributeName);\n            if (this.stringMap.get(attributeName) != value) {\n                this.stringMapValueChanged(value, key, oldValue);\n            }\n            if (value == null) {\n                const oldValue = this.stringMap.get(attributeName);\n                this.stringMap.delete(attributeName);\n                if (oldValue)\n                    this.stringMapKeyRemoved(key, attributeName, oldValue);\n            }\n            else {\n                this.stringMap.set(attributeName, value);\n            }\n        }\n    }\n    stringMapKeyAdded(key, attributeName) {\n        if (this.delegate.stringMapKeyAdded) {\n            this.delegate.stringMapKeyAdded(key, attributeName);\n        }\n    }\n    stringMapValueChanged(value, key, oldValue) {\n        if (this.delegate.stringMapValueChanged) {\n            this.delegate.stringMapValueChanged(value, key, oldValue);\n        }\n    }\n    stringMapKeyRemoved(key, attributeName, oldValue) {\n        if (this.delegate.stringMapKeyRemoved) {\n            this.delegate.stringMapKeyRemoved(key, attributeName, oldValue);\n        }\n    }\n    get knownAttributeNames() {\n        return Array.from(new Set(this.currentAttributeNames.concat(this.recordedAttributeNames)));\n    }\n    get currentAttributeNames() {\n        return Array.from(this.element.attributes).map((attribute) => attribute.name);\n    }\n    get recordedAttributeNames() {\n        return Array.from(this.stringMap.keys());\n    }\n}\n\nclass TokenListObserver {\n    constructor(element, attributeName, delegate) {\n        this.attributeObserver = new AttributeObserver(element, attributeName, this);\n        this.delegate = delegate;\n        this.tokensByElement = new Multimap();\n    }\n    get started() {\n        return this.attributeObserver.started;\n    }\n    start() {\n        this.attributeObserver.start();\n    }\n    pause(callback) {\n        this.attributeObserver.pause(callback);\n    }\n    stop() {\n        this.attributeObserver.stop();\n    }\n    refresh() {\n        this.attributeObserver.refresh();\n    }\n    get element() {\n        return this.attributeObserver.element;\n    }\n    get attributeName() {\n        return this.attributeObserver.attributeName;\n    }\n    elementMatchedAttribute(element) {\n        this.tokensMatched(this.readTokensForElement(element));\n    }\n    elementAttributeValueChanged(element) {\n        const [unmatchedTokens, matchedTokens] = this.refreshTokensForElement(element);\n        this.tokensUnmatched(unmatchedTokens);\n        this.tokensMatched(matchedTokens);\n    }\n    elementUnmatchedAttribute(element) {\n        this.tokensUnmatched(this.tokensByElement.getValuesForKey(element));\n    }\n    tokensMatched(tokens) {\n        tokens.forEach((token) => this.tokenMatched(token));\n    }\n    tokensUnmatched(tokens) {\n        tokens.forEach((token) => this.tokenUnmatched(token));\n    }\n    tokenMatched(token) {\n        this.delegate.tokenMatched(token);\n        this.tokensByElement.add(token.element, token);\n    }\n    tokenUnmatched(token) {\n        this.delegate.tokenUnmatched(token);\n        this.tokensByElement.delete(token.element, token);\n    }\n    refreshTokensForElement(element) {\n        const previousTokens = this.tokensByElement.getValuesForKey(element);\n        const currentTokens = this.readTokensForElement(element);\n        const firstDifferingIndex = zip(previousTokens, currentTokens).findIndex(([previousToken, currentToken]) => !tokensAreEqual(previousToken, currentToken));\n        if (firstDifferingIndex == -1) {\n            return [[], []];\n        }\n        else {\n            return [previousTokens.slice(firstDifferingIndex), currentTokens.slice(firstDifferingIndex)];\n        }\n    }\n    readTokensForElement(element) {\n        const attributeName = this.attributeName;\n        const tokenString = element.getAttribute(attributeName) || \"\";\n        return parseTokenString(tokenString, element, attributeName);\n    }\n}\nfunction parseTokenString(tokenString, element, attributeName) {\n    return tokenString\n        .trim()\n        .split(/\\s+/)\n        .filter((content) => content.length)\n        .map((content, index) => ({ element, attributeName, content, index }));\n}\nfunction zip(left, right) {\n    const length = Math.max(left.length, right.length);\n    return Array.from({ length }, (_, index) => [left[index], right[index]]);\n}\nfunction tokensAreEqual(left, right) {\n    return left && right && left.index == right.index && left.content == right.content;\n}\n\nclass ValueListObserver {\n    constructor(element, attributeName, delegate) {\n        this.tokenListObserver = new TokenListObserver(element, attributeName, this);\n        this.delegate = delegate;\n        this.parseResultsByToken = new WeakMap();\n        this.valuesByTokenByElement = new WeakMap();\n    }\n    get started() {\n        return this.tokenListObserver.started;\n    }\n    start() {\n        this.tokenListObserver.start();\n    }\n    stop() {\n        this.tokenListObserver.stop();\n    }\n    refresh() {\n        this.tokenListObserver.refresh();\n    }\n    get element() {\n        return this.tokenListObserver.element;\n    }\n    get attributeName() {\n        return this.tokenListObserver.attributeName;\n    }\n    tokenMatched(token) {\n        const { element } = token;\n        const { value } = this.fetchParseResultForToken(token);\n        if (value) {\n            this.fetchValuesByTokenForElement(element).set(token, value);\n            this.delegate.elementMatchedValue(element, value);\n        }\n    }\n    tokenUnmatched(token) {\n        const { element } = token;\n        const { value } = this.fetchParseResultForToken(token);\n        if (value) {\n            this.fetchValuesByTokenForElement(element).delete(token);\n            this.delegate.elementUnmatchedValue(element, value);\n        }\n    }\n    fetchParseResultForToken(token) {\n        let parseResult = this.parseResultsByToken.get(token);\n        if (!parseResult) {\n            parseResult = this.parseToken(token);\n            this.parseResultsByToken.set(token, parseResult);\n        }\n        return parseResult;\n    }\n    fetchValuesByTokenForElement(element) {\n        let valuesByToken = this.valuesByTokenByElement.get(element);\n        if (!valuesByToken) {\n            valuesByToken = new Map();\n            this.valuesByTokenByElement.set(element, valuesByToken);\n        }\n        return valuesByToken;\n    }\n    parseToken(token) {\n        try {\n            const value = this.delegate.parseValueForToken(token);\n            return { value };\n        }\n        catch (error) {\n            return { error };\n        }\n    }\n}\n\nclass BindingObserver {\n    constructor(context, delegate) {\n        this.context = context;\n        this.delegate = delegate;\n        this.bindingsByAction = new Map();\n    }\n    start() {\n        if (!this.valueListObserver) {\n            this.valueListObserver = new ValueListObserver(this.element, this.actionAttribute, this);\n            this.valueListObserver.start();\n        }\n    }\n    stop() {\n        if (this.valueListObserver) {\n            this.valueListObserver.stop();\n            delete this.valueListObserver;\n            this.disconnectAllActions();\n        }\n    }\n    get element() {\n        return this.context.element;\n    }\n    get identifier() {\n        return this.context.identifier;\n    }\n    get actionAttribute() {\n        return this.schema.actionAttribute;\n    }\n    get schema() {\n        return this.context.schema;\n    }\n    get bindings() {\n        return Array.from(this.bindingsByAction.values());\n    }\n    connectAction(action) {\n        const binding = new Binding(this.context, action);\n        this.bindingsByAction.set(action, binding);\n        this.delegate.bindingConnected(binding);\n    }\n    disconnectAction(action) {\n        const binding = this.bindingsByAction.get(action);\n        if (binding) {\n            this.bindingsByAction.delete(action);\n            this.delegate.bindingDisconnected(binding);\n        }\n    }\n    disconnectAllActions() {\n        this.bindings.forEach((binding) => this.delegate.bindingDisconnected(binding, true));\n        this.bindingsByAction.clear();\n    }\n    parseValueForToken(token) {\n        const action = Action.forToken(token, this.schema);\n        if (action.identifier == this.identifier) {\n            return action;\n        }\n    }\n    elementMatchedValue(element, action) {\n        this.connectAction(action);\n    }\n    elementUnmatchedValue(element, action) {\n        this.disconnectAction(action);\n    }\n}\n\nclass ValueObserver {\n    constructor(context, receiver) {\n        this.context = context;\n        this.receiver = receiver;\n        this.stringMapObserver = new StringMapObserver(this.element, this);\n        this.valueDescriptorMap = this.controller.valueDescriptorMap;\n    }\n    start() {\n        this.stringMapObserver.start();\n        this.invokeChangedCallbacksForDefaultValues();\n    }\n    stop() {\n        this.stringMapObserver.stop();\n    }\n    get element() {\n        return this.context.element;\n    }\n    get controller() {\n        return this.context.controller;\n    }\n    getStringMapKeyForAttribute(attributeName) {\n        if (attributeName in this.valueDescriptorMap) {\n            return this.valueDescriptorMap[attributeName].name;\n        }\n    }\n    stringMapKeyAdded(key, attributeName) {\n        const descriptor = this.valueDescriptorMap[attributeName];\n        if (!this.hasValue(key)) {\n            this.invokeChangedCallback(key, descriptor.writer(this.receiver[key]), descriptor.writer(descriptor.defaultValue));\n        }\n    }\n    stringMapValueChanged(value, name, oldValue) {\n        const descriptor = this.valueDescriptorNameMap[name];\n        if (value === null)\n            return;\n        if (oldValue === null) {\n            oldValue = descriptor.writer(descriptor.defaultValue);\n        }\n        this.invokeChangedCallback(name, value, oldValue);\n    }\n    stringMapKeyRemoved(key, attributeName, oldValue) {\n        const descriptor = this.valueDescriptorNameMap[key];\n        if (this.hasValue(key)) {\n            this.invokeChangedCallback(key, descriptor.writer(this.receiver[key]), oldValue);\n        }\n        else {\n            this.invokeChangedCallback(key, descriptor.writer(descriptor.defaultValue), oldValue);\n        }\n    }\n    invokeChangedCallbacksForDefaultValues() {\n        for (const { key, name, defaultValue, writer } of this.valueDescriptors) {\n            if (defaultValue != undefined && !this.controller.data.has(key)) {\n                this.invokeChangedCallback(name, writer(defaultValue), undefined);\n            }\n        }\n    }\n    invokeChangedCallback(name, rawValue, rawOldValue) {\n        const changedMethodName = `${name}Changed`;\n        const changedMethod = this.receiver[changedMethodName];\n        if (typeof changedMethod == \"function\") {\n            const descriptor = this.valueDescriptorNameMap[name];\n            try {\n                const value = descriptor.reader(rawValue);\n                let oldValue = rawOldValue;\n                if (rawOldValue) {\n                    oldValue = descriptor.reader(rawOldValue);\n                }\n                changedMethod.call(this.receiver, value, oldValue);\n            }\n            catch (error) {\n                if (error instanceof TypeError) {\n                    error.message = `Stimulus Value \"${this.context.identifier}.${descriptor.name}\" - ${error.message}`;\n                }\n                throw error;\n            }\n        }\n    }\n    get valueDescriptors() {\n        const { valueDescriptorMap } = this;\n        return Object.keys(valueDescriptorMap).map((key) => valueDescriptorMap[key]);\n    }\n    get valueDescriptorNameMap() {\n        const descriptors = {};\n        Object.keys(this.valueDescriptorMap).forEach((key) => {\n            const descriptor = this.valueDescriptorMap[key];\n            descriptors[descriptor.name] = descriptor;\n        });\n        return descriptors;\n    }\n    hasValue(attributeName) {\n        const descriptor = this.valueDescriptorNameMap[attributeName];\n        const hasMethodName = `has${capitalize(descriptor.name)}`;\n        return this.receiver[hasMethodName];\n    }\n}\n\nclass TargetObserver {\n    constructor(context, delegate) {\n        this.context = context;\n        this.delegate = delegate;\n        this.targetsByName = new Multimap();\n    }\n    start() {\n        if (!this.tokenListObserver) {\n            this.tokenListObserver = new TokenListObserver(this.element, this.attributeName, this);\n            this.tokenListObserver.start();\n        }\n    }\n    stop() {\n        if (this.tokenListObserver) {\n            this.disconnectAllTargets();\n            this.tokenListObserver.stop();\n            delete this.tokenListObserver;\n        }\n    }\n    tokenMatched({ element, content: name }) {\n        if (this.scope.containsElement(element)) {\n            this.connectTarget(element, name);\n        }\n    }\n    tokenUnmatched({ element, content: name }) {\n        this.disconnectTarget(element, name);\n    }\n    connectTarget(element, name) {\n        var _a;\n        if (!this.targetsByName.has(name, element)) {\n            this.targetsByName.add(name, element);\n            (_a = this.tokenListObserver) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.targetConnected(element, name));\n        }\n    }\n    disconnectTarget(element, name) {\n        var _a;\n        if (this.targetsByName.has(name, element)) {\n            this.targetsByName.delete(name, element);\n            (_a = this.tokenListObserver) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.targetDisconnected(element, name));\n        }\n    }\n    disconnectAllTargets() {\n        for (const name of this.targetsByName.keys) {\n            for (const element of this.targetsByName.getValuesForKey(name)) {\n                this.disconnectTarget(element, name);\n            }\n        }\n    }\n    get attributeName() {\n        return `data-${this.context.identifier}-target`;\n    }\n    get element() {\n        return this.context.element;\n    }\n    get scope() {\n        return this.context.scope;\n    }\n}\n\nfunction readInheritableStaticArrayValues(constructor, propertyName) {\n    const ancestors = getAncestorsForConstructor(constructor);\n    return Array.from(ancestors.reduce((values, constructor) => {\n        getOwnStaticArrayValues(constructor, propertyName).forEach((name) => values.add(name));\n        return values;\n    }, new Set()));\n}\nfunction readInheritableStaticObjectPairs(constructor, propertyName) {\n    const ancestors = getAncestorsForConstructor(constructor);\n    return ancestors.reduce((pairs, constructor) => {\n        pairs.push(...getOwnStaticObjectPairs(constructor, propertyName));\n        return pairs;\n    }, []);\n}\nfunction getAncestorsForConstructor(constructor) {\n    const ancestors = [];\n    while (constructor) {\n        ancestors.push(constructor);\n        constructor = Object.getPrototypeOf(constructor);\n    }\n    return ancestors.reverse();\n}\nfunction getOwnStaticArrayValues(constructor, propertyName) {\n    const definition = constructor[propertyName];\n    return Array.isArray(definition) ? definition : [];\n}\nfunction getOwnStaticObjectPairs(constructor, propertyName) {\n    const definition = constructor[propertyName];\n    return definition ? Object.keys(definition).map((key) => [key, definition[key]]) : [];\n}\n\nclass OutletObserver {\n    constructor(context, delegate) {\n        this.started = false;\n        this.context = context;\n        this.delegate = delegate;\n        this.outletsByName = new Multimap();\n        this.outletElementsByName = new Multimap();\n        this.selectorObserverMap = new Map();\n        this.attributeObserverMap = new Map();\n    }\n    start() {\n        if (!this.started) {\n            this.outletDefinitions.forEach((outletName) => {\n                this.setupSelectorObserverForOutlet(outletName);\n                this.setupAttributeObserverForOutlet(outletName);\n            });\n            this.started = true;\n            this.dependentContexts.forEach((context) => context.refresh());\n        }\n    }\n    refresh() {\n        this.selectorObserverMap.forEach((observer) => observer.refresh());\n        this.attributeObserverMap.forEach((observer) => observer.refresh());\n    }\n    stop() {\n        if (this.started) {\n            this.started = false;\n            this.disconnectAllOutlets();\n            this.stopSelectorObservers();\n            this.stopAttributeObservers();\n        }\n    }\n    stopSelectorObservers() {\n        if (this.selectorObserverMap.size > 0) {\n            this.selectorObserverMap.forEach((observer) => observer.stop());\n            this.selectorObserverMap.clear();\n        }\n    }\n    stopAttributeObservers() {\n        if (this.attributeObserverMap.size > 0) {\n            this.attributeObserverMap.forEach((observer) => observer.stop());\n            this.attributeObserverMap.clear();\n        }\n    }\n    selectorMatched(element, _selector, { outletName }) {\n        const outlet = this.getOutlet(element, outletName);\n        if (outlet) {\n            this.connectOutlet(outlet, element, outletName);\n        }\n    }\n    selectorUnmatched(element, _selector, { outletName }) {\n        const outlet = this.getOutletFromMap(element, outletName);\n        if (outlet) {\n            this.disconnectOutlet(outlet, element, outletName);\n        }\n    }\n    selectorMatchElement(element, { outletName }) {\n        const selector = this.selector(outletName);\n        const hasOutlet = this.hasOutlet(element, outletName);\n        const hasOutletController = element.matches(`[${this.schema.controllerAttribute}~=${outletName}]`);\n        if (selector) {\n            return hasOutlet && hasOutletController && element.matches(selector);\n        }\n        else {\n            return false;\n        }\n    }\n    elementMatchedAttribute(_element, attributeName) {\n        const outletName = this.getOutletNameFromOutletAttributeName(attributeName);\n        if (outletName) {\n            this.updateSelectorObserverForOutlet(outletName);\n        }\n    }\n    elementAttributeValueChanged(_element, attributeName) {\n        const outletName = this.getOutletNameFromOutletAttributeName(attributeName);\n        if (outletName) {\n            this.updateSelectorObserverForOutlet(outletName);\n        }\n    }\n    elementUnmatchedAttribute(_element, attributeName) {\n        const outletName = this.getOutletNameFromOutletAttributeName(attributeName);\n        if (outletName) {\n            this.updateSelectorObserverForOutlet(outletName);\n        }\n    }\n    connectOutlet(outlet, element, outletName) {\n        var _a;\n        if (!this.outletElementsByName.has(outletName, element)) {\n            this.outletsByName.add(outletName, outlet);\n            this.outletElementsByName.add(outletName, element);\n            (_a = this.selectorObserverMap.get(outletName)) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.outletConnected(outlet, element, outletName));\n        }\n    }\n    disconnectOutlet(outlet, element, outletName) {\n        var _a;\n        if (this.outletElementsByName.has(outletName, element)) {\n            this.outletsByName.delete(outletName, outlet);\n            this.outletElementsByName.delete(outletName, element);\n            (_a = this.selectorObserverMap\n                .get(outletName)) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.outletDisconnected(outlet, element, outletName));\n        }\n    }\n    disconnectAllOutlets() {\n        for (const outletName of this.outletElementsByName.keys) {\n            for (const element of this.outletElementsByName.getValuesForKey(outletName)) {\n                for (const outlet of this.outletsByName.getValuesForKey(outletName)) {\n                    this.disconnectOutlet(outlet, element, outletName);\n                }\n            }\n        }\n    }\n    updateSelectorObserverForOutlet(outletName) {\n        const observer = this.selectorObserverMap.get(outletName);\n        if (observer) {\n            observer.selector = this.selector(outletName);\n        }\n    }\n    setupSelectorObserverForOutlet(outletName) {\n        const selector = this.selector(outletName);\n        const selectorObserver = new SelectorObserver(document.body, selector, this, { outletName });\n        this.selectorObserverMap.set(outletName, selectorObserver);\n        selectorObserver.start();\n    }\n    setupAttributeObserverForOutlet(outletName) {\n        const attributeName = this.attributeNameForOutletName(outletName);\n        const attributeObserver = new AttributeObserver(this.scope.element, attributeName, this);\n        this.attributeObserverMap.set(outletName, attributeObserver);\n        attributeObserver.start();\n    }\n    selector(outletName) {\n        return this.scope.outlets.getSelectorForOutletName(outletName);\n    }\n    attributeNameForOutletName(outletName) {\n        return this.scope.schema.outletAttributeForScope(this.identifier, outletName);\n    }\n    getOutletNameFromOutletAttributeName(attributeName) {\n        return this.outletDefinitions.find((outletName) => this.attributeNameForOutletName(outletName) === attributeName);\n    }\n    get outletDependencies() {\n        const dependencies = new Multimap();\n        this.router.modules.forEach((module) => {\n            const constructor = module.definition.controllerConstructor;\n            const outlets = readInheritableStaticArrayValues(constructor, \"outlets\");\n            outlets.forEach((outlet) => dependencies.add(outlet, module.identifier));\n        });\n        return dependencies;\n    }\n    get outletDefinitions() {\n        return this.outletDependencies.getKeysForValue(this.identifier);\n    }\n    get dependentControllerIdentifiers() {\n        return this.outletDependencies.getValuesForKey(this.identifier);\n    }\n    get dependentContexts() {\n        const identifiers = this.dependentControllerIdentifiers;\n        return this.router.contexts.filter((context) => identifiers.includes(context.identifier));\n    }\n    hasOutlet(element, outletName) {\n        return !!this.getOutlet(element, outletName) || !!this.getOutletFromMap(element, outletName);\n    }\n    getOutlet(element, outletName) {\n        return this.application.getControllerForElementAndIdentifier(element, outletName);\n    }\n    getOutletFromMap(element, outletName) {\n        return this.outletsByName.getValuesForKey(outletName).find((outlet) => outlet.element === element);\n    }\n    get scope() {\n        return this.context.scope;\n    }\n    get schema() {\n        return this.context.schema;\n    }\n    get identifier() {\n        return this.context.identifier;\n    }\n    get application() {\n        return this.context.application;\n    }\n    get router() {\n        return this.application.router;\n    }\n}\n\nclass Context {\n    constructor(module, scope) {\n        this.logDebugActivity = (functionName, detail = {}) => {\n            const { identifier, controller, element } = this;\n            detail = Object.assign({ identifier, controller, element }, detail);\n            this.application.logDebugActivity(this.identifier, functionName, detail);\n        };\n        this.module = module;\n        this.scope = scope;\n        this.controller = new module.controllerConstructor(this);\n        this.bindingObserver = new BindingObserver(this, this.dispatcher);\n        this.valueObserver = new ValueObserver(this, this.controller);\n        this.targetObserver = new TargetObserver(this, this);\n        this.outletObserver = new OutletObserver(this, this);\n        try {\n            this.controller.initialize();\n            this.logDebugActivity(\"initialize\");\n        }\n        catch (error) {\n            this.handleError(error, \"initializing controller\");\n        }\n    }\n    connect() {\n        this.bindingObserver.start();\n        this.valueObserver.start();\n        this.targetObserver.start();\n        this.outletObserver.start();\n        try {\n            this.controller.connect();\n            this.logDebugActivity(\"connect\");\n        }\n        catch (error) {\n            this.handleError(error, \"connecting controller\");\n        }\n    }\n    refresh() {\n        this.outletObserver.refresh();\n    }\n    disconnect() {\n        try {\n            this.controller.disconnect();\n            this.logDebugActivity(\"disconnect\");\n        }\n        catch (error) {\n            this.handleError(error, \"disconnecting controller\");\n        }\n        this.outletObserver.stop();\n        this.targetObserver.stop();\n        this.valueObserver.stop();\n        this.bindingObserver.stop();\n    }\n    get application() {\n        return this.module.application;\n    }\n    get identifier() {\n        return this.module.identifier;\n    }\n    get schema() {\n        return this.application.schema;\n    }\n    get dispatcher() {\n        return this.application.dispatcher;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get parentElement() {\n        return this.element.parentElement;\n    }\n    handleError(error, message, detail = {}) {\n        const { identifier, controller, element } = this;\n        detail = Object.assign({ identifier, controller, element }, detail);\n        this.application.handleError(error, `Error ${message}`, detail);\n    }\n    targetConnected(element, name) {\n        this.invokeControllerMethod(`${name}TargetConnected`, element);\n    }\n    targetDisconnected(element, name) {\n        this.invokeControllerMethod(`${name}TargetDisconnected`, element);\n    }\n    outletConnected(outlet, element, name) {\n        this.invokeControllerMethod(`${namespaceCamelize(name)}OutletConnected`, outlet, element);\n    }\n    outletDisconnected(outlet, element, name) {\n        this.invokeControllerMethod(`${namespaceCamelize(name)}OutletDisconnected`, outlet, element);\n    }\n    invokeControllerMethod(methodName, ...args) {\n        const controller = this.controller;\n        if (typeof controller[methodName] == \"function\") {\n            controller[methodName](...args);\n        }\n    }\n}\n\nfunction bless(constructor) {\n    return shadow(constructor, getBlessedProperties(constructor));\n}\nfunction shadow(constructor, properties) {\n    const shadowConstructor = extend(constructor);\n    const shadowProperties = getShadowProperties(constructor.prototype, properties);\n    Object.defineProperties(shadowConstructor.prototype, shadowProperties);\n    return shadowConstructor;\n}\nfunction getBlessedProperties(constructor) {\n    const blessings = readInheritableStaticArrayValues(constructor, \"blessings\");\n    return blessings.reduce((blessedProperties, blessing) => {\n        const properties = blessing(constructor);\n        for (const key in properties) {\n            const descriptor = blessedProperties[key] || {};\n            blessedProperties[key] = Object.assign(descriptor, properties[key]);\n        }\n        return blessedProperties;\n    }, {});\n}\nfunction getShadowProperties(prototype, properties) {\n    return getOwnKeys(properties).reduce((shadowProperties, key) => {\n        const descriptor = getShadowedDescriptor(prototype, properties, key);\n        if (descriptor) {\n            Object.assign(shadowProperties, { [key]: descriptor });\n        }\n        return shadowProperties;\n    }, {});\n}\nfunction getShadowedDescriptor(prototype, properties, key) {\n    const shadowingDescriptor = Object.getOwnPropertyDescriptor(prototype, key);\n    const shadowedByValue = shadowingDescriptor && \"value\" in shadowingDescriptor;\n    if (!shadowedByValue) {\n        const descriptor = Object.getOwnPropertyDescriptor(properties, key).value;\n        if (shadowingDescriptor) {\n            descriptor.get = shadowingDescriptor.get || descriptor.get;\n            descriptor.set = shadowingDescriptor.set || descriptor.set;\n        }\n        return descriptor;\n    }\n}\nconst getOwnKeys = (() => {\n    if (typeof Object.getOwnPropertySymbols == \"function\") {\n        return (object) => [...Object.getOwnPropertyNames(object), ...Object.getOwnPropertySymbols(object)];\n    }\n    else {\n        return Object.getOwnPropertyNames;\n    }\n})();\nconst extend = (() => {\n    function extendWithReflect(constructor) {\n        function extended() {\n            return Reflect.construct(constructor, arguments, new.target);\n        }\n        extended.prototype = Object.create(constructor.prototype, {\n            constructor: { value: extended },\n        });\n        Reflect.setPrototypeOf(extended, constructor);\n        return extended;\n    }\n    function testReflectExtension() {\n        const a = function () {\n            this.a.call(this);\n        };\n        const b = extendWithReflect(a);\n        b.prototype.a = function () { };\n        return new b();\n    }\n    try {\n        testReflectExtension();\n        return extendWithReflect;\n    }\n    catch (error) {\n        return (constructor) => class extended extends constructor {\n        };\n    }\n})();\n\nfunction blessDefinition(definition) {\n    return {\n        identifier: definition.identifier,\n        controllerConstructor: bless(definition.controllerConstructor),\n    };\n}\n\nclass Module {\n    constructor(application, definition) {\n        this.application = application;\n        this.definition = blessDefinition(definition);\n        this.contextsByScope = new WeakMap();\n        this.connectedContexts = new Set();\n    }\n    get identifier() {\n        return this.definition.identifier;\n    }\n    get controllerConstructor() {\n        return this.definition.controllerConstructor;\n    }\n    get contexts() {\n        return Array.from(this.connectedContexts);\n    }\n    connectContextForScope(scope) {\n        const context = this.fetchContextForScope(scope);\n        this.connectedContexts.add(context);\n        context.connect();\n    }\n    disconnectContextForScope(scope) {\n        const context = this.contextsByScope.get(scope);\n        if (context) {\n            this.connectedContexts.delete(context);\n            context.disconnect();\n        }\n    }\n    fetchContextForScope(scope) {\n        let context = this.contextsByScope.get(scope);\n        if (!context) {\n            context = new Context(this, scope);\n            this.contextsByScope.set(scope, context);\n        }\n        return context;\n    }\n}\n\nclass ClassMap {\n    constructor(scope) {\n        this.scope = scope;\n    }\n    has(name) {\n        return this.data.has(this.getDataKey(name));\n    }\n    get(name) {\n        return this.getAll(name)[0];\n    }\n    getAll(name) {\n        const tokenString = this.data.get(this.getDataKey(name)) || \"\";\n        return tokenize(tokenString);\n    }\n    getAttributeName(name) {\n        return this.data.getAttributeNameForKey(this.getDataKey(name));\n    }\n    getDataKey(name) {\n        return `${name}-class`;\n    }\n    get data() {\n        return this.scope.data;\n    }\n}\n\nclass DataMap {\n    constructor(scope) {\n        this.scope = scope;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get identifier() {\n        return this.scope.identifier;\n    }\n    get(key) {\n        const name = this.getAttributeNameForKey(key);\n        return this.element.getAttribute(name);\n    }\n    set(key, value) {\n        const name = this.getAttributeNameForKey(key);\n        this.element.setAttribute(name, value);\n        return this.get(key);\n    }\n    has(key) {\n        const name = this.getAttributeNameForKey(key);\n        return this.element.hasAttribute(name);\n    }\n    delete(key) {\n        if (this.has(key)) {\n            const name = this.getAttributeNameForKey(key);\n            this.element.removeAttribute(name);\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n    getAttributeNameForKey(key) {\n        return `data-${this.identifier}-${dasherize(key)}`;\n    }\n}\n\nclass Guide {\n    constructor(logger) {\n        this.warnedKeysByObject = new WeakMap();\n        this.logger = logger;\n    }\n    warn(object, key, message) {\n        let warnedKeys = this.warnedKeysByObject.get(object);\n        if (!warnedKeys) {\n            warnedKeys = new Set();\n            this.warnedKeysByObject.set(object, warnedKeys);\n        }\n        if (!warnedKeys.has(key)) {\n            warnedKeys.add(key);\n            this.logger.warn(message, object);\n        }\n    }\n}\n\nfunction attributeValueContainsToken(attributeName, token) {\n    return `[${attributeName}~=\"${token}\"]`;\n}\n\nclass TargetSet {\n    constructor(scope) {\n        this.scope = scope;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get identifier() {\n        return this.scope.identifier;\n    }\n    get schema() {\n        return this.scope.schema;\n    }\n    has(targetName) {\n        return this.find(targetName) != null;\n    }\n    find(...targetNames) {\n        return targetNames.reduce((target, targetName) => target || this.findTarget(targetName) || this.findLegacyTarget(targetName), undefined);\n    }\n    findAll(...targetNames) {\n        return targetNames.reduce((targets, targetName) => [\n            ...targets,\n            ...this.findAllTargets(targetName),\n            ...this.findAllLegacyTargets(targetName),\n        ], []);\n    }\n    findTarget(targetName) {\n        const selector = this.getSelectorForTargetName(targetName);\n        return this.scope.findElement(selector);\n    }\n    findAllTargets(targetName) {\n        const selector = this.getSelectorForTargetName(targetName);\n        return this.scope.findAllElements(selector);\n    }\n    getSelectorForTargetName(targetName) {\n        const attributeName = this.schema.targetAttributeForScope(this.identifier);\n        return attributeValueContainsToken(attributeName, targetName);\n    }\n    findLegacyTarget(targetName) {\n        const selector = this.getLegacySelectorForTargetName(targetName);\n        return this.deprecate(this.scope.findElement(selector), targetName);\n    }\n    findAllLegacyTargets(targetName) {\n        const selector = this.getLegacySelectorForTargetName(targetName);\n        return this.scope.findAllElements(selector).map((element) => this.deprecate(element, targetName));\n    }\n    getLegacySelectorForTargetName(targetName) {\n        const targetDescriptor = `${this.identifier}.${targetName}`;\n        return attributeValueContainsToken(this.schema.targetAttribute, targetDescriptor);\n    }\n    deprecate(element, targetName) {\n        if (element) {\n            const { identifier } = this;\n            const attributeName = this.schema.targetAttribute;\n            const revisedAttributeName = this.schema.targetAttributeForScope(identifier);\n            this.guide.warn(element, `target:${targetName}`, `Please replace ${attributeName}=\"${identifier}.${targetName}\" with ${revisedAttributeName}=\"${targetName}\". ` +\n                `The ${attributeName} attribute is deprecated and will be removed in a future version of Stimulus.`);\n        }\n        return element;\n    }\n    get guide() {\n        return this.scope.guide;\n    }\n}\n\nclass OutletSet {\n    constructor(scope, controllerElement) {\n        this.scope = scope;\n        this.controllerElement = controllerElement;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get identifier() {\n        return this.scope.identifier;\n    }\n    get schema() {\n        return this.scope.schema;\n    }\n    has(outletName) {\n        return this.find(outletName) != null;\n    }\n    find(...outletNames) {\n        return outletNames.reduce((outlet, outletName) => outlet || this.findOutlet(outletName), undefined);\n    }\n    findAll(...outletNames) {\n        return outletNames.reduce((outlets, outletName) => [...outlets, ...this.findAllOutlets(outletName)], []);\n    }\n    getSelectorForOutletName(outletName) {\n        const attributeName = this.schema.outletAttributeForScope(this.identifier, outletName);\n        return this.controllerElement.getAttribute(attributeName);\n    }\n    findOutlet(outletName) {\n        const selector = this.getSelectorForOutletName(outletName);\n        if (selector)\n            return this.findElement(selector, outletName);\n    }\n    findAllOutlets(outletName) {\n        const selector = this.getSelectorForOutletName(outletName);\n        return selector ? this.findAllElements(selector, outletName) : [];\n    }\n    findElement(selector, outletName) {\n        const elements = this.scope.queryElements(selector);\n        return elements.filter((element) => this.matchesElement(element, selector, outletName))[0];\n    }\n    findAllElements(selector, outletName) {\n        const elements = this.scope.queryElements(selector);\n        return elements.filter((element) => this.matchesElement(element, selector, outletName));\n    }\n    matchesElement(element, selector, outletName) {\n        const controllerAttribute = element.getAttribute(this.scope.schema.controllerAttribute) || \"\";\n        return element.matches(selector) && controllerAttribute.split(\" \").includes(outletName);\n    }\n}\n\nclass Scope {\n    constructor(schema, element, identifier, logger) {\n        this.targets = new TargetSet(this);\n        this.classes = new ClassMap(this);\n        this.data = new DataMap(this);\n        this.containsElement = (element) => {\n            return element.closest(this.controllerSelector) === this.element;\n        };\n        this.schema = schema;\n        this.element = element;\n        this.identifier = identifier;\n        this.guide = new Guide(logger);\n        this.outlets = new OutletSet(this.documentScope, element);\n    }\n    findElement(selector) {\n        return this.element.matches(selector) ? this.element : this.queryElements(selector).find(this.containsElement);\n    }\n    findAllElements(selector) {\n        return [\n            ...(this.element.matches(selector) ? [this.element] : []),\n            ...this.queryElements(selector).filter(this.containsElement),\n        ];\n    }\n    queryElements(selector) {\n        return Array.from(this.element.querySelectorAll(selector));\n    }\n    get controllerSelector() {\n        return attributeValueContainsToken(this.schema.controllerAttribute, this.identifier);\n    }\n    get isDocumentScope() {\n        return this.element === document.documentElement;\n    }\n    get documentScope() {\n        return this.isDocumentScope\n            ? this\n            : new Scope(this.schema, document.documentElement, this.identifier, this.guide.logger);\n    }\n}\n\nclass ScopeObserver {\n    constructor(element, schema, delegate) {\n        this.element = element;\n        this.schema = schema;\n        this.delegate = delegate;\n        this.valueListObserver = new ValueListObserver(this.element, this.controllerAttribute, this);\n        this.scopesByIdentifierByElement = new WeakMap();\n        this.scopeReferenceCounts = new WeakMap();\n    }\n    start() {\n        this.valueListObserver.start();\n    }\n    stop() {\n        this.valueListObserver.stop();\n    }\n    get controllerAttribute() {\n        return this.schema.controllerAttribute;\n    }\n    parseValueForToken(token) {\n        const { element, content: identifier } = token;\n        return this.parseValueForElementAndIdentifier(element, identifier);\n    }\n    parseValueForElementAndIdentifier(element, identifier) {\n        const scopesByIdentifier = this.fetchScopesByIdentifierForElement(element);\n        let scope = scopesByIdentifier.get(identifier);\n        if (!scope) {\n            scope = this.delegate.createScopeForElementAndIdentifier(element, identifier);\n            scopesByIdentifier.set(identifier, scope);\n        }\n        return scope;\n    }\n    elementMatchedValue(element, value) {\n        const referenceCount = (this.scopeReferenceCounts.get(value) || 0) + 1;\n        this.scopeReferenceCounts.set(value, referenceCount);\n        if (referenceCount == 1) {\n            this.delegate.scopeConnected(value);\n        }\n    }\n    elementUnmatchedValue(element, value) {\n        const referenceCount = this.scopeReferenceCounts.get(value);\n        if (referenceCount) {\n            this.scopeReferenceCounts.set(value, referenceCount - 1);\n            if (referenceCount == 1) {\n                this.delegate.scopeDisconnected(value);\n            }\n        }\n    }\n    fetchScopesByIdentifierForElement(element) {\n        let scopesByIdentifier = this.scopesByIdentifierByElement.get(element);\n        if (!scopesByIdentifier) {\n            scopesByIdentifier = new Map();\n            this.scopesByIdentifierByElement.set(element, scopesByIdentifier);\n        }\n        return scopesByIdentifier;\n    }\n}\n\nclass Router {\n    constructor(application) {\n        this.application = application;\n        this.scopeObserver = new ScopeObserver(this.element, this.schema, this);\n        this.scopesByIdentifier = new Multimap();\n        this.modulesByIdentifier = new Map();\n    }\n    get element() {\n        return this.application.element;\n    }\n    get schema() {\n        return this.application.schema;\n    }\n    get logger() {\n        return this.application.logger;\n    }\n    get controllerAttribute() {\n        return this.schema.controllerAttribute;\n    }\n    get modules() {\n        return Array.from(this.modulesByIdentifier.values());\n    }\n    get contexts() {\n        return this.modules.reduce((contexts, module) => contexts.concat(module.contexts), []);\n    }\n    start() {\n        this.scopeObserver.start();\n    }\n    stop() {\n        this.scopeObserver.stop();\n    }\n    loadDefinition(definition) {\n        this.unloadIdentifier(definition.identifier);\n        const module = new Module(this.application, definition);\n        this.connectModule(module);\n        const afterLoad = definition.controllerConstructor.afterLoad;\n        if (afterLoad) {\n            afterLoad.call(definition.controllerConstructor, definition.identifier, this.application);\n        }\n    }\n    unloadIdentifier(identifier) {\n        const module = this.modulesByIdentifier.get(identifier);\n        if (module) {\n            this.disconnectModule(module);\n        }\n    }\n    getContextForElementAndIdentifier(element, identifier) {\n        const module = this.modulesByIdentifier.get(identifier);\n        if (module) {\n            return module.contexts.find((context) => context.element == element);\n        }\n    }\n    proposeToConnectScopeForElementAndIdentifier(element, identifier) {\n        const scope = this.scopeObserver.parseValueForElementAndIdentifier(element, identifier);\n        if (scope) {\n            this.scopeObserver.elementMatchedValue(scope.element, scope);\n        }\n        else {\n            console.error(`Couldn't find or create scope for identifier: \"${identifier}\" and element:`, element);\n        }\n    }\n    handleError(error, message, detail) {\n        this.application.handleError(error, message, detail);\n    }\n    createScopeForElementAndIdentifier(element, identifier) {\n        return new Scope(this.schema, element, identifier, this.logger);\n    }\n    scopeConnected(scope) {\n        this.scopesByIdentifier.add(scope.identifier, scope);\n        const module = this.modulesByIdentifier.get(scope.identifier);\n        if (module) {\n            module.connectContextForScope(scope);\n        }\n    }\n    scopeDisconnected(scope) {\n        this.scopesByIdentifier.delete(scope.identifier, scope);\n        const module = this.modulesByIdentifier.get(scope.identifier);\n        if (module) {\n            module.disconnectContextForScope(scope);\n        }\n    }\n    connectModule(module) {\n        this.modulesByIdentifier.set(module.identifier, module);\n        const scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);\n        scopes.forEach((scope) => module.connectContextForScope(scope));\n    }\n    disconnectModule(module) {\n        this.modulesByIdentifier.delete(module.identifier);\n        const scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);\n        scopes.forEach((scope) => module.disconnectContextForScope(scope));\n    }\n}\n\nconst defaultSchema = {\n    controllerAttribute: \"data-controller\",\n    actionAttribute: \"data-action\",\n    targetAttribute: \"data-target\",\n    targetAttributeForScope: (identifier) => `data-${identifier}-target`,\n    outletAttributeForScope: (identifier, outlet) => `data-${identifier}-${outlet}-outlet`,\n    keyMappings: Object.assign(Object.assign({ enter: \"Enter\", tab: \"Tab\", esc: \"Escape\", space: \" \", up: \"ArrowUp\", down: \"ArrowDown\", left: \"ArrowLeft\", right: \"ArrowRight\", home: \"Home\", end: \"End\", page_up: \"PageUp\", page_down: \"PageDown\" }, objectFromEntries(\"abcdefghijklmnopqrstuvwxyz\".split(\"\").map((c) => [c, c]))), objectFromEntries(\"0123456789\".split(\"\").map((n) => [n, n]))),\n};\nfunction objectFromEntries(array) {\n    return array.reduce((memo, [k, v]) => (Object.assign(Object.assign({}, memo), { [k]: v })), {});\n}\n\nclass Application {\n    constructor(element = document.documentElement, schema = defaultSchema) {\n        this.logger = console;\n        this.debug = false;\n        this.logDebugActivity = (identifier, functionName, detail = {}) => {\n            if (this.debug) {\n                this.logFormattedMessage(identifier, functionName, detail);\n            }\n        };\n        this.element = element;\n        this.schema = schema;\n        this.dispatcher = new Dispatcher(this);\n        this.router = new Router(this);\n        this.actionDescriptorFilters = Object.assign({}, defaultActionDescriptorFilters);\n    }\n    static start(element, schema) {\n        const application = new this(element, schema);\n        application.start();\n        return application;\n    }\n    async start() {\n        await domReady();\n        this.logDebugActivity(\"application\", \"starting\");\n        this.dispatcher.start();\n        this.router.start();\n        this.logDebugActivity(\"application\", \"start\");\n    }\n    stop() {\n        this.logDebugActivity(\"application\", \"stopping\");\n        this.dispatcher.stop();\n        this.router.stop();\n        this.logDebugActivity(\"application\", \"stop\");\n    }\n    register(identifier, controllerConstructor) {\n        this.load({ identifier, controllerConstructor });\n    }\n    registerActionOption(name, filter) {\n        this.actionDescriptorFilters[name] = filter;\n    }\n    load(head, ...rest) {\n        const definitions = Array.isArray(head) ? head : [head, ...rest];\n        definitions.forEach((definition) => {\n            if (definition.controllerConstructor.shouldLoad) {\n                this.router.loadDefinition(definition);\n            }\n        });\n    }\n    unload(head, ...rest) {\n        const identifiers = Array.isArray(head) ? head : [head, ...rest];\n        identifiers.forEach((identifier) => this.router.unloadIdentifier(identifier));\n    }\n    get controllers() {\n        return this.router.contexts.map((context) => context.controller);\n    }\n    getControllerForElementAndIdentifier(element, identifier) {\n        const context = this.router.getContextForElementAndIdentifier(element, identifier);\n        return context ? context.controller : null;\n    }\n    handleError(error, message, detail) {\n        var _a;\n        this.logger.error(`%s\\n\\n%o\\n\\n%o`, message, error, detail);\n        (_a = window.onerror) === null || _a === void 0 ? void 0 : _a.call(window, message, \"\", 0, 0, error);\n    }\n    logFormattedMessage(identifier, functionName, detail = {}) {\n        detail = Object.assign({ application: this }, detail);\n        this.logger.groupCollapsed(`${identifier} #${functionName}`);\n        this.logger.log(\"details:\", Object.assign({}, detail));\n        this.logger.groupEnd();\n    }\n}\nfunction domReady() {\n    return new Promise((resolve) => {\n        if (document.readyState == \"loading\") {\n            document.addEventListener(\"DOMContentLoaded\", () => resolve());\n        }\n        else {\n            resolve();\n        }\n    });\n}\n\nfunction ClassPropertiesBlessing(constructor) {\n    const classes = readInheritableStaticArrayValues(constructor, \"classes\");\n    return classes.reduce((properties, classDefinition) => {\n        return Object.assign(properties, propertiesForClassDefinition(classDefinition));\n    }, {});\n}\nfunction propertiesForClassDefinition(key) {\n    return {\n        [`${key}Class`]: {\n            get() {\n                const { classes } = this;\n                if (classes.has(key)) {\n                    return classes.get(key);\n                }\n                else {\n                    const attribute = classes.getAttributeName(key);\n                    throw new Error(`Missing attribute \"${attribute}\"`);\n                }\n            },\n        },\n        [`${key}Classes`]: {\n            get() {\n                return this.classes.getAll(key);\n            },\n        },\n        [`has${capitalize(key)}Class`]: {\n            get() {\n                return this.classes.has(key);\n            },\n        },\n    };\n}\n\nfunction OutletPropertiesBlessing(constructor) {\n    const outlets = readInheritableStaticArrayValues(constructor, \"outlets\");\n    return outlets.reduce((properties, outletDefinition) => {\n        return Object.assign(properties, propertiesForOutletDefinition(outletDefinition));\n    }, {});\n}\nfunction getOutletController(controller, element, identifier) {\n    return controller.application.getControllerForElementAndIdentifier(element, identifier);\n}\nfunction getControllerAndEnsureConnectedScope(controller, element, outletName) {\n    let outletController = getOutletController(controller, element, outletName);\n    if (outletController)\n        return outletController;\n    controller.application.router.proposeToConnectScopeForElementAndIdentifier(element, outletName);\n    outletController = getOutletController(controller, element, outletName);\n    if (outletController)\n        return outletController;\n}\nfunction propertiesForOutletDefinition(name) {\n    const camelizedName = namespaceCamelize(name);\n    return {\n        [`${camelizedName}Outlet`]: {\n            get() {\n                const outletElement = this.outlets.find(name);\n                const selector = this.outlets.getSelectorForOutletName(name);\n                if (outletElement) {\n                    const outletController = getControllerAndEnsureConnectedScope(this, outletElement, name);\n                    if (outletController)\n                        return outletController;\n                    throw new Error(`The provided outlet element is missing an outlet controller \"${name}\" instance for host controller \"${this.identifier}\"`);\n                }\n                throw new Error(`Missing outlet element \"${name}\" for host controller \"${this.identifier}\". Stimulus couldn't find a matching outlet element using selector \"${selector}\".`);\n            },\n        },\n        [`${camelizedName}Outlets`]: {\n            get() {\n                const outlets = this.outlets.findAll(name);\n                if (outlets.length > 0) {\n                    return outlets\n                        .map((outletElement) => {\n                        const outletController = getControllerAndEnsureConnectedScope(this, outletElement, name);\n                        if (outletController)\n                            return outletController;\n                        console.warn(`The provided outlet element is missing an outlet controller \"${name}\" instance for host controller \"${this.identifier}\"`, outletElement);\n                    })\n                        .filter((controller) => controller);\n                }\n                return [];\n            },\n        },\n        [`${camelizedName}OutletElement`]: {\n            get() {\n                const outletElement = this.outlets.find(name);\n                const selector = this.outlets.getSelectorForOutletName(name);\n                if (outletElement) {\n                    return outletElement;\n                }\n                else {\n                    throw new Error(`Missing outlet element \"${name}\" for host controller \"${this.identifier}\". Stimulus couldn't find a matching outlet element using selector \"${selector}\".`);\n                }\n            },\n        },\n        [`${camelizedName}OutletElements`]: {\n            get() {\n                return this.outlets.findAll(name);\n            },\n        },\n        [`has${capitalize(camelizedName)}Outlet`]: {\n            get() {\n                return this.outlets.has(name);\n            },\n        },\n    };\n}\n\nfunction TargetPropertiesBlessing(constructor) {\n    const targets = readInheritableStaticArrayValues(constructor, \"targets\");\n    return targets.reduce((properties, targetDefinition) => {\n        return Object.assign(properties, propertiesForTargetDefinition(targetDefinition));\n    }, {});\n}\nfunction propertiesForTargetDefinition(name) {\n    return {\n        [`${name}Target`]: {\n            get() {\n                const target = this.targets.find(name);\n                if (target) {\n                    return target;\n                }\n                else {\n                    throw new Error(`Missing target element \"${name}\" for \"${this.identifier}\" controller`);\n                }\n            },\n        },\n        [`${name}Targets`]: {\n            get() {\n                return this.targets.findAll(name);\n            },\n        },\n        [`has${capitalize(name)}Target`]: {\n            get() {\n                return this.targets.has(name);\n            },\n        },\n    };\n}\n\nfunction ValuePropertiesBlessing(constructor) {\n    const valueDefinitionPairs = readInheritableStaticObjectPairs(constructor, \"values\");\n    const propertyDescriptorMap = {\n        valueDescriptorMap: {\n            get() {\n                return valueDefinitionPairs.reduce((result, valueDefinitionPair) => {\n                    const valueDescriptor = parseValueDefinitionPair(valueDefinitionPair, this.identifier);\n                    const attributeName = this.data.getAttributeNameForKey(valueDescriptor.key);\n                    return Object.assign(result, { [attributeName]: valueDescriptor });\n                }, {});\n            },\n        },\n    };\n    return valueDefinitionPairs.reduce((properties, valueDefinitionPair) => {\n        return Object.assign(properties, propertiesForValueDefinitionPair(valueDefinitionPair));\n    }, propertyDescriptorMap);\n}\nfunction propertiesForValueDefinitionPair(valueDefinitionPair, controller) {\n    const definition = parseValueDefinitionPair(valueDefinitionPair, controller);\n    const { key, name, reader: read, writer: write } = definition;\n    return {\n        [name]: {\n            get() {\n                const value = this.data.get(key);\n                if (value !== null) {\n                    return read(value);\n                }\n                else {\n                    return definition.defaultValue;\n                }\n            },\n            set(value) {\n                if (value === undefined) {\n                    this.data.delete(key);\n                }\n                else {\n                    this.data.set(key, write(value));\n                }\n            },\n        },\n        [`has${capitalize(name)}`]: {\n            get() {\n                return this.data.has(key) || definition.hasCustomDefaultValue;\n            },\n        },\n    };\n}\nfunction parseValueDefinitionPair([token, typeDefinition], controller) {\n    return valueDescriptorForTokenAndTypeDefinition({\n        controller,\n        token,\n        typeDefinition,\n    });\n}\nfunction parseValueTypeConstant(constant) {\n    switch (constant) {\n        case Array:\n            return \"array\";\n        case Boolean:\n            return \"boolean\";\n        case Number:\n            return \"number\";\n        case Object:\n            return \"object\";\n        case String:\n            return \"string\";\n    }\n}\nfunction parseValueTypeDefault(defaultValue) {\n    switch (typeof defaultValue) {\n        case \"boolean\":\n            return \"boolean\";\n        case \"number\":\n            return \"number\";\n        case \"string\":\n            return \"string\";\n    }\n    if (Array.isArray(defaultValue))\n        return \"array\";\n    if (Object.prototype.toString.call(defaultValue) === \"[object Object]\")\n        return \"object\";\n}\nfunction parseValueTypeObject(payload) {\n    const { controller, token, typeObject } = payload;\n    const hasType = isSomething(typeObject.type);\n    const hasDefault = isSomething(typeObject.default);\n    const fullObject = hasType && hasDefault;\n    const onlyType = hasType && !hasDefault;\n    const onlyDefault = !hasType && hasDefault;\n    const typeFromObject = parseValueTypeConstant(typeObject.type);\n    const typeFromDefaultValue = parseValueTypeDefault(payload.typeObject.default);\n    if (onlyType)\n        return typeFromObject;\n    if (onlyDefault)\n        return typeFromDefaultValue;\n    if (typeFromObject !== typeFromDefaultValue) {\n        const propertyPath = controller ? `${controller}.${token}` : token;\n        throw new Error(`The specified default value for the Stimulus Value \"${propertyPath}\" must match the defined type \"${typeFromObject}\". The provided default value of \"${typeObject.default}\" is of type \"${typeFromDefaultValue}\".`);\n    }\n    if (fullObject)\n        return typeFromObject;\n}\nfunction parseValueTypeDefinition(payload) {\n    const { controller, token, typeDefinition } = payload;\n    const typeObject = { controller, token, typeObject: typeDefinition };\n    const typeFromObject = parseValueTypeObject(typeObject);\n    const typeFromDefaultValue = parseValueTypeDefault(typeDefinition);\n    const typeFromConstant = parseValueTypeConstant(typeDefinition);\n    const type = typeFromObject || typeFromDefaultValue || typeFromConstant;\n    if (type)\n        return type;\n    const propertyPath = controller ? `${controller}.${typeDefinition}` : token;\n    throw new Error(`Unknown value type \"${propertyPath}\" for \"${token}\" value`);\n}\nfunction defaultValueForDefinition(typeDefinition) {\n    const constant = parseValueTypeConstant(typeDefinition);\n    if (constant)\n        return defaultValuesByType[constant];\n    const hasDefault = hasProperty(typeDefinition, \"default\");\n    const hasType = hasProperty(typeDefinition, \"type\");\n    const typeObject = typeDefinition;\n    if (hasDefault)\n        return typeObject.default;\n    if (hasType) {\n        const { type } = typeObject;\n        const constantFromType = parseValueTypeConstant(type);\n        if (constantFromType)\n            return defaultValuesByType[constantFromType];\n    }\n    return typeDefinition;\n}\nfunction valueDescriptorForTokenAndTypeDefinition(payload) {\n    const { token, typeDefinition } = payload;\n    const key = `${dasherize(token)}-value`;\n    const type = parseValueTypeDefinition(payload);\n    return {\n        type,\n        key,\n        name: camelize(key),\n        get defaultValue() {\n            return defaultValueForDefinition(typeDefinition);\n        },\n        get hasCustomDefaultValue() {\n            return parseValueTypeDefault(typeDefinition) !== undefined;\n        },\n        reader: readers[type],\n        writer: writers[type] || writers.default,\n    };\n}\nconst defaultValuesByType = {\n    get array() {\n        return [];\n    },\n    boolean: false,\n    number: 0,\n    get object() {\n        return {};\n    },\n    string: \"\",\n};\nconst readers = {\n    array(value) {\n        const array = JSON.parse(value);\n        if (!Array.isArray(array)) {\n            throw new TypeError(`expected value of type \"array\" but instead got value \"${value}\" of type \"${parseValueTypeDefault(array)}\"`);\n        }\n        return array;\n    },\n    boolean(value) {\n        return !(value == \"0\" || String(value).toLowerCase() == \"false\");\n    },\n    number(value) {\n        return Number(value.replace(/_/g, \"\"));\n    },\n    object(value) {\n        const object = JSON.parse(value);\n        if (object === null || typeof object != \"object\" || Array.isArray(object)) {\n            throw new TypeError(`expected value of type \"object\" but instead got value \"${value}\" of type \"${parseValueTypeDefault(object)}\"`);\n        }\n        return object;\n    },\n    string(value) {\n        return value;\n    },\n};\nconst writers = {\n    default: writeString,\n    array: writeJSON,\n    object: writeJSON,\n};\nfunction writeJSON(value) {\n    return JSON.stringify(value);\n}\nfunction writeString(value) {\n    return `${value}`;\n}\n\nclass Controller {\n    constructor(context) {\n        this.context = context;\n    }\n    static get shouldLoad() {\n        return true;\n    }\n    static afterLoad(_identifier, _application) {\n        return;\n    }\n    get application() {\n        return this.context.application;\n    }\n    get scope() {\n        return this.context.scope;\n    }\n    get element() {\n        return this.scope.element;\n    }\n    get identifier() {\n        return this.scope.identifier;\n    }\n    get targets() {\n        return this.scope.targets;\n    }\n    get outlets() {\n        return this.scope.outlets;\n    }\n    get classes() {\n        return this.scope.classes;\n    }\n    get data() {\n        return this.scope.data;\n    }\n    initialize() {\n    }\n    connect() {\n    }\n    disconnect() {\n    }\n    dispatch(eventName, { target = this.element, detail = {}, prefix = this.identifier, bubbles = true, cancelable = true, } = {}) {\n        const type = prefix ? `${prefix}:${eventName}` : eventName;\n        const event = new CustomEvent(type, { detail, bubbles, cancelable });\n        target.dispatchEvent(event);\n        return event;\n    }\n}\nController.blessings = [\n    ClassPropertiesBlessing,\n    TargetPropertiesBlessing,\n    ValuePropertiesBlessing,\n    OutletPropertiesBlessing,\n];\nController.targets = [];\nController.outlets = [];\nController.values = {};\n\nexport { Application, AttributeObserver, Context, Controller, ElementObserver, IndexedMultimap, Multimap, SelectorObserver, StringMapObserver, TokenListObserver, ValueListObserver, add, defaultSchema, del, fetch, prune };\n","import GohireController from \"./controllers/gohire_controller\";\nwindow.Stimulus.register(\"gohire\", GohireController);\n","import { Controller } from \"@hotwired/stimulus\";\n\nexport default class extends Controller {\n  static values = {\n    clientId: String,\n    apiDomain: { type: String, default: \"https://api.gohire.io\" },\n    baseDomain: { type: String, default: \"https://app.gohire.io\" },\n    width: { type: Number, default: 625 },\n    timeout: { type: Number, default: 15 },\n    zIndex: { type: Number, default: 10000 }\n  };\n\n  connect() {\n    this.host = window.location.host;\n    this.isMobile = window.innerWidth < this.widthValue;\n    this.jobsData = [];\n    this.elements = {};\n\n    this.initializeStyles();\n    this.createElements();\n    this.loadJobs();\n  }\n\n  disconnect() {\n    if (this.timer) {\n      clearTimeout(this.timer);\n    }\n    if (this.sizeInterval) {\n      clearInterval(this.sizeInterval);\n    }\n  }\n\n  initializeStyles() {\n    // Check if styles are already added\n    if (document.getElementById('gohire_styles')) {\n      return;\n    }\n\n    const css = `\n      .gohire,.gohire * { color:#333 !important; }\n\n      .gohire_active { overflow:hidden !important; }\n      .gohire_active_mobile { overflow:hidden !important; height:100% !important; width:100% !important; position:fixed !important; }\n      .gohire_holder { position:fixed; top:0; right:0; width:${this.widthValue}px; height:100vh; background-color:#fff; transition:right 0.5s; z-index:${this.zIndexValue + 1}; }\n      .gohire_cover { position:fixed; top:0; left:0; width:100vw; height:100vh; background-color:rgba(0,0,0,.5); transition: opacity 0.5s; z-index:${this.zIndexValue}; }\n      .gohire_iframe { position:absolute; top:0; left:0; width:100%; height:100%; border:0; transition:opacity 0.5s; }\n      .gohire_loading { position:absolute; top:0; left:0; width:100%; height:100%; }\n      .gohire_error { position:absolute; top:0; left:0; width:100%; height:100%; }\n\n      .gohire_holder_hidden { right:-${this.widthValue}px; }\n      .gohire_cover_hidden { pointer-events:none; opacity:0; }\n      .gohire_iframe_hidden { opacity:0; }\n      .gohire_hidden { display:none; }\n\n      .gohire_no_select { -webkit-touch-callout: none; -webkit-user-select: none; -khtml-user-select: none; -moz-user-select: none; -ms-user-select: none; user-select: none; }\n\n      .gohire_spinner:before { border-top: 2px solid #c3c8d1; content: ''; box-sizing: border-box; position: absolute; top: 47%; left: 50%; width: 40px; height: 40px; margin-top: -20px; margin-left: -20px; border-radius: 50%; border-right: 2px solid transparent; animation: gohire_spinner .6s linear infinite; }\n\n      @keyframes gohire_spinner { to {transform: rotate(360deg); } }\n\n      @media screen and (max-width: 850px) {\n        .gohire_holder { width: 100vw; }\n        .gohire_holder_hidden { right:calc(-100vw); }\n      }\n\n      .gohire-job-list { width: 100%; box-shadow: 0 1px 3px 1px rgba(160,161,188,.14); background-color:#fff; border-radius: 12px; margin: 20px 0; border: solid 1px #E0E6ED; -webkit-user-select: none; -moz-user-select: none; -ms-user-select: none; user-select: none; }\n      .gohire-job-list-item { cursor: pointer; display: flex; flex-direction: row; align-items: center; padding: 25px 0; margin:0 20px 0 20px; border-bottom: solid 1px #E0E6ED !important; transition: all 0.5s; }\n      .gohire-job-list a:last-child .gohire-job-list-item { border-bottom: none !important; }\n      .gohire-job-list-item-detail .gohire-job-list-item-detail-title { font-size: 16px !important; font-weight: bold !important; transition: all 0.5s; margin: 0 !important; color:#005cff !important; }\n      .gohire-job-list-item-detail .gohire-job-list-item-detail-sub { font-size: 13px !important; color: #3e5167 !important; margin:0 !important; }\n      .gohire-job-list-item:hover .gohire-job-list-item-detail-title { text-decoration: underline !important; }\n      .gohire-job-list-item-nav { margin-left:auto !important; }\n      .gohire-job-list-item-nav path { fill:#005cff !important; }\n\n      @media screen and (max-width: 500px) {\n        .gohire-job-list-item-nav { display:none !important; }\n      }\n    `;\n\n    const style = document.createElement('style');\n    style.id = 'gohire_styles';\n    style.type = 'text/css';\n    style.innerHTML = css;\n    document.body.appendChild(style);\n  }\n\n  createElements() {\n    // Create holder\n    this.elements.holder = document.createElement('div');\n    this.elements.holder.className = 'gohire gohire_holder gohire_no_select gohire_holder_hidden';\n    document.body.appendChild(this.elements.holder);\n\n    // Create cover\n    this.elements.cover = document.createElement('div');\n    this.elements.cover.className = 'gohire gohire_cover gohire_cover_hidden';\n    this.elements.cover.style.display = 'none';\n    document.body.appendChild(this.elements.cover);\n\n    setTimeout(() => {\n      this.elements.cover.style.display = 'block';\n    }, 0);\n\n    // Create iframe\n    this.elements.frame = document.createElement('iframe');\n    this.elements.frame.className = 'gohire gohire_iframe gohire_iframe_hidden';\n    this.elements.holder.appendChild(this.elements.frame);\n\n    // Create error container\n    this.elements.error = document.createElement('div');\n    this.elements.error.className = 'gohire gohire_error gohire_hidden';\n    this.elements.holder.appendChild(this.elements.error);\n\n    // Create loading spinner\n    this.elements.loading = document.createElement('div');\n    this.elements.loading.className = 'gohire gohire_loading';\n    this.elements.loading.innerHTML = '<div class=\"gohire_spinner\"></div>';\n    this.elements.holder.appendChild(this.elements.loading);\n\n    // Add click event to cover to close\n    this.elements.cover.addEventListener('click', () => this.hide());\n\n    // Listen for messages from iframe\n    window.addEventListener('message', this.handleMessage.bind(this));\n  }\n\n  handleMessage(message) {\n    if (message.data?.type === 'gohire') {\n      if (message.data.data === 'loaded') {\n        this.loaded();\n      } else if (message.data.data === 'close') {\n        this.hide();\n      }\n    }\n  }\n\n  loadJobs() {\n    const attrString = this.buildAttributeString();\n    const url = `/widget-jobs?clientId=${this.clientIdValue}${attrString}`;\n\n    this.get(url, (data) => {\n      if (!data) return;\n\n      // Apply brand color if provided\n      if (data.colour) {\n        this.applyBrandColor(data.colour);\n      }\n\n      // Render jobs\n      if (Array.isArray(data.jobs)) {\n        this.template = data.template || this.getDefaultTemplate();\n        const html = data.jobs.map(job => {\n          this.jobsData.push(job);\n          return this.templateReplacements(job);\n        }).join('');\n\n        if (data.custom) {\n          this.element.innerHTML = html;\n          while (this.element.firstChild) {\n            this.element.parentNode.insertBefore(this.element.firstChild, this.element);\n          }\n          this.element.parentNode.removeChild(this.element);\n        } else {\n          const div = document.createElement('div');\n          div.className = 'gohire-job-list';\n          div.innerHTML = html;\n          this.element.parentNode.insertBefore(div, this.element);\n          this.element.parentNode.removeChild(this.element);\n        }\n      }\n    });\n  }\n\n  buildAttributeString() {\n    let attrString = '';\n    if (this.element.attributes) {\n      for (const attr of this.element.attributes) {\n        if (!attr.nodeName.startsWith('data-gohire')) {\n          attrString += `&${attr.nodeName}=${attr.nodeValue}`;\n        }\n      }\n    }\n    return attrString;\n  }\n\n  applyBrandColor(colour) {\n    if (document.getElementById('gohire_styles_brand')) {\n      return;\n    }\n\n    const style = document.createElement('style');\n    style.id = 'gohire_styles_brand';\n    style.type = 'text/css';\n    style.innerHTML = `\n      .gohire-job-list-item-detail .gohire-job-list-item-detail-title { color: ${colour} !important; }\n      .gohire-job-list-item-nav path { fill: ${colour} !important; }\n    `;\n    document.body.appendChild(style);\n  }\n\n  getDefaultTemplate() {\n    return `\n      <a href=\"{{link}}\" target=\"_blank\">\n        <div class=\"gohire-job-list-item\">\n          <div class=\"gohire-job-list-item-detail\">\n            <p class=\"gohire-job-list-item-detail-title gohire-brand-colour\">{{title}}</p>\n            <p class=\"gohire-job-list-item-detail-sub\">{{location}} &middot; Posted {{date}}</p>\n          </div>\n          <div class=\"gohire-job-list-item-nav\"><svg width=\"20\" height=\"20\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 192 512\"><path d=\"M187.8 264.5L41 412.5c-4.7 4.7-12.3 4.7-17 0L4.2 392.7c-4.7-4.7-4.7-12.3 0-17L122.7 256 4.2 136.3c-4.7-4.7-4.7-12.3 0-17L24 99.5c4.7-4.7 12.3-4.7 17 0l146.8 148c4.7 4.7 4.7 12.3 0 17z\" /></svg></div>\n        </div>\n      </a>\n    `;\n  }\n\n  templateReplacements(job) {\n    if (!this.template) return '';\n\n    let template = this.template;\n    if (typeof job === 'object' && job) {\n      Object.keys(job).forEach(key => {\n        const data = this.htmlEncode(job[key]).replace(/{{/g, '').replace(/}}/g, '');\n        template = template.replace(new RegExp(`{{${key}}}`, 'g'), data);\n      });\n    }\n    return template;\n  }\n\n  htmlEncode(string) {\n    if (string === null) return '';\n    return String(string)\n      .replace(/&/g, '&amp;')\n      .replace(/</g, '&lt;')\n      .replace(/>/g, '&gt;')\n      .replace(/\"/g, '&quot;');\n  }\n\n  open(jobId) {\n    if (!jobId) {\n      alert('Invalid job ID');\n      return;\n    }\n\n    this.jobId = jobId;\n\n    setTimeout(() => {\n      const referrer = document.referrer ? `&referrer=${encodeURIComponent(document.referrer)}` : '';\n      const url = `${this.baseDomainValue}/widget/${this.clientIdValue}/${this.jobId}?host=${this.host}${referrer}`;\n      this.elements.frame.setAttribute('src', url);\n    }, 500);\n\n    this.show();\n\n    if (this.timer) {\n      clearTimeout(this.timer);\n    }\n\n    this.timer = setTimeout(() => {\n      this.showError('There seems to be a problem loading the apply widget, please <a href=\"#\" onclick=\"window.location.reload(); return false;\">reload the page</a> and try again');\n    }, this.timeoutValue * 1000);\n  }\n\n  show() {\n    document.body.classList.add('gohire_active');\n\n    if (this.isMobile) {\n      document.body.classList.add('gohire_active_mobile');\n    }\n\n    this.elements.holder.classList.remove('gohire_holder_hidden');\n    this.elements.cover.classList.remove('gohire_cover_hidden');\n    this.elements.loading.classList.remove('gohire_hidden');\n    this.elements.error.classList.add('gohire_hidden');\n    this.elements.frame.classList.add('gohire_iframe_hidden');\n\n    if (this.isMobile) {\n      this.sizeInterval = setInterval(() => {\n        this.resize();\n      }, 100);\n    }\n  }\n\n  hide() {\n    document.body.classList.remove('gohire_active');\n    document.body.classList.remove('gohire_active_mobile');\n    this.elements.holder.classList.add('gohire_holder_hidden');\n    this.elements.cover.classList.add('gohire_cover_hidden');\n\n    setTimeout(() => {\n      this.elements.frame.setAttribute('src', '');\n    }, 500);\n\n    if (this.sizeInterval) {\n      clearInterval(this.sizeInterval);\n    }\n  }\n\n  loaded() {\n    if (this.timer) {\n      clearTimeout(this.timer);\n    }\n    this.elements.frame.classList.remove('gohire_iframe_hidden');\n    this.elements.loading.classList.add('gohire_hidden');\n  }\n\n  showError(error) {\n    this.elements.loading.classList.add('gohire_hidden');\n    this.elements.error.classList.remove('gohire_hidden');\n    this.elements.error.innerHTML = error;\n  }\n\n  resize() {\n    this.elements.holder.style.height = `${window.innerHeight}px`;\n  }\n\n  get(url, success, error) {\n    const request = new XMLHttpRequest();\n    request.open('GET', this.apiDomainValue + url);\n    request.setRequestHeader('Widget-Host', this.host);\n\n    request.onload = () => {\n      try {\n        const json = JSON.parse(request.responseText);\n        if (request.status >= 200 && request.status < 300) {\n          if (typeof success === 'function') {\n            success(json);\n          }\n        } else if (typeof error === 'function') {\n          error(json);\n        }\n      } catch (e) {\n        console.error('GoHire: Error parsing response', e);\n      }\n    };\n\n    request.onerror = () => {\n      console.error('GoHire: Network error');\n      if (typeof error === 'function') {\n        error();\n      }\n    };\n\n    request.send();\n  }\n}\n"],"names":["camelize","value","replace","_","char","toUpperCase","capitalize","charAt","slice","isSomething","object","hasProperty","property","Object","prototype","hasOwnProperty","call","readInheritableStaticArrayValues","constructor","propertyName","ancestors","getAncestorsForConstructor","Array","from","reduce","values","definition","isArray","getOwnStaticArrayValues","forEach","name","add","Set","push","getPrototypeOf","reverse","objectFromEntries","array","memo","k","v","assign","getOutletController","controller","element","identifier","application","getControllerForElementAndIdentifier","getControllerAndEnsureConnectedScope","outletName","outletController","router","proposeToConnectScopeForElementAndIdentifier","parseValueDefinitionPair","token","typeDefinition","payload","key","toLowerCase","type","typeFromObject","typeObject","hasType","hasDefault","default","fullObject","onlyType","onlyDefault","parseValueTypeConstant","typeFromDefaultValue","parseValueTypeDefault","Error","parseValueTypeObject","typeFromConstant","parseValueTypeDefinition","defaultValue","constant","defaultValuesByType","constantFromType","defaultValueForDefinition","hasCustomDefaultValue","undefined","reader","readers","writer","writers","valueDescriptorForTokenAndTypeDefinition","Boolean","Number","String","toString","getOwnPropertySymbols","getOwnPropertyNames","extendWithReflect","extended","Reflect","construct","arguments","create","setPrototypeOf","b","this","a","testReflectExtension","error","enter","tab","esc","space","up","down","left","right","home","end","page_up","page_down","split","map","c","n","boolean","number","string","JSON","parse","TypeError","writeJSON","stringify","Controller","context","shouldLoad","afterLoad","_identifier","_application","scope","targets","outlets","classes","data","initialize","connect","disconnect","dispatch","eventName","target","detail","prefix","bubbles","cancelable","event","CustomEvent","dispatchEvent","blessings","properties","classDefinition","get","has","attribute","getAttributeName","getAll","targetDefinition","find","findAll","valueDefinitionPairs","pairs","keys","getOwnStaticObjectPairs","readInheritableStaticObjectPairs","propertyDescriptorMap","valueDescriptorMap","result","valueDefinitionPair","valueDescriptor","attributeName","getAttributeNameForKey","propertiesForValueDefinitionPair","read","write","set","delete","outletDefinition","camelizedName","outletElement","selector","getSelectorForOutletName","length","console","warn","filter","propertiesForOutletDefinition","window","Stimulus","register","static","clientId","apiDomain","baseDomain","width","timeout","zIndex","host","location","isMobile","innerWidth","widthValue","jobsData","elements","initializeStyles","createElements","loadJobs","timer","clearTimeout","sizeInterval","clearInterval","document","getElementById","css","zIndexValue","style","createElement","id","innerHTML","body","appendChild","holder","className","cover","display","setTimeout","frame","loading","addEventListener","hide","handleMessage","bind","message","loaded","attrString","buildAttributeString","url","clientIdValue","colour","applyBrandColor","jobs","template","getDefaultTemplate","html","job","templateReplacements","join","custom","firstChild","parentNode","insertBefore","removeChild","div","attributes","attr","nodeName","startsWith","nodeValue","htmlEncode","RegExp","open","jobId","referrer","encodeURIComponent","baseDomainValue","setAttribute","show","showError","timeoutValue","alert","classList","remove","setInterval","resize","height","innerHeight","success","request","XMLHttpRequest","apiDomainValue","setRequestHeader","onload","json","responseText","status","e","onerror","send"],"sourceRoot":""}