super 0.0.0 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fab4db6e7d173cf9cbc0e0e75ca591b8713701420074507aafa20399725e644
-  data.tar.gz: 5a5dcc7ab979a1b97c36cb5131e39dad148fd2777b745829875622430429e6b3
+  metadata.gz: 7b59b4010b17c09a380b5aff7b71a7f3f17c8406553c24349454ed8bc2e80028
+  data.tar.gz: 6854ff2172e6c70ce60b64718133b71970e84d60db0e5a15296ba5bcf9b7a981
 SHA512:
-  metadata.gz: 58a086effc3234a454f7bbf06ee8560dd263bd8fa7b905a913e09181fd485debf6cbc9f23660a3a1d0204db1ee2db1439777f76009bca54526e4d19233b5773d
-  data.tar.gz: 02301b7074c541457cd396547870f1fd92bf8c83ca55bc571b801c8c0f50ee073f8691f265dbaf98df1ad3398cb95d5dec0f45a1ced7c450d0bf3df821d065af
+  metadata.gz: c243fa381ef6be45965a63a77d6684206b9e12e6a392059cca8dfcc4e7fec57bd8b14da4f26a8af05bf2c65aeeae8791aaa39801fe684c03df1e099f2ea3dff6
+  data.tar.gz: c7c4e6312ad9bd301effddf4363c1cea2e01d1e4221f113160b6571dd0e07b4709d7dbc0da87660960147a9a81c79a0da812cccc10fa81231cbcd8700e5b9c0b

data/.yardopts

@@ -0,0 +1,10 @@
+--exclude lib/generators
+--markup markdown
+--load ./docs/yard_customizations.rb
+-
+CONTRIBUTING.md
+LICENSE
+docs/quick_start.md
+docs/webpacker.md
+docs/controls.md
+docs/faq.md

data/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -1,28 +1,76 @@
 # Super
-Short description and motivation.
 
-## Usage
-How to use my plugin.
+Super is a zero dependency admin framework for Ruby on Rails applications.
 
-## Installation
-Add this line to your application's Gemfile:
+Super is made for developers. They will find it easy to build and modify admin
+pages. It builds on top of Rails controllers and views, so it's straightforward
+to customize. It's fully configurable without a DSL.
 
-```ruby
-gem 'super'
-```
+Super is made for admins. Power users and casual users alike will find the admin
+pages simple and efficient. And the Professional add-on can make it even more
+powerful.
 
-And then execute:
-```bash
-$ bundle
-```
 
