super 0.0.15 → 0.19.0.rc1

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

@@ -1,6 +1,905 @@
 var Super = (function (exports) {
   'use strict';
 
+  (function () {
+
+    var n = window.Document.prototype.createElement,
+        p = window.Document.prototype.createElementNS,
+        aa = window.Document.prototype.importNode,
+        ba = window.Document.prototype.prepend,
+        ca = window.Document.prototype.append,
+        da = window.DocumentFragment.prototype.prepend,
+        ea = window.DocumentFragment.prototype.append,
+        q = window.Node.prototype.cloneNode,
+        r = window.Node.prototype.appendChild,
+        t = window.Node.prototype.insertBefore,
+        u = window.Node.prototype.removeChild,
+        v = window.Node.prototype.replaceChild,
+        w = Object.getOwnPropertyDescriptor(window.Node.prototype, "textContent"),
+        y = window.Element.prototype.attachShadow,
+        z = Object.getOwnPropertyDescriptor(window.Element.prototype, "innerHTML"),
+        A = window.Element.prototype.getAttribute,
+        B = window.Element.prototype.setAttribute,
+        C = window.Element.prototype.removeAttribute,
+        D = window.Element.prototype.getAttributeNS,
+        E = window.Element.prototype.setAttributeNS,
+        F = window.Element.prototype.removeAttributeNS,
+        G = window.Element.prototype.insertAdjacentElement,
+        H = window.Element.prototype.insertAdjacentHTML,
+        fa = window.Element.prototype.prepend,
+        ha = window.Element.prototype.append,
+        ia = window.Element.prototype.before,
+        ja = window.Element.prototype.after,
+        ka = window.Element.prototype.replaceWith,
+        la = window.Element.prototype.remove,
+        ma = window.HTMLElement,
+        I = Object.getOwnPropertyDescriptor(window.HTMLElement.prototype, "innerHTML"),
+        na = window.HTMLElement.prototype.insertAdjacentElement,
+        oa = window.HTMLElement.prototype.insertAdjacentHTML;
+    var pa = new Set();
+    "annotation-xml color-profile font-face font-face-src font-face-uri font-face-format font-face-name missing-glyph".split(" ").forEach(function (a) {
+      return pa.add(a);
+    });
+
+    function qa(a) {
+      var b = pa.has(a);
+      a = /^[a-z][.0-9_a-z]*-[-.0-9_a-z]*$/.test(a);
+      return !b && a;
+    }
+
+    var ra = document.contains ? document.contains.bind(document) : document.documentElement.contains.bind(document.documentElement);
+
+    function J(a) {
+      var b = a.isConnected;
+      if (void 0 !== b) return b;
+      if (ra(a)) return !0;
+
+      for (; a && !(a.__CE_isImportDocument || a instanceof Document);) a = a.parentNode || (window.ShadowRoot && a instanceof ShadowRoot ? a.host : void 0);
+
+      return !(!a || !(a.__CE_isImportDocument || a instanceof Document));
+    }
+
+    function K(a) {
+      var b = a.children;
+      if (b) return Array.prototype.slice.call(b);
+      b = [];
+
+      for (a = a.firstChild; a; a = a.nextSibling) a.nodeType === Node.ELEMENT_NODE && b.push(a);
+
+      return b;
+    }
+
+    function L(a, b) {
+      for (; b && b !== a && !b.nextSibling;) b = b.parentNode;
+
+      return b && b !== a ? b.nextSibling : null;
+    }
+
+    function M(a, b, c) {
+      for (var f = a; f;) {
+        if (f.nodeType === Node.ELEMENT_NODE) {
+          var d = f;
+          b(d);
+          var e = d.localName;
+
+          if ("link" === e && "import" === d.getAttribute("rel")) {
+            f = d.import;
+            void 0 === c && (c = new Set());
+            if (f instanceof Node && !c.has(f)) for (c.add(f), f = f.firstChild; f; f = f.nextSibling) M(f, b, c);
+            f = L(a, d);
+            continue;
+          } else if ("template" === e) {
+            f = L(a, d);
+            continue;
+          }
+
+          if (d = d.__CE_shadowRoot) for (d = d.firstChild; d; d = d.nextSibling) M(d, b, c);
+        }
+
+        f = f.firstChild ? f.firstChild : L(a, f);
+      }
+    }
+
+    function N() {
+      var a = !(null === O || void 0 === O || !O.noDocumentConstructionObserver),
+          b = !(null === O || void 0 === O || !O.shadyDomFastWalk);
+      this.m = [];
+      this.g = [];
+      this.j = !1;
+      this.shadyDomFastWalk = b;
+      this.I = !a;
+    }
+
+    function P(a, b, c, f) {
+      var d = window.ShadyDOM;
+
+      if (a.shadyDomFastWalk && d && d.inUse) {
+        if (b.nodeType === Node.ELEMENT_NODE && c(b), b.querySelectorAll) for (a = d.nativeMethods.querySelectorAll.call(b, "*"), b = 0; b < a.length; b++) c(a[b]);
+      } else M(b, c, f);
+    }
+
+    function sa(a, b) {
+      a.j = !0;
+      a.m.push(b);
+    }
+
+    function ta(a, b) {
+      a.j = !0;
+      a.g.push(b);
+    }
+
+    function Q(a, b) {
+      a.j && P(a, b, function (c) {
+        return R(a, c);
+      });
+    }
+
+    function R(a, b) {
+      if (a.j && !b.__CE_patched) {
+        b.__CE_patched = !0;
+
+        for (var c = 0; c < a.m.length; c++) a.m[c](b);
+
+        for (c = 0; c < a.g.length; c++) a.g[c](b);
+      }
+    }
+
+    function S(a, b) {
+      var c = [];
+      P(a, b, function (d) {
+        return c.push(d);
+      });
+
+      for (b = 0; b < c.length; b++) {
+        var f = c[b];
+        1 === f.__CE_state ? a.connectedCallback(f) : T(a, f);
+      }
+    }
+
+    function U(a, b) {
+      var c = [];
+      P(a, b, function (d) {
+        return c.push(d);
+      });
+
+      for (b = 0; b < c.length; b++) {
+        var f = c[b];
+        1 === f.__CE_state && a.disconnectedCallback(f);
+      }
+    }
+
+    function V(a, b, c) {
+      c = void 0 === c ? {} : c;
+
+      var f = c.J,
+          d = c.upgrade || function (g) {
+        return T(a, g);
+      },
+          e = [];
+
+      P(a, b, function (g) {
+        a.j && R(a, g);
+
+        if ("link" === g.localName && "import" === g.getAttribute("rel")) {
+          var h = g.import;
+          h instanceof Node && (h.__CE_isImportDocument = !0, h.__CE_registry = document.__CE_registry);
+          h && "complete" === h.readyState ? h.__CE_documentLoadHandled = !0 : g.addEventListener("load", function () {
+            var k = g.import;
+
+            if (!k.__CE_documentLoadHandled) {
+              k.__CE_documentLoadHandled = !0;
+              var l = new Set();
+              f && (f.forEach(function (m) {
+                return l.add(m);
+              }), l.delete(k));
+              V(a, k, {
+                J: l,
+                upgrade: d
+              });
+            }
+          });
+        } else e.push(g);
+      }, f);
+
+      for (b = 0; b < e.length; b++) d(e[b]);
+    }
+
+    function T(a, b) {
+      try {
+        var c = b.ownerDocument,
+            f = c.__CE_registry;
+        var d = f && (c.defaultView || c.__CE_isImportDocument) ? W(f, b.localName) : void 0;
+
+        if (d && void 0 === b.__CE_state) {
+          d.constructionStack.push(b);
+
+          try {
+            try {
+              if (new d.constructorFunction() !== b) throw Error("The custom element constructor did not produce the element being upgraded.");
+            } finally {
+              d.constructionStack.pop();
+            }
+          } catch (k) {
+            throw b.__CE_state = 2, k;
+          }
+
+          b.__CE_state = 1;
+          b.__CE_definition = d;
+
+          if (d.attributeChangedCallback && b.hasAttributes()) {
+            var e = d.observedAttributes;
+
+            for (d = 0; d < e.length; d++) {
+              var g = e[d],
+                  h = b.getAttribute(g);
+              null !== h && a.attributeChangedCallback(b, g, null, h, null);
+            }
+          }
+
+          J(b) && a.connectedCallback(b);
+        }
+      } catch (k) {
+        X(k);
+      }
+    }
+
+    N.prototype.connectedCallback = function (a) {
+      var b = a.__CE_definition;
+      if (b.connectedCallback) try {
+        b.connectedCallback.call(a);
+      } catch (c) {
+        X(c);
+      }
+    };
+
+    N.prototype.disconnectedCallback = function (a) {
+      var b = a.__CE_definition;
+      if (b.disconnectedCallback) try {
+        b.disconnectedCallback.call(a);
+      } catch (c) {
+        X(c);
+      }
+    };
+
+    N.prototype.attributeChangedCallback = function (a, b, c, f, d) {
+      var e = a.__CE_definition;
+      if (e.attributeChangedCallback && -1 < e.observedAttributes.indexOf(b)) try {
+        e.attributeChangedCallback.call(a, b, c, f, d);
+      } catch (g) {
+        X(g);
+      }
+    };
+
+    function ua(a, b, c, f) {
+      var d = b.__CE_registry;
+      if (d && (null === f || "http://www.w3.org/1999/xhtml" === f) && (d = W(d, c))) try {
+        var e = new d.constructorFunction();
+        if (void 0 === e.__CE_state || void 0 === e.__CE_definition) throw Error("Failed to construct '" + c + "': The returned value was not constructed with the HTMLElement constructor.");
+        if ("http://www.w3.org/1999/xhtml" !== e.namespaceURI) throw Error("Failed to construct '" + c + "': The constructed element's namespace must be the HTML namespace.");
+        if (e.hasAttributes()) throw Error("Failed to construct '" + c + "': The constructed element must not have any attributes.");
+        if (null !== e.firstChild) throw Error("Failed to construct '" + c + "': The constructed element must not have any children.");
+        if (null !== e.parentNode) throw Error("Failed to construct '" + c + "': The constructed element must not have a parent node.");
+        if (e.ownerDocument !== b) throw Error("Failed to construct '" + c + "': The constructed element's owner document is incorrect.");
+        if (e.localName !== c) throw Error("Failed to construct '" + c + "': The constructed element's local name is incorrect.");
+        return e;
+      } catch (g) {
+        return X(g), b = null === f ? n.call(b, c) : p.call(b, f, c), Object.setPrototypeOf(b, HTMLUnknownElement.prototype), b.__CE_state = 2, b.__CE_definition = void 0, R(a, b), b;
+      }
+      b = null === f ? n.call(b, c) : p.call(b, f, c);
+      R(a, b);
+      return b;
+    }
+
+    function X(a) {
+      var b = a.message,
+          c = a.sourceURL || a.fileName || "",
+          f = a.line || a.lineNumber || 0,
+          d = a.column || a.columnNumber || 0,
+          e = void 0;
+      void 0 === ErrorEvent.prototype.initErrorEvent ? e = new ErrorEvent("error", {
+        cancelable: !0,
+        message: b,
+        filename: c,
+        lineno: f,
+        colno: d,
+        error: a
+      }) : (e = document.createEvent("ErrorEvent"), e.initErrorEvent("error", !1, !0, b, c, f), e.preventDefault = function () {
+        Object.defineProperty(this, "defaultPrevented", {
+          configurable: !0,
+          get: function () {
+            return !0;
+          }
+        });
+      });
+      void 0 === e.error && Object.defineProperty(e, "error", {
+        configurable: !0,
+        enumerable: !0,
+        get: function () {
+          return a;
+        }
+      });
+      window.dispatchEvent(e);
+      e.defaultPrevented || console.error(a);
+    }
+
+    function va() {
+      var a = this;
+      this.g = void 0;
+      this.F = new Promise(function (b) {
+        a.l = b;
+      });
+    }
+
+    va.prototype.resolve = function (a) {
+      if (this.g) throw Error("Already resolved.");
+      this.g = a;
+      this.l(a);
+    };
+
+    function wa(a) {
+      var b = document;
+      this.l = void 0;
+      this.h = a;
+      this.g = b;
+      V(this.h, this.g);
+      "loading" === this.g.readyState && (this.l = new MutationObserver(this.G.bind(this)), this.l.observe(this.g, {
+        childList: !0,
+        subtree: !0
+      }));
+    }
+
+    function xa(a) {
+      a.l && a.l.disconnect();
+    }
+
+    wa.prototype.G = function (a) {
+      var b = this.g.readyState;
+      "interactive" !== b && "complete" !== b || xa(this);
+
+      for (b = 0; b < a.length; b++) for (var c = a[b].addedNodes, f = 0; f < c.length; f++) V(this.h, c[f]);
+    };
+
+    function Y(a) {
+      this.s = new Map();
+      this.u = new Map();
+      this.C = new Map();
+      this.A = !1;
+      this.B = new Map();
+
+      this.o = function (b) {
+        return b();
+      };
+
+      this.i = !1;
+      this.v = [];
+      this.h = a;
+      this.D = a.I ? new wa(a) : void 0;
+    }
+
+    Y.prototype.H = function (a, b) {
+      var c = this;
+      if (!(b instanceof Function)) throw new TypeError("Custom element constructor getters must be functions.");
+      ya(this, a);
+      this.s.set(a, b);
+      this.v.push(a);
+      this.i || (this.i = !0, this.o(function () {
+        return za(c);
+      }));
+    };
+
+    Y.prototype.define = function (a, b) {
+      var c = this;
+      if (!(b instanceof Function)) throw new TypeError("Custom element constructors must be functions.");
+      ya(this, a);
+      Aa(this, a, b);
+      this.v.push(a);
+      this.i || (this.i = !0, this.o(function () {
+        return za(c);
+      }));
+    };
+
+    function ya(a, b) {
+      if (!qa(b)) throw new SyntaxError("The element name '" + b + "' is not valid.");
+      if (W(a, b)) throw Error("A custom element with name '" + (b + "' has already been defined."));
+      if (a.A) throw Error("A custom element is already being defined.");
+    }
+
+    function Aa(a, b, c) {
+      a.A = !0;
+      var f;
+
+      try {
+        var d = c.prototype;
+        if (!(d instanceof Object)) throw new TypeError("The custom element constructor's prototype is not an object.");
+
+        var e = function (m) {
+          var x = d[m];
+          if (void 0 !== x && !(x instanceof Function)) throw Error("The '" + m + "' callback must be a function.");
+          return x;
+        };
+
+        var g = e("connectedCallback");
+        var h = e("disconnectedCallback");
+        var k = e("adoptedCallback");
+        var l = (f = e("attributeChangedCallback")) && c.observedAttributes || [];
+      } catch (m) {
+        throw m;
+      } finally {
+        a.A = !1;
+      }
+
+      c = {
+        localName: b,
+        constructorFunction: c,
+        connectedCallback: g,
+        disconnectedCallback: h,
+        adoptedCallback: k,
+        attributeChangedCallback: f,
+        observedAttributes: l,
+        constructionStack: []
+      };
+      a.u.set(b, c);
+      a.C.set(c.constructorFunction, c);
+      return c;
+    }
+
+    Y.prototype.upgrade = function (a) {
+      V(this.h, a);
+    };
+
+    function za(a) {
+      if (!1 !== a.i) {
+        a.i = !1;
+
+        for (var b = [], c = a.v, f = new Map(), d = 0; d < c.length; d++) f.set(c[d], []);
+
+        V(a.h, document, {
+          upgrade: function (k) {
+            if (void 0 === k.__CE_state) {
+              var l = k.localName,
+                  m = f.get(l);
+              m ? m.push(k) : a.u.has(l) && b.push(k);
+            }
+          }
+        });
+
+        for (d = 0; d < b.length; d++) T(a.h, b[d]);
+
+        for (d = 0; d < c.length; d++) {
+          for (var e = c[d], g = f.get(e), h = 0; h < g.length; h++) T(a.h, g[h]);
+
+          (e = a.B.get(e)) && e.resolve(void 0);
+        }
+
+        c.length = 0;
+      }
+    }
+
+    Y.prototype.get = function (a) {
+      if (a = W(this, a)) return a.constructorFunction;
+    };
+
+    Y.prototype.whenDefined = function (a) {
+      if (!qa(a)) return Promise.reject(new SyntaxError("'" + a + "' is not a valid custom element name."));
+      var b = this.B.get(a);
+      if (b) return b.F;
+      b = new va();
+      this.B.set(a, b);
+      var c = this.u.has(a) || this.s.has(a);
+      a = -1 === this.v.indexOf(a);
+      c && a && b.resolve(void 0);
+      return b.F;
+    };
+
+    Y.prototype.polyfillWrapFlushCallback = function (a) {
+      this.D && xa(this.D);
+      var b = this.o;
+
+      this.o = function (c) {
+        return a(function () {
+          return b(c);
+        });
+      };
+    };
+
+    function W(a, b) {
+      var c = a.u.get(b);
+      if (c) return c;
+
+      if (c = a.s.get(b)) {
+        a.s.delete(b);
+
+        try {
+          return Aa(a, b, c());
+        } catch (f) {
+          X(f);
+        }
+      }
+    }
+
+    window.CustomElementRegistry = Y;
+    Y.prototype.define = Y.prototype.define;
+    Y.prototype.upgrade = Y.prototype.upgrade;
+    Y.prototype.get = Y.prototype.get;
+    Y.prototype.whenDefined = Y.prototype.whenDefined;
+    Y.prototype.polyfillDefineLazy = Y.prototype.H;
+    Y.prototype.polyfillWrapFlushCallback = Y.prototype.polyfillWrapFlushCallback;
+
+    function Z(a, b, c) {
+      function f(d) {
+        return function (e) {
+          for (var g = [], h = 0; h < arguments.length; ++h) g[h] = arguments[h];
+
+          h = [];
+
+          for (var k = [], l = 0; l < g.length; l++) {
+            var m = g[l];
+            m instanceof Element && J(m) && k.push(m);
+            if (m instanceof DocumentFragment) for (m = m.firstChild; m; m = m.nextSibling) h.push(m);else h.push(m);
+          }
+
+          d.apply(this, g);
+
+          for (g = 0; g < k.length; g++) U(a, k[g]);
+
+          if (J(this)) for (g = 0; g < h.length; g++) k = h[g], k instanceof Element && S(a, k);
+        };
+      }
+
+      void 0 !== c.prepend && (b.prepend = f(c.prepend));
+      void 0 !== c.append && (b.append = f(c.append));
+    }
+
+    function Ba(a) {
+      Document.prototype.createElement = function (b) {
+        return ua(a, this, b, null);
+      };
+
+      Document.prototype.importNode = function (b, c) {
+        b = aa.call(this, b, !!c);
+        this.__CE_registry ? V(a, b) : Q(a, b);
+        return b;
+      };
+
+      Document.prototype.createElementNS = function (b, c) {
+        return ua(a, this, c, b);
+      };
+
+      Z(a, Document.prototype, {
+        prepend: ba,
+        append: ca
+      });
+    }
+
+    function Ca(a) {
+      function b(f) {
+        return function (d) {
+          for (var e = [], g = 0; g < arguments.length; ++g) e[g] = arguments[g];
+
+          g = [];
+
+          for (var h = [], k = 0; k < e.length; k++) {
+            var l = e[k];
+            l instanceof Element && J(l) && h.push(l);
+            if (l instanceof DocumentFragment) for (l = l.firstChild; l; l = l.nextSibling) g.push(l);else g.push(l);
+          }
+
+          f.apply(this, e);
+
+          for (e = 0; e < h.length; e++) U(a, h[e]);
+
+          if (J(this)) for (e = 0; e < g.length; e++) h = g[e], h instanceof Element && S(a, h);
+        };
+      }
+
+      var c = Element.prototype;
+      void 0 !== ia && (c.before = b(ia));
+      void 0 !== ja && (c.after = b(ja));
+      void 0 !== ka && (c.replaceWith = function (f) {
+        for (var d = [], e = 0; e < arguments.length; ++e) d[e] = arguments[e];
+
+        e = [];
+
+        for (var g = [], h = 0; h < d.length; h++) {
+          var k = d[h];
+          k instanceof Element && J(k) && g.push(k);
+          if (k instanceof DocumentFragment) for (k = k.firstChild; k; k = k.nextSibling) e.push(k);else e.push(k);
+        }
+
+        h = J(this);
+        ka.apply(this, d);
+
+        for (d = 0; d < g.length; d++) U(a, g[d]);
+
+        if (h) for (U(a, this), d = 0; d < e.length; d++) g = e[d], g instanceof Element && S(a, g);
+      });
+      void 0 !== la && (c.remove = function () {
+        var f = J(this);
+        la.call(this);
+        f && U(a, this);
+      });
+    }
+
+    function Da(a) {
+      function b(d, e) {
+        Object.defineProperty(d, "innerHTML", {
+          enumerable: e.enumerable,
+          configurable: !0,
+          get: e.get,
+          set: function (g) {
+            var h = this,
+                k = void 0;
+            J(this) && (k = [], P(a, this, function (x) {
+              x !== h && k.push(x);
+            }));
+            e.set.call(this, g);
+            if (k) for (var l = 0; l < k.length; l++) {
+              var m = k[l];
+              1 === m.__CE_state && a.disconnectedCallback(m);
+            }
+            this.ownerDocument.__CE_registry ? V(a, this) : Q(a, this);
+            return g;
+          }
+        });
+      }
+
+      function c(d, e) {
+        d.insertAdjacentElement = function (g, h) {
+          var k = J(h);
+          g = e.call(this, g, h);
+          k && U(a, h);
+          J(g) && S(a, h);
+          return g;
+        };
+      }
+
+      function f(d, e) {
+        function g(h, k) {
+          for (var l = []; h !== k; h = h.nextSibling) l.push(h);
+
+          for (k = 0; k < l.length; k++) V(a, l[k]);
+        }
+
+        d.insertAdjacentHTML = function (h, k) {
+          h = h.toLowerCase();
+
+          if ("beforebegin" === h) {
+            var l = this.previousSibling;
+            e.call(this, h, k);
+            g(l || this.parentNode.firstChild, this);
+          } else if ("afterbegin" === h) l = this.firstChild, e.call(this, h, k), g(this.firstChild, l);else if ("beforeend" === h) l = this.lastChild, e.call(this, h, k), g(l || this.firstChild, null);else if ("afterend" === h) l = this.nextSibling, e.call(this, h, k), g(this.nextSibling, l);else throw new SyntaxError("The value provided (" + String(h) + ") is not one of 'beforebegin', 'afterbegin', 'beforeend', or 'afterend'.");
+        };
+      }
+
+      y && (Element.prototype.attachShadow = function (d) {
+        d = y.call(this, d);
+
+        if (a.j && !d.__CE_patched) {
+          d.__CE_patched = !0;
+
+          for (var e = 0; e < a.m.length; e++) a.m[e](d);
+        }
+
+        return this.__CE_shadowRoot = d;
+      });
+      z && z.get ? b(Element.prototype, z) : I && I.get ? b(HTMLElement.prototype, I) : ta(a, function (d) {
+        b(d, {
+          enumerable: !0,
+          configurable: !0,
+          get: function () {
+            return q.call(this, !0).innerHTML;
+          },
+          set: function (e) {
+            var g = "template" === this.localName,
+                h = g ? this.content : this,
+                k = p.call(document, this.namespaceURI, this.localName);
+
+            for (k.innerHTML = e; 0 < h.childNodes.length;) u.call(h, h.childNodes[0]);
+
+            for (e = g ? k.content : k; 0 < e.childNodes.length;) r.call(h, e.childNodes[0]);
+          }
+        });
+      });
+
+      Element.prototype.setAttribute = function (d, e) {
+        if (1 !== this.__CE_state) return B.call(this, d, e);
+        var g = A.call(this, d);
+        B.call(this, d, e);
+        e = A.call(this, d);
+        a.attributeChangedCallback(this, d, g, e, null);
+      };
+
+      Element.prototype.setAttributeNS = function (d, e, g) {
+        if (1 !== this.__CE_state) return E.call(this, d, e, g);
+        var h = D.call(this, d, e);
+        E.call(this, d, e, g);
+        g = D.call(this, d, e);
+        a.attributeChangedCallback(this, e, h, g, d);
+      };
+
+      Element.prototype.removeAttribute = function (d) {
+        if (1 !== this.__CE_state) return C.call(this, d);
+        var e = A.call(this, d);
+        C.call(this, d);
+        null !== e && a.attributeChangedCallback(this, d, e, null, null);
+      };
+
+      Element.prototype.removeAttributeNS = function (d, e) {
+        if (1 !== this.__CE_state) return F.call(this, d, e);
+        var g = D.call(this, d, e);
+        F.call(this, d, e);
+        var h = D.call(this, d, e);
+        g !== h && a.attributeChangedCallback(this, e, g, h, d);
+      };
+
+      na ? c(HTMLElement.prototype, na) : G && c(Element.prototype, G);
+      oa ? f(HTMLElement.prototype, oa) : H && f(Element.prototype, H);
+      Z(a, Element.prototype, {
+        prepend: fa,
+        append: ha
+      });
+      Ca(a);
+    }
+    var Ea = {};
+
+    function Fa(a) {
+      function b() {
+        var c = this.constructor;
+
+        var f = document.__CE_registry.C.get(c);
+
+        if (!f) throw Error("Failed to construct a custom element: The constructor was not registered with `customElements`.");
+        var d = f.constructionStack;
+        if (0 === d.length) return d = n.call(document, f.localName), Object.setPrototypeOf(d, c.prototype), d.__CE_state = 1, d.__CE_definition = f, R(a, d), d;
+        var e = d.length - 1,
+            g = d[e];
+        if (g === Ea) throw Error("Failed to construct '" + f.localName + "': This element was already constructed.");
+        d[e] = Ea;
+        Object.setPrototypeOf(g, c.prototype);
+        R(a, g);
+        return g;
+      }
+
+      b.prototype = ma.prototype;
+      Object.defineProperty(HTMLElement.prototype, "constructor", {
+        writable: !0,
+        configurable: !0,
+        enumerable: !1,
+        value: b
+      });
+      window.HTMLElement = b;
+    }
+
+    function Ga(a) {
+      function b(c, f) {
+        Object.defineProperty(c, "textContent", {
+          enumerable: f.enumerable,
+          configurable: !0,
+          get: f.get,
+          set: function (d) {
+            if (this.nodeType === Node.TEXT_NODE) f.set.call(this, d);else {
+              var e = void 0;
+
+              if (this.firstChild) {
+                var g = this.childNodes,
+                    h = g.length;
+
+                if (0 < h && J(this)) {
+                  e = Array(h);
+
+                  for (var k = 0; k < h; k++) e[k] = g[k];
+                }
+              }
+
+              f.set.call(this, d);
+              if (e) for (d = 0; d < e.length; d++) U(a, e[d]);
+            }
+          }
+        });
+      }
+
+      Node.prototype.insertBefore = function (c, f) {
+        if (c instanceof DocumentFragment) {
+          var d = K(c);
+          c = t.call(this, c, f);
+          if (J(this)) for (f = 0; f < d.length; f++) S(a, d[f]);
+          return c;
+        }
+
+        d = c instanceof Element && J(c);
+        f = t.call(this, c, f);
+        d && U(a, c);
+        J(this) && S(a, c);
+        return f;
+      };
+
+      Node.prototype.appendChild = function (c) {
+        if (c instanceof DocumentFragment) {
+          var f = K(c);
+          c = r.call(this, c);
+          if (J(this)) for (var d = 0; d < f.length; d++) S(a, f[d]);
+          return c;
+        }
+
+        f = c instanceof Element && J(c);
+        d = r.call(this, c);
+        f && U(a, c);
+        J(this) && S(a, c);
+        return d;
+      };
+
+      Node.prototype.cloneNode = function (c) {
+        c = q.call(this, !!c);
+        this.ownerDocument.__CE_registry ? V(a, c) : Q(a, c);
+        return c;
+      };
+
+      Node.prototype.removeChild = function (c) {
+        var f = c instanceof Element && J(c),
+            d = u.call(this, c);
+        f && U(a, c);
+        return d;
+      };
+
+      Node.prototype.replaceChild = function (c, f) {
+        if (c instanceof DocumentFragment) {
+          var d = K(c);
+          c = v.call(this, c, f);
+          if (J(this)) for (U(a, f), f = 0; f < d.length; f++) S(a, d[f]);
+          return c;
+        }
+
+        d = c instanceof Element && J(c);
+        var e = v.call(this, c, f),
+            g = J(this);
+        g && U(a, f);
+        d && U(a, c);
+        g && S(a, c);
+        return e;
+      };
+
+      w && w.get ? b(Node.prototype, w) : sa(a, function (c) {
+        b(c, {
+          enumerable: !0,
+          configurable: !0,
+          get: function () {
+            for (var f = [], d = this.firstChild; d; d = d.nextSibling) d.nodeType !== Node.COMMENT_NODE && f.push(d.textContent);
+
+            return f.join("");
+          },
+          set: function (f) {
+            for (; this.firstChild;) u.call(this, this.firstChild);
+
+            null != f && "" !== f && r.call(this, document.createTextNode(f));
+          }
+        });
+      });
+    }
+    var O = window.customElements;
+
+    function Ha() {
+      var a = new N();
+      Fa(a);
+      Ba(a);
+      Z(a, DocumentFragment.prototype, {
+        prepend: da,
+        append: ea
+      });
+      Ga(a);
+      Da(a);
+      a = new Y(a);
+      document.__CE_registry = a;
+      Object.defineProperty(window, "customElements", {
+        configurable: !0,
+        enumerable: !0,
+        value: a
+      });
+    }
+
+    O && !O.forcePolyfill && "function" == typeof O.define && "function" == typeof O.get || Ha();
+    window.__CE_installPolyfill = Ha;
+  }).call(self);
+
   /*
   Details Element Polyfill 2.4.0
   Copyright © 2019 Javan Makhmali
@@ -228,6 +1127,292 @@ var Super = (function (exports) {
     }
   })();
 
+  const CLOSE_ATTR = 'data-close-dialog';
+  const CLOSE_SELECTOR = `[${CLOSE_ATTR}]`;
+
+  function autofocus(el) {
+    let autofocusElement = Array.from(el.querySelectorAll('[autofocus]')).filter(focusable)[0];
+
+    if (!autofocusElement) {
+      autofocusElement = el;
+      el.setAttribute('tabindex', '-1');
+    }
+
+    autofocusElement.focus();
+  }
+
+  function keydown(event) {
+    const details = event.currentTarget;
+    if (!(details instanceof Element)) return;
+
+    if (event.key === 'Escape' || event.key === 'Esc') {
+      toggleDetails(details, false);
+      event.stopPropagation();
+    } else if (event.key === 'Tab') {
+      restrictTabBehavior(event);
+    }
+  }
+
+  function focusable(el) {
+    return el.tabIndex >= 0 && !el.disabled && visible(el);
+  }
+
+  function visible(el) {
+    return !el.hidden && (!el.type || el.type !== 'hidden') && (el.offsetWidth > 0 || el.offsetHeight > 0);
+  }
+
+  function restrictTabBehavior(event) {
+    if (!(event.currentTarget instanceof Element)) return;
+    const dialog = event.currentTarget.querySelector('details-dialog');
+    if (!dialog) return;
+    event.preventDefault();
+    const elements = Array.from(dialog.querySelectorAll('*')).filter(focusable);
+    if (elements.length === 0) return;
+    const movement = event.shiftKey ? -1 : 1;
+    const root = dialog.getRootNode();
+    const currentFocus = dialog.contains(root.activeElement) ? root.activeElement : null;
+    let targetIndex = movement === -1 ? -1 : 0;
+
+    if (currentFocus instanceof HTMLElement) {
+      const currentIndex = elements.indexOf(currentFocus);
+
+      if (currentIndex !== -1) {
+        targetIndex = currentIndex + movement;
+      }
+    }
+
+    if (targetIndex < 0) {
+      targetIndex = elements.length - 1;
+    } else {
+      targetIndex = targetIndex % elements.length;
+    }
+
+    elements[targetIndex].focus();
+  }
+
+  function allowClosingDialog(details) {
+    const dialog = details.querySelector('details-dialog');
+    if (!(dialog instanceof DetailsDialogElement)) return true;
+    return dialog.dispatchEvent(new CustomEvent('details-dialog-close', {
+      bubbles: true,
+      cancelable: true
+    }));
+  }
+
+  function onSummaryClick(event) {
+    if (!(event.currentTarget instanceof Element)) return;
+    const details = event.currentTarget.closest('details');
+    if (!details || !details.hasAttribute('open')) return;
+
+    if (!allowClosingDialog(details)) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+  }
+
+  function toggle(event) {
+    const details = event.currentTarget;
+    if (!(details instanceof Element)) return;
+    const dialog = details.querySelector('details-dialog');
+    if (!(dialog instanceof DetailsDialogElement)) return;
+
+    if (details.hasAttribute('open')) {
+      const root = 'getRootNode' in dialog ? dialog.getRootNode() : document;
+
+      if (root.activeElement instanceof HTMLElement) {
+        initialized.set(dialog, {
+          details,
+          activeElement: root.activeElement
+        });
+      }
+
+      autofocus(dialog);
+      details.addEventListener('keydown', keydown);
+    } else {
+      for (const form of dialog.querySelectorAll('form')) {
+        form.reset();
+      }
+
+      const focusElement = findFocusElement(details, dialog);
+      if (focusElement) focusElement.focus();
+      details.removeEventListener('keydown', keydown);
+    }
+  }
+
+  function findFocusElement(details, dialog) {
+    const state = initialized.get(dialog);
+
+    if (state && state.activeElement instanceof HTMLElement) {
+      return state.activeElement;
+    } else {
+      return details.querySelector('summary');
+    }
+  }
+
+  function toggleDetails(details, open) {
+    if (open === details.hasAttribute('open')) return;
+
+    if (open) {
+      details.setAttribute('open', '');
+    } else if (allowClosingDialog(details)) {
+      details.removeAttribute('open');
+    }
+  }
+
+  function loadIncludeFragment(event) {
+    const details = event.currentTarget;
+    if (!(details instanceof Element)) return;
+    const dialog = details.querySelector('details-dialog');
+    if (!(dialog instanceof DetailsDialogElement)) return;
+    const loader = dialog.querySelector('include-fragment:not([src])');
+    if (!loader) return;
+    const src = dialog.src;
+    if (src === null) return;
+    loader.addEventListener('loadend', () => {
+      if (details.hasAttribute('open')) autofocus(dialog);
+    });
+    loader.setAttribute('src', src);
+    removeIncludeFragmentEventListeners(details);
+  }
+
+  function updateIncludeFragmentEventListeners(details, src, preload) {
+    removeIncludeFragmentEventListeners(details);
+
+    if (src) {
+      details.addEventListener('toggle', loadIncludeFragment, {
+        once: true
+      });
+    }
+
+    if (src && preload) {
+      details.addEventListener('mouseover', loadIncludeFragment, {
+        once: true
+      });
+    }
+  }
+
+  function removeIncludeFragmentEventListeners(details) {
+    details.removeEventListener('toggle', loadIncludeFragment);
+    details.removeEventListener('mouseover', loadIncludeFragment);
+  }
+
+  const initialized = new WeakMap();
+
+  class DetailsDialogElement extends HTMLElement {
+    static get CLOSE_ATTR() {
+      return CLOSE_ATTR;
+    }
+
+    static get CLOSE_SELECTOR() {
+      return CLOSE_SELECTOR;
+    }
+
+    constructor() {
+      super();
+      initialized.set(this, {
+        details: null,
+        activeElement: null
+      });
+      this.addEventListener('click', function ({
+        target
+      }) {
+        if (!(target instanceof Element)) return;
+        const details = target.closest('details');
+
+        if (details && target.closest(CLOSE_SELECTOR)) {
+          toggleDetails(details, false);
+        }
+      });
+    }
+
+    get src() {
+      return this.getAttribute('src');
+    }
+
+    set src(value) {
+      this.setAttribute('src', value || '');
+    }
+
+    get preload() {
+      return this.hasAttribute('preload');
+    }
+
+    set preload(value) {
+      value ? this.setAttribute('preload', '') : this.removeAttribute('preload');
+    }
+
+    connectedCallback() {
+      this.setAttribute('role', 'dialog');
+      this.setAttribute('aria-modal', 'true');
+      const state = initialized.get(this);
+      if (!state) return;
+      const details = this.parentElement;
+      if (!details) return;
+      const summary = details.querySelector('summary');
+
+      if (summary) {
+        if (!summary.hasAttribute('role')) summary.setAttribute('role', 'button');
+        summary.addEventListener('click', onSummaryClick, {
+          capture: true
+        });
+      }
+
+      details.addEventListener('toggle', toggle);
+      state.details = details;
+      updateIncludeFragmentEventListeners(details, this.src, this.preload);
+    }
+
+    disconnectedCallback() {
+      const state = initialized.get(this);
+      if (!state) return;
+      const {
+        details
+      } = state;
+      if (!details) return;
+      details.removeEventListener('toggle', toggle);
+      removeIncludeFragmentEventListeners(details);
+      const summary = details.querySelector('summary');
+
+      if (summary) {
+        summary.removeEventListener('click', onSummaryClick, {
+          capture: true
+        });
+      }
+
+      state.details = null;
+    }
+
+    toggle(open) {
+      const state = initialized.get(this);
+      if (!state) return;
+      const {
+        details
+      } = state;
+      if (!details) return;
+      toggleDetails(details, open);
+    }
+
+    static get observedAttributes() {
+      return ['src', 'preload'];
+    }
+
+    attributeChangedCallback() {
+      const state = initialized.get(this);
+      if (!state) return;
+      const {
+        details
+      } = state;
+      if (!details) return;
+      updateIncludeFragmentEventListeners(details, this.src, this.preload);
+    }
+
+  }
+
+  if (!window.customElements.get('details-dialog')) {
+    window.DetailsDialogElement = DetailsDialogElement;
+    window.customElements.define('details-dialog', DetailsDialogElement);
+  }
+
   var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
   function createCommonjsModule(fn) {
@@ -237,7 +1422,7 @@ var Super = (function (exports) {
 
   /*
   Unobtrusive JavaScript
-  https://github.com/rails/rails/blob/master/actionview/app/assets/javascripts
+  https://github.com/rails/rails/blob/main/actionview/app/assets/javascripts
   Released under the MIT license
    */
   createCommonjsModule(function (module) {
@@ -252,8 +1437,8 @@ var Super = (function (exports) {
               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])',
+            formSubmitSelector: 'form:not([data-turbo=true])',
+            formInputClickSelector: 'form:not([data-turbo=true]) input[type=submit], form:not([data-turbo=true]) input[type=image], form:not([data-turbo=true]) button[type=submit], form:not([data-turbo=true]) 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])',
@@ -413,7 +1598,7 @@ var Super = (function (exports) {
         }).call(this);
         (function () {
           var AcceptHeaders, CSRFProtection, createXHR, cspNonce, prepareOptions, processResponse;
-          cspNonce = Rails.cspNonce, CSRFProtection = Rails.CSRFProtection, Rails.fire;
+          cspNonce = Rails.cspNonce, CSRFProtection = Rails.CSRFProtection;
           AcceptHeaders = {
             '*': '*/*',
             text: 'text/plain',
@@ -489,9 +1674,9 @@ var Super = (function (exports) {
 
             if (!options.crossDomain) {
               xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+              CSRFProtection(xhr);
             }
 
-            CSRFProtection(xhr);
             xhr.withCredentials = !!options.withCredentials;
 
             xhr.onreadystatechange = function () {
@@ -1035,9 +2220,7 @@ var Super = (function (exports) {
     }).call(commonjsGlobal);
   });
 
-  var EventListener =
-  /** @class */
-  function () {
+  var EventListener = function () {
     function EventListener(eventTarget, eventName, eventOptions) {
       this.eventTarget = eventTarget;
       this.eventName = eventName;
@@ -1109,9 +2292,7 @@ var Super = (function (exports) {
     }
   }
 
-  var Dispatcher =
-  /** @class */
-  function () {
+  var Dispatcher = function () {
     function Dispatcher(application) {
       this.application = application;
       this.eventListenerMaps = new Map();
@@ -1257,9 +2438,7 @@ var Super = (function (exports) {
     }
   }
 
-  var Action =
-  /** @class */
-  function () {
+  var Action = function () {
     function Action(element, index, descriptor) {
       this.element = element;
       this.index = index;
@@ -1320,9 +2499,7 @@ var Super = (function (exports) {
     throw new Error(message);
   }
 
-  var Binding =
-  /** @class */
-  function () {
+  var Binding = function () {
     function Binding(context, action) {
       this.context = context;
       this.action = action;
@@ -1448,9 +2625,7 @@ var Super = (function (exports) {
     return Binding;
   }();
 
-  var ElementObserver =
-  /** @class */
-  function () {
+  var ElementObserver = function () {
     function ElementObserver(element, delegate) {
       var _this = this;
 
@@ -1617,9 +2792,7 @@ var Super = (function (exports) {
     return ElementObserver;
   }();
 
-  var AttributeObserver =
-  /** @class */
-  function () {
+  var AttributeObserver = function () {
     function AttributeObserver(element, attributeName, delegate) {
       this.attributeName = attributeName;
       this.delegate = delegate;
@@ -1692,9 +2865,7 @@ var Super = (function (exports) {
     return AttributeObserver;
   }();
 
-  var StringMapObserver =
-  /** @class */
-  function () {
+  var StringMapObserver = function () {
     function StringMapObserver(element, delegate) {
       var _this = this;
 
@@ -1845,9 +3016,7 @@ var Super = (function (exports) {
     }
   }
 
-  var Multimap =
-  /** @class */
-  function () {
+  var Multimap = function () {
     function Multimap() {
       this.valuesByKey = new Map();
     }
@@ -1941,7 +3110,6 @@ var Super = (function (exports) {
     };
   }();
 
-  /** @class */
   (function (_super) {
     __extends$1(IndexedMultimap, _super);
 
@@ -1984,9 +3152,7 @@ var Super = (function (exports) {
     return IndexedMultimap;
   })(Multimap);
 
-  var TokenListObserver =
-  /** @class */
-  function () {
+  var TokenListObserver = function () {
     function TokenListObserver(element, attributeName, delegate) {
       this.attributeObserver = new AttributeObserver(element, attributeName, this);
       this.delegate = delegate;
@@ -2122,9 +3288,7 @@ var Super = (function (exports) {
     return left && right && left.index == right.index && left.content == right.content;
   }
 
-  var ValueListObserver =
-  /** @class */
-  function () {
+  var ValueListObserver = function () {
     function ValueListObserver(element, attributeName, delegate) {
       this.tokenListObserver = new TokenListObserver(element, attributeName, this);
       this.delegate = delegate;
@@ -2225,9 +3389,7 @@ var Super = (function (exports) {
     return ValueListObserver;
   }();
 
-  var BindingObserver =
-  /** @class */
-  function () {
+  var BindingObserver = function () {
     function BindingObserver(context, delegate) {
       this.context = context;
       this.delegate = delegate;
@@ -2329,9 +3491,7 @@ var Super = (function (exports) {
     return BindingObserver;
   }();
 
-  var ValueObserver =
-  /** @class */
-  function () {
+  var ValueObserver = function () {
     function ValueObserver(context, receiver) {
       this.context = context;
       this.receiver = receiver;
@@ -2409,9 +3569,7 @@ var Super = (function (exports) {
     return ValueObserver;
   }();
 
-  var Context =
-  /** @class */
-  function () {
+  var Context = function () {
     function Context(module, scope) {
       this.module = module;
       this.scope = scope;
@@ -2684,18 +3842,15 @@ var Super = (function (exports) {
       return extendWithReflect;
     } catch (error) {
       return function (constructor) {
-        return (
-          /** @class */
-          function (_super) {
-            __extends(extended, _super);
+        return function (_super) {
+          __extends(extended, _super);
 
-            function extended() {
-              return _super !== null && _super.apply(this, arguments) || this;
-            }
+          function extended() {
+            return _super !== null && _super.apply(this, arguments) || this;
+          }
 
-            return extended;
-          }(constructor)
-        );
+          return extended;
+        }(constructor);
       };
     }
   }();
@@ -2709,9 +3864,7 @@ var Super = (function (exports) {
     };
   }
 
-  var Module =
-  /** @class */
-  function () {
+  var Module = function () {
     function Module(application, definition) {
       this.application = application;
       this.definition = blessDefinition(definition);
@@ -2770,9 +3923,7 @@ var Super = (function (exports) {
     return Module;
   }();
 
-  var ClassMap =
-  /** @class */
-  function () {
+  var ClassMap = function () {
     function ClassMap(scope) {
       this.scope = scope;
     }
@@ -2817,9 +3968,7 @@ var Super = (function (exports) {
     });
   }
 
-  var DataMap =
-  /** @class */
-  function () {
+  var DataMap = function () {
     function DataMap(scope) {
       this.scope = scope;
     }
@@ -2872,9 +4021,7 @@ var Super = (function (exports) {
     return DataMap;
   }();
 
-  var Guide =
-  /** @class */
-  function () {
+  var Guide = function () {
     function Guide(logger) {
       this.warnedKeysByObject = new WeakMap();
       this.logger = logger;
@@ -2910,9 +4057,7 @@ var Super = (function (exports) {
     return r;
   };
 
-  var TargetSet =
-  /** @class */
-  function () {
+  var TargetSet = function () {
     function TargetSet(scope) {
       this.scope = scope;
     }
@@ -3033,9 +4178,7 @@ var Super = (function (exports) {
     return r;
   };
 
-  var Scope =
-  /** @class */
-  function () {
+  var Scope = function () {
     function Scope(schema, element, identifier, logger) {
       var _this = this;
 
@@ -3075,9 +4218,7 @@ var Super = (function (exports) {
     return Scope;
   }();
 
-  var ScopeObserver =
-  /** @class */
-  function () {
+  var ScopeObserver = function () {
     function ScopeObserver(element, schema, delegate) {
       this.element = element;
       this.schema = schema;
@@ -3158,9 +4299,7 @@ var Super = (function (exports) {
     return ScopeObserver;
   }();
 
-  var Router =
-  /** @class */
-  function () {
+  var Router = function () {
     function Router(application) {
       this.application = application;
       this.scopeObserver = new ScopeObserver(this.element, this.schema, this);
@@ -3456,9 +4595,7 @@ var Super = (function (exports) {
     return r;
   };
 
-  var Application =
-  /** @class */
-  function () {
+  var Application = function () {
     function Application(element, schema) {
       if (element === void 0) {
         element = document.documentElement;
@@ -3802,9 +4939,7 @@ var Super = (function (exports) {
     return "" + value;
   }
 
-  var Controller =
-  /** @class */
-  function () {
+  var Controller = function () {
     function Controller(context) {
       this.context = context;
     }
@@ -3951,6 +5086,8 @@ var Super = (function (exports) {
   function _possibleConstructorReturn(self, call) {
     if (call && (typeof call === "object" || typeof call === "function")) {
       return call;
+    } else if (call !== void 0) {
+      throw new TypeError("Derived constructors may only return object or undefined");
     }
 
     return _assertThisInitialized(self);
@@ -3975,7 +5112,7 @@ var Super = (function (exports) {
     };
   }
 
-  var _default$6 = /*#__PURE__*/function (_Controller) {
+  var _default$8 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -4004,7 +5141,43 @@ var Super = (function (exports) {
     return _default;
   }(Controller);
 
-  var _default$5 = /*#__PURE__*/function (_Controller) {
+  var _default$7 = /*#__PURE__*/function (_Controller) {
+    _inherits(_default, _Controller);
+
+    var _super = _createSuper(_default);
+
+    function _default() {
+      _classCallCheck(this, _default);
+
+      return _super.apply(this, arguments);
+    }
+
+    _createClass(_default, [{
+      key: "submit",
+      value: function submit() {
+        var form = this.element.closest("form");
+        form.method = this.methodValue;
+        form.action = this.actionValue;
+        var authenticityTokenInput = document.createElement("input");
+        authenticityTokenInput.type = "hidden";
+        authenticityTokenInput.name = document.querySelector("meta[name='csrf-param']").content;
+        authenticityTokenInput.value = document.querySelector("meta[name='csrf-token']").content;
+        form.appendChild(authenticityTokenInput);
+      }
+    }], [{
+      key: "values",
+      get: function get() {
+        return {
+          method: String,
+          action: String
+        };
+      }
+    }]);
+
+    return _default;
+  }(Controller);
+
+  var _default$6 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -4040,7 +5213,7 @@ var Super = (function (exports) {
     return _default;
   }(Controller);
 
-  var _default$4 = /*#__PURE__*/function (_Controller) {
+  var _default$5 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -4064,37 +5237,7 @@ var Super = (function (exports) {
     return _default;
   }(Controller);
 
-  var _default$3 = /*#__PURE__*/function (_Controller) {
-    _inherits(_default, _Controller);
-
-    var _super = _createSuper(_default);
-
-    function _default() {
-      _classCallCheck(this, _default);
-
-      return _super.apply(this, arguments);
-    }
-
-    _createClass(_default, [{
-      key: "close",
-      value: function close(event) {
-        if (!this.element.hasAttribute("open")) {
-          return true;
-        }
-
-        if (this.element === event.target || this.element.contains(event.target)) {
-          return true;
-        }
-
-        this.element.removeAttribute("open");
-        return true;
-      }
-    }]);
-
-    return _default;
-  }(Controller);
-
-  var _default$2 = /*#__PURE__*/function (_Controller) {
+  var _default$4 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -6354,7 +7497,7 @@ var Super = (function (exports) {
     window.flatpickr = flatpickr;
   }
 
-  var _default$1 = /*#__PURE__*/function (_Controller) {
+  var _default$3 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -6382,6 +7525,137 @@ var Super = (function (exports) {
     return _default;
   }(Controller);
 
+  var _default$2 = /*#__PURE__*/function (_Controller) {
+    _inherits(_default, _Controller);
+
+    var _super = _createSuper(_default);
+
+    function _default() {
+      _classCallCheck(this, _default);
+
+      return _super.apply(this, arguments);
+    }
+
+    _createClass(_default, [{
+      key: "connect",
+      value: function connect() {
+        var _this = this;
+
+        this.tabTargets.forEach(function (tab) {
+          tab.tabContainer = _this;
+        });
+      }
+    }, {
+      key: "activeTabIdentifier",
+      get: function get() {
+        return this.controlTarget.value;
+      }
+    }, {
+      key: "change",
+      value: function change(event) {
+        this.update(event.target.value);
+      }
+    }, {
+      key: "update",
+      value: function update(newActiveTabIdentifier) {
+        var _this2 = this;
+
+        this.tabTargets.forEach(function (tab) {
+          var tabController = _this2.application.getControllerForElementAndIdentifier(tab, _this2.tabControllerNameValue);
+
+          if (tab.dataset[_this2.tabIdentifierGetterValue] == newActiveTabIdentifier) {
+            tabController.show();
+          } else {
+            tabController.hide();
+          }
+        });
+      }
+    }], [{
+      key: "targets",
+      get: function get() {
+        return ["control", "tab"];
+      }
+    }, {
+      key: "values",
+      get: function get() {
+        return {
+          tabIdentifierGetter: String,
+          tabControllerName: String
+        };
+      }
+    }]);
+
+    return _default;
+  }(Controller);
+
+  var _default$1 = /*#__PURE__*/function (_Controller) {
+    _inherits(_default, _Controller);
+
+    var _super = _createSuper(_default);
+
+    function _default() {
+      _classCallCheck(this, _default);
+
+      return _super.apply(this, arguments);
+    }
+
+    _createClass(_default, [{
+      key: "connect",
+      value: function connect() {
+        var tabContainer = this.element[this.tabContainerGetterValue];
+
+        if (tabContainer.activeTabIdentifier === this.identifierValue) {
+          this.show();
+        } else {
+          this.hide();
+        }
+      }
+    }, {
+      key: "toggle",
+      value: function toggle() {
+        if (this.hasContentTarget) {
+          this.hide();
+        } else {
+          this.show();
+        }
+      }
+    }, {
+      key: "show",
+      value: function show() {
+        if (this.hasContentTarget) {
+          return;
+        }
+
+        var pocketContent = this.pocketTarget.content.cloneNode(true);
+        this.element.appendChild(pocketContent);
+      }
+    }, {
+      key: "hide",
+      value: function hide() {
+        if (!this.hasContentTarget) {
+          return;
+        }
+
+        this.contentTarget.remove();
+      }
+    }], [{
+      key: "targets",
+      get: function get() {
+        return ["pocket", "content"];
+      }
+    }, {
+      key: "values",
+      get: function get() {
+        return {
+          identifier: String,
+          tabContainerGetter: String
+        };
+      }
+    }]);
+
+    return _default;
+  }(Controller);
+
   var _default = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
@@ -6412,12 +7686,14 @@ var Super = (function (exports) {
   }(Controller);
 
   var StimulusApplication = Application.start();
-  StimulusApplication.register("apply-template", _default$6);
-  StimulusApplication.register("clean-filter-param", _default$5);
-  StimulusApplication.register("clean-filter-params", _default$4);
-  StimulusApplication.register("click-outside-to-close", _default$3);
-  StimulusApplication.register("delete", _default$2);
-  StimulusApplication.register("flatpickr", _default$1);
+  StimulusApplication.register("apply-template", _default$8);
+  StimulusApplication.register("batch", _default$7);
+  StimulusApplication.register("clean-filter-param", _default$6);
+  StimulusApplication.register("clean-filter-params", _default$5);
+  StimulusApplication.register("delete", _default$4);
+  StimulusApplication.register("flatpickr", _default$3);
+  StimulusApplication.register("tab-container", _default$2);
+  StimulusApplication.register("tab", _default$1);
   StimulusApplication.register("toggle-pending-destruction", _default);
 
   exports.StimulusApplication = StimulusApplication;
@@ -6427,4 +7703,4 @@ var Super = (function (exports) {
 
   return exports;
 
-}({}));
+})({});