{"version":3,"file":"js/379-b5be9fa80e117327ec89.js","mappings":"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","sources":["webpack://app/./node_modules/@rails/actioncable/app/assets/javascripts/actioncable.esm.js","webpack://app/./node_modules/morphdom/dist/morphdom-esm.js","webpack://app/./node_modules/cable_ready/javascript/enums.js","webpack://app/./node_modules/cable_ready/javascript/utils.js","webpack://app/./node_modules/cable_ready/javascript/cable_ready.js","webpack://app/./node_modules/cable_ready/javascript/callbacks.js","webpack://app/./node_modules/stimulus_reflex/javascript/schema.js","webpack://app/./node_modules/stimulus_reflex/javascript/consumer.js","webpack://app/./node_modules/stimulus_reflex/javascript/utils.js","webpack://app/./node_modules/stimulus_reflex/javascript/debug.js","webpack://app/./node_modules/stimulus_reflex/javascript/lifecycle.js","webpack://app/./node_modules/stimulus_reflex/javascript/attributes.js","webpack://app/./node_modules/stimulus_reflex/javascript/controllers.js","webpack://app/./node_modules/stimulus_reflex/javascript/log.js","webpack://app/./node_modules/stimulus_reflex/javascript/stimulus_reflex.js"],"sourcesContent":["var adapters = {\n  logger: self.console,\n  WebSocket: self.WebSocket\n};\n\nvar logger = {\n  log(...messages) {\n    if (this.enabled) {\n      messages.push(Date.now());\n      adapters.logger.log(\"[ActionCable]\", ...messages);\n    }\n  }\n};\n\nconst now = () => (new Date).getTime();\n\nconst secondsSince = time => (now() - time) / 1e3;\n\nclass ConnectionMonitor {\n  constructor(connection) {\n    this.visibilityDidChange = this.visibilityDidChange.bind(this);\n    this.connection = connection;\n    this.reconnectAttempts = 0;\n  }\n  start() {\n    if (!this.isRunning()) {\n      this.startedAt = now();\n      delete this.stoppedAt;\n      this.startPolling();\n      addEventListener(\"visibilitychange\", this.visibilityDidChange);\n      logger.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);\n    }\n  }\n  stop() {\n    if (this.isRunning()) {\n      this.stoppedAt = now();\n      this.stopPolling();\n      removeEventListener(\"visibilitychange\", this.visibilityDidChange);\n      logger.log(\"ConnectionMonitor stopped\");\n    }\n  }\n  isRunning() {\n    return this.startedAt && !this.stoppedAt;\n  }\n  recordPing() {\n    this.pingedAt = now();\n  }\n  recordConnect() {\n    this.reconnectAttempts = 0;\n    this.recordPing();\n    delete this.disconnectedAt;\n    logger.log(\"ConnectionMonitor recorded connect\");\n  }\n  recordDisconnect() {\n    this.disconnectedAt = now();\n    logger.log(\"ConnectionMonitor recorded disconnect\");\n  }\n  startPolling() {\n    this.stopPolling();\n    this.poll();\n  }\n  stopPolling() {\n    clearTimeout(this.pollTimeout);\n  }\n  poll() {\n    this.pollTimeout = setTimeout((() => {\n      this.reconnectIfStale();\n      this.poll();\n    }), this.getPollInterval());\n  }\n  getPollInterval() {\n    const {staleThreshold: staleThreshold, reconnectionBackoffRate: reconnectionBackoffRate} = this.constructor;\n    const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));\n    const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;\n    const jitter = jitterMax * Math.random();\n    return staleThreshold * 1e3 * backoff * (1 + jitter);\n  }\n  reconnectIfStale() {\n    if (this.connectionIsStale()) {\n      logger.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);\n      this.reconnectAttempts++;\n      if (this.disconnectedRecently()) {\n        logger.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);\n      } else {\n        logger.log(\"ConnectionMonitor reopening\");\n        this.connection.reopen();\n      }\n    }\n  }\n  get refreshedAt() {\n    return this.pingedAt ? this.pingedAt : this.startedAt;\n  }\n  connectionIsStale() {\n    return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;\n  }\n  disconnectedRecently() {\n    return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;\n  }\n  visibilityDidChange() {\n    if (document.visibilityState === \"visible\") {\n      setTimeout((() => {\n        if (this.connectionIsStale() || !this.connection.isOpen()) {\n          logger.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`);\n          this.connection.reopen();\n        }\n      }), 200);\n    }\n  }\n}\n\nConnectionMonitor.staleThreshold = 6;\n\nConnectionMonitor.reconnectionBackoffRate = .15;\n\nvar INTERNAL = {\n  message_types: {\n    welcome: \"welcome\",\n    disconnect: \"disconnect\",\n    ping: \"ping\",\n    confirmation: \"confirm_subscription\",\n    rejection: \"reject_subscription\"\n  },\n  disconnect_reasons: {\n    unauthorized: \"unauthorized\",\n    invalid_request: \"invalid_request\",\n    server_restart: \"server_restart\"\n  },\n  default_mount_path: \"/cable\",\n  protocols: [ \"actioncable-v1-json\", \"actioncable-unsupported\" ]\n};\n\nconst {message_types: message_types, protocols: protocols} = INTERNAL;\n\nconst supportedProtocols = protocols.slice(0, protocols.length - 1);\n\nconst indexOf = [].indexOf;\n\nclass Connection {\n  constructor(consumer) {\n    this.open = this.open.bind(this);\n    this.consumer = consumer;\n    this.subscriptions = this.consumer.subscriptions;\n    this.monitor = new ConnectionMonitor(this);\n    this.disconnected = true;\n  }\n  send(data) {\n    if (this.isOpen()) {\n      this.webSocket.send(JSON.stringify(data));\n      return true;\n    } else {\n      return false;\n    }\n  }\n  open() {\n    if (this.isActive()) {\n      logger.log(`Attempted to open WebSocket, but existing socket is ${this.getState()}`);\n      return false;\n    } else {\n      logger.log(`Opening WebSocket, current state is ${this.getState()}, subprotocols: ${protocols}`);\n      if (this.webSocket) {\n        this.uninstallEventHandlers();\n      }\n      this.webSocket = new adapters.WebSocket(this.consumer.url, protocols);\n      this.installEventHandlers();\n      this.monitor.start();\n      return true;\n    }\n  }\n  close({allowReconnect: allowReconnect} = {\n    allowReconnect: true\n  }) {\n    if (!allowReconnect) {\n      this.monitor.stop();\n    }\n    if (this.isOpen()) {\n      return this.webSocket.close();\n    }\n  }\n  reopen() {\n    logger.log(`Reopening WebSocket, current state is ${this.getState()}`);\n    if (this.isActive()) {\n      try {\n        return this.close();\n      } catch (error) {\n        logger.log(\"Failed to reopen WebSocket\", error);\n      } finally {\n        logger.log(`Reopening WebSocket in ${this.constructor.reopenDelay}ms`);\n        setTimeout(this.open, this.constructor.reopenDelay);\n      }\n    } else {\n      return this.open();\n    }\n  }\n  getProtocol() {\n    if (this.webSocket) {\n      return this.webSocket.protocol;\n    }\n  }\n  isOpen() {\n    return this.isState(\"open\");\n  }\n  isActive() {\n    return this.isState(\"open\", \"connecting\");\n  }\n  isProtocolSupported() {\n    return indexOf.call(supportedProtocols, this.getProtocol()) >= 0;\n  }\n  isState(...states) {\n    return indexOf.call(states, this.getState()) >= 0;\n  }\n  getState() {\n    if (this.webSocket) {\n      for (let state in adapters.WebSocket) {\n        if (adapters.WebSocket[state] === this.webSocket.readyState) {\n          return state.toLowerCase();\n        }\n      }\n    }\n    return null;\n  }\n  installEventHandlers() {\n    for (let eventName in this.events) {\n      const handler = this.events[eventName].bind(this);\n      this.webSocket[`on${eventName}`] = handler;\n    }\n  }\n  uninstallEventHandlers() {\n    for (let eventName in this.events) {\n      this.webSocket[`on${eventName}`] = function() {};\n    }\n  }\n}\n\nConnection.reopenDelay = 500;\n\nConnection.prototype.events = {\n  message(event) {\n    if (!this.isProtocolSupported()) {\n      return;\n    }\n    const {identifier: identifier, message: message, reason: reason, reconnect: reconnect, type: type} = JSON.parse(event.data);\n    switch (type) {\n     case message_types.welcome:\n      this.monitor.recordConnect();\n      return this.subscriptions.reload();\n\n     case message_types.disconnect:\n      logger.log(`Disconnecting. Reason: ${reason}`);\n      return this.close({\n        allowReconnect: reconnect\n      });\n\n     case message_types.ping:\n      return this.monitor.recordPing();\n\n     case message_types.confirmation:\n      this.subscriptions.confirmSubscription(identifier);\n      return this.subscriptions.notify(identifier, \"connected\");\n\n     case message_types.rejection:\n      return this.subscriptions.reject(identifier);\n\n     default:\n      return this.subscriptions.notify(identifier, \"received\", message);\n    }\n  },\n  open() {\n    logger.log(`WebSocket onopen event, using '${this.getProtocol()}' subprotocol`);\n    this.disconnected = false;\n    if (!this.isProtocolSupported()) {\n      logger.log(\"Protocol is unsupported. Stopping monitor and disconnecting.\");\n      return this.close({\n        allowReconnect: false\n      });\n    }\n  },\n  close(event) {\n    logger.log(\"WebSocket onclose event\");\n    if (this.disconnected) {\n      return;\n    }\n    this.disconnected = true;\n    this.monitor.recordDisconnect();\n    return this.subscriptions.notifyAll(\"disconnected\", {\n      willAttemptReconnect: this.monitor.isRunning()\n    });\n  },\n  error() {\n    logger.log(\"WebSocket onerror event\");\n  }\n};\n\nconst extend = function(object, properties) {\n  if (properties != null) {\n    for (let key in properties) {\n      const value = properties[key];\n      object[key] = value;\n    }\n  }\n  return object;\n};\n\nclass Subscription {\n  constructor(consumer, params = {}, mixin) {\n    this.consumer = consumer;\n    this.identifier = JSON.stringify(params);\n    extend(this, mixin);\n  }\n  perform(action, data = {}) {\n    data.action = action;\n    return this.send(data);\n  }\n  send(data) {\n    return this.consumer.send({\n      command: \"message\",\n      identifier: this.identifier,\n      data: JSON.stringify(data)\n    });\n  }\n  unsubscribe() {\n    return this.consumer.subscriptions.remove(this);\n  }\n}\n\nclass SubscriptionGuarantor {\n  constructor(subscriptions) {\n    this.subscriptions = subscriptions;\n    this.pendingSubscriptions = [];\n  }\n  guarantee(subscription) {\n    if (this.pendingSubscriptions.indexOf(subscription) == -1) {\n      logger.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`);\n      this.pendingSubscriptions.push(subscription);\n    } else {\n      logger.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`);\n    }\n    this.startGuaranteeing();\n  }\n  forget(subscription) {\n    logger.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`);\n    this.pendingSubscriptions = this.pendingSubscriptions.filter((s => s !== subscription));\n  }\n  startGuaranteeing() {\n    this.stopGuaranteeing();\n    this.retrySubscribing();\n  }\n  stopGuaranteeing() {\n    clearTimeout(this.retryTimeout);\n  }\n  retrySubscribing() {\n    this.retryTimeout = setTimeout((() => {\n      if (this.subscriptions && typeof this.subscriptions.subscribe === \"function\") {\n        this.pendingSubscriptions.map((subscription => {\n          logger.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`);\n          this.subscriptions.subscribe(subscription);\n        }));\n      }\n    }), 500);\n  }\n}\n\nclass Subscriptions {\n  constructor(consumer) {\n    this.consumer = consumer;\n    this.guarantor = new SubscriptionGuarantor(this);\n    this.subscriptions = [];\n  }\n  create(channelName, mixin) {\n    const channel = channelName;\n    const params = typeof channel === \"object\" ? channel : {\n      channel: channel\n    };\n    const subscription = new Subscription(this.consumer, params, mixin);\n    return this.add(subscription);\n  }\n  add(subscription) {\n    this.subscriptions.push(subscription);\n    this.consumer.ensureActiveConnection();\n    this.notify(subscription, \"initialized\");\n    this.subscribe(subscription);\n    return subscription;\n  }\n  remove(subscription) {\n    this.forget(subscription);\n    if (!this.findAll(subscription.identifier).length) {\n      this.sendCommand(subscription, \"unsubscribe\");\n    }\n    return subscription;\n  }\n  reject(identifier) {\n    return this.findAll(identifier).map((subscription => {\n      this.forget(subscription);\n      this.notify(subscription, \"rejected\");\n      return subscription;\n    }));\n  }\n  forget(subscription) {\n    this.guarantor.forget(subscription);\n    this.subscriptions = this.subscriptions.filter((s => s !== subscription));\n    return subscription;\n  }\n  findAll(identifier) {\n    return this.subscriptions.filter((s => s.identifier === identifier));\n  }\n  reload() {\n    return this.subscriptions.map((subscription => this.subscribe(subscription)));\n  }\n  notifyAll(callbackName, ...args) {\n    return this.subscriptions.map((subscription => this.notify(subscription, callbackName, ...args)));\n  }\n  notify(subscription, callbackName, ...args) {\n    let subscriptions;\n    if (typeof subscription === \"string\") {\n      subscriptions = this.findAll(subscription);\n    } else {\n      subscriptions = [ subscription ];\n    }\n    return subscriptions.map((subscription => typeof subscription[callbackName] === \"function\" ? subscription[callbackName](...args) : undefined));\n  }\n  subscribe(subscription) {\n    if (this.sendCommand(subscription, \"subscribe\")) {\n      this.guarantor.guarantee(subscription);\n    }\n  }\n  confirmSubscription(identifier) {\n    logger.log(`Subscription confirmed ${identifier}`);\n    this.findAll(identifier).map((subscription => this.guarantor.forget(subscription)));\n  }\n  sendCommand(subscription, command) {\n    const {identifier: identifier} = subscription;\n    return this.consumer.send({\n      command: command,\n      identifier: identifier\n    });\n  }\n}\n\nclass Consumer {\n  constructor(url) {\n    this._url = url;\n    this.subscriptions = new Subscriptions(this);\n    this.connection = new Connection(this);\n  }\n  get url() {\n    return createWebSocketURL(this._url);\n  }\n  send(data) {\n    return this.connection.send(data);\n  }\n  connect() {\n    return this.connection.open();\n  }\n  disconnect() {\n    return this.connection.close({\n      allowReconnect: false\n    });\n  }\n  ensureActiveConnection() {\n    if (!this.connection.isActive()) {\n      return this.connection.open();\n    }\n  }\n}\n\nfunction createWebSocketURL(url) {\n  if (typeof url === \"function\") {\n    url = url();\n  }\n  if (url && !/^wss?:/i.test(url)) {\n    const a = document.createElement(\"a\");\n    a.href = url;\n    a.href = a.href;\n    a.protocol = a.protocol.replace(\"http\", \"ws\");\n    return a.href;\n  } else {\n    return url;\n  }\n}\n\nfunction createConsumer(url = getConfig(\"url\") || INTERNAL.default_mount_path) {\n  return new Consumer(url);\n}\n\nfunction getConfig(name) {\n  const element = document.head.querySelector(`meta[name='action-cable-${name}']`);\n  if (element) {\n    return element.getAttribute(\"content\");\n  }\n}\n\nexport { Connection, ConnectionMonitor, Consumer, INTERNAL, Subscription, SubscriptionGuarantor, Subscriptions, adapters, createConsumer, createWebSocketURL, getConfig, logger };\n","var DOCUMENT_FRAGMENT_NODE = 11;\n\nfunction morphAttrs(fromNode, toNode) {\n    var toNodeAttrs = toNode.attributes;\n    var attr;\n    var attrName;\n    var attrNamespaceURI;\n    var attrValue;\n    var fromValue;\n\n    // document-fragments dont have attributes so lets not do anything\n    if (toNode.nodeType === DOCUMENT_FRAGMENT_NODE || fromNode.nodeType === DOCUMENT_FRAGMENT_NODE) {\n      return;\n    }\n\n    // update attributes on original DOM element\n    for (var i = toNodeAttrs.length - 1; i >= 0; i--) {\n        attr = toNodeAttrs[i];\n        attrName = attr.name;\n        attrNamespaceURI = attr.namespaceURI;\n        attrValue = attr.value;\n\n        if (attrNamespaceURI) {\n            attrName = attr.localName || attrName;\n            fromValue = fromNode.getAttributeNS(attrNamespaceURI, attrName);\n\n            if (fromValue !== attrValue) {\n                if (attr.prefix === 'xmlns'){\n                    attrName = attr.name; // It's not allowed to set an attribute with the XMLNS namespace without specifying the `xmlns` prefix\n                }\n                fromNode.setAttributeNS(attrNamespaceURI, attrName, attrValue);\n            }\n        } else {\n            fromValue = fromNode.getAttribute(attrName);\n\n            if (fromValue !== attrValue) {\n                fromNode.setAttribute(attrName, attrValue);\n            }\n        }\n    }\n\n    // Remove any extra attributes found on the original DOM element that\n    // weren't found on the target element.\n    var fromNodeAttrs = fromNode.attributes;\n\n    for (var d = fromNodeAttrs.length - 1; d >= 0; d--) {\n        attr = fromNodeAttrs[d];\n        attrName = attr.name;\n        attrNamespaceURI = attr.namespaceURI;\n\n        if (attrNamespaceURI) {\n            attrName = attr.localName || attrName;\n\n            if (!toNode.hasAttributeNS(attrNamespaceURI, attrName)) {\n                fromNode.removeAttributeNS(attrNamespaceURI, attrName);\n            }\n        } else {\n            if (!toNode.hasAttribute(attrName)) {\n                fromNode.removeAttribute(attrName);\n            }\n        }\n    }\n}\n\nvar range; // Create a range object for efficently rendering strings to elements.\nvar NS_XHTML = 'http://www.w3.org/1999/xhtml';\n\nvar doc = typeof document === 'undefined' ? undefined : document;\nvar HAS_TEMPLATE_SUPPORT = !!doc && 'content' in doc.createElement('template');\nvar HAS_RANGE_SUPPORT = !!doc && doc.createRange && 'createContextualFragment' in doc.createRange();\n\nfunction createFragmentFromTemplate(str) {\n    var template = doc.createElement('template');\n    template.innerHTML = str;\n    return template.content.childNodes[0];\n}\n\nfunction createFragmentFromRange(str) {\n    if (!range) {\n        range = doc.createRange();\n        range.selectNode(doc.body);\n    }\n\n    var fragment = range.createContextualFragment(str);\n    return fragment.childNodes[0];\n}\n\nfunction createFragmentFromWrap(str) {\n    var fragment = doc.createElement('body');\n    fragment.innerHTML = str;\n    return fragment.childNodes[0];\n}\n\n/**\n * This is about the same\n * var html = new DOMParser().parseFromString(str, 'text/html');\n * return html.body.firstChild;\n *\n * @method toElement\n * @param {String} str\n */\nfunction toElement(str) {\n    str = str.trim();\n    if (HAS_TEMPLATE_SUPPORT) {\n      // avoid restrictions on content for things like `<tr><th>Hi</th></tr>` which\n      // createContextualFragment doesn't support\n      // <template> support not available in IE\n      return createFragmentFromTemplate(str);\n    } else if (HAS_RANGE_SUPPORT) {\n      return createFragmentFromRange(str);\n    }\n\n    return createFragmentFromWrap(str);\n}\n\n/**\n * Returns true if two node's names are the same.\n *\n * NOTE: We don't bother checking `namespaceURI` because you will never find two HTML elements with the same\n *       nodeName and different namespace URIs.\n *\n * @param {Element} a\n * @param {Element} b The target element\n * @return {boolean}\n */\nfunction compareNodeNames(fromEl, toEl) {\n    var fromNodeName = fromEl.nodeName;\n    var toNodeName = toEl.nodeName;\n    var fromCodeStart, toCodeStart;\n\n    if (fromNodeName === toNodeName) {\n        return true;\n    }\n\n    fromCodeStart = fromNodeName.charCodeAt(0);\n    toCodeStart = toNodeName.charCodeAt(0);\n\n    // If the target element is a virtual DOM node or SVG node then we may\n    // need to normalize the tag name before comparing. Normal HTML elements that are\n    // in the \"http://www.w3.org/1999/xhtml\"\n    // are converted to upper case\n    if (fromCodeStart <= 90 && toCodeStart >= 97) { // from is upper and to is lower\n        return fromNodeName === toNodeName.toUpperCase();\n    } else if (toCodeStart <= 90 && fromCodeStart >= 97) { // to is upper and from is lower\n        return toNodeName === fromNodeName.toUpperCase();\n    } else {\n        return false;\n    }\n}\n\n/**\n * Create an element, optionally with a known namespace URI.\n *\n * @param {string} name the element name, e.g. 'div' or 'svg'\n * @param {string} [namespaceURI] the element's namespace URI, i.e. the value of\n * its `xmlns` attribute or its inferred namespace.\n *\n * @return {Element}\n */\nfunction createElementNS(name, namespaceURI) {\n    return !namespaceURI || namespaceURI === NS_XHTML ?\n        doc.createElement(name) :\n        doc.createElementNS(namespaceURI, name);\n}\n\n/**\n * Copies the children of one DOM element to another DOM element\n */\nfunction moveChildren(fromEl, toEl) {\n    var curChild = fromEl.firstChild;\n    while (curChild) {\n        var nextChild = curChild.nextSibling;\n        toEl.appendChild(curChild);\n        curChild = nextChild;\n    }\n    return toEl;\n}\n\nfunction syncBooleanAttrProp(fromEl, toEl, name) {\n    if (fromEl[name] !== toEl[name]) {\n        fromEl[name] = toEl[name];\n        if (fromEl[name]) {\n            fromEl.setAttribute(name, '');\n        } else {\n            fromEl.removeAttribute(name);\n        }\n    }\n}\n\nvar specialElHandlers = {\n    OPTION: function(fromEl, toEl) {\n        var parentNode = fromEl.parentNode;\n        if (parentNode) {\n            var parentName = parentNode.nodeName.toUpperCase();\n            if (parentName === 'OPTGROUP') {\n                parentNode = parentNode.parentNode;\n                parentName = parentNode && parentNode.nodeName.toUpperCase();\n            }\n            if (parentName === 'SELECT' && !parentNode.hasAttribute('multiple')) {\n                if (fromEl.hasAttribute('selected') && !toEl.selected) {\n                    // Workaround for MS Edge bug where the 'selected' attribute can only be\n                    // removed if set to a non-empty value:\n                    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12087679/\n                    fromEl.setAttribute('selected', 'selected');\n                    fromEl.removeAttribute('selected');\n                }\n                // We have to reset select element's selectedIndex to -1, otherwise setting\n                // fromEl.selected using the syncBooleanAttrProp below has no effect.\n                // The correct selectedIndex will be set in the SELECT special handler below.\n                parentNode.selectedIndex = -1;\n            }\n        }\n        syncBooleanAttrProp(fromEl, toEl, 'selected');\n    },\n    /**\n     * The \"value\" attribute is special for the <input> element since it sets\n     * the initial value. Changing the \"value\" attribute without changing the\n     * \"value\" property will have no effect since it is only used to the set the\n     * initial value.  Similar for the \"checked\" attribute, and \"disabled\".\n     */\n    INPUT: function(fromEl, toEl) {\n        syncBooleanAttrProp(fromEl, toEl, 'checked');\n        syncBooleanAttrProp(fromEl, toEl, 'disabled');\n\n        if (fromEl.value !== toEl.value) {\n            fromEl.value = toEl.value;\n        }\n\n        if (!toEl.hasAttribute('value')) {\n            fromEl.removeAttribute('value');\n        }\n    },\n\n    TEXTAREA: function(fromEl, toEl) {\n        var newValue = toEl.value;\n        if (fromEl.value !== newValue) {\n            fromEl.value = newValue;\n        }\n\n        var firstChild = fromEl.firstChild;\n        if (firstChild) {\n            // Needed for IE. Apparently IE sets the placeholder as the\n            // node value and vise versa. This ignores an empty update.\n            var oldValue = firstChild.nodeValue;\n\n            if (oldValue == newValue || (!newValue && oldValue == fromEl.placeholder)) {\n                return;\n            }\n\n            firstChild.nodeValue = newValue;\n        }\n    },\n    SELECT: function(fromEl, toEl) {\n        if (!toEl.hasAttribute('multiple')) {\n            var selectedIndex = -1;\n            var i = 0;\n            // We have to loop through children of fromEl, not toEl since nodes can be moved\n            // from toEl to fromEl directly when morphing.\n            // At the time this special handler is invoked, all children have already been morphed\n            // and appended to / removed from fromEl, so using fromEl here is safe and correct.\n            var curChild = fromEl.firstChild;\n            var optgroup;\n            var nodeName;\n            while(curChild) {\n                nodeName = curChild.nodeName && curChild.nodeName.toUpperCase();\n                if (nodeName === 'OPTGROUP') {\n                    optgroup = curChild;\n                    curChild = optgroup.firstChild;\n                } else {\n                    if (nodeName === 'OPTION') {\n                        if (curChild.hasAttribute('selected')) {\n                            selectedIndex = i;\n                            break;\n                        }\n                        i++;\n                    }\n                    curChild = curChild.nextSibling;\n                    if (!curChild && optgroup) {\n                        curChild = optgroup.nextSibling;\n                        optgroup = null;\n                    }\n                }\n            }\n\n            fromEl.selectedIndex = selectedIndex;\n        }\n    }\n};\n\nvar ELEMENT_NODE = 1;\nvar DOCUMENT_FRAGMENT_NODE$1 = 11;\nvar TEXT_NODE = 3;\nvar COMMENT_NODE = 8;\n\nfunction noop() {}\n\nfunction defaultGetNodeKey(node) {\n  if (node) {\n      return (node.getAttribute && node.getAttribute('id')) || node.id;\n  }\n}\n\nfunction morphdomFactory(morphAttrs) {\n\n    return function morphdom(fromNode, toNode, options) {\n        if (!options) {\n            options = {};\n        }\n\n        if (typeof toNode === 'string') {\n            if (fromNode.nodeName === '#document' || fromNode.nodeName === 'HTML' || fromNode.nodeName === 'BODY') {\n                var toNodeHtml = toNode;\n                toNode = doc.createElement('html');\n                toNode.innerHTML = toNodeHtml;\n            } else {\n                toNode = toElement(toNode);\n            }\n        }\n\n        var getNodeKey = options.getNodeKey || defaultGetNodeKey;\n        var onBeforeNodeAdded = options.onBeforeNodeAdded || noop;\n        var onNodeAdded = options.onNodeAdded || noop;\n        var onBeforeElUpdated = options.onBeforeElUpdated || noop;\n        var onElUpdated = options.onElUpdated || noop;\n        var onBeforeNodeDiscarded = options.onBeforeNodeDiscarded || noop;\n        var onNodeDiscarded = options.onNodeDiscarded || noop;\n        var onBeforeElChildrenUpdated = options.onBeforeElChildrenUpdated || noop;\n        var childrenOnly = options.childrenOnly === true;\n\n        // This object is used as a lookup to quickly find all keyed elements in the original DOM tree.\n        var fromNodesLookup = Object.create(null);\n        var keyedRemovalList = [];\n\n        function addKeyedRemoval(key) {\n            keyedRemovalList.push(key);\n        }\n\n        function walkDiscardedChildNodes(node, skipKeyedNodes) {\n            if (node.nodeType === ELEMENT_NODE) {\n                var curChild = node.firstChild;\n                while (curChild) {\n\n                    var key = undefined;\n\n                    if (skipKeyedNodes && (key = getNodeKey(curChild))) {\n                        // If we are skipping keyed nodes then we add the key\n                        // to a list so that it can be handled at the very end.\n                        addKeyedRemoval(key);\n                    } else {\n                        // Only report the node as discarded if it is not keyed. We do this because\n                        // at the end we loop through all keyed elements that were unmatched\n                        // and then discard them in one final pass.\n                        onNodeDiscarded(curChild);\n                        if (curChild.firstChild) {\n                            walkDiscardedChildNodes(curChild, skipKeyedNodes);\n                        }\n                    }\n\n                    curChild = curChild.nextSibling;\n                }\n            }\n        }\n\n        /**\n         * Removes a DOM node out of the original DOM\n         *\n         * @param  {Node} node The node to remove\n         * @param  {Node} parentNode The nodes parent\n         * @param  {Boolean} skipKeyedNodes If true then elements with keys will be skipped and not discarded.\n         * @return {undefined}\n         */\n        function removeNode(node, parentNode, skipKeyedNodes) {\n            if (onBeforeNodeDiscarded(node) === false) {\n                return;\n            }\n\n            if (parentNode) {\n                parentNode.removeChild(node);\n            }\n\n            onNodeDiscarded(node);\n            walkDiscardedChildNodes(node, skipKeyedNodes);\n        }\n\n        // // TreeWalker implementation is no faster, but keeping this around in case this changes in the future\n        // function indexTree(root) {\n        //     var treeWalker = document.createTreeWalker(\n        //         root,\n        //         NodeFilter.SHOW_ELEMENT);\n        //\n        //     var el;\n        //     while((el = treeWalker.nextNode())) {\n        //         var key = getNodeKey(el);\n        //         if (key) {\n        //             fromNodesLookup[key] = el;\n        //         }\n        //     }\n        // }\n\n        // // NodeIterator implementation is no faster, but keeping this around in case this changes in the future\n        //\n        // function indexTree(node) {\n        //     var nodeIterator = document.createNodeIterator(node, NodeFilter.SHOW_ELEMENT);\n        //     var el;\n        //     while((el = nodeIterator.nextNode())) {\n        //         var key = getNodeKey(el);\n        //         if (key) {\n        //             fromNodesLookup[key] = el;\n        //         }\n        //     }\n        // }\n\n        function indexTree(node) {\n            if (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE$1) {\n                var curChild = node.firstChild;\n                while (curChild) {\n                    var key = getNodeKey(curChild);\n                    if (key) {\n                        fromNodesLookup[key] = curChild;\n                    }\n\n                    // Walk recursively\n                    indexTree(curChild);\n\n                    curChild = curChild.nextSibling;\n                }\n            }\n        }\n\n        indexTree(fromNode);\n\n        function handleNodeAdded(el) {\n            onNodeAdded(el);\n\n            var curChild = el.firstChild;\n            while (curChild) {\n                var nextSibling = curChild.nextSibling;\n\n                var key = getNodeKey(curChild);\n                if (key) {\n                    var unmatchedFromEl = fromNodesLookup[key];\n                    // if we find a duplicate #id node in cache, replace `el` with cache value\n                    // and morph it to the child node.\n                    if (unmatchedFromEl && compareNodeNames(curChild, unmatchedFromEl)) {\n                        curChild.parentNode.replaceChild(unmatchedFromEl, curChild);\n                        morphEl(unmatchedFromEl, curChild);\n                    } else {\n                      handleNodeAdded(curChild);\n                    }\n                } else {\n                  // recursively call for curChild and it's children to see if we find something in\n                  // fromNodesLookup\n                  handleNodeAdded(curChild);\n                }\n\n                curChild = nextSibling;\n            }\n        }\n\n        function cleanupFromEl(fromEl, curFromNodeChild, curFromNodeKey) {\n            // We have processed all of the \"to nodes\". If curFromNodeChild is\n            // non-null then we still have some from nodes left over that need\n            // to be removed\n            while (curFromNodeChild) {\n                var fromNextSibling = curFromNodeChild.nextSibling;\n                if ((curFromNodeKey = getNodeKey(curFromNodeChild))) {\n                    // Since the node is keyed it might be matched up later so we defer\n                    // the actual removal to later\n                    addKeyedRemoval(curFromNodeKey);\n                } else {\n                    // NOTE: we skip nested keyed nodes from being removed since there is\n                    //       still a chance they will be matched up later\n                    removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);\n                }\n                curFromNodeChild = fromNextSibling;\n            }\n        }\n\n        function morphEl(fromEl, toEl, childrenOnly) {\n            var toElKey = getNodeKey(toEl);\n\n            if (toElKey) {\n                // If an element with an ID is being morphed then it will be in the final\n                // DOM so clear it out of the saved elements collection\n                delete fromNodesLookup[toElKey];\n            }\n\n            if (!childrenOnly) {\n                // optional\n                if (onBeforeElUpdated(fromEl, toEl) === false) {\n                    return;\n                }\n\n                // update attributes on original DOM element first\n                morphAttrs(fromEl, toEl);\n                // optional\n                onElUpdated(fromEl);\n\n                if (onBeforeElChildrenUpdated(fromEl, toEl) === false) {\n                    return;\n                }\n            }\n\n            if (fromEl.nodeName !== 'TEXTAREA') {\n              morphChildren(fromEl, toEl);\n            } else {\n              specialElHandlers.TEXTAREA(fromEl, toEl);\n            }\n        }\n\n        function morphChildren(fromEl, toEl) {\n            var curToNodeChild = toEl.firstChild;\n            var curFromNodeChild = fromEl.firstChild;\n            var curToNodeKey;\n            var curFromNodeKey;\n\n            var fromNextSibling;\n            var toNextSibling;\n            var matchingFromEl;\n\n            // walk the children\n            outer: while (curToNodeChild) {\n                toNextSibling = curToNodeChild.nextSibling;\n                curToNodeKey = getNodeKey(curToNodeChild);\n\n                // walk the fromNode children all the way through\n                while (curFromNodeChild) {\n                    fromNextSibling = curFromNodeChild.nextSibling;\n\n                    if (curToNodeChild.isSameNode && curToNodeChild.isSameNode(curFromNodeChild)) {\n                        curToNodeChild = toNextSibling;\n                        curFromNodeChild = fromNextSibling;\n                        continue outer;\n                    }\n\n                    curFromNodeKey = getNodeKey(curFromNodeChild);\n\n                    var curFromNodeType = curFromNodeChild.nodeType;\n\n                    // this means if the curFromNodeChild doesnt have a match with the curToNodeChild\n                    var isCompatible = undefined;\n\n                    if (curFromNodeType === curToNodeChild.nodeType) {\n                        if (curFromNodeType === ELEMENT_NODE) {\n                            // Both nodes being compared are Element nodes\n\n                            if (curToNodeKey) {\n                                // The target node has a key so we want to match it up with the correct element\n                                // in the original DOM tree\n                                if (curToNodeKey !== curFromNodeKey) {\n                                    // The current element in the original DOM tree does not have a matching key so\n                                    // let's check our lookup to see if there is a matching element in the original\n                                    // DOM tree\n                                    if ((matchingFromEl = fromNodesLookup[curToNodeKey])) {\n                                        if (fromNextSibling === matchingFromEl) {\n                                            // Special case for single element removals. To avoid removing the original\n                                            // DOM node out of the tree (since that can break CSS transitions, etc.),\n                                            // we will instead discard the current node and wait until the next\n                                            // iteration to properly match up the keyed target element with its matching\n                                            // element in the original tree\n                                            isCompatible = false;\n                                        } else {\n                                            // We found a matching keyed element somewhere in the original DOM tree.\n                                            // Let's move the original DOM node into the current position and morph\n                                            // it.\n\n                                            // NOTE: We use insertBefore instead of replaceChild because we want to go through\n                                            // the `removeNode()` function for the node that is being discarded so that\n                                            // all lifecycle hooks are correctly invoked\n                                            fromEl.insertBefore(matchingFromEl, curFromNodeChild);\n\n                                            // fromNextSibling = curFromNodeChild.nextSibling;\n\n                                            if (curFromNodeKey) {\n                                                // Since the node is keyed it might be matched up later so we defer\n                                                // the actual removal to later\n                                                addKeyedRemoval(curFromNodeKey);\n                                            } else {\n                                                // NOTE: we skip nested keyed nodes from being removed since there is\n                                                //       still a chance they will be matched up later\n                                                removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);\n                                            }\n\n                                            curFromNodeChild = matchingFromEl;\n                                        }\n                                    } else {\n                                        // The nodes are not compatible since the \"to\" node has a key and there\n                                        // is no matching keyed node in the source tree\n                                        isCompatible = false;\n                                    }\n                                }\n                            } else if (curFromNodeKey) {\n                                // The original has a key\n                                isCompatible = false;\n                            }\n\n                            isCompatible = isCompatible !== false && compareNodeNames(curFromNodeChild, curToNodeChild);\n                            if (isCompatible) {\n                                // We found compatible DOM elements so transform\n                                // the current \"from\" node to match the current\n                                // target DOM node.\n                                // MORPH\n                                morphEl(curFromNodeChild, curToNodeChild);\n                            }\n\n                        } else if (curFromNodeType === TEXT_NODE || curFromNodeType == COMMENT_NODE) {\n                            // Both nodes being compared are Text or Comment nodes\n                            isCompatible = true;\n                            // Simply update nodeValue on the original node to\n                            // change the text value\n                            if (curFromNodeChild.nodeValue !== curToNodeChild.nodeValue) {\n                                curFromNodeChild.nodeValue = curToNodeChild.nodeValue;\n                            }\n\n                        }\n                    }\n\n                    if (isCompatible) {\n                        // Advance both the \"to\" child and the \"from\" child since we found a match\n                        // Nothing else to do as we already recursively called morphChildren above\n                        curToNodeChild = toNextSibling;\n                        curFromNodeChild = fromNextSibling;\n                        continue outer;\n                    }\n\n                    // No compatible match so remove the old node from the DOM and continue trying to find a\n                    // match in the original DOM. However, we only do this if the from node is not keyed\n                    // since it is possible that a keyed node might match up with a node somewhere else in the\n                    // target tree and we don't want to discard it just yet since it still might find a\n                    // home in the final DOM tree. After everything is done we will remove any keyed nodes\n                    // that didn't find a home\n                    if (curFromNodeKey) {\n                        // Since the node is keyed it might be matched up later so we defer\n                        // the actual removal to later\n                        addKeyedRemoval(curFromNodeKey);\n                    } else {\n                        // NOTE: we skip nested keyed nodes from being removed since there is\n                        //       still a chance they will be matched up later\n                        removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);\n                    }\n\n                    curFromNodeChild = fromNextSibling;\n                } // END: while(curFromNodeChild) {}\n\n                // If we got this far then we did not find a candidate match for\n                // our \"to node\" and we exhausted all of the children \"from\"\n                // nodes. Therefore, we will just append the current \"to\" node\n                // to the end\n                if (curToNodeKey && (matchingFromEl = fromNodesLookup[curToNodeKey]) && compareNodeNames(matchingFromEl, curToNodeChild)) {\n                    fromEl.appendChild(matchingFromEl);\n                    // MORPH\n                    morphEl(matchingFromEl, curToNodeChild);\n                } else {\n                    var onBeforeNodeAddedResult = onBeforeNodeAdded(curToNodeChild);\n                    if (onBeforeNodeAddedResult !== false) {\n                        if (onBeforeNodeAddedResult) {\n                            curToNodeChild = onBeforeNodeAddedResult;\n                        }\n\n                        if (curToNodeChild.actualize) {\n                            curToNodeChild = curToNodeChild.actualize(fromEl.ownerDocument || doc);\n                        }\n                        fromEl.appendChild(curToNodeChild);\n                        handleNodeAdded(curToNodeChild);\n                    }\n                }\n\n                curToNodeChild = toNextSibling;\n                curFromNodeChild = fromNextSibling;\n            }\n\n            cleanupFromEl(fromEl, curFromNodeChild, curFromNodeKey);\n\n            var specialElHandler = specialElHandlers[fromEl.nodeName];\n            if (specialElHandler) {\n                specialElHandler(fromEl, toEl);\n            }\n        } // END: morphChildren(...)\n\n        var morphedNode = fromNode;\n        var morphedNodeType = morphedNode.nodeType;\n        var toNodeType = toNode.nodeType;\n\n        if (!childrenOnly) {\n            // Handle the case where we are given two DOM nodes that are not\n            // compatible (e.g. <div> --> <span> or <div> --> TEXT)\n            if (morphedNodeType === ELEMENT_NODE) {\n                if (toNodeType === ELEMENT_NODE) {\n                    if (!compareNodeNames(fromNode, toNode)) {\n                        onNodeDiscarded(fromNode);\n                        morphedNode = moveChildren(fromNode, createElementNS(toNode.nodeName, toNode.namespaceURI));\n                    }\n                } else {\n                    // Going from an element node to a text node\n                    morphedNode = toNode;\n                }\n            } else if (morphedNodeType === TEXT_NODE || morphedNodeType === COMMENT_NODE) { // Text or comment node\n                if (toNodeType === morphedNodeType) {\n                    if (morphedNode.nodeValue !== toNode.nodeValue) {\n                        morphedNode.nodeValue = toNode.nodeValue;\n                    }\n\n                    return morphedNode;\n                } else {\n                    // Text node to something else\n                    morphedNode = toNode;\n                }\n            }\n        }\n\n        if (morphedNode === toNode) {\n            // The \"to node\" was not compatible with the \"from node\" so we had to\n            // toss out the \"from node\" and use the \"to node\"\n            onNodeDiscarded(fromNode);\n        } else {\n            if (toNode.isSameNode && toNode.isSameNode(morphedNode)) {\n                return;\n            }\n\n            morphEl(morphedNode, toNode, childrenOnly);\n\n            // We now need to loop over any keyed nodes that might need to be\n            // removed. We only do the removal if we know that the keyed node\n            // never found a match. When a keyed node is matched up we remove\n            // it out of fromNodesLookup and we use fromNodesLookup to determine\n            // if a keyed node has been matched up or not\n            if (keyedRemovalList) {\n                for (var i=0, len=keyedRemovalList.length; i<len; i++) {\n                    var elToRemove = fromNodesLookup[keyedRemovalList[i]];\n                    if (elToRemove) {\n                        removeNode(elToRemove, elToRemove.parentNode, false);\n                    }\n                }\n            }\n        }\n\n        if (!childrenOnly && morphedNode !== fromNode && fromNode.parentNode) {\n            if (morphedNode.actualize) {\n                morphedNode = morphedNode.actualize(fromNode.ownerDocument || doc);\n            }\n            // If we had to swap out the from node with a new node because the old\n            // node was not compatible with the target node then we need to\n            // replace the old DOM node in the original DOM tree. This is only\n            // possible if the original DOM node was part of a DOM tree which\n            // we know is the case if it has a parent node.\n            fromNode.parentNode.replaceChild(morphedNode, fromNode);\n        }\n\n        return morphedNode;\n    };\n}\n\nvar morphdom = morphdomFactory(morphAttrs);\n\nexport default morphdom;\n","export const inputTags = {\r\n  INPUT: true,\r\n  TEXTAREA: true,\r\n  SELECT: true\r\n}\r\n\r\nexport const mutableTags = {\r\n  INPUT: true,\r\n  TEXTAREA: true,\r\n  OPTION: true\r\n}\r\n\r\nexport const textInputTypes = {\r\n  'datetime-local': true,\r\n  'select-multiple': true,\r\n  'select-one': true,\r\n  color: true,\r\n  date: true,\r\n  datetime: true,\r\n  email: true,\r\n  month: true,\r\n  number: true,\r\n  password: true,\r\n  range: true,\r\n  search: true,\r\n  tel: true,\r\n  text: true,\r\n  textarea: true,\r\n  time: true,\r\n  url: true,\r\n  week: true\r\n}\r\n","import { inputTags, textInputTypes } from './enums'\r\nimport { activeElement } from './cable_ready'\r\n\r\n// Indicates if the passed element is considered a text input.\r\n//\r\nexport const isTextInput = element => {\r\n  return inputTags[element.tagName] && textInputTypes[element.type]\r\n}\r\n\r\n// Assigns focus to the appropriate element... preferring the explicitly passed selector\r\n//\r\n// * selector - a CSS selector for the element that should have focus\r\n//\r\nexport const assignFocus = selector => {\r\n  const element =\r\n    selector && selector.nodeType === Node.ELEMENT_NODE\r\n      ? selector\r\n      : document.querySelector(selector)\r\n  const focusElement = element || activeElement\r\n  if (focusElement && focusElement.focus) focusElement.focus()\r\n}\r\n\r\n// Dispatches an event on the passed element\r\n//\r\n// * element - the element\r\n// * name - the name of the event\r\n// * detail - the event detail\r\n//\r\nexport const dispatch = (element, name, detail = {}) => {\r\n  const init = { bubbles: true, cancelable: true, detail: detail }\r\n  const evt = new CustomEvent(name, init)\r\n  element.dispatchEvent(evt)\r\n  if (window.jQuery) window.jQuery(element).trigger(name, detail)\r\n}\r\n\r\n// Accepts an xPath query and returns the element found at that position in the DOM\r\n//\r\nexport const xpathToElement = xpath => {\r\n  return document.evaluate(\r\n    xpath,\r\n    document,\r\n    null,\r\n    XPathResult.FIRST_ORDERED_NODE_TYPE,\r\n    null\r\n  ).singleNodeValue\r\n}\r\n\r\n// Return an array with the class names to be used\r\n//\r\n// * names - could be a string or an array of strings for multiple classes.\r\n//\r\nexport const getClassNames = names => Array(names).flat()\r\n\r\n// Perform operation for either the first or all of the elements returned by CSS selector\r\n//\r\n// * operation - the instruction payload from perform\r\n// * callback - the operation function to run for each element\r\n//\r\nexport const processElements = (operation, callback) => {\r\n  Array.from(\r\n    operation.selectAll ? operation.element : [operation.element]\r\n  ).forEach(callback)\r\n}\r\n","import morphdom from 'morphdom'\nimport { verifyNotMutable, verifyNotPermanent } from './callbacks'\nimport {\n  assignFocus,\n  dispatch,\n  xpathToElement,\n  getClassNames,\n  processElements\n} from './utils'\n\nexport let activeElement\n\nconst shouldMorphCallbacks = [verifyNotMutable, verifyNotPermanent]\nconst didMorphCallbacks = []\n\n// Indicates whether or not we should morph an element via onBeforeElUpdated callback\n// SEE: https://github.com/patrick-steele-idem/morphdom#morphdomfromnode-tonode-options--node\n//\nconst shouldMorph = operation => (fromEl, toEl) => {\n  return !shouldMorphCallbacks\n    .map(callback => {\n      return typeof callback === 'function'\n        ? callback(operation, fromEl, toEl)\n        : true\n    })\n    .includes(false)\n}\n\n// Execute any pluggable functions that modify elements after morphing via onElUpdated callback\n//\nconst didMorph = operation => el => {\n  didMorphCallbacks.forEach(callback => {\n    if (typeof callback === 'function') callback(operation, el)\n  })\n}\n\nconst DOMOperations = {\n  // DOM Mutations\n\n  append: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-append', operation)\n      const { html, focusSelector } = operation\n      if (!operation.cancel) {\n        element.insertAdjacentHTML('beforeend', html)\n        assignFocus(focusSelector)\n      }\n      dispatch(element, 'cable-ready:after-append', operation)\n    })\n  },\n\n  graft: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-graft', operation)\n      const { parent, focusSelector } = operation\n      const parentElement = document.querySelector(parent)\n      if (!operation.cancel && parentElement) {\n        parentElement.appendChild(element)\n        assignFocus(focusSelector)\n      }\n      dispatch(element, 'cable-ready:after-graft', operation)\n    })\n  },\n\n  innerHtml: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-inner-html', operation)\n      const { html, focusSelector } = operation\n      if (!operation.cancel) {\n        element.innerHTML = html\n        assignFocus(focusSelector)\n      }\n      dispatch(element, 'cable-ready:after-inner-html', operation)\n    })\n  },\n\n  insertAdjacentHtml: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-insert-adjacent-html', operation)\n      const { html, position, focusSelector } = operation\n      if (!operation.cancel) {\n        element.insertAdjacentHTML(position || 'beforeend', html)\n        assignFocus(focusSelector)\n      }\n      dispatch(element, 'cable-ready:after-insert-adjacent-html', operation)\n    })\n  },\n\n  insertAdjacentText: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-insert-adjacent-text', operation)\n      const { text, position, focusSelector } = operation\n      if (!operation.cancel) {\n        element.insertAdjacentText(position || 'beforeend', text)\n        assignFocus(focusSelector)\n      }\n      dispatch(element, 'cable-ready:after-insert-adjacent-text', operation)\n    })\n  },\n\n  morph: operation => {\n    processElements(operation, element => {\n      const { html } = operation\n      const template = document.createElement('template')\n      template.innerHTML = String(html).trim()\n      operation.content = template.content\n      dispatch(element, 'cable-ready:before-morph', operation)\n      const { childrenOnly, focusSelector } = operation\n      const parent = element.parentElement\n      const ordinal = Array.from(parent.children).indexOf(element)\n      if (!operation.cancel) {\n        morphdom(\n          element,\n          childrenOnly ? template.content : template.innerHTML,\n          {\n            childrenOnly: !!childrenOnly,\n            onBeforeElUpdated: shouldMorph(operation),\n            onElUpdated: didMorph(operation)\n          }\n        )\n        assignFocus(focusSelector)\n      }\n      dispatch(parent.children[ordinal], 'cable-ready:after-morph', operation)\n    })\n  },\n\n  outerHtml: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-outer-html', operation)\n      const { html, focusSelector } = operation\n      const parent = element.parentElement\n      const ordinal = Array.from(parent.children).indexOf(element)\n      if (!operation.cancel) {\n        element.outerHTML = html\n        assignFocus(focusSelector)\n      }\n      dispatch(\n        parent.children[ordinal],\n        'cable-ready:after-outer-html',\n        operation\n      )\n    })\n  },\n\n  prepend: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-prepend', operation)\n      const { html, focusSelector } = operation\n      if (!operation.cancel) {\n        element.insertAdjacentHTML('afterbegin', html)\n        assignFocus(focusSelector)\n      }\n      dispatch(element, 'cable-ready:after-prepend', operation)\n    })\n  },\n\n  remove: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-remove', operation)\n      const { focusSelector } = operation\n      if (!operation.cancel) {\n        element.remove()\n        assignFocus(focusSelector)\n      }\n      dispatch(document, 'cable-ready:after-remove', operation)\n    })\n  },\n\n  replace: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-replace', operation)\n      const { html, focusSelector } = operation\n      const parent = element.parentElement\n      const ordinal = Array.from(parent.children).indexOf(element)\n      if (!operation.cancel) {\n        element.outerHTML = html\n        assignFocus(focusSelector)\n      }\n      dispatch(parent.children[ordinal], 'cable-ready:after-replace', operation)\n    })\n  },\n\n  textContent: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-text-content', operation)\n      const { text, focusSelector } = operation\n      if (!operation.cancel) {\n        element.textContent = text\n        assignFocus(focusSelector)\n      }\n      dispatch(element, 'cable-ready:after-text-content', operation)\n    })\n  },\n\n  // Element Property Mutations\n\n  addCssClass: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-add-css-class', operation)\n      const { name } = operation\n      if (!operation.cancel) element.classList.add(...getClassNames(name))\n      dispatch(element, 'cable-ready:after-add-css-class', operation)\n    })\n  },\n\n  removeAttribute: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-remove-attribute', operation)\n      const { name } = operation\n      if (!operation.cancel) element.removeAttribute(name)\n      dispatch(element, 'cable-ready:after-remove-attribute', operation)\n    })\n  },\n\n  removeCssClass: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-remove-css-class', operation)\n      const { name } = operation\n      if (!operation.cancel) element.classList.remove(...getClassNames(name))\n      dispatch(element, 'cable-ready:after-remove-css-class', operation)\n    })\n  },\n\n  setAttribute: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-set-attribute', operation)\n      const { name, value } = operation\n      if (!operation.cancel) element.setAttribute(name, value)\n      dispatch(element, 'cable-ready:after-set-attribute', operation)\n    })\n  },\n\n  setDatasetProperty: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-set-dataset-property', operation)\n      const { name, value } = operation\n      if (!operation.cancel) element.dataset[name] = value\n      dispatch(element, 'cable-ready:after-set-dataset-property', operation)\n    })\n  },\n\n  setProperty: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-set-property', operation)\n      const { name, value } = operation\n      if (!operation.cancel && name in element) element[name] = value\n      dispatch(element, 'cable-ready:after-set-property', operation)\n    })\n  },\n\n  setStyle: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-set-style', operation)\n      const { name, value } = operation\n      if (!operation.cancel) element.style[name] = value\n      dispatch(element, 'cable-ready:after-set-style', operation)\n    })\n  },\n\n  setStyles: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-set-styles', operation)\n      const { styles } = operation\n      for (let [name, value] of Object.entries(styles)) {\n        if (!operation.cancel) element.style[name] = value\n      }\n      dispatch(element, 'cable-ready:after-set-styles', operation)\n    })\n  },\n\n  setValue: operation => {\n    processElements(operation, element => {\n      dispatch(element, 'cable-ready:before-set-value', operation)\n      const { value } = operation\n      if (!operation.cancel) element.value = value\n      dispatch(element, 'cable-ready:after-set-value', operation)\n    })\n  },\n\n  // DOM Events\n\n  dispatchEvent: operation => {\n    processElements(operation, element => {\n      const { name, detail } = operation\n      dispatch(element, name, detail)\n    })\n  },\n\n  // Browser Manipulations\n\n  clearStorage: operation => {\n    dispatch(document, 'cable-ready:before-clear-storage', operation)\n    const { type } = operation\n    const storage = type === 'session' ? sessionStorage : localStorage\n    if (!operation.cancel) storage.clear()\n    dispatch(document, 'cable-ready:after-clear-storage', operation)\n  },\n\n  go: operation => {\n    dispatch(window, 'cable-ready:before-go', operation)\n    const { delta } = operation\n    if (!operation.cancel) history.go(delta)\n    dispatch(window, 'cable-ready:after-go', operation)\n  },\n\n  pushState: operation => {\n    dispatch(window, 'cable-ready:before-push-state', operation)\n    const { state, title, url } = operation\n    if (!operation.cancel) history.pushState(state || {}, title || '', url)\n    dispatch(window, 'cable-ready:after-push-state', operation)\n  },\n\n  removeStorageItem: operation => {\n    dispatch(document, 'cable-ready:before-remove-storage-item', operation)\n    const { key, type } = operation\n    const storage = type === 'session' ? sessionStorage : localStorage\n    if (!operation.cancel) storage.removeItem(key)\n    dispatch(document, 'cable-ready:after-remove-storage-item', operation)\n  },\n\n  replaceState: operation => {\n    dispatch(window, 'cable-ready:before-replace-state', operation)\n    const { state, title, url } = operation\n    if (!operation.cancel) history.replaceState(state || {}, title || '', url)\n    dispatch(window, 'cable-ready:after-replace-state', operation)\n  },\n\n  scrollIntoView: operation => {\n    const { element } = operation\n    dispatch(element, 'cable-ready:before-scroll-into-view', operation)\n    if (!operation.cancel) element.scrollIntoView(operation)\n    dispatch(element, 'cable-ready:after-scroll-into-view', operation)\n  },\n\n  setCookie: operation => {\n    dispatch(document, 'cable-ready:before-set-cookie', operation)\n    const { cookie } = operation\n    if (!operation.cancel) document.cookie = cookie\n    dispatch(document, 'cable-ready:after-set-cookie', operation)\n  },\n\n  setFocus: operation => {\n    const { element } = operation\n    dispatch(element, 'cable-ready:before-set-focus', operation)\n    if (!operation.cancel) assignFocus(element)\n    dispatch(element, 'cable-ready:after-set-focus', operation)\n  },\n\n  setStorageItem: operation => {\n    dispatch(document, 'cable-ready:before-set-storage-item', operation)\n    const { key, value, type } = operation\n    const storage = type === 'session' ? sessionStorage : localStorage\n    if (!operation.cancel) storage.setItem(key, value)\n    dispatch(document, 'cable-ready:after-set-storage-item', operation)\n  },\n\n  // Notifications\n\n  consoleLog: operation => {\n    const { message, level } = operation\n    level && ['warn', 'info', 'error'].includes(level)\n      ? console[level](message)\n      : console.log(message)\n  },\n\n  notification: operation => {\n    dispatch(document, 'cable-ready:before-notification', operation)\n    const { title, options } = operation\n    if (!operation.cancel)\n      Notification.requestPermission().then(result => {\n        operation.permission = result\n        if (result === 'granted') new Notification(title || '', options)\n      })\n    dispatch(document, 'cable-ready:after-notification', operation)\n  },\n\n  playSound: operation => {\n    dispatch(document, 'cable-ready:before-play-sound', operation)\n    const { src } = operation\n    if (!operation.cancel) {\n      const canplaythrough = () => {\n        document.audio.removeEventListener('canplaythrough', canplaythrough)\n        document.audio.play()\n      }\n      const ended = () => {\n        document.audio.removeEventListener('ended', canplaythrough)\n        dispatch(document, 'cable-ready:after-play-sound', operation)\n      }\n      document.audio.addEventListener('canplaythrough', canplaythrough)\n      document.audio.addEventListener('ended', ended)\n      document.audio.src = src\n      document.audio.play()\n    } else dispatch(document, 'cable-ready:after-play-sound', operation)\n  }\n}\n\nconst perform = (\n  operations,\n  options = { emitMissingElementWarnings: true }\n) => {\n  for (let name in operations) {\n    if (operations.hasOwnProperty(name)) {\n      const entries = operations[name]\n      for (let i = 0; i < entries.length; i++) {\n        const operation = entries[i]\n        try {\n          if (operation.selector) {\n            operation.element = operation.xpath\n              ? xpathToElement(operation.selector)\n              : document[\n                  operation.selectAll ? 'querySelectorAll' : 'querySelector'\n                ](operation.selector)\n          } else {\n            operation.element = document\n          }\n          if (operation.element || options.emitMissingElementWarnings) {\n            activeElement = document.activeElement\n            DOMOperations[name](operation)\n          }\n        } catch (e) {\n          if (operation.element) {\n            console.error(\n              `CableReady detected an error in ${name}: ${e.message}. If you need to support older browsers make sure you've included the corresponding polyfills. https://docs.stimulusreflex.com/setup#polyfills-for-ie11.`\n            )\n            console.error(e)\n          } else {\n            console.log(\n              `CableReady ${name} failed due to missing DOM element for selector: '${operation.selector}'`\n            )\n          }\n        }\n      }\n    }\n  }\n}\n\nconst performAsync = (\n  operations,\n  options = { emitMissingElementWarnings: true }\n) => {\n  return new Promise((resolve, reject) => {\n    try {\n      resolve(perform(operations, options))\n    } catch (err) {\n      reject(err)\n    }\n  })\n}\n\ndocument.addEventListener('DOMContentLoaded', function () {\n  if (!document.audio) {\n    document.audio = new Audio(\n      'data:audio/mpeg;base64,//OExAAAAAAAAAAAAEluZm8AAAAHAAAABAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/P39/f39/f39/f39/f39/f39/f39/f39/f3+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/AAAAAAAAAAAAAAAAAAAAAAAAAAAAJAa/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//MUxAAAAANIAAAAAExBTUUzLjk2LjFV//MUxAsAAANIAAAAAFVVVVVVVVVVVVVV//MUxBYAAANIAAAAAFVVVVVVVVVVVVVV//MUxCEAAANIAAAAAFVVVVVVVVVVVVVV'\n    )\n    const unlockAudio = () => {\n      document.body.removeEventListener('click', unlockAudio)\n      document.body.removeEventListener('touchstart', unlockAudio)\n      document.audio\n        .play()\n        .then(() => {})\n        .catch(() => {})\n    }\n    document.body.addEventListener('click', unlockAudio)\n    document.body.addEventListener('touchstart', unlockAudio)\n  }\n})\n\nexport default {\n  perform,\n  performAsync,\n  DOMOperations,\n  shouldMorphCallbacks,\n  didMorphCallbacks\n}\n","import { mutableTags } from './enums'\r\nimport { isTextInput } from './utils'\r\nimport { activeElement } from './cable_ready'\r\n\r\nexport const verifyNotMutable = (detail, fromEl, toEl) => {\r\n  // Skip nodes that are equal:\r\n  // https://github.com/patrick-steele-idem/morphdom#can-i-make-morphdom-blaze-through-the-dom-tree-even-faster-yes\r\n  if (!mutableTags[fromEl.tagName] && fromEl.isEqualNode(toEl)) return false\r\n  return true\r\n}\r\n\r\nexport const verifyNotPermanent = (detail, fromEl, toEl) => {\r\n  const { permanentAttributeName } = detail\r\n  if (!permanentAttributeName) return true\r\n\r\n  const permanent = fromEl.closest(`[${permanentAttributeName}]`)\r\n\r\n  // only morph attributes on the active non-permanent text input\r\n  if (!permanent && isTextInput(fromEl) && fromEl === activeElement) {\r\n    const ignore = { value: true }\r\n    Array.from(toEl.attributes).forEach(attribute => {\r\n      if (!ignore[attribute.name])\r\n        fromEl.setAttribute(attribute.name, attribute.value)\r\n    })\r\n    return false\r\n  }\r\n\r\n  return !permanent\r\n}\r\n","export const defaultSchema = {\n  reflexAttribute: 'data-reflex',\n  reflexPermanentAttribute: 'data-reflex-permanent',\n  reflexRootAttribute: 'data-reflex-root',\n  reflexDatasetAttribute: 'data-reflex-dataset'\n}\n","import { createConsumer } from '@rails/actioncable'\n\nfunction isConsumer (object) {\n  if (object) {\n    try {\n      return (\n        object.constructor.name === 'Consumer' &&\n        object.connect &&\n        object.disconnect &&\n        object.send\n      )\n    } catch (e) {}\n  }\n  return false\n}\n\nfunction findConsumer (object, depth = 0) {\n  if (!object) return null\n  if (depth > 3) return null\n  if (isConsumer(object)) return object\n  return Object.values(object)\n    .map(o => findConsumer(o, depth + 1))\n    .find(o => o)\n}\n\nexport function getConsumer () {\n  return findConsumer(window) || createConsumer()\n}\n","// uuid4 function taken from stackoverflow\n// https://stackoverflow.com/a/2117523/554903\n\nexport const uuidv4 = () => {\n  const crypto = window.crypto || window.msCrypto\n  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c =>\n    (\n      c ^\n      (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))\n    ).toString(16)\n  )\n}\n\nexport const serializeForm = (form, options = {}) => {\n  if (!form) return ''\n\n  const w = options.w || window\n  const { element } = options\n  const formData = new w.FormData(form)\n  const data = Array.from(formData, e => e.map(encodeURIComponent).join('='))\n  const submitButton = form.querySelector('input[type=submit]')\n  if (\n    element &&\n    element.name &&\n    element.nodeName === 'INPUT' &&\n    element.type === 'submit'\n  ) {\n    data.push(\n      `${encodeURIComponent(element.name)}=${encodeURIComponent(element.value)}`\n    )\n  } else if (submitButton && submitButton.name) {\n    data.push(\n      `${encodeURIComponent(submitButton.name)}=${encodeURIComponent(\n        submitButton.value\n      )}`\n    )\n  }\n\n  return Array.from(new Set(data)).join('&')\n}\n\nexport const camelize = (value, uppercaseFirstLetter = true) => {\n  if (typeof value !== 'string') return ''\n  value = value\n    .replace(/[\\s_](.)/g, $1 => $1.toUpperCase())\n    .replace(/[\\s_]/g, '')\n    .replace(/^(.)/, $1 => $1.toLowerCase())\n\n  if (uppercaseFirstLetter)\n    value = value.substr(0, 1).toUpperCase() + value.substr(1)\n\n  return value\n}\n\nexport const debounce = (callback, delay = 250) => {\n  let timeoutId\n  return (...args) => {\n    clearTimeout(timeoutId)\n    timeoutId = setTimeout(() => {\n      timeoutId = null\n      callback(...args)\n    }, delay)\n  }\n}\n\nexport const extractReflexName = reflexString => {\n  const match = reflexString.match(/(?:.*->)?(.*?)(?:Reflex)?#/)\n\n  return match ? match[1] : ''\n}\n\nexport const emitEvent = (event, detail) => {\n  document.dispatchEvent(\n    new CustomEvent(event, {\n      bubbles: true,\n      cancelable: false,\n      detail\n    })\n  )\n  if (window.jQuery) window.jQuery(document).trigger(event, detail)\n}\n\n// construct a valid xPath for an element in the DOM\nexport const elementToXPath = element => {\n  if (element.id !== '') return \"//*[@id='\" + element.id + \"']\"\n  if (element === document.body) return '/html/body'\n\n  let ix = 0\n  const siblings = element.parentNode.childNodes\n\n  for (var i = 0; i < siblings.length; i++) {\n    const sibling = siblings[i]\n    if (sibling === element) {\n      const computedPath = elementToXPath(element.parentNode)\n      const tagName = element.tagName.toLowerCase()\n      const ixInc = ix + 1\n      return `${computedPath}/${tagName}[${ixInc}]`\n    }\n\n    if (sibling.nodeType === 1 && sibling.tagName === element.tagName) {\n      ix++\n    }\n  }\n}\n\nexport const XPathToElement = xpath => {\n  return document.evaluate(\n    xpath,\n    document,\n    null,\n    XPathResult.FIRST_ORDERED_NODE_TYPE,\n    null\n  ).singleNodeValue\n}\n","let debugging = false\n\nexport default {\n  get enabled () {\n    return debugging\n  },\n  get disabled () {\n    return !debugging\n  },\n  get value () {\n    return debugging\n  },\n  set (value) {\n    debugging = !!value\n  },\n  set debug (value) {\n    debugging = !!value\n  }\n}\n","import { camelize } from './utils'\nimport Debug from './debug'\n\n// Invokes a lifecycle method on a StimulusReflex controller.\n//\n// - stage - the lifecycle stage\n//   * before\n//   * success\n//   * error\n//   * halted\n//   * after\n//   * finalize\n//\n// - reflexElement - the element that triggered the Reflex (not necessarily the StimulusReflex Controller Element)\n//\n// - controllerElement - the element holding the StimulusReflex Controller\n//\n// - reflexId - the UUIDv4 which uniquely identifies the Reflex\n//\nconst invokeLifecycleMethod = (\n  stage,\n  reflexElement,\n  controllerElement,\n  reflexId\n) => {\n  if (!controllerElement || !controllerElement.reflexData[reflexId]) return\n\n  const controller = controllerElement.reflexController[reflexId]\n  const reflex = controllerElement.reflexData[reflexId].target\n  const reflexMethodName = reflex.split('#')[1]\n\n  const specificLifecycleMethodName = ['before', 'after', 'finalize'].includes(\n    stage\n  )\n    ? `${stage}${camelize(reflexMethodName)}`\n    : `${camelize(reflexMethodName, false)}${camelize(stage)}`\n  const specificLifecycleMethod = controller[specificLifecycleMethodName]\n\n  const genericLifecycleMethodName = ['before', 'after', 'finalize'].includes(\n    stage\n  )\n    ? `${stage}Reflex`\n    : `reflex${camelize(stage)}`\n  const genericLifecycleMethod = controller[genericLifecycleMethodName]\n\n  if (typeof specificLifecycleMethod === 'function') {\n    specificLifecycleMethod.call(\n      controller,\n      reflexElement,\n      reflex,\n      controllerElement.reflexError[reflexId],\n      reflexId\n    )\n  }\n\n  if (typeof genericLifecycleMethod === 'function') {\n    genericLifecycleMethod.call(\n      controller,\n      reflexElement,\n      reflex,\n      controllerElement.reflexError[reflexId],\n      reflexId\n    )\n  }\n\n  if (reflexes[reflexId] && stage === reflexes[reflexId].finalStage) {\n    Reflect.deleteProperty(controllerElement.reflexController, reflexId)\n    Reflect.deleteProperty(controllerElement.reflexData, reflexId)\n    Reflect.deleteProperty(controllerElement.reflexError, reflexId)\n    Reflect.deleteProperty(reflexes, reflexId)\n  }\n}\n\ndocument.addEventListener(\n  'stimulus-reflex:before',\n  event =>\n    invokeLifecycleMethod(\n      'before',\n      event.detail.element,\n      event.detail.controller.element,\n      event.detail.reflexId\n    ),\n  true\n)\n\ndocument.addEventListener(\n  'stimulus-reflex:success',\n  event => {\n    invokeLifecycleMethod(\n      'success',\n      event.detail.element,\n      event.detail.controller.element,\n      event.detail.reflexId\n    )\n    dispatchLifecycleEvent(\n      'after',\n      event.detail.element,\n      event.detail.controller.element,\n      event.detail.reflexId\n    )\n  },\n  true\n)\n\ndocument.addEventListener(\n  'stimulus-reflex:nothing',\n  event => {\n    invokeLifecycleMethod(\n      'success',\n      event.detail.element,\n      event.detail.controller.element,\n      event.detail.reflexId\n    )\n    dispatchLifecycleEvent(\n      'after',\n      event.detail.element,\n      event.detail.controller.element,\n      event.detail.reflexId\n    )\n  },\n  true\n)\n\ndocument.addEventListener(\n  'stimulus-reflex:error',\n  event => {\n    invokeLifecycleMethod(\n      'error',\n      event.detail.element,\n      event.detail.controller.element,\n      event.detail.reflexId\n    )\n    dispatchLifecycleEvent(\n      'after',\n      event.detail.element,\n      event.detail.controller.element,\n      event.detail.reflexId\n    )\n  },\n  true\n)\n\ndocument.addEventListener(\n  'stimulus-reflex:halted',\n  event =>\n    invokeLifecycleMethod(\n      'halted',\n      event.detail.element,\n      event.detail.controller.element,\n      event.detail.reflexId\n    ),\n  true\n)\n\ndocument.addEventListener(\n  'stimulus-reflex:after',\n  event =>\n    invokeLifecycleMethod(\n      'after',\n      event.detail.element,\n      event.detail.controller.element,\n      event.detail.reflexId\n    ),\n  true\n)\n\ndocument.addEventListener(\n  'stimulus-reflex:finalize',\n  event =>\n    invokeLifecycleMethod(\n      'finalize',\n      event.detail.element,\n      event.detail.controller.element,\n      event.detail.reflexId\n    ),\n  true\n)\n\n// Dispatches a lifecycle event on document\n//\n// - stage - the lifecycle stage\n//   * before\n//   * success\n//   * error\n//   * halted\n//   * after\n//   * finalize\n//\n// - reflexElement - the element that triggered the Reflex (not necessarily the StimulusReflex Controller Element)\n//\n// - controllerElement - the element holding the StimulusReflex Controller\n//\n// - reflexId - the UUIDv4 which uniquely identifies the Reflex\n//\nexport const dispatchLifecycleEvent = (\n  stage,\n  reflexElement,\n  controllerElement,\n  reflexId\n) => {\n  if (!controllerElement) {\n    if (Debug.enabled && !reflexes[reflexId].warned) {\n      console.warn(\n        `StimulusReflex was not able execute callbacks or emit events for \"${stage}\" or later life-cycle stages for this Reflex. The StimulusReflex Controller Element is no longer present in the DOM. Could you move the StimulusReflex Controller to an element higher in your DOM?`\n      )\n      reflexes[reflexId].warned = true\n    }\n    return\n  }\n\n  if (\n    !controllerElement.reflexController ||\n    (controllerElement.reflexController &&\n      !controllerElement.reflexController[reflexId])\n  ) {\n    if (Debug.enabled && !reflexes[reflexId].warned) {\n      console.warn(\n        `StimulusReflex detected that the StimulusReflex Controller responsible for this Reflex has been replaced with a new instance. Callbacks and events for \"${stage}\" or later life-cycle stages cannot be executed.`\n      )\n      reflexes[reflexId].warned = true\n    }\n    return\n  }\n\n  const { target } = controllerElement.reflexData[reflexId] || {}\n  const controller = controllerElement.reflexController[reflexId] || {}\n  const event = `stimulus-reflex:${stage}`\n  const detail = {\n    reflex: target,\n    controller,\n    reflexId,\n    element: reflexElement\n  }\n\n  controllerElement.dispatchEvent(\n    new CustomEvent(event, { bubbles: true, cancelable: false, detail })\n  )\n  if (window.jQuery) window.jQuery(controllerElement).trigger(event, detail)\n}\n","import { defaultSchema } from './schema'\nimport Debug from './debug'\n\nconst multipleInstances = element => {\n  if (['checkbox', 'radio'].includes(element.type)) {\n    return (\n      document.querySelectorAll(\n        `input[type=\"${element.type}\"][name=\"${element.name}\"]`\n      ).length > 1\n    )\n  }\n  return false\n}\nconst collectCheckedOptions = element => {\n  return Array.from(element.querySelectorAll('option:checked'))\n    .concat(\n      Array.from(\n        document.querySelectorAll(\n          `input[type=\"${element.type}\"][name=\"${element.name}\"]`\n        )\n      ).filter(elem => elem.checked)\n    )\n    .map(o => o.value)\n}\n\n// Returns a string value for the passed array.\n//\n//   attributeValue(['', 'one', null, 'two', 'three ']) // 'one two three'\n//\nexport const attributeValue = (values = []) => {\n  const value = values\n    .filter(v => v && String(v).length)\n    .map(v => v.trim())\n    .join(' ')\n    .trim()\n  return value.length ? value : null\n}\n\n// Returns an array for the passed string value by splitting on whitespace.\n//\n//   attributeValues('one two three ') // ['one', 'two', 'three']\n//\nexport const attributeValues = value => {\n  if (!value) return []\n  if (!value.length) return []\n  return value.split(' ').filter(v => v.trim().length)\n}\n\n// Extracts attributes from a DOM element.\n//\nexport const extractElementAttributes = element => {\n  let attrs = Array.from(element.attributes).reduce((memo, attr) => {\n    memo[attr.name] = attr.value\n    return memo\n  }, {})\n\n  attrs.checked = !!element.checked\n  attrs.selected = !!element.selected\n  attrs.tag_name = element.tagName\n\n  if (element.tagName.match(/select/i) || multipleInstances(element)) {\n    const collectedOptions = collectCheckedOptions(element)\n    attrs.values = collectedOptions\n    attrs.value = collectedOptions.join(',')\n  } else {\n    attrs.value = element.value\n  }\n  return attrs\n}\n\n// Extracts the dataset of an element and combines it with the data attributes from all parents if requested.\n//\nexport const extractElementDataset = (element, datasetAttribute = null) => {\n  let attrs = extractDataAttributes(element) || {}\n  const dataset = datasetAttribute && element.attributes[datasetAttribute]\n\n  if (dataset && dataset.value === 'combined') {\n    let parent = element.parentElement\n\n    while (parent) {\n      attrs = { ...extractDataAttributes(parent), ...attrs }\n      parent = parent.parentElement\n    }\n  }\n\n  return attrs\n}\n\n// Extracts all data attributes from a DOM element.\n//\nexport const extractDataAttributes = element => {\n  let attrs = {}\n\n  if (element && element.attributes) {\n    Array.from(element.attributes).forEach(attr => {\n      if (attr.name.startsWith('data-')) {\n        attrs[attr.name] = attr.value\n      }\n    })\n  }\n\n  return attrs\n}\n","import { attributeValues } from './attributes'\n\n// Returns StimulusReflex controllers local to the passed element based on the data-controller attribute.\n//\nconst localReflexControllers = (app, element) => {\n  return attributeValues(\n    element.getAttribute(app.schema.controllerAttribute)\n  ).reduce((memo, name) => {\n    const controller = app.getControllerForElementAndIdentifier(element, name)\n    if (controller && controller.StimulusReflex) memo.push(controller)\n    return memo\n  }, [])\n}\n\n// Returns all StimulusReflex controllers for the passed element.\n// Traverses DOM ancestors starting with element.\n//\nexport const allReflexControllers = (app, element) => {\n  let controllers = []\n  while (element) {\n    controllers = controllers.concat(localReflexControllers(app, element))\n    element = element.parentElement\n  }\n  return controllers\n}\n","function request (\n  reflexId,\n  target,\n  args,\n  controller,\n  element,\n  controllerElement\n) {\n  reflexes[reflexId].timestamp = new Date()\n  console.log(`\\u2191 stimulus \\u2191 ${target}`, {\n    reflexId,\n    args,\n    controller,\n    element,\n    controllerElement\n  })\n}\n\nfunction success (event) {\n  const { detail } = event || {}\n  const { selector } = detail || {}\n  const { reflexId, target, morph, serverMessage } = detail.stimulusReflex || {}\n  const reflex = reflexes[reflexId]\n  const progress =\n    reflex.totalOperations > 1\n      ? ` ${reflex.completedOperations}/${reflex.totalOperations}`\n      : ''\n  const duration = reflex.timestamp\n    ? `in ${new Date() - reflex.timestamp}ms`\n    : 'CLONED'\n  const operation = event.type\n    .split(':')[1]\n    .split('-')\n    .slice(1)\n    .join('_')\n  const halted = (serverMessage && serverMessage.subject === 'halted') || false\n  console.log(\n    `\\u2193 reflex \\u2193 ${target} \\u2192 ${selector ||\n      '\\u221E'}${progress} ${duration}`,\n    { reflexId, morph, operation, halted }\n  )\n}\n\nfunction error (event) {\n  const { detail } = event || {}\n  const { reflexId, target, serverMessage } = detail.stimulusReflex || {}\n  const reflex = reflexes[reflexId]\n  const duration = reflex.timestamp\n    ? `in ${new Date() - reflex.timestamp}ms`\n    : 'CLONED'\n  const payload = detail.stimulusReflex\n  console.log(\n    `\\u2193 reflex \\u2193 ${target} ${duration} %cERROR: ${serverMessage.body}`,\n    'color: #f00;',\n    { reflexId, payload }\n  )\n}\n\nexport default { request, success, error }\n","import { Controller } from 'stimulus'\nimport CableReady from 'cable_ready'\nimport { defaultSchema } from './schema'\nimport { getConsumer } from './consumer'\nimport { dispatchLifecycleEvent } from './lifecycle'\nimport { allReflexControllers } from './controllers'\nimport { uuidv4, debounce, emitEvent, serializeForm } from './utils'\nimport Log from './log'\nimport Debug from './debug'\nimport {\n  attributeValue,\n  attributeValues,\n  extractElementAttributes,\n  extractElementDataset\n} from './attributes'\nimport { extractReflexName, elementToXPath, XPathToElement } from './utils'\n\n// A lambda that does nothing. Very zen; we are made of stars\nconst NOOP = () => {}\n\n// A reference to the Stimulus application registered with: StimulusReflex.initialize\nlet stimulusApplication\n\n// A reference to the ActionCable consumer registered with: StimulusReflex.initialize or getConsumer\nlet actionCableConsumer\n\n// A reference to an optional object called params defined in the StimulusReflex.initialize and passed to channels\nlet actionCableParams\n\n// Flag which will be false if the server does not accept the channel subscription\nlet actionCableSubscriptionActive = false\n\n// A dictionary of all active Reflex operations, indexed by reflexId\nwindow.reflexes = {}\n\n// Should Reflex playback be restricted to the tab that called it?\nlet isolationMode\n\n// Subscribes a StimulusReflex controller to an ActionCable channel.\n// controller - the StimulusReflex controller to subscribe\n//\nconst createSubscription = controller => {\n  actionCableConsumer = actionCableConsumer || getConsumer()\n  const { channel } = controller.StimulusReflex\n  const subscription = { channel, ...actionCableParams }\n  const identifier = JSON.stringify(subscription)\n\n  controller.StimulusReflex.subscription =\n    actionCableConsumer.subscriptions.findAll(identifier)[0] ||\n    actionCableConsumer.subscriptions.create(subscription, {\n      received: data => {\n        if (!data.cableReady) return\n\n        let reflexOperations = {}\n\n        for (let name in data.operations) {\n          if (data.operations.hasOwnProperty(name)) {\n            for (let i = data.operations[name].length - 1; i >= 0; i--) {\n              if (\n                data.operations[name][i].stimulusReflex ||\n                (data.operations[name][i].detail &&\n                  data.operations[name][i].detail.stimulusReflex)\n              ) {\n                reflexOperations[name] = reflexOperations[name] || []\n                reflexOperations[name].push(data.operations[name][i])\n                data.operations[name].splice(i, 1)\n              }\n            }\n            if (!data.operations[name].length)\n              Reflect.deleteProperty(data.operations, name)\n          }\n        }\n\n        let totalOperations = 0\n        let reflexData\n\n        const dispatchEvent = reflexOperations['dispatchEvent']\n        const morph = reflexOperations['morph']\n        const innerHtml = reflexOperations['innerHtml']\n\n        ;[dispatchEvent, morph, innerHtml].forEach(operation => {\n          if (operation && operation.length) {\n            const urls = Array.from(\n              new Set(\n                operation.map(m =>\n                  m.detail ? m.detail.stimulusReflex.url : m.stimulusReflex.url\n                )\n              )\n            )\n\n            if (urls.length !== 1 || urls[0] !== location.href) return\n            totalOperations += operation.length\n\n            if (!reflexData) {\n              reflexData = operation[0].detail\n                ? operation[0].detail.stimulusReflex\n                : operation[0].stimulusReflex\n            }\n          }\n        })\n\n        if (reflexData) {\n          const { reflexId } = reflexData\n\n          if (!reflexes[reflexId] && !isolationMode) {\n            const controllerElement = XPathToElement(reflexData.xpathController)\n            const reflexElement = XPathToElement(reflexData.xpathElement)\n            controllerElement.reflexController =\n              controllerElement.reflexController || {}\n            controllerElement.reflexData = controllerElement.reflexData || {}\n            controllerElement.reflexError = controllerElement.reflexError || {}\n\n            controllerElement.reflexController[\n              reflexId\n            ] = stimulusApplication.getControllerForElementAndIdentifier(\n              controllerElement,\n              reflexData.reflexController\n            )\n\n            controllerElement.reflexData[reflexId] = reflexData\n            dispatchLifecycleEvent(\n              'before',\n              reflexElement,\n              controllerElement,\n              reflexId\n            )\n            registerReflex(reflexData)\n          }\n\n          if (reflexes[reflexId]) {\n            reflexes[reflexId].totalOperations = totalOperations\n            reflexes[reflexId].pendingOperations = totalOperations\n            reflexes[reflexId].completedOperations = 0\n            CableReady.perform(reflexOperations)\n          }\n        }\n\n        // run piggy back operations after stimulus reflex behavior\n        CableReady.perform(data.operations)\n      },\n      connected: () => {\n        actionCableSubscriptionActive = true\n        emitEvent('stimulus-reflex:connected')\n      },\n      rejected: () => {\n        actionCableSubscriptionActive = false\n        emitEvent('stimulus-reflex:rejected')\n        if (Debug.enabled) console.warn('Channel subscription was rejected.')\n      },\n      disconnected: willAttemptReconnect => {\n        actionCableSubscriptionActive = false\n        emitEvent('stimulus-reflex:disconnected', willAttemptReconnect)\n      }\n    })\n}\n\n// Extends a regular Stimulus controller with StimulusReflex behavior.\n//\n// Methods added to the Stimulus controller:\n// - stimulate\n// - __perform\n//\nconst extendStimulusController = controller => {\n  Object.assign(controller, {\n    // Indicates if the ActionCable web socket connection is open.\n    // The connection must be open before calling stimulate.\n    //\n    isActionCableConnectionOpen () {\n      return this.StimulusReflex.subscription.consumer.connection.isOpen()\n    },\n\n    // Invokes a server side reflex method.\n    //\n    // - target - the reflex target (full name of the server side reflex) i.e. 'ReflexClassName#method'\n    // - controllerElement - [optional] the element that triggered the reflex, defaults to this.element\n    // - options - [optional] an object that contains at least one of attrs, reflexId, selectors, resolveLate, serializeForm\n    // - *args - remaining arguments are forwarded to the server side reflex method\n    //\n    stimulate () {\n      const url = location.href\n      const args = Array.from(arguments)\n      const target = args.shift() || 'StimulusReflex::Reflex#default_reflex'\n      const controllerElement = this.element\n      const reflexElement =\n        args[0] && args[0].nodeType === Node.ELEMENT_NODE\n          ? args.shift()\n          : controllerElement\n      if (\n        reflexElement.type === 'number' &&\n        reflexElement.validity &&\n        reflexElement.validity.badInput\n      ) {\n        if (Debug.enabled) console.warn('Reflex aborted: invalid numeric input')\n        return\n      }\n      const options = {}\n      if (\n        args[0] &&\n        typeof args[0] === 'object' &&\n        Object.keys(args[0]).filter(key =>\n          [\n            'attrs',\n            'selectors',\n            'reflexId',\n            'resolveLate',\n            'serializeForm'\n          ].includes(key)\n        ).length\n      ) {\n        const opts = args.shift()\n        Object.keys(opts).forEach(o => (options[o] = opts[o]))\n      }\n      const attrs = options['attrs'] || extractElementAttributes(reflexElement)\n      const reflexId = options['reflexId'] || uuidv4()\n      let selectors = options['selectors'] || getReflexRoots(reflexElement)\n      if (typeof selectors === 'string') selectors = [selectors]\n      const resolveLate = options['resolveLate'] || false\n      const datasetAttribute = stimulusApplication.schema.reflexDatasetAttribute\n      const dataset = extractElementDataset(reflexElement, datasetAttribute)\n      const xpathController = elementToXPath(controllerElement)\n      const xpathElement = elementToXPath(reflexElement)\n      const data = {\n        target,\n        args,\n        url,\n        attrs,\n        dataset,\n        selectors,\n        reflexId,\n        resolveLate,\n        xpathController,\n        xpathElement,\n        reflexController: this.identifier,\n        permanentAttributeName:\n          stimulusApplication.schema.reflexPermanentAttribute\n      }\n      const { subscription } = this.StimulusReflex\n\n      if (!this.isActionCableConnectionOpen())\n        throw 'The ActionCable connection is not open! `this.isActionCableConnectionOpen()` must return true before calling `this.stimulate()`'\n\n      if (!actionCableSubscriptionActive)\n        throw 'The ActionCable channel subscription for StimulusReflex was rejected.'\n\n      // lifecycle setup\n      controllerElement.reflexController =\n        controllerElement.reflexController || {}\n      controllerElement.reflexData = controllerElement.reflexData || {}\n      controllerElement.reflexError = controllerElement.reflexError || {}\n\n      controllerElement.reflexController[reflexId] = this\n      controllerElement.reflexData[reflexId] = data\n\n      dispatchLifecycleEvent(\n        'before',\n        reflexElement,\n        controllerElement,\n        reflexId\n      )\n\n      setTimeout(() => {\n        const { params } = controllerElement.reflexData[reflexId] || {}\n        const formData =\n          options['serializeForm'] === false\n            ? ''\n            : serializeForm(reflexElement.closest('form'), {\n                element: reflexElement\n              })\n\n        controllerElement.reflexData[reflexId] = {\n          ...data,\n          params,\n          formData\n        }\n\n        subscription.send(controllerElement.reflexData[reflexId])\n      })\n\n      const promise = registerReflex(data)\n\n      if (Debug.enabled) {\n        Log.request(\n          reflexId,\n          target,\n          args,\n          this.context.scope.identifier,\n          reflexElement,\n          controllerElement\n        )\n      }\n\n      return promise\n    },\n\n    // Wraps the call to stimulate for any data-reflex elements.\n    // This is internal and should not be invoked directly.\n    __perform (event) {\n      let element = event.target\n      let reflex\n\n      while (element && !reflex) {\n        reflex = element.getAttribute(\n          stimulusApplication.schema.reflexAttribute\n        )\n        if (!reflex || !reflex.trim().length) element = element.parentElement\n      }\n\n      const match = attributeValues(reflex).find(\n        reflex => reflex.split('->')[0] === event.type\n      )\n\n      if (match) {\n        event.preventDefault()\n        event.stopPropagation()\n        this.stimulate(match.split('->')[1], element)\n      }\n    }\n  })\n}\n\nconst registerReflex = data => {\n  const { reflexId } = data\n  reflexes[reflexId] = { finalStage: 'finalize' }\n\n  const promise = new Promise((resolve, reject) => {\n    reflexes[reflexId].promise = {\n      resolve,\n      reject,\n      data\n    }\n  })\n\n  promise.reflexId = reflexId\n\n  if (Debug.enabled) promise.catch(NOOP)\n\n  return promise\n}\n\n// Registers a Stimulus controller and extends it with StimulusReflex behavior\n//\n// controller - the Stimulus controller\n// options - [optional] configuration\n//\nconst register = (controller, options = {}) => {\n  const channel = 'StimulusReflex::Channel'\n  controller.StimulusReflex = { ...options, channel }\n  createSubscription(controller)\n  extendStimulusController(controller)\n}\n\n// Default StimulusReflexController that is implicitly wired up as data-controller for any DOM elements\n// that have configured data-reflex. Note that this default can be overridden when initializing the application.\n// i.e. StimulusReflex.initialize(myStimulusApplication, MyCustomDefaultController);\n//\nclass StimulusReflexController extends Controller {\n  constructor (...args) {\n    super(...args)\n    register(this)\n  }\n}\n\n// Sets up declarative reflex behavior.\n// Any elements that define data-reflex will automatically be wired up with the default StimulusReflexController.\n//\nconst setupDeclarativeReflexes = debounce(() => {\n  document\n    .querySelectorAll(`[${stimulusApplication.schema.reflexAttribute}]`)\n    .forEach(element => {\n      const controllers = attributeValues(\n        element.getAttribute(stimulusApplication.schema.controllerAttribute)\n      )\n      const reflexAttributeNames = attributeValues(\n        element.getAttribute(stimulusApplication.schema.reflexAttribute)\n      )\n      const actions = attributeValues(\n        element.getAttribute(stimulusApplication.schema.actionAttribute)\n      )\n      reflexAttributeNames.forEach(reflexName => {\n        const controller = findControllerByReflexName(\n          reflexName,\n          allReflexControllers(stimulusApplication, element)\n        )\n        let action\n        if (controller) {\n          action = `${reflexName.split('->')[0]}->${\n            controller.identifier\n          }#__perform`\n          if (!actions.includes(action)) actions.push(action)\n        } else {\n          action = `${reflexName.split('->')[0]}->stimulus-reflex#__perform`\n          if (!controllers.includes('stimulus-reflex')) {\n            controllers.push('stimulus-reflex')\n          }\n          if (!actions.includes(action)) actions.push(action)\n        }\n      })\n      const controllerValue = attributeValue(controllers)\n      const actionValue = attributeValue(actions)\n      if (\n        controllerValue &&\n        element.getAttribute(stimulusApplication.schema.controllerAttribute) !=\n          controllerValue\n      ) {\n        element.setAttribute(\n          stimulusApplication.schema.controllerAttribute,\n          controllerValue\n        )\n      }\n      if (\n        actionValue &&\n        element.getAttribute(stimulusApplication.schema.actionAttribute) !=\n          actionValue\n      )\n        element.setAttribute(\n          stimulusApplication.schema.actionAttribute,\n          actionValue\n        )\n    })\n  emitEvent('stimulus-reflex:ready')\n}, 20)\n\n// Given a reflex string such as 'click->TestReflex#create' and a list of\n// controllers. It will find the matching controller based on the controller's\n// identifier. e.g. Given these controller identifiers ['foo', 'bar', 'test'],\n// it would select the 'test' controller.\nconst findControllerByReflexName = (reflexName, controllers) => {\n  const controller = controllers.find(controller => {\n    if (!controller.identifier) return\n\n    return (\n      extractReflexName(reflexName).toLowerCase() ===\n      controller.identifier.toLowerCase()\n    )\n  })\n\n  return controller || controllers[0]\n}\n\n// compute the DOM element(s) which will be the morph root\n// use the data-reflex-root attribute on the reflex or the controller\n// optional value is a CSS selector(s); comma-separated list\n// order of preference is data-reflex, data-controller, document body (default)\nconst getReflexRoots = element => {\n  let list = []\n  while (list.length === 0 && element) {\n    const reflexRoot = element.getAttribute(\n      stimulusApplication.schema.reflexRootAttribute\n    )\n    if (reflexRoot) {\n      if (reflexRoot.length === 0 && element.id) reflexRoot = `#${element.id}`\n      const selectors = reflexRoot.split(',').filter(s => s.trim().length)\n      if (selectors.length === 0) {\n        console.error(\n          `No value found for ${stimulusApplication.schema.reflexRootAttribute}. Add an #id to the element or provide a value for ${stimulusApplication.schema.reflexRootAttribute}.`,\n          element\n        )\n      }\n      list = list.concat(selectors.filter(s => document.querySelector(s)))\n    }\n    element = element.parentElement\n      ? element.parentElement.closest(\n          `[${stimulusApplication.schema.reflexRootAttribute}]`\n        )\n      : null\n  }\n  return list\n}\n\n// Initializes StimulusReflex by registering the default Stimulus controller with the passed Stimulus application.\n//\n// - application - the Stimulus application\n// - options\n//   * controller - [optional] the default StimulusReflexController\n//   * consumer - [optional] the ActionCable consumer\n//   * debug - [false] log all Reflexes to the console\n//   * params - [{}] key/value parameters to send during channel subscription\n//   * isolate - [false] restrict Reflex playback to the tab which initiated it\n//\nconst initialize = (application, initializeOptions = {}) => {\n  const { controller, consumer, debug, params, isolate } = initializeOptions\n  actionCableConsumer = consumer\n  actionCableParams = params\n  isolationMode = !!isolate\n  stimulusApplication = application\n  stimulusApplication.schema = { ...defaultSchema, ...application.schema }\n  stimulusApplication.register(\n    'stimulus-reflex',\n    controller || StimulusReflexController\n  )\n  Debug.set(!!debug)\n}\n\nif (!document.stimulusReflexInitialized) {\n  document.stimulusReflexInitialized = true\n\n  window.addEventListener('load', () => {\n    setupDeclarativeReflexes()\n    const observer = new MutationObserver(setupDeclarativeReflexes)\n    observer.observe(document.documentElement, {\n      attributes: true,\n      childList: true,\n      subtree: true\n    })\n  })\n\n  const beforeDOMUpdate = event => {\n    const { stimulusReflex } = event.detail || {}\n    if (!stimulusReflex) return\n    const { reflexId, xpathElement, xpathController } = stimulusReflex\n    const controllerElement = XPathToElement(xpathController)\n    const reflexElement = XPathToElement(xpathElement)\n    const reflex = reflexes[reflexId]\n    const promise = reflex.promise\n\n    reflex.pendingOperations--\n\n    if (reflex.pendingOperations > 0) return\n\n    if (!stimulusReflex.resolveLate)\n      setTimeout(() =>\n        promise.resolve({ element: reflexElement, event, data: promise.data })\n      )\n\n    setTimeout(() =>\n      dispatchLifecycleEvent(\n        'success',\n        reflexElement,\n        controllerElement,\n        reflexId\n      )\n    )\n  }\n\n  document.addEventListener('cable-ready:before-inner-html', beforeDOMUpdate)\n  document.addEventListener('cable-ready:before-morph', beforeDOMUpdate)\n\n  const afterDOMUpdate = event => {\n    const { stimulusReflex } = event.detail || {}\n    if (!stimulusReflex) return\n    const { reflexId, xpathElement, xpathController } = stimulusReflex\n    const controllerElement = XPathToElement(xpathController)\n    const reflexElement = XPathToElement(xpathElement)\n    const reflex = reflexes[reflexId]\n    const promise = reflex.promise\n\n    reflex.completedOperations++\n\n    if (Debug.enabled) Log.success(event)\n\n    if (reflex.completedOperations < reflex.totalOperations) return\n\n    if (stimulusReflex.resolveLate)\n      setTimeout(() =>\n        promise.resolve({ element: reflexElement, event, data: promise.data })\n      )\n\n    setTimeout(() =>\n      dispatchLifecycleEvent(\n        'finalize',\n        reflexElement,\n        controllerElement,\n        reflexId\n      )\n    )\n  }\n\n  document.addEventListener('cable-ready:after-inner-html', afterDOMUpdate)\n  document.addEventListener('cable-ready:after-morph', afterDOMUpdate)\n\n  document.addEventListener('stimulus-reflex:server-message', event => {\n    const { reflexId, serverMessage, xpathController, xpathElement } =\n      event.detail.stimulusReflex || {}\n    const { subject, body } = serverMessage\n    const controllerElement = XPathToElement(xpathController)\n    const reflexElement = XPathToElement(xpathElement)\n    const promise = reflexes[reflexId].promise\n    const subjects = { error: true, halted: true, nothing: true, success: true }\n\n    controllerElement.reflexError = controllerElement.reflexError || {}\n\n    if (controllerElement && subject === 'error')\n      controllerElement.reflexError[reflexId] = body\n\n    promise[subject === 'error' ? 'reject' : 'resolve']({\n      data: promise.data,\n      element: reflexElement,\n      event,\n      toString: () => body\n    })\n\n    reflexes[reflexId].finalStage = subject === 'halted' ? 'halted' : 'after'\n\n    if (Debug.enabled) Log[subject === 'error' ? 'error' : 'success'](event)\n\n    if (subjects[subject])\n      dispatchLifecycleEvent(\n        subject,\n        reflexElement,\n        controllerElement,\n        reflexId\n      )\n  })\n}\n\nexport default {\n  initialize,\n  register,\n  get debug () {\n    return Debug.value\n  },\n  set debug (value) {\n    Debug.set(!!value)\n  }\n}\n"],"names":["adapters","logger","self","console","WebSocket","log","messages","this","enabled","push","Date","now","getTime","secondsSince","time","ConnectionMonitor","constructor","connection","visibilityDidChange","bind","reconnectAttempts","start","isRunning","startedAt","stoppedAt","startPolling","addEventListener","staleThreshold","stop","stopPolling","removeEventListener","recordPing","pingedAt","recordConnect","disconnectedAt","recordDisconnect","poll","clearTimeout","pollTimeout","setTimeout","reconnectIfStale","getPollInterval","reconnectionBackoffRate","Math","pow","min","random","connectionIsStale","refreshedAt","disconnectedRecently","reopen","document","visibilityState","isOpen","INTERNAL","message_types","welcome","disconnect","ping","confirmation","rejection","disconnect_reasons","unauthorized","invalid_request","server_restart","default_mount_path","protocols","supportedProtocols","slice","length","indexOf","Connection","consumer","open","subscriptions","monitor","disconnected","send","data","webSocket","JSON","stringify","isActive","getState","uninstallEventHandlers","url","installEventHandlers","close","allowReconnect","error","reopenDelay","getProtocol","protocol","isState","isProtocolSupported","call","states","state","readyState","toLowerCase","eventName","events","handler","prototype","message","event","identifier","reason","reconnect","type","parse","reload","confirmSubscription","notify","reject","notifyAll","willAttemptReconnect","Subscription","params","mixin","object","properties","key","value","extend","perform","action","command","unsubscribe","remove","SubscriptionGuarantor","pendingSubscriptions","guarantee","subscription","startGuaranteeing","forget","filter","s","stopGuaranteeing","retrySubscribing","retryTimeout","subscribe","map","Subscriptions","guarantor","create","channelName","channel","add","ensureActiveConnection","findAll","sendCommand","callbackName","args","undefined","Consumer","_url","test","a","createElement","href","replace","createWebSocketURL","connect","createConsumer","name","element","head","querySelector","getAttribute","getConfig","range","doc","HAS_TEMPLATE_SUPPORT","HAS_RANGE_SUPPORT","createRange","toElement","str","trim","template","innerHTML","content","childNodes","createFragmentFromTemplate","selectNode","body","createContextualFragment","createFragmentFromRange","fragment","createFragmentFromWrap","compareNodeNames","fromEl","toEl","fromCodeStart","toCodeStart","fromNodeName","nodeName","toNodeName","charCodeAt","toUpperCase","syncBooleanAttrProp","setAttribute","removeAttribute","specialElHandlers","OPTION","parentNode","parentName","hasAttribute","selected","selectedIndex","INPUT","TEXTAREA","newValue","firstChild","oldValue","nodeValue","placeholder","SELECT","optgroup","i","curChild","nextSibling","noop","defaultGetNodeKey","node","id","morphdom","morphAttrs","fromNode","toNode","options","toNodeHtml","getNodeKey","onBeforeNodeAdded","onNodeAdded","onBeforeElUpdated","onElUpdated","onBeforeNodeDiscarded","onNodeDiscarded","onBeforeElChildrenUpdated","childrenOnly","fromNodesLookup","Object","keyedRemovalList","addKeyedRemoval","walkDiscardedChildNodes","skipKeyedNodes","nodeType","removeNode","removeChild","handleNodeAdded","el","unmatchedFromEl","replaceChild","morphEl","toElKey","curToNodeKey","curFromNodeKey","fromNextSibling","toNextSibling","matchingFromEl","curToNodeChild","curFromNodeChild","outer","isSameNode","curFromNodeType","isCompatible","insertBefore","appendChild","onBeforeNodeAddedResult","actualize","ownerDocument","cleanupFromEl","specialElHandler","morphChildren","indexTree","namespaceURI","morphedNode","morphedNodeType","toNodeType","nextChild","moveChildren","createElementNS","len","elToRemove","morphdomFactory","attr","attrName","attrNamespaceURI","attrValue","toNodeAttrs","attributes","localName","getAttributeNS","prefix","setAttributeNS","fromNodeAttrs","d","hasAttributeNS","removeAttributeNS","inputTags","mutableTags","textInputTypes","color","date","datetime","email","month","number","password","search","tel","text","textarea","week","assignFocus","selector","focusElement","Node","ELEMENT_NODE","activeElement","focus","dispatch","detail","evt","CustomEvent","bubbles","cancelable","dispatchEvent","window","jQuery","trigger","getClassNames","names","Array","flat","processElements","operation","callback","from","selectAll","forEach","shouldMorphCallbacks","tagName","isEqualNode","permanentAttributeName","permanent","closest","ignore","attribute","didMorphCallbacks","shouldMorph","includes","didMorph","DOMOperations","append","html","focusSelector","cancel","insertAdjacentHTML","graft","parent","parentElement","innerHtml","insertAdjacentHtml","position","insertAdjacentText","morph","String","ordinal","children","outerHtml","outerHTML","prepend","textContent","addCssClass","classList","removeCssClass","setDatasetProperty","dataset","setProperty","setStyle","style","setStyles","styles","entries","setValue","clearStorage","storage","sessionStorage","localStorage","clear","go","delta","history","pushState","title","removeStorageItem","removeItem","replaceState","scrollIntoView","setCookie","cookie","setFocus","setStorageItem","setItem","consoleLog","level","notification","Notification","requestPermission","then","result","permission","playSound","src","canplaythrough","audio","play","ended","operations","emitMissingElementWarnings","hasOwnProperty","xpath","evaluate","XPathResult","FIRST_ORDERED_NODE_TYPE","singleNodeValue","e","Audio","unlockAudio","catch","defaultSchema","reflexAttribute","reflexPermanentAttribute","reflexRootAttribute","reflexDatasetAttribute","findConsumer","depth","isConsumer","values","o","find","getConsumer","camelize","uppercaseFirstLetter","$1","substr","emitEvent","elementToXPath","ix","siblings","sibling","XPathToElement","debugging","disabled","set","debug","invokeLifecycleMethod","stage","reflexElement","controllerElement","reflexId","reflexData","controller","reflexController","reflex","target","reflexMethodName","split","specificLifecycleMethod","genericLifecycleMethod","reflexError","reflexes","finalStage","Reflect","deleteProperty","dispatchLifecycleEvent","warned","warn","attributeValue","v","join","attributeValues","extractElementAttributes","attrs","reduce","memo","checked","tag_name","match","querySelectorAll","multipleInstances","collectedOptions","concat","elem","collectCheckedOptions","extractDataAttributes","startsWith","localReflexControllers","app","schema","controllerAttribute","getControllerForElementAndIdentifier","StimulusReflex","request","timestamp","success","serverMessage","stimulusReflex","progress","totalOperations","completedOperations","duration","halted","subject","payload","NOOP","stimulusApplication","actionCableConsumer","actionCableParams","isolationMode","actionCableSubscriptionActive","extendStimulusController","assign","isActionCableConnectionOpen","stimulate","location","arguments","shift","validity","badInput","keys","opts","crypto","msCrypto","c","getRandomValues","Uint8Array","toString","uuidv4","selectors","getReflexRoots","resolveLate","datasetAttribute","extractElementDataset","xpathController","xpathElement","formData","form","w","FormData","encodeURIComponent","submitButton","Set","serializeForm","promise","registerReflex","context","scope","__perform","preventDefault","stopPropagation","Promise","resolve","register","received","cableReady","reflexOperations","splice","urls","m","pendingOperations","connected","rejected","createSubscription","StimulusReflexController","super","setupDeclarativeReflexes","delay","timeoutId","debounce","controllers","reflexAttributeNames","actions","actionAttribute","reflexName","findControllerByReflexName","allReflexControllers","controllerValue","actionValue","reflexString","extractReflexName","list","reflexRoot","stimulusReflexInitialized","MutationObserver","observe","documentElement","childList","subtree","beforeDOMUpdate","afterDOMUpdate","nothing","initialize","application","initializeOptions","isolate"],"sourceRoot":""}