-Or install it yourself as:
-```bash
-$ gem install super
-```
+## Features
+
+* Sprockets and Webpacker compatibility
+    * Note: Webpacker support depends on one additional NPM package for parsing
+      ERB
+* Pagination
+* Configurable forms (new and edit forms)
+* Configurable display (index and show tables)
+* Supports Rails 5.0+, Ruby 2.3+
+* Configurable without a DSL
+* Looks reasonably nice and modern
+* Pre-built frontend assets (doesn't require Sass, PostCSS, Babel, etc)
+    * Vendored assets include
+        * Stimulus JS
+        * Tailwind CSS
+        * Feather icons
+
+Super was inspired in part by the admin frameworks [ActiveAdmin][activeadmin]
+and [Administrate][administrate]. If Super doesn't quite fit your requirements
+at this moment, one of those might meet your needs better.
+
+
+## Professional edition
+
+Super Professional is a paid add-on and provides additional benefits:
+
+* Feature: Filtering by column values
+* Priority email support
+* Supporting long term development of Super
+* An LGPL exemption
+
+It will be available soon. Subscribe to the [newsletter][newsletter] to be
+notified of its availability or for brief, occasional updates.
+
+
+## Demos
+
+* [Super Demo][super_demo]
+    * [Super Demo source][super_demo_source]
+* [Super Professional Demo][super_professional]
+
+
+## Installation and Usage
+
+See [Quick start](./docs/quick_start.md)
+
 
 ## Contributing
-Contribution directions go here.
+
+See [CONTRIBUTING](./CONTRIBUTING.md)
+
 
 ## License
-The gem is available under the terms of the [Fair Source 5 License](https://fair.io).
+
+The gem is available under the terms of the [GNU LGPLv3](./LICENSE).
+
+
+[administrate]: https://github.com/thoughtbot/administrate
+[activeadmin]: https://github.com/activeadmin/activeadmin
+[newsletter]: https://tinyletter.com/zachahn
+[super_demo]: https://demo-super.herokuapp.com/admin/members
+[super_demo_source]: https://github.com/zachahn/super_demo
+[super_professional]: https://demo-super-professional.herokuapp.com/admin/members

data/Rakefile

@@ -14,7 +14,9 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+require_relative "dummy_path"
+
+APP_RAKEFILE = File.expand_path("#{SUPER_DUMMY_PATH}/Rakefile", __dir__)
 load 'rails/tasks/engine.rake'
 
 load 'rails/tasks/statistics.rake'

data/app/assets/config/super_manifest.js

@@ -0,0 +1,2 @@
+//= link super/application.css
+//= link super/application.js

data/app/assets/javascripts/super/application.js

@@ -0,0 +1,3618 @@
+// modules are defined as an array
+// [ module function, map of requires ]
+//
+// map of requires is short require name -> numeric require
+//
+// anything defined in a previous bundle is accessed via the
+// orig method which is the require for previous bundles
+parcelRequire = (function (modules, cache, entry, globalName) {
+  // Save the require from previous bundle to this closure if any
+  var previousRequire = typeof parcelRequire === 'function' && parcelRequire;
+  var nodeRequire = typeof require === 'function' && require;
+
+  function newRequire(name, jumped) {
+    if (!cache[name]) {
+      if (!modules[name]) {
+        // if we cannot find the module within our internal map or
+        // cache jump to the current global require ie. the last bundle
+        // that was added to the page.
+        var currentRequire = typeof parcelRequire === 'function' && parcelRequire;
+        if (!jumped && currentRequire) {
+          return currentRequire(name, true);
+        }
+
+        // If there are other bundles on this page the require from the
+        // previous one is saved to 'previousRequire'. Repeat this as
+        // many times as there are bundles until the module is found or
+        // we exhaust the require chain.
+        if (previousRequire) {
+          return previousRequire(name, true);
+        }
+
+        // Try the node require function if it exists.
+        if (nodeRequire && typeof name === 'string') {
+          return nodeRequire(name);
+        }
+
+        var err = new Error('Cannot find module \'' + name + '\'');
+        err.code = 'MODULE_NOT_FOUND';
+        throw err;
+      }
+
+      localRequire.resolve = resolve;
+      localRequire.cache = {};
+
+      var module = cache[name] = new newRequire.Module(name);
+
+      modules[name][0].call(module.exports, localRequire, module, module.exports, this);
+    }
+
+    return cache[name].exports;
+
+    function localRequire(x){
+      return newRequire(localRequire.resolve(x));
+    }
+
+    function resolve(x){
+      return modules[name][1][x] || x;
+    }
+  }
+
+  function Module(moduleName) {
+    this.id = moduleName;
+    this.bundle = newRequire;
+    this.exports = {};
+  }
+
+  newRequire.isParcelRequire = true;
+  newRequire.Module = Module;
+  newRequire.modules = modules;
+  newRequire.cache = cache;
+  newRequire.parent = previousRequire;
+  newRequire.register = function (id, exports) {
+    modules[id] = [function (require, module) {
+      module.exports = exports;
+    }, {}];
+  };
+
+  var error;
+  for (var i = 0; i < entry.length; i++) {
+    try {
+      newRequire(entry[i]);
+    } catch (e) {
+      // Save first error but execute all entries
+      if (!error) {
+        error = e;
+      }
+    }
+  }
+
+  if (entry.length) {
+    // Expose entry point to Node, AMD or browser globals
+    // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
+    var mainExports = newRequire(entry[entry.length - 1]);
+
+    // CommonJS
+    if (typeof exports === "object" && typeof module !== "undefined") {
+      module.exports = mainExports;
+
+    // RequireJS
+    } else if (typeof define === "function" && define.amd) {
+     define(function () {
+       return mainExports;
+     });
+
+    // <script>
+    } else if (globalName) {
+      this[globalName] = mainExports;
+    }
+  }
+
+  // Override the current require with this new one
+  parcelRequire = newRequire;
+
+  if (error) {
+    // throw error from earlier, _after updating parcelRequire_
+    throw error;
+  }
+
+  return newRequire;
+})({"../node_modules/@rails/ujs/lib/assets/compiled/rails-ujs.js":[function(require,module,exports) {
+var define;
+/*
+Unobtrusive JavaScript
+https://github.com/rails/rails/blob/master/actionview/app/assets/javascripts
+Released under the MIT license
+ */;
+
+(function() {
+  var context = this;
+
+  (function() {
+    (function() {
+      this.Rails = {
+        linkClickSelector: 'a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]',
+        buttonClickSelector: {
+          selector: 'button[data-remote]:not([form]), button[data-confirm]:not([form])',
+          exclude: 'form button'
+        },
+        inputChangeSelector: 'select[data-remote], input[data-remote], textarea[data-remote]',
+        formSubmitSelector: 'form',
+        formInputClickSelector: 'form input[type=submit], form input[type=image], form button[type=submit], form button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])',
+        formDisableSelector: 'input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled',
+        formEnableSelector: 'input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled',
+        fileInputSelector: 'input[name][type=file]:not([disabled])',
+        linkDisableSelector: 'a[data-disable-with], a[data-disable]',
+        buttonDisableSelector: 'button[data-remote][data-disable-with], button[data-remote][data-disable]'
+      };
+
+    }).call(this);
+  }).call(context);
+
+  var Rails = context.Rails;
+
+  (function() {
+    (function() {
+      var nonce;
+
+      nonce = null;
+
+      Rails.loadCSPNonce = function() {
+        var ref;
+        return nonce = (ref = document.querySelector("meta[name=csp-nonce]")) != null ? ref.content : void 0;
+      };
+
+      Rails.cspNonce = function() {
+        return nonce != null ? nonce : Rails.loadCSPNonce();
+      };
+
+    }).call(this);
+    (function() {
+      var expando, m;
+
+      m = Element.prototype.matches || Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector;
+
+      Rails.matches = function(element, selector) {
+        if (selector.exclude != null) {
+          return m.call(element, selector.selector) && !m.call(element, selector.exclude);
+        } else {
+          return m.call(element, selector);
+        }
+      };
+
+      expando = '_ujsData';
+
+      Rails.getData = function(element, key) {
+        var ref;
+        return (ref = element[expando]) != null ? ref[key] : void 0;
+      };
+
+      Rails.setData = function(element, key, value) {
+        if (element[expando] == null) {
+          element[expando] = {};
+        }
+        return element[expando][key] = value;
+      };
+
+      Rails.$ = function(selector) {
+        return Array.prototype.slice.call(document.querySelectorAll(selector));
+      };
+
+    }).call(this);
+    (function() {
+      var $, csrfParam, csrfToken;
+
+      $ = Rails.$;
+
+      csrfToken = Rails.csrfToken = function() {
+        var meta;
+        meta = document.querySelector('meta[name=csrf-token]');
+        return meta && meta.content;
+      };
+
+      csrfParam = Rails.csrfParam = function() {
+        var meta;
+        meta = document.querySelector('meta[name=csrf-param]');
+        return meta && meta.content;
+      };
+
+      Rails.CSRFProtection = function(xhr) {
+        var token;
+        token = csrfToken();
+        if (token != null) {
+          return xhr.setRequestHeader('X-CSRF-Token', token);
+        }
+      };
+
+      Rails.refreshCSRFTokens = function() {
+        var param, token;
+        token = csrfToken();
+        param = csrfParam();
+        if ((token != null) && (param != null)) {
+          return $('form input[name="' + param + '"]').forEach(function(input) {
+            return input.value = token;
+          });
+        }
+      };
+
+    }).call(this);
+    (function() {
+      var CustomEvent, fire, matches, preventDefault;
+
+      matches = Rails.matches;
+
+      CustomEvent = window.CustomEvent;
+
+      if (typeof CustomEvent !== 'function') {
+        CustomEvent = function(event, params) {
+          var evt;
+          evt = document.createEvent('CustomEvent');
+          evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+          return evt;
+        };
+        CustomEvent.prototype = window.Event.prototype;
+        preventDefault = CustomEvent.prototype.preventDefault;
+        CustomEvent.prototype.preventDefault = function() {
+          var result;
+          result = preventDefault.call(this);
+          if (this.cancelable && !this.defaultPrevented) {
+            Object.defineProperty(this, 'defaultPrevented', {
+              get: function() {
+                return true;
+              }
+            });
+          }
+          return result;
+        };
+      }
+
+      fire = Rails.fire = function(obj, name, data) {
+        var event;
+        event = new CustomEvent(name, {
+          bubbles: true,
+          cancelable: true,
+          detail: data
+        });
+        obj.dispatchEvent(event);
+        return !event.defaultPrevented;
+      };
+
+      Rails.stopEverything = function(e) {
+        fire(e.target, 'ujs:everythingStopped');
+        e.preventDefault();
+        e.stopPropagation();
+        return e.stopImmediatePropagation();
+      };
+
+      Rails.delegate = function(element, selector, eventType, handler) {
+        return element.addEventListener(eventType, function(e) {
+          var target;
+          target = e.target;
+          while (!(!(target instanceof Element) || matches(target, selector))) {
+            target = target.parentNode;
+          }
+          if (target instanceof Element && handler.call(target, e) === false) {
+            e.preventDefault();
+            return e.stopPropagation();
+          }
+        });
+      };
+
+    }).call(this);
+    (function() {
+      var AcceptHeaders, CSRFProtection, createXHR, cspNonce, fire, prepareOptions, processResponse;
+
+      cspNonce = Rails.cspNonce, CSRFProtection = Rails.CSRFProtection, fire = Rails.fire;
+
+      AcceptHeaders = {
+        '*': '*/*',
+        text: 'text/plain',
+        html: 'text/html',
+        xml: 'application/xml, text/xml',
+        json: 'application/json, text/javascript',
+        script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript'
+      };
+
+      Rails.ajax = function(options) {
+        var xhr;
+        options = prepareOptions(options);
+        xhr = createXHR(options, function() {
+          var ref, response;
+          response = processResponse((ref = xhr.response) != null ? ref : xhr.responseText, xhr.getResponseHeader('Content-Type'));
+          if (Math.floor(xhr.status / 100) === 2) {
+            if (typeof options.success === "function") {
+              options.success(response, xhr.statusText, xhr);
+            }
+          } else {
+            if (typeof options.error === "function") {
+              options.error(response, xhr.statusText, xhr);
+            }
+          }
+          return typeof options.complete === "function" ? options.complete(xhr, xhr.statusText) : void 0;
+        });
+        if ((options.beforeSend != null) && !options.beforeSend(xhr, options)) {
+          return false;
+        }
+        if (xhr.readyState === XMLHttpRequest.OPENED) {
+          return xhr.send(options.data);
+        }
+      };
+
+      prepareOptions = function(options) {
+        options.url = options.url || location.href;
+        options.type = options.type.toUpperCase();
+        if (options.type === 'GET' && options.data) {
+          if (options.url.indexOf('?') < 0) {
+            options.url += '?' + options.data;
+          } else {
+            options.url += '&' + options.data;
+          }
+        }
+        if (AcceptHeaders[options.dataType] == null) {
+          options.dataType = '*';
+        }
+        options.accept = AcceptHeaders[options.dataType];
+        if (options.dataType !== '*') {
+          options.accept += ', */*; q=0.01';
+        }
+        return options;
+      };
+
+      createXHR = function(options, done) {
+        var xhr;
+        xhr = new XMLHttpRequest();
+        xhr.open(options.type, options.url, true);
+        xhr.setRequestHeader('Accept', options.accept);
+        if (typeof options.data === 'string') {
+          xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');
+        }
+        if (!options.crossDomain) {
+          xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+        }
+        CSRFProtection(xhr);
+        xhr.withCredentials = !!options.withCredentials;
+        xhr.onreadystatechange = function() {
+          if (xhr.readyState === XMLHttpRequest.DONE) {
+            return done(xhr);
+          }
+        };
+        return xhr;
+      };
+
+      processResponse = function(response, type) {
+        var parser, script;
+        if (typeof response === 'string' && typeof type === 'string') {
+          if (type.match(/\bjson\b/)) {
+            try {
+              response = JSON.parse(response);
+            } catch (error) {}
+          } else if (type.match(/\b(?:java|ecma)script\b/)) {
+            script = document.createElement('script');
+            script.setAttribute('nonce', cspNonce());
+            script.text = response;
+            document.head.appendChild(script).parentNode.removeChild(script);
+          } else if (type.match(/\b(xml|html|svg)\b/)) {
+            parser = new DOMParser();
+            type = type.replace(/;.+/, '');
+            try {
+              response = parser.parseFromString(response, type);
+            } catch (error) {}
+          }
+        }
+        return response;
+      };
+
+      Rails.href = function(element) {
+        return element.href;
+      };
+
+      Rails.isCrossDomain = function(url) {
+        var e, originAnchor, urlAnchor;
+        originAnchor = document.createElement('a');
+        originAnchor.href = location.href;
+        urlAnchor = document.createElement('a');
+        try {
+          urlAnchor.href = url;
+          return !(((!urlAnchor.protocol || urlAnchor.protocol === ':') && !urlAnchor.host) || (originAnchor.protocol + '//' + originAnchor.host === urlAnchor.protocol + '//' + urlAnchor.host));
+        } catch (error) {
+          e = error;
+          return true;
+        }
+      };
+
+    }).call(this);
+    (function() {
+      var matches, toArray;
+
+      matches = Rails.matches;
+
+      toArray = function(e) {
+        return Array.prototype.slice.call(e);
+      };
+
+      Rails.serializeElement = function(element, additionalParam) {
+        var inputs, params;
+        inputs = [element];
+        if (matches(element, 'form')) {
+          inputs = toArray(element.elements);
+        }
+        params = [];
+        inputs.forEach(function(input) {
+          if (!input.name || input.disabled) {
+            return;
+          }
+          if (matches(input, 'fieldset[disabled] *')) {
+            return;
+          }
+          if (matches(input, 'select')) {
+            return toArray(input.options).forEach(function(option) {
+              if (option.selected) {
+                return params.push({
+                  name: input.name,
+                  value: option.value
+                });
+              }
+            });
+          } else if (input.checked || ['radio', 'checkbox', 'submit'].indexOf(input.type) === -1) {
+            return params.push({
+              name: input.name,
+              value: input.value
+            });
+          }
+        });
+        if (additionalParam) {
+          params.push(additionalParam);
+        }
+        return params.map(function(param) {
+          if (param.name != null) {
+            return (encodeURIComponent(param.name)) + "=" + (encodeURIComponent(param.value));
+          } else {
+            return param;
+          }
+        }).join('&');
+      };
+
+      Rails.formElements = function(form, selector) {
+        if (matches(form, 'form')) {
+          return toArray(form.elements).filter(function(el) {
+            return matches(el, selector);
+          });
+        } else {
+          return toArray(form.querySelectorAll(selector));
+        }
+      };
+
+    }).call(this);
+    (function() {
+      var allowAction, fire, stopEverything;
+
+      fire = Rails.fire, stopEverything = Rails.stopEverything;
+
+      Rails.handleConfirm = function(e) {
+        if (!allowAction(this)) {
+          return stopEverything(e);
+        }
+      };
+
+      Rails.confirm = function(message, element) {
+        return confirm(message);
+      };
+
+      allowAction = function(element) {
+        var answer, callback, message;
+        message = element.getAttribute('data-confirm');
+        if (!message) {
+          return true;
+        }
+        answer = false;
+        if (fire(element, 'confirm')) {
+          try {
+            answer = Rails.confirm(message, element);
+          } catch (error) {}
+          callback = fire(element, 'confirm:complete', [answer]);
+        }
+        return answer && callback;
+      };
+
+    }).call(this);
+    (function() {
+      var disableFormElement, disableFormElements, disableLinkElement, enableFormElement, enableFormElements, enableLinkElement, formElements, getData, isXhrRedirect, matches, setData, stopEverything;
+
+      matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, stopEverything = Rails.stopEverything, formElements = Rails.formElements;
+
+      Rails.handleDisabledElement = function(e) {
+        var element;
+        element = this;
+        if (element.disabled) {
+          return stopEverything(e);
+        }
+      };
+
+      Rails.enableElement = function(e) {
+        var element;
+        if (e instanceof Event) {
+          if (isXhrRedirect(e)) {
+            return;
+          }
+          element = e.target;
+        } else {
+          element = e;
+        }
+        if (matches(element, Rails.linkDisableSelector)) {
+          return enableLinkElement(element);
+        } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formEnableSelector)) {
+          return enableFormElement(element);
+        } else if (matches(element, Rails.formSubmitSelector)) {
+          return enableFormElements(element);
+        }
+      };
+
+      Rails.disableElement = function(e) {
+        var element;
+        element = e instanceof Event ? e.target : e;
+        if (matches(element, Rails.linkDisableSelector)) {
+          return disableLinkElement(element);
+        } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formDisableSelector)) {
+          return disableFormElement(element);
+        } else if (matches(element, Rails.formSubmitSelector)) {
+          return disableFormElements(element);
+        }
+      };
+
+      disableLinkElement = function(element) {
+        var replacement;
+        if (getData(element, 'ujs:disabled')) {
+          return;
+        }
+        replacement = element.getAttribute('data-disable-with');
+        if (replacement != null) {
+          setData(element, 'ujs:enable-with', element.innerHTML);
+          element.innerHTML = replacement;
+        }
+        element.addEventListener('click', stopEverything);
+        return setData(element, 'ujs:disabled', true);
+      };
+
+      enableLinkElement = function(element) {
+        var originalText;
+        originalText = getData(element, 'ujs:enable-with');
+        if (originalText != null) {
+          element.innerHTML = originalText;
+          setData(element, 'ujs:enable-with', null);
+        }
+        element.removeEventListener('click', stopEverything);
+        return setData(element, 'ujs:disabled', null);
+      };
+
+      disableFormElements = function(form) {
+        return formElements(form, Rails.formDisableSelector).forEach(disableFormElement);
+      };
+
+      disableFormElement = function(element) {
+        var replacement;
+        if (getData(element, 'ujs:disabled')) {
+          return;
+        }
+        replacement = element.getAttribute('data-disable-with');
+        if (replacement != null) {
+          if (matches(element, 'button')) {
+            setData(element, 'ujs:enable-with', element.innerHTML);
+            element.innerHTML = replacement;
+          } else {
+            setData(element, 'ujs:enable-with', element.value);
+            element.value = replacement;
+          }
+        }
+        element.disabled = true;
+        return setData(element, 'ujs:disabled', true);
+      };
+
+      enableFormElements = function(form) {
+        return formElements(form, Rails.formEnableSelector).forEach(enableFormElement);
+      };
+
+      enableFormElement = function(element) {
+        var originalText;
+        originalText = getData(element, 'ujs:enable-with');
+        if (originalText != null) {
+          if (matches(element, 'button')) {
+            element.innerHTML = originalText;
+          } else {
+            element.value = originalText;
+          }
+          setData(element, 'ujs:enable-with', null);
+        }
+        element.disabled = false;
+        return setData(element, 'ujs:disabled', null);
+      };
+
+      isXhrRedirect = function(event) {
+        var ref, xhr;
+        xhr = (ref = event.detail) != null ? ref[0] : void 0;
+        return (xhr != null ? xhr.getResponseHeader("X-Xhr-Redirect") : void 0) != null;
+      };
+
+    }).call(this);
+    (function() {
+      var stopEverything;
+
+      stopEverything = Rails.stopEverything;
+
+      Rails.handleMethod = function(e) {
+        var csrfParam, csrfToken, form, formContent, href, link, method;
+        link = this;
+        method = link.getAttribute('data-method');
+        if (!method) {
+          return;
+        }
+        href = Rails.href(link);
+        csrfToken = Rails.csrfToken();
+        csrfParam = Rails.csrfParam();
+        form = document.createElement('form');
+        formContent = "<input name='_method' value='" + method + "' type='hidden' />";
+        if ((csrfParam != null) && (csrfToken != null) && !Rails.isCrossDomain(href)) {
+          formContent += "<input name='" + csrfParam + "' value='" + csrfToken + "' type='hidden' />";
+        }
+        formContent += '<input type="submit" />';
+        form.method = 'post';
+        form.action = href;
+        form.target = link.target;
+        form.innerHTML = formContent;
+        form.style.display = 'none';
+        document.body.appendChild(form);
+        form.querySelector('[type="submit"]').click();
+        return stopEverything(e);
+      };
+
+    }).call(this);
+    (function() {
+      var ajax, fire, getData, isCrossDomain, isRemote, matches, serializeElement, setData, stopEverything,
+        slice = [].slice;
+
+      matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, fire = Rails.fire, stopEverything = Rails.stopEverything, ajax = Rails.ajax, isCrossDomain = Rails.isCrossDomain, serializeElement = Rails.serializeElement;
+
+      isRemote = function(element) {
+        var value;
+        value = element.getAttribute('data-remote');
+        return (value != null) && value !== 'false';
+      };
+
+      Rails.handleRemote = function(e) {
+        var button, data, dataType, element, method, url, withCredentials;
+        element = this;
+        if (!isRemote(element)) {
+          return true;
+        }
+        if (!fire(element, 'ajax:before')) {
+          fire(element, 'ajax:stopped');
+          return false;
+        }
+        withCredentials = element.getAttribute('data-with-credentials');
+        dataType = element.getAttribute('data-type') || 'script';
+        if (matches(element, Rails.formSubmitSelector)) {
+          button = getData(element, 'ujs:submit-button');
+          method = getData(element, 'ujs:submit-button-formmethod') || element.method;
+          url = getData(element, 'ujs:submit-button-formaction') || element.getAttribute('action') || location.href;
+          if (method.toUpperCase() === 'GET') {
+            url = url.replace(/\?.*$/, '');
+          }
+          if (element.enctype === 'multipart/form-data') {
+            data = new FormData(element);
+            if (button != null) {
+              data.append(button.name, button.value);
+            }
+          } else {
+            data = serializeElement(element, button);
+          }
+          setData(element, 'ujs:submit-button', null);
+          setData(element, 'ujs:submit-button-formmethod', null);
+          setData(element, 'ujs:submit-button-formaction', null);
+        } else if (matches(element, Rails.buttonClickSelector) || matches(element, Rails.inputChangeSelector)) {
+          method = element.getAttribute('data-method');
+          url = element.getAttribute('data-url');
+          data = serializeElement(element, element.getAttribute('data-params'));
+        } else {
+          method = element.getAttribute('data-method');
+          url = Rails.href(element);
+          data = element.getAttribute('data-params');
+        }
+        ajax({
+          type: method || 'GET',
+          url: url,
+          data: data,
+          dataType: dataType,
+          beforeSend: function(xhr, options) {
+            if (fire(element, 'ajax:beforeSend', [xhr, options])) {
+              return fire(element, 'ajax:send', [xhr]);
+            } else {
+              fire(element, 'ajax:stopped');
+              return false;
+            }
+          },
+          success: function() {
+            var args;
+            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+            return fire(element, 'ajax:success', args);
+          },
+          error: function() {
+            var args;
+            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+            return fire(element, 'ajax:error', args);
+          },
+          complete: function() {
+            var args;
+            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+            return fire(element, 'ajax:complete', args);
+          },
+          crossDomain: isCrossDomain(url),
+          withCredentials: (withCredentials != null) && withCredentials !== 'false'
+        });
+        return stopEverything(e);
+      };
+
+      Rails.formSubmitButtonClick = function(e) {
+        var button, form;
+        button = this;
+        form = button.form;
+        if (!form) {
+          return;
+        }
+        if (button.name) {
+          setData(form, 'ujs:submit-button', {
+            name: button.name,
+            value: button.value
+          });
+        }
+        setData(form, 'ujs:formnovalidate-button', button.formNoValidate);
+        setData(form, 'ujs:submit-button-formaction', button.getAttribute('formaction'));
+        return setData(form, 'ujs:submit-button-formmethod', button.getAttribute('formmethod'));
+      };
+
+      Rails.preventInsignificantClick = function(e) {
+        var data, insignificantMetaClick, link, metaClick, method, nonPrimaryMouseClick;
+        link = this;
+        method = (link.getAttribute('data-method') || 'GET').toUpperCase();
+        data = link.getAttribute('data-params');
+        metaClick = e.metaKey || e.ctrlKey;
+        insignificantMetaClick = metaClick && method === 'GET' && !data;
+        nonPrimaryMouseClick = (e.button != null) && e.button !== 0;
+        if (nonPrimaryMouseClick || insignificantMetaClick) {
+          return e.stopImmediatePropagation();
+        }
+      };
+
+    }).call(this);
+    (function() {
+      var $, CSRFProtection, delegate, disableElement, enableElement, fire, formSubmitButtonClick, getData, handleConfirm, handleDisabledElement, handleMethod, handleRemote, loadCSPNonce, preventInsignificantClick, refreshCSRFTokens;
+
+      fire = Rails.fire, delegate = Rails.delegate, getData = Rails.getData, $ = Rails.$, refreshCSRFTokens = Rails.refreshCSRFTokens, CSRFProtection = Rails.CSRFProtection, loadCSPNonce = Rails.loadCSPNonce, enableElement = Rails.enableElement, disableElement = Rails.disableElement, handleDisabledElement = Rails.handleDisabledElement, handleConfirm = Rails.handleConfirm, preventInsignificantClick = Rails.preventInsignificantClick, handleRemote = Rails.handleRemote, formSubmitButtonClick = Rails.formSubmitButtonClick, handleMethod = Rails.handleMethod;
+
+      if ((typeof jQuery !== "undefined" && jQuery !== null) && (jQuery.ajax != null)) {
+        if (jQuery.rails) {
+          throw new Error('If you load both jquery_ujs and rails-ujs, use rails-ujs only.');
+        }
+        jQuery.rails = Rails;
+        jQuery.ajaxPrefilter(function(options, originalOptions, xhr) {
+          if (!options.crossDomain) {
+            return CSRFProtection(xhr);
+          }
+        });
+      }
+
+      Rails.start = function() {
+        if (window._rails_loaded) {
+          throw new Error('rails-ujs has already been loaded!');
+        }
+        window.addEventListener('pageshow', function() {
+          $(Rails.formEnableSelector).forEach(function(el) {
+            if (getData(el, 'ujs:disabled')) {
+              return enableElement(el);
+            }
+          });
+          return $(Rails.linkDisableSelector).forEach(function(el) {
+            if (getData(el, 'ujs:disabled')) {
+              return enableElement(el);
+            }
+          });
+        });
+        delegate(document, Rails.linkDisableSelector, 'ajax:complete', enableElement);
+        delegate(document, Rails.linkDisableSelector, 'ajax:stopped', enableElement);
+        delegate(document, Rails.buttonDisableSelector, 'ajax:complete', enableElement);
+        delegate(document, Rails.buttonDisableSelector, 'ajax:stopped', enableElement);
+        delegate(document, Rails.linkClickSelector, 'click', preventInsignificantClick);
+        delegate(document, Rails.linkClickSelector, 'click', handleDisabledElement);
+        delegate(document, Rails.linkClickSelector, 'click', handleConfirm);
+        delegate(document, Rails.linkClickSelector, 'click', disableElement);
+        delegate(document, Rails.linkClickSelector, 'click', handleRemote);
+        delegate(document, Rails.linkClickSelector, 'click', handleMethod);
+        delegate(document, Rails.buttonClickSelector, 'click', preventInsignificantClick);
+        delegate(document, Rails.buttonClickSelector, 'click', handleDisabledElement);
+        delegate(document, Rails.buttonClickSelector, 'click', handleConfirm);
+        delegate(document, Rails.buttonClickSelector, 'click', disableElement);
+        delegate(document, Rails.buttonClickSelector, 'click', handleRemote);
+        delegate(document, Rails.inputChangeSelector, 'change', handleDisabledElement);
+        delegate(document, Rails.inputChangeSelector, 'change', handleConfirm);
+        delegate(document, Rails.inputChangeSelector, 'change', handleRemote);
+        delegate(document, Rails.formSubmitSelector, 'submit', handleDisabledElement);
+        delegate(document, Rails.formSubmitSelector, 'submit', handleConfirm);
+        delegate(document, Rails.formSubmitSelector, 'submit', handleRemote);
+        delegate(document, Rails.formSubmitSelector, 'submit', function(e) {
+          return setTimeout((function() {
+            return disableElement(e);
+          }), 13);
+        });
+        delegate(document, Rails.formSubmitSelector, 'ajax:send', disableElement);
+        delegate(document, Rails.formSubmitSelector, 'ajax:complete', enableElement);
+        delegate(document, Rails.formInputClickSelector, 'click', preventInsignificantClick);
+        delegate(document, Rails.formInputClickSelector, 'click', handleDisabledElement);
+        delegate(document, Rails.formInputClickSelector, 'click', handleConfirm);
+        delegate(document, Rails.formInputClickSelector, 'click', formSubmitButtonClick);
+        document.addEventListener('DOMContentLoaded', refreshCSRFTokens);
+        document.addEventListener('DOMContentLoaded', loadCSPNonce);
+        return window._rails_loaded = true;
+      };
+
+      if (window.Rails === Rails && fire(document, 'rails:attachBindings')) {
+        Rails.start();
+      }
+
+    }).call(this);
+  }).call(this);
+
+  if (typeof module === "object" && module.exports) {
+    module.exports = Rails;
+  } else if (typeof define === "function" && define.amd) {
+    define(Rails);
+  }
+}).call(this);
+
+},{}],"../node_modules/@stimulus/core/dist/src/event_listener.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventListener = void 0;
+
+var EventListener =
+/** @class */
+function () {
+  function EventListener(eventTarget, eventName) {
+    this.eventTarget = eventTarget;
+    this.eventName = eventName;
+    this.unorderedBindings = new Set();
+  }
+
+  EventListener.prototype.connect = function () {
+    this.eventTarget.addEventListener(this.eventName, this, false);
+  };
+
+  EventListener.prototype.disconnect = function () {
+    this.eventTarget.removeEventListener(this.eventName, this, false);
+  }; // Binding observer delegate
+
+  /** @hidden */
+
+
+  EventListener.prototype.bindingConnected = function (binding) {
+    this.unorderedBindings.add(binding);
+  };
+  /** @hidden */
+
+
+  EventListener.prototype.bindingDisconnected = function (binding) {
+    this.unorderedBindings.delete(binding);
+  };
+
+  EventListener.prototype.handleEvent = function (event) {
+    var extendedEvent = extendEvent(event);
+
+    for (var _i = 0, _a = this.bindings; _i < _a.length; _i++) {
+      var binding = _a[_i];
+
+      if (extendedEvent.immediatePropagationStopped) {
+        break;
+      } else {
+        binding.handleEvent(extendedEvent);
+      }
+    }
+  };
+
+  Object.defineProperty(EventListener.prototype, "bindings", {
+    get: function () {
+      return Array.from(this.unorderedBindings).sort(function (left, right) {
+        var leftIndex = left.index,
+            rightIndex = right.index;
+        return leftIndex < rightIndex ? -1 : leftIndex > rightIndex ? 1 : 0;
+      });
+    },
+    enumerable: true,
+    configurable: true
+  });
+  return EventListener;
+}();
+
+exports.EventListener = EventListener;
+
+function extendEvent(event) {
+  if ("immediatePropagationStopped" in event) {
+    return event;
+  } else {
+    var stopImmediatePropagation_1 = event.stopImmediatePropagation;
+    return Object.assign(event, {
+      immediatePropagationStopped: false,
+      stopImmediatePropagation: function () {
+        this.immediatePropagationStopped = true;
+        stopImmediatePropagation_1.call(this);
+      }
+    });
+  }
+}
+},{}],"../node_modules/@stimulus/core/dist/src/dispatcher.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Dispatcher = void 0;
+
+var _event_listener = require("./event_listener");
+
+var Dispatcher =
+/** @class */
+function () {
+  function Dispatcher(application) {
+    this.application = application;
+    this.eventListenerMaps = new Map();
+    this.started = false;
+  }
+
+  Dispatcher.prototype.start = function () {
+    if (!this.started) {
+      this.started = true;
+      this.eventListeners.forEach(function (eventListener) {
+        return eventListener.connect();
+      });
+    }
+  };
+
+  Dispatcher.prototype.stop = function () {
+    if (this.started) {
+      this.started = false;
+      this.eventListeners.forEach(function (eventListener) {
+        return eventListener.disconnect();
+      });
+    }
+  };
+
+  Object.defineProperty(Dispatcher.prototype, "eventListeners", {
+    get: function () {
+      return Array.from(this.eventListenerMaps.values()).reduce(function (listeners, map) {
+        return listeners.concat(Array.from(map.values()));
+      }, []);
+    },
+    enumerable: true,
+    configurable: true
+  }); // Binding observer delegate
+
+  /** @hidden */
+
+  Dispatcher.prototype.bindingConnected = function (binding) {
+    this.fetchEventListenerForBinding(binding).bindingConnected(binding);
+  };
+  /** @hidden */
+
+
+  Dispatcher.prototype.bindingDisconnected = function (binding) {
+    this.fetchEventListenerForBinding(binding).bindingDisconnected(binding);
+  }; // Error handling
+
+
+  Dispatcher.prototype.handleError = function (error, message, detail) {
+    if (detail === void 0) {
+      detail = {};
+    }
+
+    this.application.handleError(error, "Error " + message, detail);
+  };
+
+  Dispatcher.prototype.fetchEventListenerForBinding = function (binding) {
+    var eventTarget = binding.eventTarget,
+        eventName = binding.eventName;
+    return this.fetchEventListener(eventTarget, eventName);
+  };
+
+  Dispatcher.prototype.fetchEventListener = function (eventTarget, eventName) {
+    var eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);
+    var eventListener = eventListenerMap.get(eventName);
+
+    if (!eventListener) {
+      eventListener = this.createEventListener(eventTarget, eventName);
+      eventListenerMap.set(eventName, eventListener);
+    }
+
+    return eventListener;
+  };
+
+  Dispatcher.prototype.createEventListener = function (eventTarget, eventName) {
+    var eventListener = new _event_listener.EventListener(eventTarget, eventName);
+
+    if (this.started) {
+      eventListener.connect();
+    }
+
+    return eventListener;
+  };
+
+  Dispatcher.prototype.fetchEventListenerMapForEventTarget = function (eventTarget) {
+    var eventListenerMap = this.eventListenerMaps.get(eventTarget);
+
+    if (!eventListenerMap) {
+      eventListenerMap = new Map();
+      this.eventListenerMaps.set(eventTarget, eventListenerMap);
+    }
+
+    return eventListenerMap;
+  };
+
+  return Dispatcher;
+}();
+
+exports.Dispatcher = Dispatcher;
+},{"./event_listener":"../node_modules/@stimulus/core/dist/src/event_listener.js"}],"../node_modules/@stimulus/core/dist/src/action_descriptor.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseDescriptorString = parseDescriptorString;
+exports.stringifyEventTarget = stringifyEventTarget;
+// capture nos.:            12   23 4               43   1 5   56 7  76
+var descriptorPattern = /^((.+?)(@(window|document))?->)?(.+?)(#(.+))?$/;
+
+function parseDescriptorString(descriptorString) {
+  var source = descriptorString.trim();
+  var matches = source.match(descriptorPattern) || [];
+  return {
+    eventTarget: parseEventTarget(matches[4]),
+    eventName: matches[2],
+    identifier: matches[5],
+    methodName: matches[7]
+  };
+}
+
+function parseEventTarget(eventTargetName) {
+  if (eventTargetName == "window") {
+    return window;
+  } else if (eventTargetName == "document") {
+    return document;
+  }
+}
+
+function stringifyEventTarget(eventTarget) {
+  if (eventTarget == window) {
+    return "window";
+  } else if (eventTarget == document) {
+    return "document";
+  }
+}
+},{}],"../node_modules/@stimulus/core/dist/src/action.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDefaultEventNameForElement = getDefaultEventNameForElement;
+exports.Action = void 0;
+
+var _action_descriptor = require("./action_descriptor");
+
+var Action =
+/** @class */
+function () {
+  function Action(element, index, descriptor) {
+    this.element = element;
+    this.index = index;
+    this.eventTarget = descriptor.eventTarget || element;
+    this.eventName = descriptor.eventName || getDefaultEventNameForElement(element) || error("missing event name");
+    this.identifier = descriptor.identifier || error("missing identifier");
+    this.methodName = descriptor.methodName || error("missing method name");
+  }
+
+  Action.forToken = function (token) {
+    return new this(token.element, token.index, (0, _action_descriptor.parseDescriptorString)(token.content));
+  };
+
+  Action.prototype.toString = function () {
+    var eventNameSuffix = this.eventTargetName ? "@" + this.eventTargetName : "";
+    return "" + this.eventName + eventNameSuffix + "->" + this.identifier + "#" + this.methodName;
+  };
+
+  Object.defineProperty(Action.prototype, "eventTargetName", {
+    get: function () {
+      return (0, _action_descriptor.stringifyEventTarget)(this.eventTarget);
+    },
+    enumerable: true,
+    configurable: true
+  });
+  return Action;
+}();
+
+exports.Action = Action;
+var defaultEventNames = {
+  "a": function (e) {
+    return "click";
+  },
+  "button": function (e) {
+    return "click";
+  },
+  "form": function (e) {
+    return "submit";
+  },
+  "input": function (e) {
+    return e.getAttribute("type") == "submit" ? "click" : "change";
+  },
+  "select": function (e) {
+    return "change";
+  },
+  "textarea": function (e) {
+    return "change";
+  }
+};
+
+function getDefaultEventNameForElement(element) {
+  var tagName = element.tagName.toLowerCase();
+
+  if (tagName in defaultEventNames) {
+    return defaultEventNames[tagName](element);
+  }
+}
+
+function error(message) {
+  throw new Error(message);
+}
+},{"./action_descriptor":"../node_modules/@stimulus/core/dist/src/action_descriptor.js"}],"../node_modules/@stimulus/core/dist/src/binding.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Binding = void 0;
+
+var Binding =
+/** @class */
+function () {
+  function Binding(context, action) {
+    this.context = context;
+    this.action = action;
+  }
+
+  Object.defineProperty(Binding.prototype, "index", {
+    get: function () {
+      return this.action.index;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Binding.prototype, "eventTarget", {
+    get: function () {
+      return this.action.eventTarget;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Binding.prototype, "identifier", {
+    get: function () {
+      return this.context.identifier;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  Binding.prototype.handleEvent = function (event) {
+    if (this.willBeInvokedByEvent(event)) {
+      this.invokeWithEvent(event);
+    }
+  };
+
+  Object.defineProperty(Binding.prototype, "eventName", {
+    get: function () {
+      return this.action.eventName;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Binding.prototype, "method", {
+    get: function () {
+      var method = this.controller[this.methodName];
+
+      if (typeof method == "function") {
+        return method;
+      }
+
+      throw new Error("Action \"" + this.action + "\" references undefined method \"" + this.methodName + "\"");
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  Binding.prototype.invokeWithEvent = function (event) {
+    try {
+      this.method.call(this.controller, event);
+    } catch (error) {
+      var _a = this,
+          identifier = _a.identifier,
+          controller = _a.controller,
+          element = _a.element,
+          index = _a.index;
+
+      var detail = {
+        identifier: identifier,
+        controller: controller,
+        element: element,
+        index: index,
+        event: event
+      };
+      this.context.handleError(error, "invoking action \"" + this.action + "\"", detail);
+    }
+  };
+
+  Binding.prototype.willBeInvokedByEvent = function (event) {
+    var eventTarget = event.target;
+
+    if (this.element === eventTarget) {
+      return true;
+    } else if (eventTarget instanceof Element && this.element.contains(eventTarget)) {
+      return this.scope.containsElement(eventTarget);
+    } else {
+      return true;
+    }
+  };
+
+  Object.defineProperty(Binding.prototype, "controller", {
+    get: function () {
+      return this.context.controller;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Binding.prototype, "methodName", {
+    get: function () {
+      return this.action.methodName;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Binding.prototype, "element", {
+    get: function () {
+      return this.scope.element;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Binding.prototype, "scope", {
+    get: function () {
+      return this.context.scope;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  return Binding;
+}();
+
+exports.Binding = Binding;
+},{}],"../node_modules/@stimulus/mutation-observers/dist/src/element_observer.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElementObserver = void 0;
+
+var ElementObserver =
+/** @class */
+function () {
+  function ElementObserver(element, delegate) {
+    var _this = this;
+
+    this.element = element;
+    this.started = false;
+    this.delegate = delegate;
+    this.elements = new Set();
+    this.mutationObserver = new MutationObserver(function (mutations) {
+      return _this.processMutations(mutations);
+    });
+  }
+
+  ElementObserver.prototype.start = function () {
+    if (!this.started) {
+      this.started = true;
+      this.mutationObserver.observe(this.element, {
+        attributes: true,
+        childList: true,
+        subtree: true
+      });
+      this.refresh();
+    }
+  };
+
+  ElementObserver.prototype.stop = function () {
+    if (this.started) {
+      this.mutationObserver.takeRecords();
+      this.mutationObserver.disconnect();
+      this.started = false;
+    }
+  };
+
+  ElementObserver.prototype.refresh = function () {
+    if (this.started) {
+      var matches = new Set(this.matchElementsInTree());
+
+      for (var _i = 0, _a = Array.from(this.elements); _i < _a.length; _i++) {
+        var element = _a[_i];
+
+        if (!matches.has(element)) {
+          this.removeElement(element);
+        }
+      }
+
+      for (var _b = 0, _c = Array.from(matches); _b < _c.length; _b++) {
+        var element = _c[_b];
+        this.addElement(element);
+      }
+    }
+  }; // Mutation record processing
+
+
+  ElementObserver.prototype.processMutations = function (mutations) {
+    if (this.started) {
+      for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {
+        var mutation = mutations_1[_i];
+        this.processMutation(mutation);
+      }
+    }
+  };
+
+  ElementObserver.prototype.processMutation = function (mutation) {
+    if (mutation.type == "attributes") {
+      this.processAttributeChange(mutation.target, mutation.attributeName);
+    } else if (mutation.type == "childList") {
+      this.processRemovedNodes(mutation.removedNodes);
+      this.processAddedNodes(mutation.addedNodes);
+    }
+  };
+
+  ElementObserver.prototype.processAttributeChange = function (node, attributeName) {
+    var element = node;
+
+    if (this.elements.has(element)) {
+      if (this.delegate.elementAttributeChanged && this.matchElement(element)) {
+        this.delegate.elementAttributeChanged(element, attributeName);
+      } else {
+        this.removeElement(element);
+      }
+    } else if (this.matchElement(element)) {
+      this.addElement(element);
+    }
+  };
+
+  ElementObserver.prototype.processRemovedNodes = function (nodes) {
+    for (var _i = 0, _a = Array.from(nodes); _i < _a.length; _i++) {
+      var node = _a[_i];
+      var element = this.elementFromNode(node);
+
+      if (element) {
+        this.processTree(element, this.removeElement);
+      }
+    }
+  };
+
+  ElementObserver.prototype.processAddedNodes = function (nodes) {
+    for (var _i = 0, _a = Array.from(nodes); _i < _a.length; _i++) {
+      var node = _a[_i];
+      var element = this.elementFromNode(node);
+
+      if (element && this.elementIsActive(element)) {
+        this.processTree(element, this.addElement);
+      }
+    }
+  }; // Element matching
+
+
+  ElementObserver.prototype.matchElement = function (element) {
+    return this.delegate.matchElement(element);
+  };
+
+  ElementObserver.prototype.matchElementsInTree = function (tree) {
+    if (tree === void 0) {
+      tree = this.element;
+    }
+
+    return this.delegate.matchElementsInTree(tree);
+  };
+
+  ElementObserver.prototype.processTree = function (tree, processor) {
+    for (var _i = 0, _a = this.matchElementsInTree(tree); _i < _a.length; _i++) {
+      var element = _a[_i];
+      processor.call(this, element);
+    }
+  };
+
+  ElementObserver.prototype.elementFromNode = function (node) {
+    if (node.nodeType == Node.ELEMENT_NODE) {
+      return node;
+    }
+  };
+
+  ElementObserver.prototype.elementIsActive = function (element) {
+    if (element.isConnected != this.element.isConnected) {
+      return false;
+    } else {
+      return this.element.contains(element);
+    }
+  }; // Element tracking
+
+
+  ElementObserver.prototype.addElement = function (element) {
+    if (!this.elements.has(element)) {
+      if (this.elementIsActive(element)) {
+        this.elements.add(element);
+
+        if (this.delegate.elementMatched) {
+          this.delegate.elementMatched(element);
+        }
+      }
+    }
+  };
+
+  ElementObserver.prototype.removeElement = function (element) {
+    if (this.elements.has(element)) {
+      this.elements.delete(element);
+
+      if (this.delegate.elementUnmatched) {
+        this.delegate.elementUnmatched(element);
+      }
+    }
+  };
+
+  return ElementObserver;
+}();
+
+exports.ElementObserver = ElementObserver;
+},{}],"../node_modules/@stimulus/mutation-observers/dist/src/attribute_observer.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AttributeObserver = void 0;
+
+var _element_observer = require("./element_observer");
+
+var AttributeObserver =
+/** @class */
+function () {
+  function AttributeObserver(element, attributeName, delegate) {
+    this.attributeName = attributeName;
+    this.delegate = delegate;
+    this.elementObserver = new _element_observer.ElementObserver(element, this);
+  }
+
+  Object.defineProperty(AttributeObserver.prototype, "element", {
+    get: function () {
+      return this.elementObserver.element;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(AttributeObserver.prototype, "selector", {
+    get: function () {
+      return "[" + this.attributeName + "]";
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  AttributeObserver.prototype.start = function () {
+    this.elementObserver.start();
+  };
+
+  AttributeObserver.prototype.stop = function () {
+    this.elementObserver.stop();
+  };
+
+  AttributeObserver.prototype.refresh = function () {
+    this.elementObserver.refresh();
+  };
+
+  Object.defineProperty(AttributeObserver.prototype, "started", {
+    get: function () {
+      return this.elementObserver.started;
+    },
+    enumerable: true,
+    configurable: true
+  }); // Element observer delegate
+
+  AttributeObserver.prototype.matchElement = function (element) {
+    return element.hasAttribute(this.attributeName);
+  };
+
+  AttributeObserver.prototype.matchElementsInTree = function (tree) {
+    var match = this.matchElement(tree) ? [tree] : [];
+    var matches = Array.from(tree.querySelectorAll(this.selector));
+    return match.concat(matches);
+  };
+
+  AttributeObserver.prototype.elementMatched = function (element) {
+    if (this.delegate.elementMatchedAttribute) {
+      this.delegate.elementMatchedAttribute(element, this.attributeName);
+    }
+  };
+
+  AttributeObserver.prototype.elementUnmatched = function (element) {
+    if (this.delegate.elementUnmatchedAttribute) {
+      this.delegate.elementUnmatchedAttribute(element, this.attributeName);
+    }
+  };
+
+  AttributeObserver.prototype.elementAttributeChanged = function (element, attributeName) {
+    if (this.delegate.elementAttributeValueChanged && this.attributeName == attributeName) {
+      this.delegate.elementAttributeValueChanged(element, attributeName);
+    }
+  };
+
+  return AttributeObserver;
+}();
+
+exports.AttributeObserver = AttributeObserver;
+},{"./element_observer":"../node_modules/@stimulus/mutation-observers/dist/src/element_observer.js"}],"../node_modules/@stimulus/multimap/dist/src/set_operations.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.add = add;
+exports.del = del;
+exports.fetch = fetch;
+exports.prune = prune;
+
+function add(map, key, value) {
+  fetch(map, key).add(value);
+}
+
+function del(map, key, value) {
+  fetch(map, key).delete(value);
+  prune(map, key);
+}
+
+function fetch(map, key) {
+  var values = map.get(key);
+
+  if (!values) {
+    values = new Set();
+    map.set(key, values);
+  }
+
+  return values;
+}
+
+function prune(map, key) {
+  var values = map.get(key);
+
+  if (values != null && values.size == 0) {
+    map.delete(key);
+  }
+}
+},{}],"../node_modules/@stimulus/multimap/dist/src/multimap.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Multimap = void 0;
+
+var _set_operations = require("./set_operations");
+
+var Multimap =
+/** @class */
+function () {
+  function Multimap() {
+    this.valuesByKey = new Map();
+  }
+
+  Object.defineProperty(Multimap.prototype, "values", {
+    get: function () {
+      var sets = Array.from(this.valuesByKey.values());
+      return sets.reduce(function (values, set) {
+        return values.concat(Array.from(set));
+      }, []);
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Multimap.prototype, "size", {
+    get: function () {
+      var sets = Array.from(this.valuesByKey.values());
+      return sets.reduce(function (size, set) {
+        return size + set.size;
+      }, 0);
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  Multimap.prototype.add = function (key, value) {
+    (0, _set_operations.add)(this.valuesByKey, key, value);
+  };
+
+  Multimap.prototype.delete = function (key, value) {
+    (0, _set_operations.del)(this.valuesByKey, key, value);
+  };
+
+  Multimap.prototype.has = function (key, value) {
+    var values = this.valuesByKey.get(key);
+    return values != null && values.has(value);
+  };
+
+  Multimap.prototype.hasKey = function (key) {
+    return this.valuesByKey.has(key);
+  };
+
+  Multimap.prototype.hasValue = function (value) {
+    var sets = Array.from(this.valuesByKey.values());
+    return sets.some(function (set) {
+      return set.has(value);
+    });
+  };
+
+  Multimap.prototype.getValuesForKey = function (key) {
+    var values = this.valuesByKey.get(key);
+    return values ? Array.from(values) : [];
+  };
+
+  Multimap.prototype.getKeysForValue = function (value) {
+    return Array.from(this.valuesByKey).filter(function (_a) {
+      var key = _a[0],
+          values = _a[1];
+      return values.has(value);
+    }).map(function (_a) {
+      var key = _a[0],
+          values = _a[1];
+      return key;
+    });
+  };
+
+  return Multimap;
+}();
+
+exports.Multimap = Multimap;
+},{"./set_operations":"../node_modules/@stimulus/multimap/dist/src/set_operations.js"}],"../node_modules/@stimulus/multimap/dist/src/indexed_multimap.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexedMultimap = void 0;
+
+var _multimap = require("./multimap");
+
+var _set_operations = require("./set_operations");
+
+var __extends = void 0 && (void 0).__extends || function () {
+  var extendStatics = Object.setPrototypeOf || {
+    __proto__: []
+  } instanceof Array && function (d, b) {
+    d.__proto__ = b;
+  } || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+  };
+
+  return function (d, b) {
+    extendStatics(d, b);
+
+    function __() {
+      this.constructor = d;
+    }
+
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+
+var IndexedMultimap =
+/** @class */
+function (_super) {
+  __extends(IndexedMultimap, _super);
+
+  function IndexedMultimap() {
+    var _this = _super.call(this) || this;
+
+    _this.keysByValue = new Map();
+    return _this;
+  }
+
+  Object.defineProperty(IndexedMultimap.prototype, "values", {
+    get: function () {
+      return Array.from(this.keysByValue.keys());
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  IndexedMultimap.prototype.add = function (key, value) {
+    _super.prototype.add.call(this, key, value);
+
+    (0, _set_operations.add)(this.keysByValue, value, key);
+  };
+
+  IndexedMultimap.prototype.delete = function (key, value) {
+    _super.prototype.delete.call(this, key, value);
+
+    (0, _set_operations.del)(this.keysByValue, value, key);
+  };
+
+  IndexedMultimap.prototype.hasValue = function (value) {
+    return this.keysByValue.has(value);
+  };
+
+  IndexedMultimap.prototype.getKeysForValue = function (value) {
+    var set = this.keysByValue.get(value);
+    return set ? Array.from(set) : [];
+  };
+
+  return IndexedMultimap;
+}(_multimap.Multimap);
+
+exports.IndexedMultimap = IndexedMultimap;
+},{"./multimap":"../node_modules/@stimulus/multimap/dist/src/multimap.js","./set_operations":"../node_modules/@stimulus/multimap/dist/src/set_operations.js"}],"../node_modules/@stimulus/multimap/dist/index.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _multimap = require("./src/multimap");
+
+Object.keys(_multimap).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _multimap[key];
+    }
+  });
+});
+
+var _indexed_multimap = require("./src/indexed_multimap");
+
+Object.keys(_indexed_multimap).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _indexed_multimap[key];
+    }
+  });
+});
+},{"./src/multimap":"../node_modules/@stimulus/multimap/dist/src/multimap.js","./src/indexed_multimap":"../node_modules/@stimulus/multimap/dist/src/indexed_multimap.js"}],"../node_modules/@stimulus/mutation-observers/dist/src/token_list_observer.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TokenListObserver = void 0;
+
+var _attribute_observer = require("./attribute_observer");
+
+var _multimap = require("@stimulus/multimap");
+
+var TokenListObserver =
+/** @class */
+function () {
+  function TokenListObserver(element, attributeName, delegate) {
+    this.attributeObserver = new _attribute_observer.AttributeObserver(element, attributeName, this);
+    this.delegate = delegate;
+    this.tokensByElement = new _multimap.Multimap();
+  }
+
+  Object.defineProperty(TokenListObserver.prototype, "started", {
+    get: function () {
+      return this.attributeObserver.started;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  TokenListObserver.prototype.start = function () {
+    this.attributeObserver.start();
+  };
+
+  TokenListObserver.prototype.stop = function () {
+    this.attributeObserver.stop();
+  };
+
+  TokenListObserver.prototype.refresh = function () {
+    this.attributeObserver.refresh();
+  };
+
+  Object.defineProperty(TokenListObserver.prototype, "element", {
+    get: function () {
+      return this.attributeObserver.element;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(TokenListObserver.prototype, "attributeName", {
+    get: function () {
+      return this.attributeObserver.attributeName;
+    },
+    enumerable: true,
+    configurable: true
+  }); // Attribute observer delegate
+
+  TokenListObserver.prototype.elementMatchedAttribute = function (element) {
+    this.tokensMatched(this.readTokensForElement(element));
+  };
+
+  TokenListObserver.prototype.elementAttributeValueChanged = function (element) {
+    var _a = this.refreshTokensForElement(element),
+        unmatchedTokens = _a[0],
+        matchedTokens = _a[1];
+
+    this.tokensUnmatched(unmatchedTokens);
+    this.tokensMatched(matchedTokens);
+  };
+
+  TokenListObserver.prototype.elementUnmatchedAttribute = function (element) {
+    this.tokensUnmatched(this.tokensByElement.getValuesForKey(element));
+  };
+
+  TokenListObserver.prototype.tokensMatched = function (tokens) {
+    var _this = this;
+
+    tokens.forEach(function (token) {
+      return _this.tokenMatched(token);
+    });
+  };
+
+  TokenListObserver.prototype.tokensUnmatched = function (tokens) {
+    var _this = this;
+
+    tokens.forEach(function (token) {
+      return _this.tokenUnmatched(token);
+    });
+  };
+
+  TokenListObserver.prototype.tokenMatched = function (token) {
+    this.delegate.tokenMatched(token);
+    this.tokensByElement.add(token.element, token);
+  };
+
+  TokenListObserver.prototype.tokenUnmatched = function (token) {
+    this.delegate.tokenUnmatched(token);
+    this.tokensByElement.delete(token.element, token);
+  };
+
+  TokenListObserver.prototype.refreshTokensForElement = function (element) {
+    var previousTokens = this.tokensByElement.getValuesForKey(element);
+    var currentTokens = this.readTokensForElement(element);
+    var firstDifferingIndex = zip(previousTokens, currentTokens).findIndex(function (_a) {
+      var previousToken = _a[0],
+          currentToken = _a[1];
+      return !tokensAreEqual(previousToken, currentToken);
+    });
+
+    if (firstDifferingIndex == -1) {
+      return [[], []];
+    } else {
+      return [previousTokens.slice(firstDifferingIndex), currentTokens.slice(firstDifferingIndex)];
+    }
+  };
+
+  TokenListObserver.prototype.readTokensForElement = function (element) {
+    var attributeName = this.attributeName;
+    var tokenString = element.getAttribute(attributeName) || "";
+    return parseTokenString(tokenString, element, attributeName);
+  };
+
+  return TokenListObserver;
+}();
+
+exports.TokenListObserver = TokenListObserver;
+
+function parseTokenString(tokenString, element, attributeName) {
+  return tokenString.trim().split(/\s+/).filter(function (content) {
+    return content.length;
+  }).map(function (content, index) {
+    return {
+      element: element,
+      attributeName: attributeName,
+      content: content,
+      index: index
+    };
+  });
+}
+
+function zip(left, right) {
+  var length = Math.max(left.length, right.length);
+  return Array.from({
+    length: length
+  }, function (_, index) {
+    return [left[index], right[index]];
+  });
+}
+
+function tokensAreEqual(left, right) {
+  return left && right && left.index == right.index && left.content == right.content;
+}
+},{"./attribute_observer":"../node_modules/@stimulus/mutation-observers/dist/src/attribute_observer.js","@stimulus/multimap":"../node_modules/@stimulus/multimap/dist/index.js"}],"../node_modules/@stimulus/mutation-observers/dist/src/value_list_observer.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValueListObserver = void 0;
+
+var _token_list_observer = require("./token_list_observer");
+
+var ValueListObserver =
+/** @class */
+function () {
+  function ValueListObserver(element, attributeName, delegate) {
+    this.tokenListObserver = new _token_list_observer.TokenListObserver(element, attributeName, this);
+    this.delegate = delegate;
+    this.parseResultsByToken = new WeakMap();
+    this.valuesByTokenByElement = new WeakMap();
+  }
+
+  Object.defineProperty(ValueListObserver.prototype, "started", {
+    get: function () {
+      return this.tokenListObserver.started;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  ValueListObserver.prototype.start = function () {
+    this.tokenListObserver.start();
+  };
+
+  ValueListObserver.prototype.stop = function () {
+    this.tokenListObserver.stop();
+  };
+
+  ValueListObserver.prototype.refresh = function () {
+    this.tokenListObserver.refresh();
+  };
+
+  Object.defineProperty(ValueListObserver.prototype, "element", {
+    get: function () {
+      return this.tokenListObserver.element;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(ValueListObserver.prototype, "attributeName", {
+    get: function () {
+      return this.tokenListObserver.attributeName;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  ValueListObserver.prototype.tokenMatched = function (token) {
+    var element = token.element;
+    var value = this.fetchParseResultForToken(token).value;
+
+    if (value) {
+      this.fetchValuesByTokenForElement(element).set(token, value);
+      this.delegate.elementMatchedValue(element, value);
+    }
+  };
+
+  ValueListObserver.prototype.tokenUnmatched = function (token) {
+    var element = token.element;
+    var value = this.fetchParseResultForToken(token).value;
+
+    if (value) {
+      this.fetchValuesByTokenForElement(element).delete(token);
+      this.delegate.elementUnmatchedValue(element, value);
+    }
+  };
+
+  ValueListObserver.prototype.fetchParseResultForToken = function (token) {
+    var parseResult = this.parseResultsByToken.get(token);
+
+    if (!parseResult) {
+      parseResult = this.parseToken(token);
+      this.parseResultsByToken.set(token, parseResult);
+    }
+
+    return parseResult;
+  };
+
+  ValueListObserver.prototype.fetchValuesByTokenForElement = function (element) {
+    var valuesByToken = this.valuesByTokenByElement.get(element);
+
+    if (!valuesByToken) {
+      valuesByToken = new Map();
+      this.valuesByTokenByElement.set(element, valuesByToken);
+    }
+
+    return valuesByToken;
+  };
+
+  ValueListObserver.prototype.parseToken = function (token) {
+    try {
+      var value = this.delegate.parseValueForToken(token);
+      return {
+        value: value
+      };
+    } catch (error) {
+      return {
+        error: error
+      };
+    }
+  };
+
+  return ValueListObserver;
+}();
+
+exports.ValueListObserver = ValueListObserver;
+},{"./token_list_observer":"../node_modules/@stimulus/mutation-observers/dist/src/token_list_observer.js"}],"../node_modules/@stimulus/mutation-observers/dist/index.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _attribute_observer = require("./src/attribute_observer");
+
+Object.keys(_attribute_observer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _attribute_observer[key];
+    }
+  });
+});
+
+var _element_observer = require("./src/element_observer");
+
+Object.keys(_element_observer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _element_observer[key];
+    }
+  });
+});
+
+var _token_list_observer = require("./src/token_list_observer");
+
+Object.keys(_token_list_observer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _token_list_observer[key];
+    }
+  });
+});
+
+var _value_list_observer = require("./src/value_list_observer");
+
+Object.keys(_value_list_observer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _value_list_observer[key];
+    }
+  });
+});
+},{"./src/attribute_observer":"../node_modules/@stimulus/mutation-observers/dist/src/attribute_observer.js","./src/element_observer":"../node_modules/@stimulus/mutation-observers/dist/src/element_observer.js","./src/token_list_observer":"../node_modules/@stimulus/mutation-observers/dist/src/token_list_observer.js","./src/value_list_observer":"../node_modules/@stimulus/mutation-observers/dist/src/value_list_observer.js"}],"../node_modules/@stimulus/core/dist/src/binding_observer.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BindingObserver = void 0;
+
+var _action = require("./action");
+
+var _binding = require("./binding");
+
+var _mutationObservers = require("@stimulus/mutation-observers");
+
+var BindingObserver =
+/** @class */
+function () {
+  function BindingObserver(context, delegate) {
+    this.context = context;
+    this.delegate = delegate;
+    this.bindingsByAction = new Map();
+  }
+
+  BindingObserver.prototype.start = function () {
+    if (!this.valueListObserver) {
+      this.valueListObserver = new _mutationObservers.ValueListObserver(this.element, this.actionAttribute, this);
+      this.valueListObserver.start();
+    }
+  };
+
+  BindingObserver.prototype.stop = function () {
+    if (this.valueListObserver) {
+      this.valueListObserver.stop();
+      delete this.valueListObserver;
+      this.disconnectAllActions();
+    }
+  };
+
+  Object.defineProperty(BindingObserver.prototype, "element", {
+    get: function () {
+      return this.context.element;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(BindingObserver.prototype, "identifier", {
+    get: function () {
+      return this.context.identifier;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(BindingObserver.prototype, "actionAttribute", {
+    get: function () {
+      return this.schema.actionAttribute;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(BindingObserver.prototype, "schema", {
+    get: function () {
+      return this.context.schema;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(BindingObserver.prototype, "bindings", {
+    get: function () {
+      return Array.from(this.bindingsByAction.values());
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  BindingObserver.prototype.connectAction = function (action) {
+    var binding = new _binding.Binding(this.context, action);
+    this.bindingsByAction.set(action, binding);
+    this.delegate.bindingConnected(binding);
+  };
+
+  BindingObserver.prototype.disconnectAction = function (action) {
+    var binding = this.bindingsByAction.get(action);
+
+    if (binding) {
+      this.bindingsByAction.delete(action);
+      this.delegate.bindingDisconnected(binding);
+    }
+  };
+
+  BindingObserver.prototype.disconnectAllActions = function () {
+    var _this = this;
+
+    this.bindings.forEach(function (binding) {
+      return _this.delegate.bindingDisconnected(binding);
+    });
+    this.bindingsByAction.clear();
+  }; // Value observer delegate
+
+
+  BindingObserver.prototype.parseValueForToken = function (token) {
+    var action = _action.Action.forToken(token);
+
+    if (action.identifier == this.identifier) {
+      return action;
+    }
+  };
+
+  BindingObserver.prototype.elementMatchedValue = function (element, action) {
+    this.connectAction(action);
+  };
+
+  BindingObserver.prototype.elementUnmatchedValue = function (element, action) {
+    this.disconnectAction(action);
+  };
+
+  return BindingObserver;
+}();
+
+exports.BindingObserver = BindingObserver;
+},{"./action":"../node_modules/@stimulus/core/dist/src/action.js","./binding":"../node_modules/@stimulus/core/dist/src/binding.js","@stimulus/mutation-observers":"../node_modules/@stimulus/mutation-observers/dist/index.js"}],"../node_modules/@stimulus/core/dist/src/context.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Context = void 0;
+
+var _binding_observer = require("./binding_observer");
+
+var Context =
+/** @class */
+function () {
+  function Context(module, scope) {
+    this.module = module;
+    this.scope = scope;
+    this.controller = new module.controllerConstructor(this);
+    this.bindingObserver = new _binding_observer.BindingObserver(this, this.dispatcher);
+
+    try {
+      this.controller.initialize();
+    } catch (error) {
+      this.handleError(error, "initializing controller");
+    }
+  }
+
+  Context.prototype.connect = function () {
+    this.bindingObserver.start();
+
+    try {
+      this.controller.connect();
+    } catch (error) {
+      this.handleError(error, "connecting controller");
+    }
+  };
+
+  Context.prototype.disconnect = function () {
+    try {
+      this.controller.disconnect();
+    } catch (error) {
+      this.handleError(error, "disconnecting controller");
+    }
+
+    this.bindingObserver.stop();
+  };
+
+  Object.defineProperty(Context.prototype, "application", {
+    get: function () {
+      return this.module.application;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Context.prototype, "identifier", {
+    get: function () {
+      return this.module.identifier;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Context.prototype, "schema", {
+    get: function () {
+      return this.application.schema;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Context.prototype, "dispatcher", {
+    get: function () {
+      return this.application.dispatcher;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Context.prototype, "element", {
+    get: function () {
+      return this.scope.element;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Context.prototype, "parentElement", {
+    get: function () {
+      return this.element.parentElement;
+    },
+    enumerable: true,
+    configurable: true
+  }); // Error handling
+
+  Context.prototype.handleError = function (error, message, detail) {
+    if (detail === void 0) {
+      detail = {};
+    }
+
+    var _a = this,
+        identifier = _a.identifier,
+        controller = _a.controller,
+        element = _a.element;
+
+    detail = Object.assign({
+      identifier: identifier,
+      controller: controller,
+      element: element
+    }, detail);
+    this.application.handleError(error, "Error " + message, detail);
+  };
+
+  return Context;
+}();
+
+exports.Context = Context;
+},{"./binding_observer":"../node_modules/@stimulus/core/dist/src/binding_observer.js"}],"../node_modules/@stimulus/core/dist/src/definition.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.blessDefinition = blessDefinition;
+
+var __extends = void 0 && (void 0).__extends || function () {
+  var extendStatics = Object.setPrototypeOf || {
+    __proto__: []
+  } instanceof Array && function (d, b) {
+    d.__proto__ = b;
+  } || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+  };
+
+  return function (d, b) {
+    extendStatics(d, b);
+
+    function __() {
+      this.constructor = d;
+    }
+
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+/** @hidden */
+
+
+function blessDefinition(definition) {
+  return {
+    identifier: definition.identifier,
+    controllerConstructor: blessControllerConstructor(definition.controllerConstructor)
+  };
+}
+
+function blessControllerConstructor(controllerConstructor) {
+  var constructor = extend(controllerConstructor);
+  constructor.bless();
+  return constructor;
+}
+
+var extend = function () {
+  function extendWithReflect(constructor) {
+    function Controller() {
+      var _newTarget = this && this instanceof Controller ? this.constructor : void 0;
+
+      return Reflect.construct(constructor, arguments, _newTarget);
+    }
+
+    Controller.prototype = Object.create(constructor.prototype, {
+      constructor: {
+        value: Controller
+      }
+    });
+    Reflect.setPrototypeOf(Controller, constructor);
+    return Controller;
+  }
+
+  function testReflectExtension() {
+    var a = function () {
+      this.a.call(this);
+    };
+
+    var b = extendWithReflect(a);
+
+    b.prototype.a = function () {};
+
+    return new b();
+  }
+
+  try {
+    testReflectExtension();
+    return extendWithReflect;
+  } catch (error) {
+    return function (constructor) {
+      return (
+        /** @class */
+        function (_super) {
+          __extends(Controller, _super);
+
+          function Controller() {
+            return _super !== null && _super.apply(this, arguments) || this;
+          }
+
+          return Controller;
+        }(constructor)
+      );
+    };
+  }
+}();
+},{}],"../node_modules/@stimulus/core/dist/src/module.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Module = void 0;
+
+var _context = require("./context");
+
+var _definition = require("./definition");
+
+var Module =
+/** @class */
+function () {
+  function Module(application, definition) {
+    this.application = application;
+    this.definition = (0, _definition.blessDefinition)(definition);
+    this.contextsByScope = new WeakMap();
+    this.connectedContexts = new Set();
+  }
+
+  Object.defineProperty(Module.prototype, "identifier", {
+    get: function () {
+      return this.definition.identifier;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Module.prototype, "controllerConstructor", {
+    get: function () {
+      return this.definition.controllerConstructor;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Module.prototype, "contexts", {
+    get: function () {
+      return Array.from(this.connectedContexts);
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  Module.prototype.connectContextForScope = function (scope) {
+    var context = this.fetchContextForScope(scope);
+    this.connectedContexts.add(context);
+    context.connect();
+  };
+
+  Module.prototype.disconnectContextForScope = function (scope) {
+    var context = this.contextsByScope.get(scope);
+
+    if (context) {
+      this.connectedContexts.delete(context);
+      context.disconnect();
+    }
+  };
+
+  Module.prototype.fetchContextForScope = function (scope) {
+    var context = this.contextsByScope.get(scope);
+
+    if (!context) {
+      context = new _context.Context(this, scope);
+      this.contextsByScope.set(scope, context);
+    }
+
+    return context;
+  };
+
+  return Module;
+}();
+
+exports.Module = Module;
+},{"./context":"../node_modules/@stimulus/core/dist/src/context.js","./definition":"../node_modules/@stimulus/core/dist/src/definition.js"}],"../node_modules/@stimulus/core/dist/src/data_map.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DataMap = void 0;
+
+var DataMap =
+/** @class */
+function () {
+  function DataMap(scope) {
+    this.scope = scope;
+  }
+
+  Object.defineProperty(DataMap.prototype, "element", {
+    get: function () {
+      return this.scope.element;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(DataMap.prototype, "identifier", {
+    get: function () {
+      return this.scope.identifier;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  DataMap.prototype.get = function (key) {
+    key = this.getFormattedKey(key);
+    return this.element.getAttribute(key);
+  };
+
+  DataMap.prototype.set = function (key, value) {
+    key = this.getFormattedKey(key);
+    this.element.setAttribute(key, value);
+    return this.get(key);
+  };
+
+  DataMap.prototype.has = function (key) {
+    key = this.getFormattedKey(key);
+    return this.element.hasAttribute(key);
+  };
+
+  DataMap.prototype.delete = function (key) {
+    if (this.has(key)) {
+      key = this.getFormattedKey(key);
+      this.element.removeAttribute(key);
+      return true;
+    } else {
+      return false;
+    }
+  };
+
+  DataMap.prototype.getFormattedKey = function (key) {
+    return "data-" + this.identifier + "-" + dasherize(key);
+  };
+
+  return DataMap;
+}();
+
+exports.DataMap = DataMap;
+
+function dasherize(value) {
+  return value.replace(/([A-Z])/g, function (_, char) {
+    return "-" + char.toLowerCase();
+  });
+}
+},{}],"../node_modules/@stimulus/core/dist/src/selectors.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attributeValueContainsToken = attributeValueContainsToken;
+
+/** @hidden */
+function attributeValueContainsToken(attributeName, token) {
+  return "[" + attributeName + "~=\"" + token + "\"]";
+}
+},{}],"../node_modules/@stimulus/core/dist/src/target_set.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TargetSet = void 0;
+
+var _selectors = require("./selectors");
+
+var TargetSet =
+/** @class */
+function () {
+  function TargetSet(scope) {
+    this.scope = scope;
+  }
+
+  Object.defineProperty(TargetSet.prototype, "element", {
+    get: function () {
+      return this.scope.element;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(TargetSet.prototype, "identifier", {
+    get: function () {
+      return this.scope.identifier;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(TargetSet.prototype, "schema", {
+    get: function () {
+      return this.scope.schema;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  TargetSet.prototype.has = function (targetName) {
+    return this.find(targetName) != null;
+  };
+
+  TargetSet.prototype.find = function () {
+    var targetNames = [];
+
+    for (var _i = 0; _i < arguments.length; _i++) {
+      targetNames[_i] = arguments[_i];
+    }
+
+    var selector = this.getSelectorForTargetNames(targetNames);
+    return this.scope.findElement(selector);
+  };
+
+  TargetSet.prototype.findAll = function () {
+    var targetNames = [];
+
+    for (var _i = 0; _i < arguments.length; _i++) {
+      targetNames[_i] = arguments[_i];
+    }
+
+    var selector = this.getSelectorForTargetNames(targetNames);
+    return this.scope.findAllElements(selector);
+  };
+
+  TargetSet.prototype.getSelectorForTargetNames = function (targetNames) {
+    var _this = this;
+
+    return targetNames.map(function (targetName) {
+      return _this.getSelectorForTargetName(targetName);
+    }).join(", ");
+  };
+
+  TargetSet.prototype.getSelectorForTargetName = function (targetName) {
+    var targetDescriptor = this.identifier + "." + targetName;
+    return (0, _selectors.attributeValueContainsToken)(this.schema.targetAttribute, targetDescriptor);
+  };
+
+  return TargetSet;
+}();
+
+exports.TargetSet = TargetSet;
+},{"./selectors":"../node_modules/@stimulus/core/dist/src/selectors.js"}],"../node_modules/@stimulus/core/dist/src/scope.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Scope = void 0;
+
+var _data_map = require("./data_map");
+
+var _target_set = require("./target_set");
+
+var _selectors = require("./selectors");
+
+var Scope =
+/** @class */
+function () {
+  function Scope(schema, identifier, element) {
+    this.schema = schema;
+    this.identifier = identifier;
+    this.element = element;
+    this.targets = new _target_set.TargetSet(this);
+    this.data = new _data_map.DataMap(this);
+  }
+
+  Scope.prototype.findElement = function (selector) {
+    return this.findAllElements(selector)[0];
+  };
+
+  Scope.prototype.findAllElements = function (selector) {
+    var head = this.element.matches(selector) ? [this.element] : [];
+    var tail = this.filterElements(Array.from(this.element.querySelectorAll(selector)));
+    return head.concat(tail);
+  };
+
+  Scope.prototype.filterElements = function (elements) {
+    var _this = this;
+
+    return elements.filter(function (element) {
+      return _this.containsElement(element);
+    });
+  };
+
+  Scope.prototype.containsElement = function (element) {
+    return element.closest(this.controllerSelector) === this.element;
+  };
+
+  Object.defineProperty(Scope.prototype, "controllerSelector", {
+    get: function () {
+      return (0, _selectors.attributeValueContainsToken)(this.schema.controllerAttribute, this.identifier);
+    },
+    enumerable: true,
+    configurable: true
+  });
+  return Scope;
+}();
+
+exports.Scope = Scope;
+},{"./data_map":"../node_modules/@stimulus/core/dist/src/data_map.js","./target_set":"../node_modules/@stimulus/core/dist/src/target_set.js","./selectors":"../node_modules/@stimulus/core/dist/src/selectors.js"}],"../node_modules/@stimulus/core/dist/src/scope_observer.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScopeObserver = void 0;
+
+var _scope = require("./scope");
+
+var _mutationObservers = require("@stimulus/mutation-observers");
+
+var ScopeObserver =
+/** @class */
+function () {
+  function ScopeObserver(element, schema, delegate) {
+    this.element = element;
+    this.schema = schema;
+    this.delegate = delegate;
+    this.valueListObserver = new _mutationObservers.ValueListObserver(this.element, this.controllerAttribute, this);
+    this.scopesByIdentifierByElement = new WeakMap();
+    this.scopeReferenceCounts = new WeakMap();
+  }
+
+  ScopeObserver.prototype.start = function () {
+    this.valueListObserver.start();
+  };
+
+  ScopeObserver.prototype.stop = function () {
+    this.valueListObserver.stop();
+  };
+
+  Object.defineProperty(ScopeObserver.prototype, "controllerAttribute", {
+    get: function () {
+      return this.schema.controllerAttribute;
+    },
+    enumerable: true,
+    configurable: true
+  }); // Value observer delegate
+
+  /** @hidden */
+
+  ScopeObserver.prototype.parseValueForToken = function (token) {
+    var element = token.element,
+        identifier = token.content;
+    var scopesByIdentifier = this.fetchScopesByIdentifierForElement(element);
+    var scope = scopesByIdentifier.get(identifier);
+
+    if (!scope) {
+      scope = new _scope.Scope(this.schema, identifier, element);
+      scopesByIdentifier.set(identifier, scope);
+    }
+
+    return scope;
+  };
+  /** @hidden */
+
+
+  ScopeObserver.prototype.elementMatchedValue = function (element, value) {
+    var referenceCount = (this.scopeReferenceCounts.get(value) || 0) + 1;
+    this.scopeReferenceCounts.set(value, referenceCount);
+
+    if (referenceCount == 1) {
+      this.delegate.scopeConnected(value);
+    }
+  };
+  /** @hidden */
+
+
+  ScopeObserver.prototype.elementUnmatchedValue = function (element, value) {
+    var referenceCount = this.scopeReferenceCounts.get(value);
+
+    if (referenceCount) {
+      this.scopeReferenceCounts.set(value, referenceCount - 1);
+
+      if (referenceCount == 1) {
+        this.delegate.scopeDisconnected(value);
+      }
+    }
+  };
+
+  ScopeObserver.prototype.fetchScopesByIdentifierForElement = function (element) {
+    var scopesByIdentifier = this.scopesByIdentifierByElement.get(element);
+
+    if (!scopesByIdentifier) {
+      scopesByIdentifier = new Map();
+      this.scopesByIdentifierByElement.set(element, scopesByIdentifier);
+    }
+
+    return scopesByIdentifier;
+  };
+
+  return ScopeObserver;
+}();
+
+exports.ScopeObserver = ScopeObserver;
+},{"./scope":"../node_modules/@stimulus/core/dist/src/scope.js","@stimulus/mutation-observers":"../node_modules/@stimulus/mutation-observers/dist/index.js"}],"../node_modules/@stimulus/core/dist/src/router.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Router = void 0;
+
+var _module = require("./module");
+
+var _multimap = require("@stimulus/multimap");
+
+var _scope_observer = require("./scope_observer");
+
+var Router =
+/** @class */
+function () {
+  function Router(application) {
+    this.application = application;
+    this.scopeObserver = new _scope_observer.ScopeObserver(this.element, this.schema, this);
+    this.scopesByIdentifier = new _multimap.Multimap();
+    this.modulesByIdentifier = new Map();
+  }
+
+  Object.defineProperty(Router.prototype, "element", {
+    get: function () {
+      return this.application.element;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Router.prototype, "schema", {
+    get: function () {
+      return this.application.schema;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Router.prototype, "controllerAttribute", {
+    get: function () {
+      return this.schema.controllerAttribute;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Router.prototype, "modules", {
+    get: function () {
+      return Array.from(this.modulesByIdentifier.values());
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Router.prototype, "contexts", {
+    get: function () {
+      return this.modules.reduce(function (contexts, module) {
+        return contexts.concat(module.contexts);
+      }, []);
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  Router.prototype.start = function () {
+    this.scopeObserver.start();
+  };
+
+  Router.prototype.stop = function () {
+    this.scopeObserver.stop();
+  };
+
+  Router.prototype.loadDefinition = function (definition) {
+    this.unloadIdentifier(definition.identifier);
+    var module = new _module.Module(this.application, definition);
+    this.connectModule(module);
+  };
+
+  Router.prototype.unloadIdentifier = function (identifier) {
+    var module = this.modulesByIdentifier.get(identifier);
+
+    if (module) {
+      this.disconnectModule(module);
+    }
+  };
+
+  Router.prototype.getContextForElementAndIdentifier = function (element, identifier) {
+    var module = this.modulesByIdentifier.get(identifier);
+
+    if (module) {
+      return module.contexts.find(function (context) {
+        return context.element == element;
+      });
+    }
+  }; // Error handler delegate
+
+  /** @hidden */
+
+
+  Router.prototype.handleError = function (error, message, detail) {
+    this.application.handleError(error, message, detail);
+  }; // Scope observer delegate
+
+  /** @hidden */
+
+
+  Router.prototype.scopeConnected = function (scope) {
+    this.scopesByIdentifier.add(scope.identifier, scope);
+    var module = this.modulesByIdentifier.get(scope.identifier);
+
+    if (module) {
+      module.connectContextForScope(scope);
+    }
+  };
+  /** @hidden */
+
+
+  Router.prototype.scopeDisconnected = function (scope) {
+    this.scopesByIdentifier.delete(scope.identifier, scope);
+    var module = this.modulesByIdentifier.get(scope.identifier);
+
+    if (module) {
+      module.disconnectContextForScope(scope);
+    }
+  }; // Modules
+
+
+  Router.prototype.connectModule = function (module) {
+    this.modulesByIdentifier.set(module.identifier, module);
+    var scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);
+    scopes.forEach(function (scope) {
+      return module.connectContextForScope(scope);
+    });
+  };
+
+  Router.prototype.disconnectModule = function (module) {
+    this.modulesByIdentifier.delete(module.identifier);
+    var scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);
+    scopes.forEach(function (scope) {
+      return module.disconnectContextForScope(scope);
+    });
+  };
+
+  return Router;
+}();
+
+exports.Router = Router;
+},{"./module":"../node_modules/@stimulus/core/dist/src/module.js","@stimulus/multimap":"../node_modules/@stimulus/multimap/dist/index.js","./scope_observer":"../node_modules/@stimulus/core/dist/src/scope_observer.js"}],"../node_modules/@stimulus/core/dist/src/schema.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultSchema = void 0;
+var defaultSchema = {
+  controllerAttribute: "data-controller",
+  actionAttribute: "data-action",
+  targetAttribute: "data-target"
+};
+exports.defaultSchema = defaultSchema;
+},{}],"../node_modules/@stimulus/core/dist/src/application.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Application = void 0;
+
+var _dispatcher = require("./dispatcher");
+
+var _router = require("./router");
+
+var _schema = require("./schema");
+
+var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : new P(function (resolve) {
+        resolve(result.value);
+      }).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+var __generator = void 0 && (void 0).__generator || function (thisArg, body) {
+  var _ = {
+    label: 0,
+    sent: function () {
+      if (t[0] & 1) throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  },
+      f,
+      y,
+      t,
+      g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+
+    while (_) try {
+      if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [0, t.value];
+
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+
+        case 7:
+          op = _.ops.pop();
+
+          _.trys.pop();
+
+          continue;
+
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+
+            _.ops.push(op);
+
+            break;
+          }
+
+          if (t[2]) _.ops.pop();
+
+          _.trys.pop();
+
+          continue;
+      }
+
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+
+var Application =
+/** @class */
+function () {
+  function Application(element, schema) {
+    if (element === void 0) {
+      element = document.documentElement;
+    }
+
+    if (schema === void 0) {
+      schema = _schema.defaultSchema;
+    }
+
+    this.element = element;
+    this.schema = schema;
+    this.dispatcher = new _dispatcher.Dispatcher(this);
+    this.router = new _router.Router(this);
+  }
+
+  Application.start = function (element, schema) {
+    var application = new Application(element, schema);
+    application.start();
+    return application;
+  };
+
+  Application.prototype.start = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4
+            /*yield*/
+            , domReady()];
+
+          case 1:
+            _a.sent();
+
+            this.router.start();
+            this.dispatcher.start();
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
+
+  Application.prototype.stop = function () {
+    this.router.stop();
+    this.dispatcher.stop();
+  };
+
+  Application.prototype.register = function (identifier, controllerConstructor) {
+    this.load({
+      identifier: identifier,
+      controllerConstructor: controllerConstructor
+    });
+  };
+
+  Application.prototype.load = function (head) {
+    var _this = this;
+
+    var rest = [];
+
+    for (var _i = 1; _i < arguments.length; _i++) {
+      rest[_i - 1] = arguments[_i];
+    }
+
+    var definitions = Array.isArray(head) ? head : [head].concat(rest);
+    definitions.forEach(function (definition) {
+      return _this.router.loadDefinition(definition);
+    });
+  };
+
+  Application.prototype.unload = function (head) {
+    var _this = this;
+
+    var rest = [];
+
+    for (var _i = 1; _i < arguments.length; _i++) {
+      rest[_i - 1] = arguments[_i];
+    }
+
+    var identifiers = Array.isArray(head) ? head : [head].concat(rest);
+    identifiers.forEach(function (identifier) {
+      return _this.router.unloadIdentifier(identifier);
+    });
+  };
+
+  Object.defineProperty(Application.prototype, "controllers", {
+    // Controllers
+    get: function () {
+      return this.router.contexts.map(function (context) {
+        return context.controller;
+      });
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  Application.prototype.getControllerForElementAndIdentifier = function (element, identifier) {
+    var context = this.router.getContextForElementAndIdentifier(element, identifier);
+    return context ? context.controller : null;
+  }; // Error handling
+
+
+  Application.prototype.handleError = function (error, message, detail) {
+    console.error("%s\n\n%o\n\n%o", message, error, detail);
+  };
+
+  return Application;
+}();
+
+exports.Application = Application;
+
+function domReady() {
+  return new Promise(function (resolve) {
+    if (document.readyState == "loading") {
+      document.addEventListener("DOMContentLoaded", resolve);
+    } else {
+      resolve();
+    }
+  });
+}
+},{"./dispatcher":"../node_modules/@stimulus/core/dist/src/dispatcher.js","./router":"../node_modules/@stimulus/core/dist/src/router.js","./schema":"../node_modules/@stimulus/core/dist/src/schema.js"}],"../node_modules/@stimulus/core/dist/src/target_properties.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defineTargetProperties = defineTargetProperties;
+
+/** @hidden */
+function defineTargetProperties(constructor) {
+  var prototype = constructor.prototype;
+  var targetNames = getTargetNamesForConstructor(constructor);
+  targetNames.forEach(function (name) {
+    var _a;
+
+    return defineLinkedProperties(prototype, (_a = {}, _a[name + "Target"] = {
+      get: function () {
+        var target = this.targets.find(name);
+
+        if (target) {
+          return target;
+        } else {
+          throw new Error("Missing target element \"" + this.identifier + "." + name + "\"");
+        }
+      }
+    }, _a[name + "Targets"] = {
+      get: function () {
+        return this.targets.findAll(name);
+      }
+    }, _a["has" + capitalize(name) + "Target"] = {
+      get: function () {
+        return this.targets.has(name);
+      }
+    }, _a));
+  });
+}
+
+function getTargetNamesForConstructor(constructor) {
+  var ancestors = getAncestorsForConstructor(constructor);
+  return Array.from(ancestors.reduce(function (targetNames, constructor) {
+    getOwnTargetNamesForConstructor(constructor).forEach(function (name) {
+      return targetNames.add(name);
+    });
+    return targetNames;
+  }, new Set()));
+}
+
+function getAncestorsForConstructor(constructor) {
+  var ancestors = [];
+
+  while (constructor) {
+    ancestors.push(constructor);
+    constructor = Object.getPrototypeOf(constructor);
+  }
+
+  return ancestors;
+}
+
+function getOwnTargetNamesForConstructor(constructor) {
+  var definition = constructor["targets"];
+  return Array.isArray(definition) ? definition : [];
+}
+
+function defineLinkedProperties(object, properties) {
+  Object.keys(properties).forEach(function (name) {
+    if (!(name in object)) {
+      var descriptor = properties[name];
+      Object.defineProperty(object, name, descriptor);
+    }
+  });
+}
+
+function capitalize(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+},{}],"../node_modules/@stimulus/core/dist/src/controller.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Controller = void 0;
+
+var _target_properties = require("./target_properties");
+
+var Controller =
+/** @class */
+function () {
+  function Controller(context) {
+    this.context = context;
+  }
+
+  Controller.bless = function () {
+    (0, _target_properties.defineTargetProperties)(this);
+  };
+
+  Object.defineProperty(Controller.prototype, "application", {
+    get: function () {
+      return this.context.application;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Controller.prototype, "scope", {
+    get: function () {
+      return this.context.scope;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Controller.prototype, "element", {
+    get: function () {
+      return this.scope.element;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Controller.prototype, "identifier", {
+    get: function () {
+      return this.scope.identifier;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Controller.prototype, "targets", {
+    get: function () {
+      return this.scope.targets;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Controller.prototype, "data", {
+    get: function () {
+      return this.scope.data;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  Controller.prototype.initialize = function () {// Override in your subclass to set up initial controller state
+  };
+
+  Controller.prototype.connect = function () {// Override in your subclass to respond when the controller is connected to the DOM
+  };
+
+  Controller.prototype.disconnect = function () {// Override in your subclass to respond when the controller is disconnected from the DOM
+  };
+
+  Controller.targets = [];
+  return Controller;
+}();
+
+exports.Controller = Controller;
+},{"./target_properties":"../node_modules/@stimulus/core/dist/src/target_properties.js"}],"../node_modules/@stimulus/core/dist/index.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Application", {
+  enumerable: true,
+  get: function () {
+    return _application.Application;
+  }
+});
+Object.defineProperty(exports, "Context", {
+  enumerable: true,
+  get: function () {
+    return _context.Context;
+  }
+});
+Object.defineProperty(exports, "Controller", {
+  enumerable: true,
+  get: function () {
+    return _controller.Controller;
+  }
+});
+Object.defineProperty(exports, "defaultSchema", {
+  enumerable: true,
+  get: function () {
+    return _schema.defaultSchema;
+  }
+});
+
+var _application = require("./src/application");
+
+var _context = require("./src/context");
+
+var _controller = require("./src/controller");
+
+var _schema = require("./src/schema");
+},{"./src/application":"../node_modules/@stimulus/core/dist/src/application.js","./src/context":"../node_modules/@stimulus/core/dist/src/context.js","./src/controller":"../node_modules/@stimulus/core/dist/src/controller.js","./src/schema":"../node_modules/@stimulus/core/dist/src/schema.js"}],"../node_modules/stimulus/index.js":[function(require,module,exports) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _core = require("@stimulus/core");
+
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _core[key];
+    }
+  });
+});
+},{"@stimulus/core":"../node_modules/@stimulus/core/dist/index.js"}],"javascripts/super/apply_template_controller.ts":[function(require,module,exports) {
+"use strict";
+
+var __extends = this && this.__extends || function () {
+  var _extendStatics = function extendStatics(d, b) {
+    _extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) {
+        if (b.hasOwnProperty(p)) d[p] = b[p];
+      }
+    };
+
+    return _extendStatics(d, b);
+  };
+
+  return function (d, b) {
+    _extendStatics(d, b);
+
+    function __() {
+      this.constructor = d;
+    }
+
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var stimulus_1 = require("stimulus");
+
+var default_1 =
+/** @class */
+function (_super) {
+  __extends(default_1, _super);
+
+  function default_1() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+
+  default_1.prototype.call = function (event) {
+    event.preventDefault();
+
+    if (this.templateTarget) {
+      var unixtime = new Date().getTime();
+      var content = this.templateTarget.innerHTML.replace(/TEMPLATEINDEX/g, unixtime.toString());
+      this.templateTarget.insertAdjacentHTML("beforebegin", content);
+    }
+  };
+
+  default_1.targets = ["template"];
+  return default_1;
+}(stimulus_1.Controller);
+
+exports.default = default_1;
+},{"stimulus":"../node_modules/stimulus/index.js"}],"javascripts/super/toggle_pending_destruction_controller.ts":[function(require,module,exports) {
+"use strict";
+
+var __extends = this && this.__extends || function () {
+  var _extendStatics = function extendStatics(d, b) {
+    _extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) {
+        if (b.hasOwnProperty(p)) d[p] = b[p];
+      }
+    };
+
+    return _extendStatics(d, b);
+  };
+
+  return function (d, b) {
+    _extendStatics(d, b);
+
+    function __() {
+      this.constructor = d;
+    }
+
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var stimulus_1 = require("stimulus");
+
+var default_1 =
+/** @class */
+function (_super) {
+  __extends(default_1, _super);
+
+  function default_1() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+
+  default_1.prototype.call = function (event) {
+    var target = event.target;
+
+    if (target) {
+      if (target.checked) {
+        this.element.classList.add("opacity-75", "bg-gray-100");
+      } else {
+        this.element.classList.remove("opacity-75", "bg-gray-100");
+      }
+    }
+  };
+
+  return default_1;
+}(stimulus_1.Controller);
+
+exports.default = default_1;
+},{"stimulus":"../node_modules/stimulus/index.js"}],"javascripts/super/application.ts":[function(require,module,exports) {
+"use strict";
+
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var ujs_1 = __importDefault(require("@rails/ujs"));
+
+var stimulus_1 = require("stimulus");
+
+var apply_template_controller_1 = __importDefault(require("./apply_template_controller"));
+
+var toggle_pending_destruction_controller_1 = __importDefault(require("./toggle_pending_destruction_controller"));
+
+ujs_1.default.start();
+var application = stimulus_1.Application.start();
+application.register("apply-template", apply_template_controller_1.default);
+application.register("toggle-pending-destruction", toggle_pending_destruction_controller_1.default);
+exports.default = {
+  StimulusApplication: application,
+  StimulusController: stimulus_1.Controller
+};
+},{"@rails/ujs":"../node_modules/@rails/ujs/lib/assets/compiled/rails-ujs.js","stimulus":"../node_modules/stimulus/index.js","./apply_template_controller":"javascripts/super/apply_template_controller.ts","./toggle_pending_destruction_controller":"javascripts/super/toggle_pending_destruction_controller.ts"}]},{},["javascripts/super/application.ts"], "Super")