1try{let e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="57bac9bc-c572-4e21-b115-25b09fc19995",e._sentryDebugIdIdentifier="sentry-dbid-57bac9bc-c572-4e21-b115-25b09fc19995")}catch(e){}("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{}).SENTRY_RELEASE={id:"v276.1-0-gc0e3075"};(globalThis.webpackChunk||=[]).push([[891],{2891(__unused_webpack_module,__webpack_exports__,__webpack_require__){__webpack_require__.d(__webpack_exports__,{lg:()=>Application,xI:()=>Controller});class EventListener{constructor(eventTarget,eventName,eventOptions){this.eventTarget=eventTarget,this.eventName=eventName,this.eventOptions=eventOptions,this.unorderedBindings=new Set}connect(){this.eventTarget.addEventListener(this.eventName,this,this.eventOptions)}disconnect(){this.eventTarget.removeEventListener(this.eventName,this,this.eventOptions)}bindingConnected(binding){this.unorderedBindings.add(binding)}bindingDisconnected(binding){this.unorderedBindings.delete(binding)}handleEvent(event){const extendedEvent=function extendEvent(event){if("immediatePropagationStopped"in event)return event;{const{stopImmediatePropagation}=event;return Object.assign(event,{immediatePropagationStopped:!1,stopImmediatePropagation(){this.immediatePropagationStopped=!0,stopImmediatePropagation.call(this)}})}}(event);for(const binding of this.bindings){if(extendedEvent.immediatePropagationStopped)break;binding.handleEvent(extendedEvent)}}hasBindings(){return this.unorderedBindings.size>0}get bindings(){return Array.from(this.unorderedBindings).sort((left,right)=>{const leftIndex=left.index,rightIndex=right.index;return leftIndex<rightIndex?-1:leftIndex>rightIndex?1:0})}}class Dispatcher{constructor(application){this.application=application,this.eventListenerMaps=new Map,this.started=!1}start(){this.started||(this.started=!0,this.eventListeners.forEach(eventListener=>eventListener.connect()))}stop(){this.started&&(this.started=!1,this.eventListeners.forEach(eventListener=>eventListener.disconnect()))}get eventListeners(){return Array.from(this.eventListenerMaps.values()).reduce((listeners,map)=>listeners.concat(Array.from(map.values())),[])}bindingConnected(binding){this.fetchEventListenerForBinding(binding).bindingConnected(binding)}bindingDisconnected(binding,clearEventListeners=!1){this.fetchEventListenerForBinding(binding).bindingDisconnected(binding),clearEventListeners&&this.clearEventListenersForBinding(binding)}handleError(error,message,detail={}){this.application.handleError(error,`Error ${message}`,detail)}clearEventListenersForBinding(binding){const eventListener=this.fetchEventListenerForBinding(binding);eventListener.hasBindings()||(eventListener.disconnect(),this.removeMappedEventListenerFor(binding))}removeMappedEventListenerFor(binding){const{eventTarget,eventName,eventOptions}=binding,eventListenerMap=this.fetchEventListenerMapForEventTarget(eventTarget),cacheKey=this.cacheKey(eventName,eventOptions);eventListenerMap.delete(cacheKey),0==eventListenerMap.size&&this.eventListenerMaps.delete(eventTarget)}fetchEventListenerForBinding(binding){const{eventTarget,eventName,eventOptions}=binding;return this.fetchEventListener(eventTarget,eventName,eventOptions)}fetchEventListener(eventTarget,eventName,eventOptions){const eventListenerMap=this.fetchEventListenerMapForEventTarget(eventTarget),cacheKey=this.cacheKey(eventName,eventOptions);let eventListener=eventListenerMap.get(cacheKey);return eventListener||(eventListener=this.createEventListener(eventTarget,eventName,eventOptions),eventListenerMap.set(cacheKey,eventListener)),eventListener}createEventListener(eventTarget,eventName,eventOptions){const eventListener=new EventListener(eventTarget,eventName,eventOptions);return this.started&&eventListener.connect(),eventListener}fetchEventListenerMapForEventTarget(eventTarget){let eventListenerMap=this.eventListenerMaps.get(eventTarget);return eventListenerMap||(eventListenerMap=new Map,this.eventListenerMaps.set(eventTarget,eventListenerMap)
vendor: 15,922 bytes, line 1
1),eventListenerMap}cacheKey(eventName,eventOptions){const parts=[eventName];return Object.keys(eventOptions).sort().forEach(key=>{parts.push(`${eventOptions[key]?"":"!"}${key}`)}),parts.join(":")}}const defaultActionDescriptorFilters={stop:({event,value})=>(value&&event.stopPropagation(),!0),prevent:({event,value})=>(value&&event.preventDefault(),!0),self:({event,value,element})=>!value||element===event.target},descriptorPattern=/^(?:(?:([^.]+?)\+)?(.+?)(?:\.(.+?))?(?:@(window|document))?->)?(.+?)(?:#([^:]+?))(?::(.+))?$/;function parseEventTarget(eventTargetName){return"window"==eventTargetName?window:"document"==eventTargetName?document:void 0}function camelize(value){return value.replace(/(?:[_-])([a-z0-9])/g,(_,char)=>char.toUpperCase())}function namespaceCamelize(value){return camelize(value.replace(/--/g,"-").replace(/__/g,"_"))}function capitalize(value){return value.charAt(0).toUpperCase()+value.slice(1)}function dasherize(value){return value.replace(/([A-Z])/g,(_,char)=>`-${char.toLowerCase()}`)}function isSomething(object){return null!=object}function hasProperty(object,property){return Object.prototype.hasOwnProperty.call(object,property)}const allModifiers=["meta","ctrl","alt","shift"];class Action{constructor(element,index,descriptor,schema){this.element=element,this.index=index,this.eventTarget=descriptor.eventTarget||element,this.eventName=descriptor.eventName||function getDefaultEventNameForElement(element){const tagName=element.tagName.toLowerCase();if(tagName in defaultEventNames)return defaultEventNames[tagName](element)}(element)||error("missing event name"),this.eventOptions=descriptor.eventOptions||{},this.identifier=descriptor.identifier||error("missing identifier"),this.methodName=descriptor.methodName||error("missing method name"),this.keyFilter=descriptor.keyFilter||"",this.schema=schema}static forToken(token,schema){return new this(token.element,token.index,function parseActionDescriptorString(descriptorString){const matches=descriptorString.trim().match(descriptorPattern)||[];let eventName=matches[2],keyFilter=matches[3];return keyFilter&&!["keydown","keyup","keypress"].includes(eventName)&&(eventName+=`.${keyFilter}`,keyFilter=""),{eventTarget:parseEventTarget(matches[4]),eventName,eventOptions:matches[7]?(eventOptions=matches[7],eventOptions.split(":").reduce((options,token)=>Object.assign(options,{[token.replace(/^!/,"")]:!/^!/.test(token)}),{})):{},identifier:matches[5],methodName:matches[6],keyFilter:matches[1]||keyFilter};var eventOptions}(token.content),schema)}toString(){const eventFilter=this.keyFilter?`.${this.keyFilter}`:"",eventTarget=this.eventTargetName?`@${this.eventTargetName}`:"";return`${this.eventName}${eventFilter}${eventTarget}->${this.identifier}#${this.methodName}`}shouldIgnoreKeyboardEvent(event){if(!this.keyFilter)return!1;const filters=this.keyFilter.split("+");if(this.keyFilterDissatisfied(event,filters))return!0;const standardFilter=filters.filter(key=>!allModifiers.includes(key))[0];return!!standardFilter&&(hasProperty(this.keyMappings,standardFilter)||error(`contains unknown key filter: ${this.keyFilter}`),this.keyMappings[standardFilter].toLowerCase()!==event.key.toLowerCase())}shouldIgnoreMouseEvent(event){if(!this.keyFilter)return!1;const filters=[this.keyFilter];return!!this.keyFilterDissatisfied(event,filters)}get params(){const params={},pattern=new RegExp(`^data-${this.identifier}-(.+)-param$`,"i");for(const{name,value}of Array.from(this.element.attributes)){const match=name.match(pattern),key=match&&match[1];key&&(params[camelize(key)]=typecast(value))}return params}get eventTargetName(){return function stringifyEventTarget(eventTarget){return eventTarget==window?"window":eventTarget==document?"document":void 0}(this.eventTarget)}get keyMappings(){return this.schema.keyMappings}keyFilterDissatisfied(event,filters){const[meta,ctrl,alt,shift]=allModifiers.map(modifier=>filters.includes(modifier));return event.metaKey!==meta||event.ctrlKey!==ctrl||event.altKey!==alt||event.shiftKey!==shift}}const defaultEventNames={a:()=>"click",button:()=>"click",form:()=>"submit",details:()=>"toggle",input:e=>"submit"==e.getAttribute("type")?"click":"input",select:()=>"change",textarea:()=>"input"};function error(message){throw new Error(message)}function typecast(value){try{return JSON.parse(value)}catch(o_O){return value}}class Binding{constructor(context,action){this.context=context,this.action=action}get index(){return this.action.index}get eventTarget(){return this.action.eventTarget}get eventOptions(){return this.action.eventOptions}get identifier(){return this.context.identifier}handleEvent(event){const actionEvent=this.prepareActionEvent(event);this.willBeInvokedByEvent(event)&&this.applyEventModifiers(actionEvent)&&this.invokeWithEvent(actionEvent)}get eventName(){return this.action.eventName}get method(){const method=this.controller[this.methodName];if("function"==typeof method)return method;throw new Error(`Action "${this.action}" references undefined method "${this.methodName}"`)}applyEventModifiers(event){const{element}=this.action,{actionDescriptorFilters}=this.context.application,{controller}=this.context;let passes=!0;for(const[name,value]of Object.entries(this.eventOptions))if(name in actionDescriptorFilters){const filter=actionDescriptorFilters[name];passes=passes&&filter({name,value,event,element,controller})}return passes}prepareActionEvent(event){return Object.assign(event,{params:this.action.params})}invokeWithEvent(event){const{target,currentTarget}=event;try{this.method.call(this.controller,event),this.context.logDebugActivity(this.methodName,{event,target,currentTarget,action:this.methodName})}catch(error){const{identifier,controller,element,index}=this,detail={identifier,controller,element,index,event};this.context.handleError(error,`invoking action "${this.action}"`,detail)}}willBeInvokedByEvent(event){const eventTarget=event.target;return!(event instanceof KeyboardEvent&&this.action.shouldIgnoreKeyboardEvent(event))&&(!(event instanceof MouseEvent&&this.action.shouldIgnoreMouseEvent(event))&&(this.element===eventTarget||(eventTarget instanceof Element&&this.element.contains(eventTarget)?this.scope.containsElement(eventTarget):this.scope.containsElement(this.action.element))))}get controller(){return this.context.controller}get methodName(){return this.action.methodName}get element(){return this.scope.element}get scope(){return this.context.scope}}class ElementObserver{constructor(element,delegate){this.mutationObserverInit={attributes:!0,childList:!0,subtree:!0},this.element=element,this.started=!1,this.delegate=delegate,this.elements=new Set,this.mutationObserver=new MutationObserver(mutations=>this.processMutations(mutations))}start(){this.started||(this.started=!0,this.mutationObserver.observe(this.element,this.mutationObserverInit),this.refresh())}pause(callback){this.started&&(this.mutationObserver.disconnect(),this.started=!1),callback(),this.started||(this.mutationObserver.observe(this.element,this.mutationObserverInit),this.started=!0)}stop(){this.started&&(this.mutationObserver.takeRecords(),this.mutationObserver.disconnect(),this.started=!1)}refresh(){if(this.started){const matches=new Set(this.matchElementsInTree());for(const element of Array.from(this.elements))matches.has(element)||this.removeElement(element);for(const element of Array.from(matches))this.addElement(element)}}processMutations(mutations){if(this.started)for(const mutation of mutations)this.processMutation(mutation)}processMutation(mutation){"attributes"==mutation.type?this.processAttributeChange(mutation.target,mutation.attributeName):"childList"==mutation.type&&(this.processRemovedNodes(mutation.removedNodes),this.processAddedNodes(mutation.addedNodes))}processAttributeChange(element,attributeName){this.elements.has(element)?this.delegate.elementAttributeChanged&&this.matchElement(element)?this.delegate.elementAttributeChanged(element,attributeName):this.removeElement(element):this.matchElement(element)&&this.addElement(element)}processRemovedNodes(nodes){for(const node of Array.from(nodes)){const element=this.elementFromNode(node);element&&this.processTree(element,this.removeElement)}}processAddedNodes(nodes){for(const node of Array.from(nodes)){const element=this.elementFromNode(node);element&&this.elementIsActive(element)&&this.processTree(element,this.addElement)}}matchElement(element){return this.delegate.matchElement(element)}matchElementsInTree(tree=this.element){return this.delegate.matchElementsInTree(tree)}processTree(tree,processor){for(const element of this.matchElementsInTree(tree))processor.call(this,element)}elementFromNode(node){if(node.nodeType==Node.ELEMENT_NODE)return node}elementIsActive(element){return element.isConnected==this.element.isConnected&&this.element.contains(element)}addElement(element){this.elements.has(element)||this.elementIsActive(element)&&(this.elements.add(element),this.delegate.elementMatched&&this.delegate.elementMatched(element))}removeElement(element){this.elements.has(element)&&(this.elements.delete(element),this.delegate.elementUnmatched&&this.delegate.elementUnmatched(element))}}class AttributeObserver{constructor(element,attributeName,delegate){this.attributeName=attributeName,this.delegate=delegate,this.elementObserver=new ElementObserver(element,this)}get element(){return this.elementObserver.element}get selector(){return`[${this.attributeName}]`}start(){this.elementObserver.start()}pause(callback){this.elementObserver.pause(callback)}stop(){this.elementObserver.stop()}refresh(){this.elementObserver.refresh()}get started(){return this.elementObserver.started}matchElement(element){return element.hasAttribute(this.attributeName)}matchElementsInTree(tree){const match=this.matchElement(tree)?[tree]:[],matches=Array.from(tree.querySelectorAll(this.selector));return match.concat(matches)}elementMatched(element){this.delegate.elementMatchedAttribute&&this.delegate.elementMatchedAttribute(element,this.attributeName)}elementUnmatched(element){this.delegate.elementUnmatchedAttribute&&this.delegate.elementUnmatchedAttribute(element,this.attributeName)}elementAttributeChanged(element,attributeName){this.delegate.elementAttributeValueChanged&&this.attributeName==attributeName&&this.delegate.elementAttributeValueChanged(element,attributeName)}}function add(map,key,value){fetch(map,key).add(value)}function del(map,key,value){fetch(map,key).delete(value),function prune(map,key){const values=map.get(key);null!=values&&0==values.size&&map.delete(key)}(map,key)}function fetch(map,key){let values=map.get(key);return values||(values=new Set,map.set(key,values)),values}class Multimap{constructor(){this.valuesByKey=new Map}get keys(){return Array.from(this.valuesByKey.keys())}get values(){return Array.from(this.valuesByKey.values()).reduce((values,set)=>values.concat(Array.from(set)),[])}get size(){return Array.from(this.valuesByKey.values()).reduce((size,set)=>size+set.size,0)}add(key,value){add(this.valuesByKey,key,value)}delete(key,value){del(this.valuesByKey,key,value)}has(key,value){const values=this.valuesByKey.get(key);return null!=values&&values.has(value)}hasKey(key){return this.valuesByKey.has(key)}hasValue(value){return Array.from(this.valuesByKey.values()).some(set=>set.has(value))}getValuesForKey(key){const values=this.valuesByKey.get(key);return values?Array.from(values):[]}getKeysForValue(value){return Array.from(this.valuesByKey).filter(([_key,values])=>values.has(value)).map(([key,_values])=>key)}}class SelectorObserver{constructor(element,selector,delegate,details){this._selector=selector,this.details=details,this.elementObserver=new ElementObserver(element,this),this.delegate=delegate,this.matchesByElement=new Multimap}get started(){return this.elementObserver.started}get selector(){return this._selector}set selector(selector){this._selector=selector,this.refresh()}start(){this.elementObserver.start()}pause(callback){this.elementObserver.pause(callback)}stop(){this.elementObserver.stop()}refresh(){this.elementObserver.refresh()}get element(){return this.elementObserver.element}matchElement(element){const{selector}=this;if(selector){const matches=element.matches(selector);return this.delegate.selectorMatchElement?matches&&this.delegate.selectorMatchElement(element,this.details):matches}return!1}matchElementsInTree(tree){const{selector}=this;if(selector){const match=this.matchElement(tree)?[tree]:[],matches=Array.from(tree.querySelectorAll(selector)).filter(match=>this.matchElement(match));return match.concat(matches)}return[]}elementMatched(element){const{selector}=this;selector&&this.selectorMatched(element,selector)}elementUnmatched(element){const selectors=this.matchesByElement.getKeysForValue(element);for(const selector of selectors)this.selectorUnmatched(element,selector)}elementAttributeChanged(element,_attributeName){const{selector}=this;if(selector){const matches=this.matchElement(element),matchedBefore=this.matchesByElement.has(selector,element);matches&&!matchedBefore?this.selectorMatched(element,selector):!matches&&matchedBefore&&this.selectorUnmatched(element,selector)}}selectorMatched(element,selector){this.delegate.selectorMatched(element,selector,this.details),this.matchesByElement.add(selector,element)}selectorUnmatched(element,selector){this.delegate.selectorUnmatched(element,selector,this.details),this.matchesByElement.delete(selector,element)}}class StringMapObserver{constructor(element,delegate){this.element=element,this.delegate=delegate,this.started=!1,this.stringMap=new Map,this.mutationObserver=new MutationObserver(mutations=>this.processMutations(mutations))}start(){this.started||(this.started=!0,this.mutationObserver.observe(this.element,{attributes:!0,attributeOldValue:!0}),this.refresh())}stop(){this.started&&(this.mutationObserver.takeRecords(),this.mutationObserver.disconnect(),this.started=!1)}refresh(){if(this.started)for(const attributeName of this.knownAttributeNames)this.refreshAttribute(attributeName,null)}processMutations(mutations){if(this.started)for(const mutation of mutations)this.processMutation(mutation)}processMutation(mutation){const attributeName=mutation.attributeName;attributeName&&this.refreshAttribute(attributeName,mutation.oldValue)}refreshAttribute(attributeName,oldValue){const key=this.delegate.getStringMapKeyForAttribute(attributeName);if(null!=key){this.stringMap.has(attributeName)||this.stringMapKeyAdded(key,attributeName);const value=this.element.getAttribute(attributeName);if(this.stringMap.get(attributeName)!=value&&this.stringMapValueChanged(value,key,oldValue),null==value){const oldValue=this.stringMap.get(attributeName);this.stringMap.delete(attributeName),oldValue&&this.stringMapKeyRemoved(key,attributeName,oldValue)}else this.stringMap.set(attributeName,value)}}stringMapKeyAdded(key,attributeName){this.delegate.stringMapKeyAdded&&this.delegate.stringMapKeyAdded(key,attributeName)}stringMapValueChanged(value,key,oldValue){this.delegate.stringMapValueChanged&&this.delegate.stringMapValueChanged(value,key,oldValue)}stringMapKeyRemoved(key,attributeName,oldValue){this.delegate.stringMapKeyRemoved&&this.delegate.stringMapKeyRemoved(key,attributeName,oldValue)}get knownAttributeNames(){return Array.from(new Set(this.currentAttributeNames.concat(this.recordedAttributeNames)))}get currentAttributeNames(){return Array.from(this.element.attributes).map(attribute=>attribute.name)}get recordedAttributeNames(){return Array.from(this.stringMap.keys())}}class TokenListObserver{constructor(element,attributeName,delegate){this.attributeObserver=new AttributeObserver(element,attributeName,this),this.delegate=delegate,this.tokensByElement=new Multimap}get started(){return this.attributeObserver.started}start(){this.attributeObserver.start()}pause(callback){this.attributeObserver.pause(callback)}stop(){this.attributeObserver.stop()}refresh(){this.attributeObserver.refresh()}
1get element(){return this.attributeObserver.element}get attributeName(){return this.attributeObserver.attributeName}elementMatchedAttribute(element){this.tokensMatched(this.readTokensForElement(element))}elementAttributeValueChanged(element){const[unmatchedTokens,matchedTokens]=this.refreshTokensForElement(element);this.tokensUnmatched(unmatchedTokens),this.tokensMatched(matchedTokens)}elementUnmatchedAttribute(element){this.tokensUnmatched(this.tokensByElement.getValuesForKey(element))}tokensMatched(tokens){tokens.forEach(token=>this.tokenMatched(token))}tokensUnmatched(tokens){tokens.forEach(token=>this.tokenUnmatched(token))}tokenMatched(token){this.delegate.tokenMatched(token),this.tokensByElement.add(token.element,token)}tokenUnmatched(token){this.delegate.tokenUnmatched(token),this.tokensByElement.delete(token.element,token)}refreshTokensForElement(element){const previousTokens=this.tokensByElement.getValuesForKey(element),currentTokens=this.readTokensForElement(element),firstDifferingIndex=function zip(left,right){const length=Math.max(left.length,right.length);return Array.from({length},(_,index)=>[left[index],right[index]])}(previousTokens,currentTokens).findIndex(([previousToken,currentToken])=>!function tokensAreEqual(left,right){return left&&right&&left.index==right.index&&left.content==right.content}(previousToken,currentToken));return-1==firstDifferingIndex?[[],[]]:[previousTokens.slice(firstDifferingIndex),currentTokens.slice(firstDifferingIndex)]}readTokensForElement(element){const attributeName=this.attributeName;return function parseTokenString(tokenString,element,attributeName){return tokenString.trim().split(/\s+/).filter(content=>content.length).map((content,index)=>({element,attributeName,content,index}))}(element.getAttribute(attributeName)||"",element,attributeName)}}class ValueListObserver{constructor(element,attributeName,delegate){this.tokenListObserver=new TokenListObserver(element,attributeName,this),this.delegate=delegate,this.parseResultsByToken=new WeakMap,this.valuesByTokenByElement=new WeakMap}get started(){return this.tokenListObserver.started}start(){this.tokenListObserver.start()}stop(){this.tokenListObserver.stop()}refresh(){this.tokenListObserver.refresh()}get element(){return this.tokenListObserver.element}get attributeName(){return this.tokenListObserver.attributeName}tokenMatched(token){const{element}=token,{value}=this.fetchParseResultForToken(token);value&&(this.fetchValuesByTokenForElement(element).set(token,value),this.delegate.elementMatchedValue(element,value))}tokenUnmatched(token){const{element}=token,{value}=this.fetchParseResultForToken(token);value&&(this.fetchValuesByTokenForElement(element).delete(token),this.delegate.elementUnmatchedValue(element,value))}fetchParseResultForToken(token){let parseResult=this.parseResultsByToken.get(token);return parseResult||(parseResult=this.parseToken(token),this.parseResultsByToken.set(token,parseResult)),parseResult}fetchValuesByTokenForElement(element){let valuesByToken=this.valuesByTokenByElement.get(element);return valuesByToken||(valuesByToken=new Map,this.valuesByTokenByElement.set(element,valuesByToken)),valuesByToken}parseToken(token){try{return{value:this.delegate.parseValueForToken(token)}}catch(error){return{error}}}}class BindingObserver{constructor(context,delegate){this.context=context,this.delegate=delegate,this.bindingsByAction=new Map}start(){this.valueListObserver||(this.valueListObserver=new ValueListObserver(this.element,this.actionAttribute,this),this.valueListObserver.start())}stop(){this.valueListObserver&&(this.valueListObserver.stop(),delete this.valueListObserver,this.disconnectAllActions())}get element(){return this.context.element}get identifier(){return this.context.identifier}get actionAttribute(){return this.schema.actionAttribute}get schema(){return this.context.schema}get bindings(){return Array.from(this.bindingsByAction.values())}connectAction(action){const binding=new Binding(this.context,action);this.bindingsByAction.set(action,binding),this.delegate.bindingConnected(binding)}disconnectAction(action){const binding=this.bindingsByAction.get(action);
vendor: 4,224 bytes, line 1
1binding&&(this.bindingsByAction.delete(action),this.delegate.bindingDisconnected(binding))}disconnectAllActions(){this.bindings.forEach(binding=>this.delegate.bindingDisconnected(binding,!0)),this.bindingsByAction.clear()}parseValueForToken(token){const action=Action.forToken(token,this.schema);if(action.identifier==this.identifier)return action}elementMatchedValue(element,action){this.connectAction(action)}elementUnmatchedValue(element,action){this.disconnectAction(action)}}class ValueObserver{constructor(context,receiver){this.context=context,this.receiver=receiver,this.stringMapObserver=new StringMapObserver(this.element,this),this.valueDescriptorMap=this.controller.valueDescriptorMap}start(){this.stringMapObserver.start(),this.invokeChangedCallbacksForDefaultValues()}stop(){this.stringMapObserver.stop()}get element(){return this.context.element}get controller(){return this.context.controller}getStringMapKeyForAttribute(attributeName){if(attributeName in this.valueDescriptorMap)return this.valueDescriptorMap[attributeName].name}stringMapKeyAdded(key,attributeName){const descriptor=this.valueDescriptorMap[attributeName];this.hasValue(key)||this.invokeChangedCallback(key,descriptor.writer(this.receiver[key]),descriptor.writer(descriptor.defaultValue))}stringMapValueChanged(value,name,oldValue){const descriptor=this.valueDescriptorNameMap[name];null!==value&&(null===oldValue&&(oldValue=descriptor.writer(descriptor.defaultValue)),this.invokeChangedCallback(name,value,oldValue))}stringMapKeyRemoved(key,attributeName,oldValue){const descriptor=this.valueDescriptorNameMap[key];this.hasValue(key)?this.invokeChangedCallback(key,descriptor.writer(this.receiver[key]),oldValue):this.invokeChangedCallback(key,descriptor.writer(descriptor.defaultValue),oldValue)}invokeChangedCallbacksForDefaultValues(){for(const{key,name,defaultValue,writer}of this.valueDescriptors)null==defaultValue||this.controller.data.has(key)||this.invokeChangedCallback(name,writer(defaultValue),void 0)}invokeChangedCallback(name,rawValue,rawOldValue){const changedMethodName=`${name}Changed`,changedMethod=this.receiver[changedMethodName];if("function"==typeof changedMethod){const descriptor=this.valueDescriptorNameMap[name];try{const value=descriptor.reader(rawValue);let oldValue=rawOldValue;rawOldValue&&(oldValue=descriptor.reader(rawOldValue)),changedMethod.call(this.receiver,value,oldValue)}catch(error){throw error instanceof TypeError&&(error.message=`Stimulus Value "${this.context.identifier}.${descriptor.name}" - ${error.message}`),error}}}get valueDescriptors(){const{valueDescriptorMap}=this;return Object.keys(valueDescriptorMap).map(key=>valueDescriptorMap[key])}get valueDescriptorNameMap(){const descriptors={};return Object.keys(this.valueDescriptorMap).forEach(key=>{const descriptor=this.valueDescriptorMap[key];descriptors[descriptor.name]=descriptor}),descriptors}hasValue(attributeName){const hasMethodName=`has${capitalize(this.valueDescriptorNameMap[attributeName].name)}`;return this.receiver[hasMethodName]}}class TargetObserver{constructor(context,delegate){this.context=context,this.delegate=delegate,this.targetsByName=new Multimap}start(){this.tokenListObserver||(this.tokenListObserver=new TokenListObserver(this.element,this.attributeName,this),this.tokenListObserver.start())}stop(){this.tokenListObserver&&(this.disconnectAllTargets(),this.tokenListObserver.stop(),delete this.tokenListObserver)}tokenMatched({element,content:name}){this.scope.containsElement(element)&&this.connectTarget(element,name)}tokenUnmatched({element,content:name}){this.disconnectTarget(element,name)}connectTarget(element,name){var _a;this.targetsByName.has(name,element)||(this.targetsByName.add(name,element),null===(_a=this.tokenListObserver)||void 0===_a||_a.pause(()=>this.delegate.targetConnected(element,name)))}disconnectTarget(element,name){var _a;this.targetsByName.has(name,element)&&(this.targetsByName.delete(name,element),null===(_a=this.tokenListObserver)||void 0===_a||_a.pause(()=>this.delegate.targetDisconnected(element,name)))}disconnectAllTargets(){for(const name of this.targetsByName.keys)for(const element of this.targetsByName.getValuesForKey(name))this.disconnectTarget(element,name)}
1get attributeName(){return`data-${this.context.identifier}-target`}get element(){return this.context.element}get scope(){return this.context.scope}}function readInheritableStaticArrayValues(constructor,propertyName){const ancestors=getAncestorsForConstructor(constructor);return Array.from(ancestors.reduce((values,constructor)=>(function getOwnStaticArrayValues(constructor,propertyName){const definition=constructor[propertyName];return Array.isArray(definition)?definition:[]}(constructor,propertyName).forEach(name=>values.add(name)),values),new Set))}function readInheritableStaticObjectPairs(constructor,propertyName){return getAncestorsForConstructor(constructor).reduce((pairs,constructor)=>(pairs.push(...function getOwnStaticObjectPairs(constructor,propertyName){const definition=constructor[propertyName];return definition?Object.keys(definition).map(key=>[key,definition[key]]):[]}(constructor,propertyName)),pairs),[])}function getAncestorsForConstructor(constructor){const ancestors=[];for(;constructor;)ancestors.push(constructor),constructor=Object.getPrototypeOf(constructor);return ancestors.reverse()}class OutletObserver{constructor(context,delegate){this.started=!1,this.context=context,this.delegate=delegate,this.outletsByName=new Multimap,this.outletElementsByName=new Multimap,this.selectorObserverMap=new Map,this.attributeObserverMap=new Map}start(){this.started||(this.outletDefinitions.forEach(outletName=>{this.setupSelectorObserverForOutlet(outletName),this.setupAttributeObserverForOutlet(outletName)}
vendor: 4,054 bytes, line 1
1),this.started=!0,this.dependentContexts.forEach(context=>context.refresh()))}refresh(){this.selectorObserverMap.forEach(observer=>observer.refresh()),this.attributeObserverMap.forEach(observer=>observer.refresh())}stop(){this.started&&(this.started=!1,this.disconnectAllOutlets(),this.stopSelectorObservers(),this.stopAttributeObservers())}stopSelectorObservers(){this.selectorObserverMap.size>0&&(this.selectorObserverMap.forEach(observer=>observer.stop()),this.selectorObserverMap.clear())}stopAttributeObservers(){this.attributeObserverMap.size>0&&(this.attributeObserverMap.forEach(observer=>observer.stop()),this.attributeObserverMap.clear())}selectorMatched(element,_selector,{outletName}){const outlet=this.getOutlet(element,outletName);outlet&&this.connectOutlet(outlet,element,outletName)}selectorUnmatched(element,_selector,{outletName}){const outlet=this.getOutletFromMap(element,outletName);outlet&&this.disconnectOutlet(outlet,element,outletName)}selectorMatchElement(element,{outletName}){const selector=this.selector(outletName),hasOutlet=this.hasOutlet(element,outletName),hasOutletController=element.matches(`[${this.schema.controllerAttribute}~=${outletName}]`);return!!selector&&(hasOutlet&&hasOutletController&&element.matches(selector))}elementMatchedAttribute(_element,attributeName){const outletName=this.getOutletNameFromOutletAttributeName(attributeName);outletName&&this.updateSelectorObserverForOutlet(outletName)}elementAttributeValueChanged(_element,attributeName){const outletName=this.getOutletNameFromOutletAttributeName(attributeName);outletName&&this.updateSelectorObserverForOutlet(outletName)}elementUnmatchedAttribute(_element,attributeName){const outletName=this.getOutletNameFromOutletAttributeName(attributeName);outletName&&this.updateSelectorObserverForOutlet(outletName)}connectOutlet(outlet,element,outletName){var _a;this.outletElementsByName.has(outletName,element)||(this.outletsByName.add(outletName,outlet),this.outletElementsByName.add(outletName,element),null===(_a=this.selectorObserverMap.get(outletName))||void 0===_a||_a.pause(()=>this.delegate.outletConnected(outlet,element,outletName)))}disconnectOutlet(outlet,element,outletName){var _a;this.outletElementsByName.has(outletName,element)&&(this.outletsByName.delete(outletName,outlet),this.outletElementsByName.delete(outletName,element),null===(_a=this.selectorObserverMap.get(outletName))||void 0===_a||_a.pause(()=>this.delegate.outletDisconnected(outlet,element,outletName)))}disconnectAllOutlets(){for(const outletName of this.outletElementsByName.keys)for(const element of this.outletElementsByName.getValuesForKey(outletName))for(const outlet of this.outletsByName.getValuesForKey(outletName))this.disconnectOutlet(outlet,element,outletName)}updateSelectorObserverForOutlet(outletName){const observer=this.selectorObserverMap.get(outletName);observer&&(observer.selector=this.selector(outletName))}setupSelectorObserverForOutlet(outletName){const selector=this.selector(outletName),selectorObserver=new SelectorObserver(document.body,selector,this,{outletName});this.selectorObserverMap.set(outletName,selectorObserver),selectorObserver.start()}setupAttributeObserverForOutlet(outletName){const attributeName=this.attributeNameForOutletName(outletName),attributeObserver=new AttributeObserver(this.scope.element,attributeName,this);this.attributeObserverMap.set(outletName,attributeObserver),attributeObserver.start()}selector(outletName){return this.scope.outlets.getSelectorForOutletName(outletName)}attributeNameForOutletName(outletName){return this.scope.schema.outletAttributeForScope(this.identifier,outletName)}getOutletNameFromOutletAttributeName(attributeName){return this.outletDefinitions.find(outletName=>this.attributeNameForOutletName(outletName)===attributeName)}get outletDependencies(){const dependencies=new Multimap;return this.router.modules.forEach(module=>{readInheritableStaticArrayValues(module.definition.controllerConstructor,"outlets").forEach(outlet=>dependencies.add(outlet,module.identifier))}),dependencies}
1get outletDefinitions(){return this.outletDependencies.getKeysForValue(this.identifier)}get dependentControllerIdentifiers(){return this.outletDependencies.getValuesForKey(this.identifier)}get dependentContexts(){const identifiers=this.dependentControllerIdentifiers;return this.router.contexts.filter(context=>identifiers.includes(context.identifier))}hasOutlet(element,outletName){return!!this.getOutlet(element,outletName)||!!this.getOutletFromMap(element,outletName)}getOutlet(element,outletName){return this.application.getControllerForElementAndIdentifier(element,outletName)}getOutletFromMap(element,outletName){return this.outletsByName.getValuesForKey(outletName).find(outlet=>outlet.element===element)}get scope(){return this.context.scope}get schema(){return this.context.schema}get identifier(){return this.context.identifier}get application(){return this.context.application}get router(){return this.application.router}}class Context{constructor(module,scope){this.logDebugActivity=(functionName,detail={})=>{const{identifier,controller,element}=this;detail=Object.assign({identifier,controller,element},detail),this.application.logDebugActivity(this.identifier,functionName,detail)},this.module=module,this.scope=scope,this.controller=new module.controllerConstructor(this),this.bindingObserver=new BindingObserver(this,this.dispatcher),this.valueObserver=new ValueObserver(this,this.controller),this.targetObserver=new TargetObserver(this,this),this.outletObserver=new OutletObserver(this,this);try{this.controller.initialize(),this.logDebugActivity("initialize")}catch(error){this.handleError(error,"initializing controller")}}connect(){this.bindingObserver.start(),this.valueObserver.start(),this.targetObserver.start(),this.outletObserver.start();try{this.controller.connect(),this.logDebugActivity("connect")}catch(error){this.handleError(error,"connecting controller")}}refresh(){this.outletObserver.refresh()}disconnect(){try{this.controller.disconnect(),this.logDebugActivity("disconnect")}catch(error){this.handleError(error,"disconnecting controller")}this.outletObserver.stop(),this.targetObserver.stop(),this.valueObserver.stop(),this.bindingObserver.stop()}get application(){return this.module.application}get identifier(){return this.module.identifier}get schema(){return this.application.schema}get dispatcher(){return this.application.dispatcher}get element(){return this.scope.element}get parentElement(){return this.element.parentElement}handleError(error,message,detail={}){const{identifier,controller,element}=this;detail=Object.assign({identifier,controller,element},detail),this.application.handleError(error,`Error ${message}`,detail)}targetConnected(element,name){this.invokeControllerMethod(`${name}TargetConnected`,element)}targetDisconnected(element,name){this.invokeControllerMethod(`${name}TargetDisconnected`,element)}outletConnected(outlet,element,name){this.invokeControllerMethod(`${namespaceCamelize(name)}OutletConnected`,outlet,element)}outletDisconnected(outlet,element,name){this.invokeControllerMethod(`${namespaceCamelize(name)}OutletDisconnected`,outlet,element)}invokeControllerMethod(methodName,...args){const controller=this.controller;"function"==typeof controller[methodName]&&controller[methodName](...args)}}function bless(constructor){return function shadow(constructor,properties){const shadowConstructor=extend(constructor),shadowProperties=function getShadowProperties(prototype,properties){return getOwnKeys(properties).reduce((shadowProperties,key)=>{const descriptor=function getShadowedDescriptor(prototype,properties,key){const shadowingDescriptor=Object.getOwnPropertyDescriptor(prototype,key);if(!shadowingDescriptor||!("value"in shadowingDescriptor)){const descriptor=Object.getOwnPropertyDescriptor(properties,key).value;return shadowingDescriptor&&(descriptor.get=shadowingDescriptor.get||descriptor.get,descriptor.set=shadowingDescriptor.set||descriptor.set),descriptor}}(prototype,properties,key);return descriptor&&Object.assign(shadowProperties,{[key]:descriptor}),shadowProperties},{})}(constructor.prototype,properties);return Object.defineProperties(shadowConstructor.prototype,shadowProperties),shadowConstructor}(constructor,function getBlessedProperties(constructor){const blessings=readInheritableStaticArrayValues(constructor,"blessings");return blessings.reduce((blessedProperties,blessing)=>{const properties=blessing(constructor);for(const key in properties){const descriptor=blessedProperties[key]||{};blessedProperties[key]=Object.assign(descriptor,properties[key])}return blessedProperties},{})}(constructor))}const getOwnKeys="function"==typeof Object.getOwnPropertySymbols?object=>[...Object.getOwnPropertyNames(object),...Object.getOwnPropertySymbols(object)]:Object.getOwnPropertyNames,extend=(()=>{function extendWithReflect(constructor){function extended(){return Reflect.construct(constructor,arguments,new.target)}return extended.prototype=Object.create(constructor.prototype,{constructor:{value:extended}}),Reflect.setPrototypeOf(extended,constructor),extended}try{return function testReflectExtension(){const b=extendWithReflect(function(){this.a.call(this)});return b.prototype.a=function(){},new b}(),extendWithReflect}catch(error){return constructor=>class extended extends constructor{}}})();class Module{constructor(application,definition){this.application=application,this.definition=function blessDefinition(definition){return{identifier:definition.identifier,controllerConstructor:bless(definition.controllerConstructor)}}(definition),this.contextsByScope=new WeakMap,this.connectedContexts=new Set}get identifier(){return this.definition.identifier}get controllerConstructor(){return this.definition.controllerConstructor}get contexts(){return Array.from(this.connectedContexts)}connectContextForScope(scope){const context=this.fetchContextForScope(scope);this.connectedContexts.add(context),context.connect()}disconnectContextForScope(scope){const context=this.contextsByScope.get(scope);context&&(this.connectedContexts.delete(context),context.disconnect())}fetchContextForScope(scope){let context=this.contextsByScope.get(scope);return context||(context=new Context(this,scope),this.contextsByScope.set(scope,context)),context}}class ClassMap{constructor(scope){this.scope=scope}has(name){return this.data.has(this.getDataKey(name))}get(name){return this.getAll(name)[0]}getAll(name){return function tokenize(value){return value.match(/[^\s]+/g)||[]}(this.data.get(this.getDataKey(name))||"")}getAttributeName(name){return this.data.getAttributeNameForKey(this.getDataKey(name))}getDataKey(name){return`${name}-class`}get data(){return this.scope.data}}class DataMap{constructor(scope){this.scope=scope}
vendor: 11,537 bytes, line 1
1get element(){return this.scope.element}get identifier(){return this.scope.identifier}get(key){const name=this.getAttributeNameForKey(key);return this.element.getAttribute(name)}set(key,value){const name=this.getAttributeNameForKey(key);return this.element.setAttribute(name,value),this.get(key)}has(key){const name=this.getAttributeNameForKey(key);return this.element.hasAttribute(name)}delete(key){if(this.has(key)){const name=this.getAttributeNameForKey(key);return this.element.removeAttribute(name),!0}return!1}getAttributeNameForKey(key){return`data-${this.identifier}-${dasherize(key)}`}}class Guide{constructor(logger){this.warnedKeysByObject=new WeakMap,this.logger=logger}warn(object,key,message){let warnedKeys=this.warnedKeysByObject.get(object);warnedKeys||(warnedKeys=new Set,this.warnedKeysByObject.set(object,warnedKeys)),warnedKeys.has(key)||(warnedKeys.add(key),this.logger.warn(message,object))}}function attributeValueContainsToken(attributeName,token){return`[${attributeName}~="${token}"]`}class TargetSet{constructor(scope){this.scope=scope}get element(){return this.scope.element}get identifier(){return this.scope.identifier}get schema(){return this.scope.schema}has(targetName){return null!=this.find(targetName)}find(...targetNames){return targetNames.reduce((target,targetName)=>target||this.findTarget(targetName)||this.findLegacyTarget(targetName),void 0)}findAll(...targetNames){return targetNames.reduce((targets,targetName)=>[...targets,...this.findAllTargets(targetName),...this.findAllLegacyTargets(targetName)],[])}findTarget(targetName){const selector=this.getSelectorForTargetName(targetName);return this.scope.findElement(selector)}findAllTargets(targetName){const selector=this.getSelectorForTargetName(targetName);return this.scope.findAllElements(selector)}getSelectorForTargetName(targetName){return attributeValueContainsToken(this.schema.targetAttributeForScope(this.identifier),targetName)}findLegacyTarget(targetName){const selector=this.getLegacySelectorForTargetName(targetName);return this.deprecate(this.scope.findElement(selector),targetName)}findAllLegacyTargets(targetName){const selector=this.getLegacySelectorForTargetName(targetName);return this.scope.findAllElements(selector).map(element=>this.deprecate(element,targetName))}getLegacySelectorForTargetName(targetName){const targetDescriptor=`${this.identifier}.${targetName}`;return attributeValueContainsToken(this.schema.targetAttribute,targetDescriptor)}deprecate(element,targetName){if(element){const{identifier}=this,attributeName=this.schema.targetAttribute,revisedAttributeName=this.schema.targetAttributeForScope(identifier);this.guide.warn(element,`target:${targetName}`,`Please replace ${attributeName}="${identifier}.${targetName}" with ${revisedAttributeName}="${targetName}". The ${attributeName} attribute is deprecated and will be removed in a future version of Stimulus.`)}return element}get guide(){return this.scope.guide}}class OutletSet{constructor(scope,controllerElement){this.scope=scope,this.controllerElement=controllerElement}get element(){return this.scope.element}get identifier(){return this.scope.identifier}get schema(){return this.scope.schema}has(outletName){return null!=this.find(outletName)}find(...outletNames){return outletNames.reduce((outlet,outletName)=>outlet||this.findOutlet(outletName),void 0)}findAll(...outletNames){return outletNames.reduce((outlets,outletName)=>[...outlets,...this.findAllOutlets(outletName)],[])}getSelectorForOutletName(outletName){const attributeName=this.schema.outletAttributeForScope(this.identifier,outletName);return this.controllerElement.getAttribute(attributeName)}findOutlet(outletName){const selector=this.getSelectorForOutletName(outletName);if(selector)return this.findElement(selector,outletName)}findAllOutlets(outletName){const selector=this.getSelectorForOutletName(outletName);return selector?this.findAllElements(selector,outletName):[]}findElement(selector,outletName){return this.scope.queryElements(selector).filter(element=>this.matchesElement(element,selector,outletName))[0]}findAllElements(selector,outletName){return this.scope.queryElements(selector).filter(element=>this.matchesElement(element,selector,outletName))}matchesElement(element,selector,outletName){const controllerAttribute=element.getAttribute(this.scope.schema.controllerAttribute)||"";return element.matches(selector)&&controllerAttribute.split(" ").includes(outletName)}}class Scope{constructor(schema,element,identifier,logger){this.targets=new TargetSet(this),this.classes=new ClassMap(this),this.data=new DataMap(this),this.containsElement=element=>element.closest(this.controllerSelector)===this.element,this.schema=schema,this.element=element,this.identifier=identifier,this.guide=new Guide(logger),this.outlets=new OutletSet(this.documentScope,element)}findElement(selector){return this.element.matches(selector)?this.element:this.queryElements(selector).find(this.containsElement)}findAllElements(selector){return[...this.element.matches(selector)?[this.element]:[],...this.queryElements(selector).filter(this.containsElement)]}queryElements(selector){return Array.from(this.element.querySelectorAll(selector))}get controllerSelector(){return attributeValueContainsToken(this.schema.controllerAttribute,this.identifier)}get isDocumentScope(){return this.element===document.documentElement}get documentScope(){return this.isDocumentScope?this:new Scope(this.schema,document.documentElement,this.identifier,this.guide.logger)}}class ScopeObserver{constructor(element,schema,delegate){this.element=element,this.schema=schema,this.delegate=delegate,this.valueListObserver=new ValueListObserver(this.element,this.controllerAttribute,this),this.scopesByIdentifierByElement=new WeakMap,this.scopeReferenceCounts=new WeakMap}start(){this.valueListObserver.start()}stop(){this.valueListObserver.stop()}get controllerAttribute(){return this.schema.controllerAttribute}parseValueForToken(token){const{element,content:identifier}=token;return this.parseValueForElementAndIdentifier(element,identifier)}parseValueForElementAndIdentifier(element,identifier){const scopesByIdentifier=this.fetchScopesByIdentifierForElement(element);let scope=scopesByIdentifier.get(identifier);return scope||(scope=this.delegate.createScopeForElementAndIdentifier(element,identifier),scopesByIdentifier.set(identifier,scope)),scope}elementMatchedValue(element,value){const referenceCount=(this.scopeReferenceCounts.get(value)||0)+1;this.scopeReferenceCounts.set(value,referenceCount),1==referenceCount&&this.delegate.scopeConnected(value)}elementUnmatchedValue(element,value){const referenceCount=this.scopeReferenceCounts.get(value);referenceCount&&(this.scopeReferenceCounts.set(value,referenceCount-1),1==referenceCount&&this.delegate.scopeDisconnected(value))}fetchScopesByIdentifierForElement(element){let scopesByIdentifier=this.scopesByIdentifierByElement.get(element);return scopesByIdentifier||(scopesByIdentifier=new Map,this.scopesByIdentifierByElement.set(element,scopesByIdentifier)),scopesByIdentifier}}class Router{constructor(application){this.application=application,this.scopeObserver=new ScopeObserver(this.element,this.schema,this),this.scopesByIdentifier=new Multimap,this.modulesByIdentifier=new Map}get element(){return this.application.element}get schema(){return this.application.schema}get logger(){return this.application.logger}get controllerAttribute(){return this.schema.controllerAttribute}get modules(){return Array.from(this.modulesByIdentifier.values())}get contexts(){return this.modules.reduce((contexts,module)=>contexts.concat(module.contexts),[])}start(){this.scopeObserver.start()}stop(){this.scopeObserver.stop()}loadDefinition(definition){this.unloadIdentifier(definition.identifier);const module=new Module(this.application,definition);this.connectModule(module);const afterLoad=definition.controllerConstructor.afterLoad;afterLoad&&afterLoad.call(definition.controllerConstructor,definition.identifier,this.application)}unloadIdentifier(identifier){const module=this.modulesByIdentifier.get(identifier);module&&this.disconnectModule(module)}getContextForElementAndIdentifier(element,identifier){const module=this.modulesByIdentifier.get(identifier);if(module)return module.contexts.find(context=>context.element==element)}proposeToConnectScopeForElementAndIdentifier(element,identifier){const scope=this.scopeObserver.parseValueForElementAndIdentifier(element,identifier);scope?this.scopeObserver.elementMatchedValue(scope.element,scope):console.error(`Couldn't find or create scope for identifier: "${identifier}" and element:`,element)}handleError(error,message,detail){this.application.handleError(error,message,detail)}createScopeForElementAndIdentifier(element,identifier){return new Scope(this.schema,element,identifier,this.logger)}scopeConnected(scope){this.scopesByIdentifier.add(scope.identifier,scope);const module=this.modulesByIdentifier.get(scope.identifier);module&&module.connectContextForScope(scope)}scopeDisconnected(scope){this.scopesByIdentifier.delete(scope.identifier,scope);const module=this.modulesByIdentifier.get(scope.identifier);module&&module.disconnectContextForScope(scope)}connectModule(module){this.modulesByIdentifier.set(module.identifier,module);this.scopesByIdentifier.getValuesForKey(module.identifier).forEach(scope=>module.connectContextForScope(scope))}disconnectModule(module){this.modulesByIdentifier.delete(module.identifier);this.scopesByIdentifier.getValuesForKey(module.identifier).forEach(scope=>module.disconnectContextForScope(scope))}}const defaultSchema={controllerAttribute:"data-controller",actionAttribute:"data-action",targetAttribute:"data-target",targetAttributeForScope:identifier=>`data-${identifier}-target`,outletAttributeForScope:(identifier,outlet)=>`data-${identifier}-${outlet}-outlet`,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])))};function objectFromEntries(array){return array.reduce((memo,[k,v])=>Object.assign(Object.assign({},memo),{[k]:v}),{})}class Application{constructor(element=document.documentElement,schema=defaultSchema){this.logger=console,this.debug=!1,this.logDebugActivity=(identifier,functionName,detail={})=>{this.debug&&this.logFormattedMessage(identifier,functionName,detail)},this.element=element,this.schema=schema,this.dispatcher=new Dispatcher(this),this.router=new Router(this),this.actionDescriptorFilters=Object.assign({},defaultActionDescriptorFilters)}static start(element,schema){const application=new this(element,schema);return application.start(),application}async start(){await function domReady(){return new Promise(resolve=>{"loading"==document.readyState?document.addEventListener("DOMContentLoaded",()=>resolve()):resolve()})}(),this.logDebugActivity("application","starting"),this.dispatcher.start(),this.router.start(),this.logDebugActivity("application","start")}stop(){this.logDebugActivity("application","stopping"),this.dispatcher.stop(),this.router.stop(),this.logDebugActivity("application","stop")}register(identifier,controllerConstructor){this.load({identifier,controllerConstructor})}registerActionOption(name,filter){this.actionDescriptorFilters[name]=filter}load(head,...rest){(Array.isArray(head)?head:[head,...rest]).forEac
1h(definition=>{definition.controllerConstructor.shouldLoad&&this.router.loadDefinition(definition)})}unload(head,...rest){(Array.isArray(head)?head:[head,...rest]).forEach(identifier=>this.router.unloadIdentifier(identifier))}get controllers(){return this.router.contexts.map(context=>context.controller)}getControllerForElementAndIdentifier(element,identifier){const context=this.router.getContextForElementAndIdentifier(element,identifier);return context?context.controller:null}handleError(error,message,detail){var _a;this.logger.error("%s\n\n%o\n\n%o",message,error,detail),null===(_a=window.onerror)||void 0===_a||_a.call(window,message,"",0,0,error)}logFormattedMessage(identifier,functionName,detail={}){detail=Object.assign({application:this},detail),this.logger.groupCollapsed(`${identifier} #${functionName}`),this.logger.log("details:",Object.assign({},detail)),this.logger.groupEnd()}}function getOutletController(controller,element,identifier){return controller.application.getControllerForElementAndIdentifier(element,identifier)}function getControllerAndEnsureConnectedScope(controller,element,outletName){let outletController=getOutletController(controller,element,outletName);return outletController||(controller.application.router.proposeToConnectScopeForElementAndIdentifier(element,outletName),outletController=getOutletController(controller,element,outletName),outletController||void 0)}function parseValueDefinitionPair([token,typeDefinition],controller){return function valueDescriptorForTokenAndTypeDefinition(payload){const{token,typeDefinition}=payload,key=`${dasherize(token)}-value`,type=function parseValueTypeDefinition(payload){const{controller,token,typeDefinition}=payload,typeObject={controller,token,typeObject:typeDefinition},typeFromObject=function parseValueTypeObject(payload){const{controller,token,typeObject}=payload,hasType=isSomething(typeObject.type),hasDefault=isSomething(typeObject.default),fullObject=hasType&&hasDefault,onlyType=hasType&&!hasDefault,onlyDefault=!hasType&&hasDefault,typeFromObject=parseValueTypeConstant(typeObject.type),typeFromDefaultValue=parseValueTypeDefault(payload.typeObject.default);if(onlyType)return typeFromObject;if(onlyDefault)return typeFromDefaultValue;if(typeFromObject!==typeFromDefaultValue){throw new Error(`The specified default value for the Stimulus Value "${controller?`${controller}.${token}`:token}" must match the defined type "${typeFromObject}". The provided default value of "${typeObject.default}" is of type "${typeFromDefaultValue}".`)}if(fullObject)return typeFromObject}(typeObject),typeFromDefaultValue=parseValueTypeDefault(typeDefinition),typeFromConstant=parseValueTypeConstant(typeDefinition),type=typeFromObject||typeFromDefaultValue||typeFromConstant;if(type)return type;const propertyPath=controller?`${controller}.${typeDefinition}`:token;throw new Error(`Unknown value type "${propertyPath}" for "${token}" value`)}(payload);return{type,key,name:camelize(key),get defaultValue(){return function defaultValueForDefinition(typeDefinition){const constant=parseValueTypeConstant(typeDefinition);if(constant)return defaultValuesByType[constant];const hasDefault=hasProperty(typeDefinition,"default"),hasType=hasProperty(typeDefinition,"type"),typeObject=typeDefinition;if(hasDefault)return typeObject.default;if(hasType){const{type}=typeObject,constantFromType=parseValueTypeConstant(type);if(constantFromType)return defaultValuesByType[constantFromType]}return typeDefinition}(typeDefinition)},get hasCustomDefaultValue(){return void 0!==parseValueTypeDefault(typeDefinition)},reader:readers[type],writer:writers[type]||writers.default}}({controller,token,typeDefinition})}function parseValueTypeConstant(constant){switch(constant){case Array:return"array";case Boolean:return"boolean";case Number:return"number";case Object:return"object";case String:return"string"}}function parseValueTypeDefault(defaultValue){switch(typeof defaultValue){case"boolean":return"boolean";case"number":return"number";case"string":return"string"}return Array.isArray(defaultValue)?"array":"[object Object]"===Object.prototype.toString.call(defaultValue)?"object":void 0}const defaultValuesByType={get array(){return[]},boolean:!1,number:0,get object(){return{}},string:""},readers={array(value){const array=JSON.parse(value);if(!Array.isArray(array))throw new TypeError(`expected value of type "array" but instead got value "${value}" of type "${parseValueTypeDefault(array)}"`);return array},boolean:value=>!("0"==value||"false"==String(value).toLowerCase()),number:value=>Number(value.replace(/_/g,"")),object(value){const object=JSON.parse(value);if(null===object||"object"!=typeof object||Array.isArray(object))throw new TypeError(`expected value of type "object" but instead got value "${value}" of type "${parseValueTypeDefault(object)}"`);return object},string:value=>value},writers={default:function writeString(value){return`${value}`},array:writeJSON,object:writeJSON};function writeJSON(value){return JSON.stringify(value)}class Controller{constructor(context){this.context=context}static get shouldLoad(){return!0}static afterLoad(_identifier,_application){}get application(){return this.context.application}get scope(){return this.context.scope}
1get element(){return this.scope.element}get identifier(){return this.scope.identifier}get targets(){return this.scope.targets}get outlets(){return this.scope.outlets}get classes(){return this.scope.classes}get data(){return this.scope.data}initialize(){}connect(){}disconnect(){}dispatch(eventName,{target=this.element,detail={},prefix=this.identifier,bubbles=!0,cancelable=!0}={}){const event=new CustomEvent(prefix?`${prefix}:${eventName}`:eventName,{detail,bubbles,cancelable});return target.dispatchEvent(event),event}}Controller.blessings=[function ClassPropertiesBlessing(constructor){return readInheritableStaticArrayValues(constructor,"classes").reduce((properties,classDefinition)=>Object.assign(properties,function propertiesForClassDefinition(key){return{[`${key}Class`]:{get(){const{classes}=this;if(classes.has(key))return classes.get(key);{const attribute=classes.getAttributeName(key);throw new Error(`Missing attribute "${attribute}"`)}}},[`${key}Classes`]:{get(){return this.classes.getAll(key)}},[`has${capitalize(key)}Class`]:{get(){return this.classes.has(key)}}}}(classDefinition)),{})},function TargetPropertiesBlessing(constructor){return readInheritableStaticArrayValues(constructor,"targets").reduce((properties,targetDefinition)=>Object.assign(properties,function propertiesForTargetDefinition(name){return{[`${name}Target`]:{get(){const target=this.targets.find(name);if(target)return target;throw new Error(`Missing target element "${name}" for "${this.identifier}" controller`)}},[`${name}Targets`]:{get(){return this.targets.findAll(name)}},[`has${capitalize(name)}Target`]:{get(){return this.targets.has(name)}}}}(targetDefinition)),{})},function ValuePropertiesBlessing(constructor){const valueDefinitionPairs=readInheritableStaticObjectPairs(constructor,"values"),propertyDescriptorMap={valueDescriptorMap:{get(){return valueDefinitionPairs.reduce((result,valueDefinitionPair)=>{const valueDescriptor=parseValueDefinitionPair(valueDefinitionPair,this.identifier),attributeName=this.data.getAttributeNameForKey(valueDescriptor.key);return Object.assign(result,{[attributeName]:valueDescriptor})},{})}}};return valueDefinitionPairs.reduce((properties,valueDefinitionPair)=>Object.assign(properties,function propertiesForValueDefinitionPair(valueDefinitionPair,controller){const definition=parseValueDefinitionPair(valueDefinitionPair,controller),{key,name,reader:read,writer:write}=definition;return{[name]:{get(){const value=this.data.get(key);return null!==value?read(value):definition.defaultValue},set(value){void 0===value?this.data.delete(key):this.data.set(key,write(value))}},[`has${capitalize(name)}`]:{get(){return this.data.has(key)||definition.hasCustomDefaultValue}}}}(valueDefinitionPair)),propertyDescriptorMap)},function OutletPropertiesBlessing(constructor){return readInheritableStaticArrayValues(constructor,"outlets").reduce((properties,outletDefinition)=>Object.assign(properties,function propertiesForOutletDefinition(name){const camelizedName=namespaceCamelize(name);return{[`${camelizedName}Outlet`]:{get(){const outletElement=this.outlets.find(name),selector=this.outlets.getSelectorForOutletName(name);if(outletElement){const outletController=getControllerAndEnsureConnectedScope(this,outletElement,name);if(outletController)return outletController;throw new Error(`The provided outlet element is missing an outlet controller "${name}" instance for host controller "${this.identifier}"`)}throw new Error(`Missing outlet element "${name}" for host controller "${this.identifier}". Stimulus couldn't find a matching outlet element using selector "${selector}".`)}},[`${camelizedName}Outlets`]:{get(){const outlets=this.outlets.findAll(name);return outlets.length>0?outlets.map(outletElement=>{const outletController=getControllerAndEnsureConnectedScope(this,outletElement,name);if(outletController)return outletController;console.warn(`The provided outlet element is missing an outlet controller "${name}" instance for host controller "${this.identifier}"`,outletElement)}).filter(controller=>controller):[]}},[`${camelizedName}OutletElement`]:{get(){const outletElement=this.outlets.find(name),selector=this.outlets.getSelectorForOutletName(name);if(outletElement)return outletElement;throw new Error(`Missing outlet element "${name}" for host controller "${this.identifier}". Stimulus couldn't find a matching outlet element using selector "${selector}".`)}},[`${camelizedName}OutletElements`]:{get(){return this.outlets.findAll(name)}},[`has${capitalize(camelizedName)}Outlet`]:{get(){return this.outlets.has(name)}}}}(outletDefinition)),{})}],Controller.targets=[],Controller.outlets=[],Controller.values={}}}]); 2//# sourceMappingURL=891.3a216eaf.js.map
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.