avo 3.13.2 → 3.13.3

data/app/assets/builds/avo.base.js

@@ -18398,12 +18398,12 @@
                 this$1$1.runCallbacks();
               }
             };
-            var config2 = chart.__config();
-            if (config2.language) {
-              loadOptions.language = config2.language;
+            var config3 = chart.__config();
+            if (config3.language) {
+              loadOptions.language = config3.language;
             }
-            if (pack === "geochart" && config2.mapsApiKey) {
-              loadOptions.mapsApiKey = config2.mapsApiKey;
+            if (pack === "geochart" && config3.mapsApiKey) {
+              loadOptions.mapsApiKey = config3.mapsApiKey;
             }
             this.library.charts.load("current", loadOptions);
           }
@@ -18687,7 +18687,7 @@
             xhr.send();
           }
         }
-        var config = {};
+        var config2 = {};
         var adapters2 = [];
         function setText(element, text) {
           if (document.body.innerText) {
@@ -18925,7 +18925,7 @@
           renderChart(this.__chartName(), this);
         };
         Chart2.prototype.__config = function __config() {
-          return config;
+          return config2;
         };
         var LineChart = /* @__PURE__ */ function(Chart3) {
           function LineChart2() {
@@ -19090,7 +19090,7 @@
           configure: function(options) {
             for (var key in options) {
               if (options.hasOwnProperty(key)) {
-                config[key] = options[key];
+                config2[key] = options[key];
               }
             }
           },
@@ -19112,7 +19112,7 @@
               }
             }
           },
-          config,
+          config: config2,
           options: {},
           adapters: adapters2,
           addAdapter,
@@ -19124,12 +19124,12 @@
         if (typeof window !== "undefined" && !window.Chartkick) {
           window.Chartkick = Chartkick2;
           document.addEventListener("turbolinks:before-render", function() {
-            if (config.autoDestroy !== false) {
+            if (config2.autoDestroy !== false) {
               Chartkick2.destroyAll();
             }
           });
           document.addEventListener("turbo:before-render", function() {
-            if (config.autoDestroy !== false) {
+            if (config2.autoDestroy !== false) {
               Chartkick2.destroyAll();
             }
           });
@@ -22785,13 +22785,13 @@
   function isIChartComponent(proto) {
     return "id" in proto && "defaults" in proto;
   }
-  function allPlugins(config) {
+  function allPlugins(config2) {
     const plugins2 = [];
     const keys2 = Object.keys(registry.plugins.items);
     for (let i5 = 0; i5 < keys2.length; i5++) {
       plugins2.push(registry.getPlugin(keys2[i5]));
     }
-    const local = config.plugins || [];
+    const local = config2.plugins || [];
     for (let i5 = 0; i5 < local.length; i5++) {
       const plugin = local[i5];
       if (plugins2.indexOf(plugin) === -1) {
@@ -22826,10 +22826,10 @@
     }
     return result;
   }
-  function pluginOpts(config, plugin, opts, context) {
-    const keys2 = config.pluginScopeKeys(plugin);
-    const scopes = config.getOptionScopes(opts, keys2);
-    return config.createResolver(scopes, context, [""], { scriptable: false, indexable: false, allKeys: true });
+  function pluginOpts(config2, plugin, opts, context) {
+    const keys2 = config2.pluginScopeKeys(plugin);
+    const scopes = config2.getOptionScopes(opts, keys2);
+    return config2.createResolver(scopes, context, [""], { scriptable: false, indexable: false, allKeys: true });
   }
   function getIndexAxis(type, options) {
     const datasetDefaults = defaults.datasets[type] || {};
@@ -22862,10 +22862,10 @@
     }
     return scaleOptions.axis || axisFromPosition(scaleOptions.position) || id.charAt(0).toLowerCase();
   }
-  function mergeScaleConfig(config, options) {
-    const chartDefaults = overrides[config.type] || { scales: {} };
+  function mergeScaleConfig(config2, options) {
+    const chartDefaults = overrides[config2.type] || { scales: {} };
     const configScales = options.scales || {};
-    const chartIndexAxis = getIndexAxis(config.type, options);
+    const chartIndexAxis = getIndexAxis(config2.type, options);
     const firstIDs = /* @__PURE__ */ Object.create(null);
     const scales2 = /* @__PURE__ */ Object.create(null);
     Object.keys(configScales).forEach((id) => {
@@ -22882,8 +22882,8 @@
       firstIDs[axis] = firstIDs[axis] || id;
       scales2[id] = mergeIf(/* @__PURE__ */ Object.create(null), [{ axis }, scaleConf, defaultScaleOptions[axis], defaultScaleOptions[defaultId]]);
     });
-    config.data.datasets.forEach((dataset) => {
-      const type = dataset.type || config.type;
+    config2.data.datasets.forEach((dataset) => {
+      const type = dataset.type || config2.type;
       const indexAxis = dataset.indexAxis || getIndexAxis(type, options);
       const datasetDefaults = overrides[type] || {};
       const defaultScaleOptions = datasetDefaults.scales || {};
@@ -22900,10 +22900,10 @@
     });
     return scales2;
   }
-  function initOptions(config) {
-    const options = config.options || (config.options = {});
+  function initOptions(config2) {
+    const options = config2.options || (config2.options = {});
     options.plugins = valueOrDefault(options.plugins, {});
-    options.scales = mergeScaleConfig(config, options);
+    options.scales = mergeScaleConfig(config2, options);
   }
   function initData(data) {
     data = data || {};
@@ -22911,11 +22911,11 @@
     data.labels = data.labels || [];
     return data;
   }
-  function initConfig(config) {
-    config = config || {};
-    config.data = initData(config.data);
-    initOptions(config);
-    return config;
+  function initConfig(config2) {
+    config2 = config2 || {};
+    config2.data = initData(config2.data);
+    initOptions(config2);
+    return config2;
   }
   function cachedKeys(cacheKey, generate) {
     let keys2 = keyCache.get(cacheKey);
@@ -24856,18 +24856,18 @@
         }
       });
       Animations = class {
-        constructor(chart, config) {
+        constructor(chart, config2) {
           this._chart = chart;
           this._properties = /* @__PURE__ */ new Map();
-          this.configure(config);
+          this.configure(config2);
         }
-        configure(config) {
-          if (!isObject(config)) {
+        configure(config2) {
+          if (!isObject(config2)) {
             return;
           }
           const animatedProps = this._properties;
-          Object.getOwnPropertyNames(config).forEach((key) => {
-            const cfg = config[key];
+          Object.getOwnPropertyNames(config2).forEach((key) => {
+            const cfg = config2[key];
             if (!isObject(cfg)) {
               return;
             }
@@ -25068,10 +25068,10 @@
           }
         }
         configure() {
-          const config = this.chart.config;
-          const scopeKeys = config.datasetScopeKeys(this._type);
-          const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);
-          this.options = config.createResolver(scopes, this.getContext());
+          const config2 = this.chart.config;
+          const scopeKeys = config2.datasetScopeKeys(this._type);
+          const scopes = config2.getOptionScopes(this.getDataset(), scopeKeys, true);
+          this.options = config2.createResolver(scopes, this.getContext());
           this._parsing = this.options.parsing;
           this._cachedDataOpts = {};
         }
@@ -25316,13 +25316,13 @@
           if (cached) {
             return cloneIfNotShared(cached, sharing);
           }
-          const config = this.chart.config;
-          const scopeKeys = config.datasetElementScopeKeys(this._type, elementType2);
+          const config2 = this.chart.config;
+          const scopeKeys = config2.datasetElementScopeKeys(this._type, elementType2);
           const prefixes = active ? [`${elementType2}Hover`, "hover", elementType2, ""] : [elementType2, ""];
-          const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
+          const scopes = config2.getOptionScopes(this.getDataset(), scopeKeys);
           const names2 = Object.keys(defaults.elements[elementType2]);
           const context = () => this.getContext(index2, active);
-          const values = config.resolveNamedOptions(scopes, names2, context, prefixes);
+          const values = config2.resolveNamedOptions(scopes, names2, context, prefixes);
           if (values.$shared) {
             values.$shared = sharing;
             cache2[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing));
@@ -25339,10 +25339,10 @@
           }
           let options;
           if (chart.options.animation !== false) {
-            const config = this.chart.config;
-            const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition2);
-            const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
-            options = config.createResolver(scopes, this.getContext(index2, active, transition2));
+            const config2 = this.chart.config;
+            const scopeKeys = config2.datasetAnimationScopeKeys(this._type, transition2);
+            const scopes = config2.getOptionScopes(this.getDataset(), scopeKeys);
+            options = config2.createResolver(scopes, this.getContext(index2, active, transition2));
           }
           const animations = new Animations(chart, options && options.animations);
           if (options && options._cacheable) {
@@ -26739,15 +26739,15 @@
         isAttached(canvas) {
           return true;
         }
-        updateConfig(config) {
+        updateConfig(config2) {
         }
       };
       BasicPlatform = class extends BasePlatform {
         acquireContext(item) {
           return item && item.getContext && item.getContext("2d") || null;
         }
-        updateConfig(config) {
-          config.options.animation = false;
+        updateConfig(config2) {
+          config2.options.animation = false;
         }
       };
       EXPANDO_KEY = "$chartjs";
@@ -28211,9 +28211,9 @@
           return descriptors2;
         }
         _createDescriptors(chart, all) {
-          const config = chart && chart.config;
-          const options = valueOrDefault(config.options && config.options.plugins, {});
-          const plugins2 = allPlugins(config);
+          const config2 = chart && chart.config;
+          const options = valueOrDefault(config2.options && config2.options.plugins, {});
+          const plugins2 = allPlugins(config2);
           return options === false && !all ? [] : createDescriptors(chart, plugins2, options, all);
         }
         _notifyStateChanges(chart) {
@@ -28233,8 +28233,8 @@
         }
       };
       Config = class {
-        constructor(config) {
-          this._config = initConfig(config);
+        constructor(config2) {
+          this._config = initConfig(config2);
           this._scopeCache = /* @__PURE__ */ new Map();
           this._resolverCache = /* @__PURE__ */ new Map();
         }
@@ -28263,9 +28263,9 @@
           return this._config.plugins;
         }
         update() {
-          const config = this._config;
+          const config2 = this._config;
           this.clearCache();
-          initOptions(config);
+          initOptions(config2);
         }
         clearCache() {
           this._scopeCache.clear();
@@ -28394,7 +28394,7 @@
       };
       Chart = class {
         constructor(item, userConfig) {
-          const config = this.config = new Config(userConfig);
+          const config2 = this.config = new Config(userConfig);
           const initialCanvas = getCanvas(item);
           const existingChart = getChart(initialCanvas);
           if (existingChart) {
@@ -28402,9 +28402,9 @@
               "Canvas is already in use. Chart with ID '" + existingChart.id + "' must be destroyed before the canvas can be reused."
             );
           }
-          const options = config.createResolver(config.chartOptionScopes(), this.getContext());
-          this.platform = new (config.platform || _detectPlatform(initialCanvas))();
-          this.platform.updateConfig(config);
+          const options = config2.createResolver(config2.chartOptionScopes(), this.getContext());
+          this.platform = new (config2.platform || _detectPlatform(initialCanvas))();
+          this.platform.updateConfig(config2);
           const context = this.platform.acquireContext(initialCanvas, options.aspectRatio);
           const canvas = context && context.canvas;
           const height = canvas && canvas.height;
@@ -28652,9 +28652,9 @@
           this.notifyPlugins("reset");
         }
         update(mode) {
-          const config = this.config;
-          config.update();
-          const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());
+          const config2 = this.config;
+          config2.update();
+          const options = this._options = config2.createResolver(config2.chartOptionScopes(), this.getContext());
           const animsDisabled = this._animationsDisabled = !options.animation;
           this._updateScales();
           this._checkEventBindings();
@@ -29719,15 +29719,15 @@
       };
       itemsEqual = (a5, b4) => a5 !== null && b4 !== null && a5.datasetIndex === b4.datasetIndex && a5.index === b4.index;
       Legend = class extends Element2 {
-        constructor(config) {
+        constructor(config2) {
           super();
           this._added = false;
           this.legendHitBoxes = [];
           this._hoveredItem = null;
           this.doughnutMode = false;
-          this.chart = config.chart;
-          this.options = config.options;
-          this.ctx = config.ctx;
+          this.chart = config2.chart;
+          this.options = config2.options;
+          this.ctx = config2.ctx;
           this.legendItems = void 0;
           this.columnSizes = void 0;
           this.lineWidths = void 0;
@@ -30176,11 +30176,11 @@
         }
       };
       Title = class extends Element2 {
-        constructor(config) {
+        constructor(config2) {
           super();
-          this.chart = config.chart;
-          this.options = config.options;
-          this.ctx = config.ctx;
+          this.chart = config2.chart;
+          this.options = config2.options;
+          this.ctx = config2.ctx;
           this._padding = void 0;
           this.top = void 0;
           this.bottom = void 0;
@@ -30390,7 +30390,7 @@
         }
       };
       Tooltip = class extends Element2 {
-        constructor(config) {
+        constructor(config2) {
           super();
           this.opacity = 0;
           this._active = [];
@@ -30400,9 +30400,9 @@
           this._tooltipItems = [];
           this.$animations = void 0;
           this.$context = void 0;
-          this.chart = config.chart || config._chart;
+          this.chart = config2.chart || config2._chart;
           this._chart = this.chart;
-          this.options = config.options;
+          this.options = config2.options;
           this.dataPoints = void 0;
           this.title = void 0;
           this.beforeBody = void 0;
@@ -55690,6 +55690,7 @@
     StreamSourceElement: () => StreamSourceElement,
     cache: () => cache,
     clearCache: () => clearCache,
+    config: () => config,
     connectStreamSource: () => connectStreamSource,
     disconnectStreamSource: () => disconnectStreamSource,
     fetch: () => fetchWithTurboHeaders,
@@ -55712,9 +55713,9 @@
     return candidate?.type == "submit" ? candidate : null;
   }
   function clickCaptured(event) {
-    const submitter = findSubmitterFromClickTarget(event.target);
-    if (submitter && submitter.form) {
-      submittersByForm.set(submitter.form, submitter);
+    const submitter2 = findSubmitterFromClickTarget(event.target);
+    if (submitter2 && submitter2.form) {
+      submittersByForm.set(submitter2.form, submitter2);
     }
   }
   function frameLoadingStyleFromString(style2) {
@@ -55725,56 +55726,6 @@
         return FrameLoadingStyle.eager;
     }
   }
-  function expandURL(locatable) {
-    return new URL(locatable.toString(), document.baseURI);
-  }
-  function getAnchor(url) {
-    let anchorMatch;
-    if (url.hash) {
-      return url.hash.slice(1);
-    } else if (anchorMatch = url.href.match(/#(.*)$/)) {
-      return anchorMatch[1];
-    }
-  }
-  function getAction$1(form, submitter) {
-    const action = submitter?.getAttribute("formaction") || form.getAttribute("action") || form.action;
-    return expandURL(action);
-  }
-  function getExtension(url) {
-    return (getLastPathComponent(url).match(/\.[^.]*$/) || [])[0] || "";
-  }
-  function isHTML(url) {
-    return !!getExtension(url).match(/^(?:|\.(?:htm|html|xhtml|php))$/);
-  }
-  function isPrefixedBy(baseURL, url) {
-    const prefix = getPrefix(url);
-    return baseURL.href === expandURL(prefix).href || baseURL.href.startsWith(prefix);
-  }
-  function locationIsVisitable(location2, rootLocation) {
-    return isPrefixedBy(location2, rootLocation) && isHTML(location2);
-  }
-  function getRequestURL(url) {
-    const anchor = getAnchor(url);
-    return anchor != null ? url.href.slice(0, -(anchor.length + 1)) : url.href;
-  }
-  function toCacheKey(url) {
-    return getRequestURL(url);
-  }
-  function urlsAreEqual(left2, right2) {
-    return expandURL(left2).href == expandURL(right2).href;
-  }
-  function getPathComponents(url) {
-    return url.pathname.split("/").slice(1);
-  }
-  function getLastPathComponent(url) {
-    return getPathComponents(url).slice(-1)[0];
-  }
-  function getPrefix(url) {
-    return addTrailingSlash(url.origin + url.pathname);
-  }
-  function addTrailingSlash(value) {
-    return value.endsWith("/") ? value : value + "/";
-  }
   function activateScriptElement(element) {
     if (element.getAttribute("data-turbo-eval") == "false") {
       return element;
@@ -55814,6 +55765,10 @@
     }
     return event;
   }
+  function cancelEvent(event) {
+    event.preventDefault();
+    event.stopImmediatePropagation();
+  }
   function nextRepaint() {
     if (document.visibilityState === "hidden") {
       return nextEventLoopTick();
@@ -55975,6 +55930,53 @@
       timeoutId = setTimeout(callback2, delay);
     };
   }
+  function expandURL(locatable) {
+    return new URL(locatable.toString(), document.baseURI);
+  }
+  function getAnchor(url) {
+    let anchorMatch;
+    if (url.hash) {
+      return url.hash.slice(1);
+    } else if (anchorMatch = url.href.match(/#(.*)$/)) {
+      return anchorMatch[1];
+    }
+  }
+  function getAction$1(form, submitter2) {
+    const action = submitter2?.getAttribute("formaction") || form.getAttribute("action") || form.action;
+    return expandURL(action);
+  }
+  function getExtension(url) {
+    return (getLastPathComponent(url).match(/\.[^.]*$/) || [])[0] || "";
+  }
+  function isPrefixedBy(baseURL, url) {
+    const prefix = getPrefix(url);
+    return baseURL.href === expandURL(prefix).href || baseURL.href.startsWith(prefix);
+  }
+  function locationIsVisitable(location2, rootLocation) {
+    return isPrefixedBy(location2, rootLocation) && !config.drive.unvisitableExtensions.has(getExtension(location2));
+  }
+  function getRequestURL(url) {
+    const anchor = getAnchor(url);
+    return anchor != null ? url.href.slice(0, -(anchor.length + 1)) : url.href;
+  }
+  function toCacheKey(url) {
+    return getRequestURL(url);
+  }
+  function urlsAreEqual(left2, right2) {
+    return expandURL(left2).href == expandURL(right2).href;
+  }
+  function getPathComponents(url) {
+    return url.pathname.split("/").slice(1);
+  }
+  function getLastPathComponent(url) {
+    return getPathComponents(url).slice(-1)[0];
+  }
+  function getPrefix(url) {
+    return addTrailingSlash(url.origin + url.pathname);
+  }
+  function addTrailingSlash(value) {
+    return value.endsWith("/") ? value : value + "/";
+  }
   function fetchWithTurboHeaders(url, options = {}) {
     const modifiedHeaders = new Headers(options.headers || {});
     const requestUID = uuid();
@@ -56047,10 +56049,10 @@
     }
     return fragment;
   }
-  function buildFormData(formElement, submitter) {
+  function buildFormData(formElement, submitter2) {
     const formData = new FormData(formElement);
-    const name = submitter?.getAttribute("name");
-    const value = submitter?.getAttribute("value");
+    const name = submitter2?.getAttribute("name");
+    const value = submitter2?.getAttribute("value");
     if (name) {
       formData.append(name, value || "");
     }
@@ -56069,10 +56071,10 @@
   function responseSucceededWithoutRedirect(response) {
     return response.statusCode == 200 && !response.redirected;
   }
-  function getFormAction(formElement, submitter) {
+  function getFormAction(formElement, submitter2) {
     const formElementAction = typeof formElement.action === "string" ? formElement.action : null;
-    if (submitter?.hasAttribute("formaction")) {
-      return submitter.getAttribute("formaction") || "";
+    if (submitter2?.hasAttribute("formaction")) {
+      return submitter2.getAttribute("formaction") || "";
     } else {
       return formElement.getAttribute("action") || formElementAction || "";
     }
@@ -56084,12 +56086,12 @@
     }
     return action;
   }
-  function getMethod(formElement, submitter) {
-    const method = submitter?.getAttribute("formmethod") || formElement.getAttribute("method") || "";
+  function getMethod(formElement, submitter2) {
+    const method = submitter2?.getAttribute("formmethod") || formElement.getAttribute("method") || "";
     return fetchMethodFromString(method.toLowerCase()) || FetchMethod.get;
   }
-  function getEnctype(formElement, submitter) {
-    return fetchEnctypeFromString(submitter?.getAttribute("formenctype") || formElement.enctype);
+  function getEnctype(formElement, submitter2) {
+    return fetchEnctypeFromString(submitter2?.getAttribute("formenctype") || formElement.enctype);
   }
   function getPermanentElementById(node, id) {
     return node.querySelector(`#${id}[data-turbo-permanent]`);
@@ -56097,12 +56099,12 @@
   function queryPermanentElementsAll(node) {
     return node.querySelectorAll("[id][data-turbo-permanent]");
   }
-  function submissionDoesNotDismissDialog(form, submitter) {
-    const method = submitter?.getAttribute("formmethod") || form.getAttribute("method");
+  function submissionDoesNotDismissDialog(form, submitter2) {
+    const method = submitter2?.getAttribute("formmethod") || form.getAttribute("method");
     return method != "dialog";
   }
-  function submissionDoesNotTargetIFrame(form, submitter) {
-    const target = submitter?.getAttribute("formtarget") || form.getAttribute("target");
+  function submissionDoesNotTargetIFrame(form, submitter2) {
+    const target = submitter2?.getAttribute("formtarget") || form.getAttribute("target");
     return doesNotTargetIFrame(target);
   }
   function createPlaceholderForPermanentElement(permanentElement) {
@@ -56125,6 +56127,17 @@
       return defaultValue;
     }
   }
+  function morphElements(currentElement, newElement, { callbacks, ...options } = {}) {
+    Idiomorph.morph(currentElement, newElement, {
+      ...options,
+      callbacks: new DefaultIdiomorphCallbacks(callbacks)
+    });
+  }
+  function morphChildren(currentElement, newElement) {
+    morphElements(currentElement, newElement.children, {
+      morphStyle: "innerHTML"
+    });
+  }
   function elementType(element) {
     if (elementIsScript(element)) {
       return "script";
@@ -56228,26 +56241,9 @@
     const contentType = response.contentType ?? "";
     return contentType.startsWith(StreamMessage.contentType);
   }
-  function morphElements(currentElement, newElement, { callbacks, ...options } = {}) {
-    Idiomorph.morph(currentElement, newElement, {
-      ...options,
-      callbacks: new DefaultIdiomorphCallbacks(callbacks)
-    });
-  }
-  function morphChildren(currentElement, newElement) {
-    morphElements(currentElement, newElement.children, {
-      morphStyle: "innerHTML"
-    });
-  }
   function canRefreshFrame(frame) {
     return frame instanceof FrameElement && frame.src && frame.refresh === "morph" && !frame.closest("[data-turbo-permanent]");
   }
-  function refreshFrame(frame) {
-    frame.addEventListener("turbo:before-frame-render", ({ detail }) => {
-      detail.render = MorphingFrameRenderer.renderElement;
-    }, { once: true });
-    frame.reload();
-  }
   function extendURLWithDeprecatedProperties(url) {
     Object.defineProperties(url, deprecatedLocationPropertyDescriptors);
   }
@@ -56276,13 +56272,22 @@
     session.clearCache();
   }
   function setProgressBarDelay(delay) {
-    session.setProgressBarDelay(delay);
+    console.warn(
+      "Please replace `Turbo.setProgressBarDelay(delay)` with `Turbo.config.drive.progressBarDelay = delay`. The top-level function is deprecated and will be removed in a future version of Turbo.`"
+    );
+    config.drive.progressBarDelay = delay;
   }
   function setConfirmMethod(confirmMethod) {
-    FormSubmission.confirmMethod = confirmMethod;
+    console.warn(
+      "Please replace `Turbo.setConfirmMethod(confirmMethod)` with `Turbo.config.forms.confirm = confirmMethod`. The top-level function is deprecated and will be removed in a future version of Turbo.`"
+    );
+    config.forms.confirm = confirmMethod;
   }
   function setFormMode(mode) {
-    session.setFormMode(mode);
+    console.warn(
+      "Please replace `Turbo.setFormMode(mode)` with `Turbo.config.forms.mode = mode`. The top-level function is deprecated and will be removed in a future version of Turbo.`"
+    );
+    config.forms.mode = mode;
   }
   function getFrameElementById(id) {
     if (id != null) {
@@ -56308,29 +56313,29 @@
       }
     }
   }
-  var submittersByForm, FrameLoadingStyle, _FrameElement, FrameElement, FetchResponse, LimitedSet, recentRequests, nativeFetch, FetchMethod, FetchEnctype, FetchRequest, AppearanceObserver, StreamMessage, PREFETCH_DELAY, PrefetchCache, cacheTtl, prefetchCache, FormSubmissionState, FormSubmission, Snapshot, FormSubmitObserver, View, FrameView, LinkInterceptor, LinkClickObserver, FormLinkClickObserver, Bardo, Renderer, FrameRenderer, _ProgressBar, ProgressBar, HeadSnapshot, PageSnapshot, ViewTransitioner, defaultOptions, TimingMetric, VisitState, SystemStatusCode, Direction, Visit, BrowserAdapter, CacheObserver, FrameRedirector, History, LinkPrefetchObserver, unfetchableLink, linkToTheSamePage, linkOptsOut, nonSafeLink, isUJS, eventPrevented, Navigator, PageStage, PageObserver, ScrollObserver, StreamMessageRenderer, StreamObserver, ErrorRenderer, Idiomorph, DefaultIdiomorphCallbacks, MorphingFrameRenderer, PageRenderer, MorphingPageRenderer, SnapshotCache, PageView, Preloader, Cache, Session, deprecatedLocationPropertyDescriptors, session, cache, navigator$1, Turbo, TurboFrameMissingError, FrameController, StreamActions, StreamElement, StreamSourceElement;
+  var submittersByForm, FrameLoadingStyle, _FrameElement, FrameElement, drive, submitter, Config2, forms, config, FetchResponse, LimitedSet, recentRequests, nativeFetch, FetchMethod, FetchEnctype, FetchRequest, AppearanceObserver, StreamMessage, PREFETCH_DELAY, PrefetchCache, cacheTtl, prefetchCache, FormSubmissionState, FormSubmission, Snapshot, FormSubmitObserver, View, FrameView, LinkInterceptor, LinkClickObserver, FormLinkClickObserver, Bardo, Renderer, FrameRenderer, Idiomorph, DefaultIdiomorphCallbacks, MorphingFrameRenderer, _ProgressBar, ProgressBar, HeadSnapshot, PageSnapshot, ViewTransitioner, defaultOptions, TimingMetric, VisitState, SystemStatusCode, Direction, Visit, BrowserAdapter, CacheObserver, FrameRedirector, History, LinkPrefetchObserver, unfetchableLink, linkToTheSamePage, linkOptsOut, nonSafeLink, isUJS, eventPrevented, Navigator, PageStage, PageObserver, ScrollObserver, StreamMessageRenderer, StreamObserver, ErrorRenderer, PageRenderer, MorphingPageRenderer, SnapshotCache, PageView, Preloader, Cache, Session, deprecatedLocationPropertyDescriptors, session, cache, navigator$1, Turbo, TurboFrameMissingError, FrameController, StreamActions, StreamElement, StreamSourceElement;
   var init_turbo_es2017_esm = __esm({
     "node_modules/@hotwired/turbo/dist/turbo.es2017-esm.js"() {
       (function(prototype) {
         if (typeof prototype.requestSubmit == "function")
           return;
-        prototype.requestSubmit = function(submitter) {
-          if (submitter) {
-            validateSubmitter(submitter, this);
-            submitter.click();
+        prototype.requestSubmit = function(submitter2) {
+          if (submitter2) {
+            validateSubmitter(submitter2, this);
+            submitter2.click();
           } else {
-            submitter = document.createElement("input");
-            submitter.type = "submit";
-            submitter.hidden = true;
-            this.appendChild(submitter);
-            submitter.click();
-            this.removeChild(submitter);
+            submitter2 = document.createElement("input");
+            submitter2.type = "submit";
+            submitter2.hidden = true;
+            this.appendChild(submitter2);
+            submitter2.click();
+            this.removeChild(submitter2);
           }
         };
-        function validateSubmitter(submitter, form) {
-          submitter instanceof HTMLElement || raise(TypeError, "parameter 1 is not of type 'HTMLElement'");
-          submitter.type == "submit" || raise(TypeError, "The specified element is not a submit button");
-          submitter.form == form || raise(DOMException, "The specified element is not owned by this form element", "NotFoundError");
+        function validateSubmitter(submitter2, form) {
+          submitter2 instanceof HTMLElement || raise(TypeError, "parameter 1 is not of type 'HTMLElement'");
+          submitter2.type == "submit" || raise(TypeError, "The specified element is not a submit button");
+          submitter2.form == form || raise(DOMException, "The specified element is not owned by this form element", "NotFoundError");
         }
         function raise(errorConstructor, message, name) {
           throw new errorConstructor("Failed to execute 'requestSubmit' on 'HTMLFormElement': " + message + ".", name);
@@ -56409,6 +56414,9 @@
             this.removeAttribute("refresh");
           }
         }
+        get shouldReloadWithMorph() {
+          return this.src && this.refresh === "morph";
+        }
         get loading() {
           return frameLoadingStyleFromString(this.getAttribute("loading") || "");
         }
@@ -56451,6 +56459,104 @@
       };
       FrameElement = _FrameElement;
       __publicField(FrameElement, "delegateConstructor");
+      drive = {
+        enabled: true,
+        progressBarDelay: 500,
+        unvisitableExtensions: /* @__PURE__ */ new Set(
+          [
+            ".7z",
+            ".aac",
+            ".apk",
+            ".avi",
+            ".bmp",
+            ".bz2",
+            ".css",
+            ".csv",
+            ".deb",
+            ".dmg",
+            ".doc",
+            ".docx",
+            ".exe",
+            ".gif",
+            ".gz",
+            ".heic",
+            ".heif",
+            ".ico",
+            ".iso",
+            ".jpeg",
+            ".jpg",
+            ".js",
+            ".json",
+            ".m4a",
+            ".mkv",
+            ".mov",
+            ".mp3",
+            ".mp4",
+            ".mpeg",
+            ".mpg",
+            ".msi",
+            ".ogg",
+            ".ogv",
+            ".pdf",
+            ".pkg",
+            ".png",
+            ".ppt",
+            ".pptx",
+            ".rar",
+            ".rtf",
+            ".svg",
+            ".tar",
+            ".tif",
+            ".tiff",
+            ".txt",
+            ".wav",
+            ".webm",
+            ".webp",
+            ".wma",
+            ".wmv",
+            ".xls",
+            ".xlsx",
+            ".xml",
+            ".zip"
+          ]
+        )
+      };
+      submitter = {
+        "aria-disabled": {
+          beforeSubmit: (submitter2) => {
+            submitter2.setAttribute("aria-disabled", "true");
+            submitter2.addEventListener("click", cancelEvent);
+          },
+          afterSubmit: (submitter2) => {
+            submitter2.removeAttribute("aria-disabled");
+            submitter2.removeEventListener("click", cancelEvent);
+          }
+        },
+        "disabled": {
+          beforeSubmit: (submitter2) => submitter2.disabled = true,
+          afterSubmit: (submitter2) => submitter2.disabled = false
+        }
+      };
+      Config2 = class {
+        #submitter = null;
+        constructor(config2) {
+          Object.assign(this, config2);
+        }
+        get submitter() {
+          return this.#submitter;
+        }
+        set submitter(value) {
+          this.#submitter = submitter[value] || value;
+        }
+      };
+      forms = new Config2({
+        mode: "on",
+        submitter: "disabled"
+      });
+      config = {
+        drive,
+        forms
+      };
       FetchResponse = class {
         constructor(response) {
           this.response = response;
@@ -56740,17 +56846,17 @@
       };
       FormSubmission = class {
         state = FormSubmissionState.initialized;
-        static confirmMethod(message, _element, _submitter) {
+        static confirmMethod(message) {
           return Promise.resolve(confirm(message));
         }
-        constructor(delegate, formElement, submitter, mustRedirect = false) {
-          const method = getMethod(formElement, submitter);
-          const action = getAction(getFormAction(formElement, submitter), method);
-          const body = buildFormData(formElement, submitter);
-          const enctype = getEnctype(formElement, submitter);
+        constructor(delegate, formElement, submitter2, mustRedirect = false) {
+          const method = getMethod(formElement, submitter2);
+          const action = getAction(getFormAction(formElement, submitter2), method);
+          const body = buildFormData(formElement, submitter2);
+          const enctype = getEnctype(formElement, submitter2);
           this.delegate = delegate;
           this.formElement = formElement;
-          this.submitter = submitter;
+          this.submitter = submitter2;
           this.fetchRequest = new FetchRequest(this, method, action, body, formElement, enctype);
           this.mustRedirect = mustRedirect;
         }
@@ -56782,7 +56888,8 @@
           const { initialized, requesting } = FormSubmissionState;
           const confirmationMessage = getAttribute("data-turbo-confirm", this.submitter, this.formElement);
           if (typeof confirmationMessage === "string") {
-            const answer = await FormSubmission.confirmMethod(confirmationMessage, this.formElement, this.submitter);
+            const confirmMethod = typeof config.forms.confirm === "function" ? config.forms.confirm : FormSubmission.confirmMethod;
+            const answer = await confirmMethod(confirmationMessage, this.formElement, this.submitter);
             if (!answer) {
               return;
             }
@@ -56813,7 +56920,8 @@
         }
         requestStarted(_request) {
           this.state = FormSubmissionState.waiting;
-          this.submitter?.setAttribute("disabled", "");
+          if (this.submitter)
+            config.forms.submitter.beforeSubmit(this.submitter);
           this.setSubmitsWith();
           markAsBusy(this.formElement);
           dispatch("turbo:submit-start", {
@@ -56851,7 +56959,8 @@
         }
         requestFinished(_request) {
           this.state = FormSubmissionState.stopped;
-          this.submitter?.removeAttribute("disabled");
+          if (this.submitter)
+            config.forms.submitter.afterSubmit(this.submitter);
           this.resetSubmitterText();
           clearBusyState(this.formElement);
           dispatch("turbo:submit-end", {
@@ -56957,11 +57066,11 @@
         submitBubbled = (event) => {
           if (!event.defaultPrevented) {
             const form = event.target instanceof HTMLFormElement ? event.target : void 0;
-            const submitter = event.submitter || void 0;
-            if (form && submissionDoesNotDismissDialog(form, submitter) && submissionDoesNotTargetIFrame(form, submitter) && this.delegate.willSubmitForm(form, submitter)) {
+            const submitter2 = event.submitter || void 0;
+            if (form && submissionDoesNotDismissDialog(form, submitter2) && submissionDoesNotTargetIFrame(form, submitter2) && this.delegate.willSubmitForm(form, submitter2)) {
               event.preventDefault();
               event.stopImmediatePropagation();
-              this.delegate.formSubmitted(form, submitter);
+              this.delegate.formSubmitted(form, submitter2);
             }
           }
         };
@@ -57249,12 +57358,14 @@
       };
       Renderer = class {
         #activeElement = null;
-        constructor(currentSnapshot, newSnapshot, renderElement, isPreview, willRender = true) {
+        static renderElement(currentElement, newElement) {
+        }
+        constructor(currentSnapshot, newSnapshot, isPreview, willRender = true) {
           this.currentSnapshot = currentSnapshot;
           this.newSnapshot = newSnapshot;
           this.isPreview = isPreview;
           this.willRender = willRender;
-          this.renderElement = renderElement;
+          this.renderElement = this.constructor.renderElement;
           this.promise = new Promise((resolve3, reject) => this.resolvingFunctions = { resolve: resolve3, reject });
         }
         get shouldRender() {
@@ -57373,6 +57484,607 @@
           return this.currentElement.querySelectorAll("script");
         }
       };
+      Idiomorph = function() {
+        let EMPTY_SET = /* @__PURE__ */ new Set();
+        let defaults4 = {
+          morphStyle: "outerHTML",
+          callbacks: {
+            beforeNodeAdded: noOp,
+            afterNodeAdded: noOp,
+            beforeNodeMorphed: noOp,
+            afterNodeMorphed: noOp,
+            beforeNodeRemoved: noOp,
+            afterNodeRemoved: noOp,
+            beforeAttributeUpdated: noOp
+          },
+          head: {
+            style: "merge",
+            shouldPreserve: function(elt) {
+              return elt.getAttribute("im-preserve") === "true";
+            },
+            shouldReAppend: function(elt) {
+              return elt.getAttribute("im-re-append") === "true";
+            },
+            shouldRemove: noOp,
+            afterHeadMorphed: noOp
+          }
+        };
+        function morph2(oldNode, newContent, config2 = {}) {
+          if (oldNode instanceof Document) {
+            oldNode = oldNode.documentElement;
+          }
+          if (typeof newContent === "string") {
+            newContent = parseContent(newContent);
+          }
+          let normalizedContent = normalizeContent(newContent);
+          let ctx = createMorphContext(oldNode, normalizedContent, config2);
+          return morphNormalizedContent(oldNode, normalizedContent, ctx);
+        }
+        function morphNormalizedContent(oldNode, normalizedNewContent, ctx) {
+          if (ctx.head.block) {
+            let oldHead = oldNode.querySelector("head");
+            let newHead = normalizedNewContent.querySelector("head");
+            if (oldHead && newHead) {
+              let promises = handleHeadElement(newHead, oldHead, ctx);
+              Promise.all(promises).then(function() {
+                morphNormalizedContent(oldNode, normalizedNewContent, Object.assign(ctx, {
+                  head: {
+                    block: false,
+                    ignore: true
+                  }
+                }));
+              });
+              return;
+            }
+          }
+          if (ctx.morphStyle === "innerHTML") {
+            morphChildren2(normalizedNewContent, oldNode, ctx);
+            return oldNode.children;
+          } else if (ctx.morphStyle === "outerHTML" || ctx.morphStyle == null) {
+            let bestMatch = findBestNodeMatch(normalizedNewContent, oldNode, ctx);
+            let previousSibling = bestMatch?.previousSibling;
+            let nextSibling = bestMatch?.nextSibling;
+            let morphedNode = morphOldNodeTo(oldNode, bestMatch, ctx);
+            if (bestMatch) {
+              return insertSiblings(previousSibling, morphedNode, nextSibling);
+            } else {
+              return [];
+            }
+          } else {
+            throw "Do not understand how to morph style " + ctx.morphStyle;
+          }
+        }
+        function ignoreValueOfActiveElement(possibleActiveElement, ctx) {
+          return ctx.ignoreActiveValue && possibleActiveElement === document.activeElement && possibleActiveElement !== document.body;
+        }
+        function morphOldNodeTo(oldNode, newContent, ctx) {
+          if (ctx.ignoreActive && oldNode === document.activeElement)
+            ;
+          else if (newContent == null) {
+            if (ctx.callbacks.beforeNodeRemoved(oldNode) === false)
+              return oldNode;
+            oldNode.remove();
+            ctx.callbacks.afterNodeRemoved(oldNode);
+            return null;
+          } else if (!isSoftMatch(oldNode, newContent)) {
+            if (ctx.callbacks.beforeNodeRemoved(oldNode) === false)
+              return oldNode;
+            if (ctx.callbacks.beforeNodeAdded(newContent) === false)
+              return oldNode;
+            oldNode.parentElement.replaceChild(newContent, oldNode);
+            ctx.callbacks.afterNodeAdded(newContent);
+            ctx.callbacks.afterNodeRemoved(oldNode);
+            return newContent;
+          } else {
+            if (ctx.callbacks.beforeNodeMorphed(oldNode, newContent) === false)
+              return oldNode;
+            if (oldNode instanceof HTMLHeadElement && ctx.head.ignore)
+              ;
+            else if (oldNode instanceof HTMLHeadElement && ctx.head.style !== "morph") {
+              handleHeadElement(newContent, oldNode, ctx);
+            } else {
+              syncNodeFrom(newContent, oldNode, ctx);
+              if (!ignoreValueOfActiveElement(oldNode, ctx)) {
+                morphChildren2(newContent, oldNode, ctx);
+              }
+            }
+            ctx.callbacks.afterNodeMorphed(oldNode, newContent);
+            return oldNode;
+          }
+        }
+        function morphChildren2(newParent, oldParent, ctx) {
+          let nextNewChild = newParent.firstChild;
+          let insertionPoint = oldParent.firstChild;
+          let newChild;
+          while (nextNewChild) {
+            newChild = nextNewChild;
+            nextNewChild = newChild.nextSibling;
+            if (insertionPoint == null) {
+              if (ctx.callbacks.beforeNodeAdded(newChild) === false)
+                return;
+              oldParent.appendChild(newChild);
+              ctx.callbacks.afterNodeAdded(newChild);
+              removeIdsFromConsideration(ctx, newChild);
+              continue;
+            }
+            if (isIdSetMatch(newChild, insertionPoint, ctx)) {
+              morphOldNodeTo(insertionPoint, newChild, ctx);
+              insertionPoint = insertionPoint.nextSibling;
+              removeIdsFromConsideration(ctx, newChild);
+              continue;
+            }
+            let idSetMatch = findIdSetMatch(newParent, oldParent, newChild, insertionPoint, ctx);
+            if (idSetMatch) {
+              insertionPoint = removeNodesBetween(insertionPoint, idSetMatch, ctx);
+              morphOldNodeTo(idSetMatch, newChild, ctx);
+              removeIdsFromConsideration(ctx, newChild);
+              continue;
+            }
+            let softMatch = findSoftMatch(newParent, oldParent, newChild, insertionPoint, ctx);
+            if (softMatch) {
+              insertionPoint = removeNodesBetween(insertionPoint, softMatch, ctx);
+              morphOldNodeTo(softMatch, newChild, ctx);
+              removeIdsFromConsideration(ctx, newChild);
+              continue;
+            }
+            if (ctx.callbacks.beforeNodeAdded(newChild) === false)
+              return;
+            oldParent.insertBefore(newChild, insertionPoint);
+            ctx.callbacks.afterNodeAdded(newChild);
+            removeIdsFromConsideration(ctx, newChild);
+          }
+          while (insertionPoint !== null) {
+            let tempNode = insertionPoint;
+            insertionPoint = insertionPoint.nextSibling;
+            removeNode(tempNode, ctx);
+          }
+        }
+        function ignoreAttribute(attr, to, updateType, ctx) {
+          if (attr === "value" && ctx.ignoreActiveValue && to === document.activeElement) {
+            return true;
+          }
+          return ctx.callbacks.beforeAttributeUpdated(attr, to, updateType) === false;
+        }
+        function syncNodeFrom(from, to, ctx) {
+          let type = from.nodeType;
+          if (type === 1) {
+            const fromAttributes = from.attributes;
+            const toAttributes = to.attributes;
+            for (const fromAttribute of fromAttributes) {
+              if (ignoreAttribute(fromAttribute.name, to, "update", ctx)) {
+                continue;
+              }
+              if (to.getAttribute(fromAttribute.name) !== fromAttribute.value) {
+                to.setAttribute(fromAttribute.name, fromAttribute.value);
+              }
+            }
+            for (let i5 = toAttributes.length - 1; 0 <= i5; i5--) {
+              const toAttribute = toAttributes[i5];
+              if (ignoreAttribute(toAttribute.name, to, "remove", ctx)) {
+                continue;
+              }
+              if (!from.hasAttribute(toAttribute.name)) {
+                to.removeAttribute(toAttribute.name);
+              }
+            }
+          }
+          if (type === 8 || type === 3) {
+            if (to.nodeValue !== from.nodeValue) {
+              to.nodeValue = from.nodeValue;
+            }
+          }
+          if (!ignoreValueOfActiveElement(to, ctx)) {
+            syncInputValue(from, to, ctx);
+          }
+        }
+        function syncBooleanAttribute(from, to, attributeName, ctx) {
+          if (from[attributeName] !== to[attributeName]) {
+            let ignoreUpdate = ignoreAttribute(attributeName, to, "update", ctx);
+            if (!ignoreUpdate) {
+              to[attributeName] = from[attributeName];
+            }
+            if (from[attributeName]) {
+              if (!ignoreUpdate) {
+                to.setAttribute(attributeName, from[attributeName]);
+              }
+            } else {
+              if (!ignoreAttribute(attributeName, to, "remove", ctx)) {
+                to.removeAttribute(attributeName);
+              }
+            }
+          }
+        }
+        function syncInputValue(from, to, ctx) {
+          if (from instanceof HTMLInputElement && to instanceof HTMLInputElement && from.type !== "file") {
+            let fromValue = from.value;
+            let toValue = to.value;
+            syncBooleanAttribute(from, to, "checked", ctx);
+            syncBooleanAttribute(from, to, "disabled", ctx);
+            if (!from.hasAttribute("value")) {
+              if (!ignoreAttribute("value", to, "remove", ctx)) {
+                to.value = "";
+                to.removeAttribute("value");
+              }
+            } else if (fromValue !== toValue) {
+              if (!ignoreAttribute("value", to, "update", ctx)) {
+                to.setAttribute("value", fromValue);
+                to.value = fromValue;
+              }
+            }
+          } else if (from instanceof HTMLOptionElement) {
+            syncBooleanAttribute(from, to, "selected", ctx);
+          } else if (from instanceof HTMLTextAreaElement && to instanceof HTMLTextAreaElement) {
+            let fromValue = from.value;
+            let toValue = to.value;
+            if (ignoreAttribute("value", to, "update", ctx)) {
+              return;
+            }
+            if (fromValue !== toValue) {
+              to.value = fromValue;
+            }
+            if (to.firstChild && to.firstChild.nodeValue !== fromValue) {
+              to.firstChild.nodeValue = fromValue;
+            }
+          }
+        }
+        function handleHeadElement(newHeadTag, currentHead, ctx) {
+          let added = [];
+          let removed = [];
+          let preserved = [];
+          let nodesToAppend = [];
+          let headMergeStyle = ctx.head.style;
+          let srcToNewHeadNodes = /* @__PURE__ */ new Map();
+          for (const newHeadChild of newHeadTag.children) {
+            srcToNewHeadNodes.set(newHeadChild.outerHTML, newHeadChild);
+          }
+          for (const currentHeadElt of currentHead.children) {
+            let inNewContent = srcToNewHeadNodes.has(currentHeadElt.outerHTML);
+            let isReAppended = ctx.head.shouldReAppend(currentHeadElt);
+            let isPreserved = ctx.head.shouldPreserve(currentHeadElt);
+            if (inNewContent || isPreserved) {
+              if (isReAppended) {
+                removed.push(currentHeadElt);
+              } else {
+                srcToNewHeadNodes.delete(currentHeadElt.outerHTML);
+                preserved.push(currentHeadElt);
+              }
+            } else {
+              if (headMergeStyle === "append") {
+                if (isReAppended) {
+                  removed.push(currentHeadElt);
+                  nodesToAppend.push(currentHeadElt);
+                }
+              } else {
+                if (ctx.head.shouldRemove(currentHeadElt) !== false) {
+                  removed.push(currentHeadElt);
+                }
+              }
+            }
+          }
+          nodesToAppend.push(...srcToNewHeadNodes.values());
+          let promises = [];
+          for (const newNode of nodesToAppend) {
+            let newElt = document.createRange().createContextualFragment(newNode.outerHTML).firstChild;
+            if (ctx.callbacks.beforeNodeAdded(newElt) !== false) {
+              if (newElt.href || newElt.src) {
+                let resolve3 = null;
+                let promise = new Promise(function(_resolve2) {
+                  resolve3 = _resolve2;
+                });
+                newElt.addEventListener("load", function() {
+                  resolve3();
+                });
+                promises.push(promise);
+              }
+              currentHead.appendChild(newElt);
+              ctx.callbacks.afterNodeAdded(newElt);
+              added.push(newElt);
+            }
+          }
+          for (const removedElement of removed) {
+            if (ctx.callbacks.beforeNodeRemoved(removedElement) !== false) {
+              currentHead.removeChild(removedElement);
+              ctx.callbacks.afterNodeRemoved(removedElement);
+            }
+          }
+          ctx.head.afterHeadMorphed(currentHead, { added, kept: preserved, removed });
+          return promises;
+        }
+        function noOp() {
+        }
+        function mergeDefaults(config2) {
+          let finalConfig = {};
+          Object.assign(finalConfig, defaults4);
+          Object.assign(finalConfig, config2);
+          finalConfig.callbacks = {};
+          Object.assign(finalConfig.callbacks, defaults4.callbacks);
+          Object.assign(finalConfig.callbacks, config2.callbacks);
+          finalConfig.head = {};
+          Object.assign(finalConfig.head, defaults4.head);
+          Object.assign(finalConfig.head, config2.head);
+          return finalConfig;
+        }
+        function createMorphContext(oldNode, newContent, config2) {
+          config2 = mergeDefaults(config2);
+          return {
+            target: oldNode,
+            newContent,
+            config: config2,
+            morphStyle: config2.morphStyle,
+            ignoreActive: config2.ignoreActive,
+            ignoreActiveValue: config2.ignoreActiveValue,
+            idMap: createIdMap(oldNode, newContent),
+            deadIds: /* @__PURE__ */ new Set(),
+            callbacks: config2.callbacks,
+            head: config2.head
+          };
+        }
+        function isIdSetMatch(node1, node2, ctx) {
+          if (node1 == null || node2 == null) {
+            return false;
+          }
+          if (node1.nodeType === node2.nodeType && node1.tagName === node2.tagName) {
+            if (node1.id !== "" && node1.id === node2.id) {
+              return true;
+            } else {
+              return getIdIntersectionCount(ctx, node1, node2) > 0;
+            }
+          }
+          return false;
+        }
+        function isSoftMatch(node1, node2) {
+          if (node1 == null || node2 == null) {
+            return false;
+          }
+          return node1.nodeType === node2.nodeType && node1.tagName === node2.tagName;
+        }
+        function removeNodesBetween(startInclusive, endExclusive, ctx) {
+          while (startInclusive !== endExclusive) {
+            let tempNode = startInclusive;
+            startInclusive = startInclusive.nextSibling;
+            removeNode(tempNode, ctx);
+          }
+          removeIdsFromConsideration(ctx, endExclusive);
+          return endExclusive.nextSibling;
+        }
+        function findIdSetMatch(newContent, oldParent, newChild, insertionPoint, ctx) {
+          let newChildPotentialIdCount = getIdIntersectionCount(ctx, newChild, oldParent);
+          let potentialMatch = null;
+          if (newChildPotentialIdCount > 0) {
+            let potentialMatch2 = insertionPoint;
+            let otherMatchCount = 0;
+            while (potentialMatch2 != null) {
+              if (isIdSetMatch(newChild, potentialMatch2, ctx)) {
+                return potentialMatch2;
+              }
+              otherMatchCount += getIdIntersectionCount(ctx, potentialMatch2, newContent);
+              if (otherMatchCount > newChildPotentialIdCount) {
+                return null;
+              }
+              potentialMatch2 = potentialMatch2.nextSibling;
+            }
+          }
+          return potentialMatch;
+        }
+        function findSoftMatch(newContent, oldParent, newChild, insertionPoint, ctx) {
+          let potentialSoftMatch = insertionPoint;
+          let nextSibling = newChild.nextSibling;
+          let siblingSoftMatchCount = 0;
+          while (potentialSoftMatch != null) {
+            if (getIdIntersectionCount(ctx, potentialSoftMatch, newContent) > 0) {
+              return null;
+            }
+            if (isSoftMatch(newChild, potentialSoftMatch)) {
+              return potentialSoftMatch;
+            }
+            if (isSoftMatch(nextSibling, potentialSoftMatch)) {
+              siblingSoftMatchCount++;
+              nextSibling = nextSibling.nextSibling;
+              if (siblingSoftMatchCount >= 2) {
+                return null;
+              }
+            }
+            potentialSoftMatch = potentialSoftMatch.nextSibling;
+          }
+          return potentialSoftMatch;
+        }
+        function parseContent(newContent) {
+          let parser = new DOMParser();
+          let contentWithSvgsRemoved = newContent.replace(/<svg(\s[^>]*>|>)([\s\S]*?)<\/svg>/gim, "");
+          if (contentWithSvgsRemoved.match(/<\/html>/) || contentWithSvgsRemoved.match(/<\/head>/) || contentWithSvgsRemoved.match(/<\/body>/)) {
+            let content = parser.parseFromString(newContent, "text/html");
+            if (contentWithSvgsRemoved.match(/<\/html>/)) {
+              content.generatedByIdiomorph = true;
+              return content;
+            } else {
+              let htmlElement = content.firstChild;
+              if (htmlElement) {
+                htmlElement.generatedByIdiomorph = true;
+                return htmlElement;
+              } else {
+                return null;
+              }
+            }
+          } else {
+            let responseDoc = parser.parseFromString("<body><template>" + newContent + "</template></body>", "text/html");
+            let content = responseDoc.body.querySelector("template").content;
+            content.generatedByIdiomorph = true;
+            return content;
+          }
+        }
+        function normalizeContent(newContent) {
+          if (newContent == null) {
+            const dummyParent = document.createElement("div");
+            return dummyParent;
+          } else if (newContent.generatedByIdiomorph) {
+            return newContent;
+          } else if (newContent instanceof Node) {
+            const dummyParent = document.createElement("div");
+            dummyParent.append(newContent);
+            return dummyParent;
+          } else {
+            const dummyParent = document.createElement("div");
+            for (const elt of [...newContent]) {
+              dummyParent.append(elt);
+            }
+            return dummyParent;
+          }
+        }
+        function insertSiblings(previousSibling, morphedNode, nextSibling) {
+          let stack = [];
+          let added = [];
+          while (previousSibling != null) {
+            stack.push(previousSibling);
+            previousSibling = previousSibling.previousSibling;
+          }
+          while (stack.length > 0) {
+            let node = stack.pop();
+            added.push(node);
+            morphedNode.parentElement.insertBefore(node, morphedNode);
+          }
+          added.push(morphedNode);
+          while (nextSibling != null) {
+            stack.push(nextSibling);
+            added.push(nextSibling);
+            nextSibling = nextSibling.nextSibling;
+          }
+          while (stack.length > 0) {
+            morphedNode.parentElement.insertBefore(stack.pop(), morphedNode.nextSibling);
+          }
+          return added;
+        }
+        function findBestNodeMatch(newContent, oldNode, ctx) {
+          let currentElement;
+          currentElement = newContent.firstChild;
+          let bestElement = currentElement;
+          let score = 0;
+          while (currentElement) {
+            let newScore = scoreElement(currentElement, oldNode, ctx);
+            if (newScore > score) {
+              bestElement = currentElement;
+              score = newScore;
+            }
+            currentElement = currentElement.nextSibling;
+          }
+          return bestElement;
+        }
+        function scoreElement(node1, node2, ctx) {
+          if (isSoftMatch(node1, node2)) {
+            return 0.5 + getIdIntersectionCount(ctx, node1, node2);
+          }
+          return 0;
+        }
+        function removeNode(tempNode, ctx) {
+          removeIdsFromConsideration(ctx, tempNode);
+          if (ctx.callbacks.beforeNodeRemoved(tempNode) === false)
+            return;
+          tempNode.remove();
+          ctx.callbacks.afterNodeRemoved(tempNode);
+        }
+        function isIdInConsideration(ctx, id) {
+          return !ctx.deadIds.has(id);
+        }
+        function idIsWithinNode(ctx, id, targetNode) {
+          let idSet = ctx.idMap.get(targetNode) || EMPTY_SET;
+          return idSet.has(id);
+        }
+        function removeIdsFromConsideration(ctx, node) {
+          let idSet = ctx.idMap.get(node) || EMPTY_SET;
+          for (const id of idSet) {
+            ctx.deadIds.add(id);
+          }
+        }
+        function getIdIntersectionCount(ctx, node1, node2) {
+          let sourceSet = ctx.idMap.get(node1) || EMPTY_SET;
+          let matchCount = 0;
+          for (const id of sourceSet) {
+            if (isIdInConsideration(ctx, id) && idIsWithinNode(ctx, id, node2)) {
+              ++matchCount;
+            }
+          }
+          return matchCount;
+        }
+        function populateIdMapForNode(node, idMap) {
+          let nodeParent = node.parentElement;
+          let idElements = node.querySelectorAll("[id]");
+          for (const elt of idElements) {
+            let current = elt;
+            while (current !== nodeParent && current != null) {
+              let idSet = idMap.get(current);
+              if (idSet == null) {
+                idSet = /* @__PURE__ */ new Set();
+                idMap.set(current, idSet);
+              }
+              idSet.add(elt.id);
+              current = current.parentElement;
+            }
+          }
+        }
+        function createIdMap(oldContent, newContent) {
+          let idMap = /* @__PURE__ */ new Map();
+          populateIdMapForNode(oldContent, idMap);
+          populateIdMapForNode(newContent, idMap);
+          return idMap;
+        }
+        return {
+          morph: morph2,
+          defaults: defaults4
+        };
+      }();
+      DefaultIdiomorphCallbacks = class {
+        #beforeNodeMorphed;
+        constructor({ beforeNodeMorphed } = {}) {
+          this.#beforeNodeMorphed = beforeNodeMorphed || (() => true);
+        }
+        beforeNodeAdded = (node) => {
+          return !(node.id && node.hasAttribute("data-turbo-permanent") && document.getElementById(node.id));
+        };
+        beforeNodeMorphed = (currentElement, newElement) => {
+          if (currentElement instanceof Element) {
+            if (!currentElement.hasAttribute("data-turbo-permanent") && this.#beforeNodeMorphed(currentElement, newElement)) {
+              const event = dispatch("turbo:before-morph-element", {
+                cancelable: true,
+                target: currentElement,
+                detail: { currentElement, newElement }
+              });
+              return !event.defaultPrevented;
+            } else {
+              return false;
+            }
+          }
+        };
+        beforeAttributeUpdated = (attributeName, target, mutationType) => {
+          const event = dispatch("turbo:before-morph-attribute", {
+            cancelable: true,
+            target,
+            detail: { attributeName, mutationType }
+          });
+          return !event.defaultPrevented;
+        };
+        beforeNodeRemoved = (node) => {
+          return this.beforeNodeMorphed(node);
+        };
+        afterNodeMorphed = (currentElement, newElement) => {
+          if (currentElement instanceof Element) {
+            dispatch("turbo:morph-element", {
+              target: currentElement,
+              detail: { currentElement, newElement }
+            });
+          }
+        };
+      };
+      MorphingFrameRenderer = class extends FrameRenderer {
+        static renderElement(currentElement, newElement) {
+          dispatch("turbo:before-frame-morph", {
+            target: currentElement,
+            detail: { currentElement, newElement }
+          });
+          morphChildren(currentElement, newElement);
+        }
+        async preservingPermanentElements(callback2) {
+          return await callback2();
+        }
+      };
       _ProgressBar = class {
         static get defaultCSS() {
           return unindent`
@@ -57971,7 +58683,9 @@
         }
         async render(callback2) {
           this.cancelRender();
-          this.frame = await nextRepaint();
+          await new Promise((resolve3) => {
+            this.frame = document.visibilityState === "hidden" ? setTimeout(() => resolve3(), 0) : requestAnimationFrame(() => resolve3());
+          });
           await callback2();
           delete this.frame;
         }
@@ -58146,32 +58860,32 @@
             frame.delegate.linkClickIntercepted(element, url, event);
           }
         }
-        willSubmitForm(element, submitter) {
-          return element.closest("turbo-frame") == null && this.#shouldSubmit(element, submitter) && this.#shouldRedirect(element, submitter);
+        willSubmitForm(element, submitter2) {
+          return element.closest("turbo-frame") == null && this.#shouldSubmit(element, submitter2) && this.#shouldRedirect(element, submitter2);
         }
-        formSubmitted(element, submitter) {
-          const frame = this.#findFrameElement(element, submitter);
+        formSubmitted(element, submitter2) {
+          const frame = this.#findFrameElement(element, submitter2);
           if (frame) {
-            frame.delegate.formSubmitted(element, submitter);
+            frame.delegate.formSubmitted(element, submitter2);
           }
         }
-        #shouldSubmit(form, submitter) {
-          const action = getAction$1(form, submitter);
+        #shouldSubmit(form, submitter2) {
+          const action = getAction$1(form, submitter2);
           const meta = this.element.ownerDocument.querySelector(`meta[name="turbo-root"]`);
           const rootLocation = expandURL(meta?.content ?? "/");
-          return this.#shouldRedirect(form, submitter) && locationIsVisitable(action, rootLocation);
+          return this.#shouldRedirect(form, submitter2) && locationIsVisitable(action, rootLocation);
         }
-        #shouldRedirect(element, submitter) {
-          const isNavigatable = element instanceof HTMLFormElement ? this.session.submissionIsNavigatable(element, submitter) : this.session.elementIsNavigatable(element);
+        #shouldRedirect(element, submitter2) {
+          const isNavigatable = element instanceof HTMLFormElement ? this.session.submissionIsNavigatable(element, submitter2) : this.session.elementIsNavigatable(element);
           if (isNavigatable) {
-            const frame = this.#findFrameElement(element, submitter);
+            const frame = this.#findFrameElement(element, submitter2);
             return frame ? frame != element.closest("turbo-frame") : false;
           } else {
             return false;
           }
         }
-        #findFrameElement(element, submitter) {
-          const id = submitter?.getAttribute("data-turbo-frame") || element.getAttribute("data-turbo-frame");
+        #findFrameElement(element, submitter2) {
+          const id = submitter2?.getAttribute("data-turbo-frame") || element.getAttribute("data-turbo-frame");
           if (id && id != "_top") {
             const frame = this.element.querySelector(`#${id}:not([disabled])`);
             if (frame instanceof FrameElement) {
@@ -58440,9 +59154,9 @@
           });
           this.currentVisit.start();
         }
-        submitForm(form, submitter) {
+        submitForm(form, submitter2) {
           this.stop();
-          this.formSubmission = new FormSubmission(this, form, submitter, true);
+          this.formSubmission = new FormSubmission(this, form, submitter2, true);
           this.formSubmission.start();
         }
         stop() {
@@ -58537,8 +59251,8 @@
           return this.history.restorationIdentifier;
         }
         #getActionForFormSubmission(formSubmission, fetchResponse) {
-          const { submitter, formElement } = formSubmission;
-          return getVisitAction(submitter, formElement) || this.#getDefaultAction(fetchResponse);
+          const { submitter: submitter2, formElement } = formSubmission;
+          return getVisitAction(submitter2, formElement) || this.#getDefaultAction(fetchResponse);
         }
         #getDefaultAction(fetchResponse) {
           const sameLocationRedirect = fetchResponse.redirected && fetchResponse.location.href === this.location?.href;
@@ -58728,604 +59442,6 @@
           return document.documentElement.querySelectorAll("script");
         }
       };
-      Idiomorph = function() {
-        let EMPTY_SET = /* @__PURE__ */ new Set();
-        let defaults4 = {
-          morphStyle: "outerHTML",
-          callbacks: {
-            beforeNodeAdded: noOp,
-            afterNodeAdded: noOp,
-            beforeNodeMorphed: noOp,
-            afterNodeMorphed: noOp,
-            beforeNodeRemoved: noOp,
-            afterNodeRemoved: noOp,
-            beforeAttributeUpdated: noOp
-          },
-          head: {
-            style: "merge",
-            shouldPreserve: function(elt) {
-              return elt.getAttribute("im-preserve") === "true";
-            },
-            shouldReAppend: function(elt) {
-              return elt.getAttribute("im-re-append") === "true";
-            },
-            shouldRemove: noOp,
-            afterHeadMorphed: noOp
-          }
-        };
-        function morph2(oldNode, newContent, config = {}) {
-          if (oldNode instanceof Document) {
-            oldNode = oldNode.documentElement;
-          }
-          if (typeof newContent === "string") {
-            newContent = parseContent(newContent);
-          }
-          let normalizedContent = normalizeContent(newContent);
-          let ctx = createMorphContext(oldNode, normalizedContent, config);
-          return morphNormalizedContent(oldNode, normalizedContent, ctx);
-        }
-        function morphNormalizedContent(oldNode, normalizedNewContent, ctx) {
-          if (ctx.head.block) {
-            let oldHead = oldNode.querySelector("head");
-            let newHead = normalizedNewContent.querySelector("head");
-            if (oldHead && newHead) {
-              let promises = handleHeadElement(newHead, oldHead, ctx);
-              Promise.all(promises).then(function() {
-                morphNormalizedContent(oldNode, normalizedNewContent, Object.assign(ctx, {
-                  head: {
-                    block: false,
-                    ignore: true
-                  }
-                }));
-              });
-              return;
-            }
-          }
-          if (ctx.morphStyle === "innerHTML") {
-            morphChildren2(normalizedNewContent, oldNode, ctx);
-            return oldNode.children;
-          } else if (ctx.morphStyle === "outerHTML" || ctx.morphStyle == null) {
-            let bestMatch = findBestNodeMatch(normalizedNewContent, oldNode, ctx);
-            let previousSibling = bestMatch?.previousSibling;
-            let nextSibling = bestMatch?.nextSibling;
-            let morphedNode = morphOldNodeTo(oldNode, bestMatch, ctx);
-            if (bestMatch) {
-              return insertSiblings(previousSibling, morphedNode, nextSibling);
-            } else {
-              return [];
-            }
-          } else {
-            throw "Do not understand how to morph style " + ctx.morphStyle;
-          }
-        }
-        function ignoreValueOfActiveElement(possibleActiveElement, ctx) {
-          return ctx.ignoreActiveValue && possibleActiveElement === document.activeElement && possibleActiveElement !== document.body;
-        }
-        function morphOldNodeTo(oldNode, newContent, ctx) {
-          if (ctx.ignoreActive && oldNode === document.activeElement)
-            ;
-          else if (newContent == null) {
-            if (ctx.callbacks.beforeNodeRemoved(oldNode) === false)
-              return oldNode;
-            oldNode.remove();
-            ctx.callbacks.afterNodeRemoved(oldNode);
-            return null;
-          } else if (!isSoftMatch(oldNode, newContent)) {
-            if (ctx.callbacks.beforeNodeRemoved(oldNode) === false)
-              return oldNode;
-            if (ctx.callbacks.beforeNodeAdded(newContent) === false)
-              return oldNode;
-            oldNode.parentElement.replaceChild(newContent, oldNode);
-            ctx.callbacks.afterNodeAdded(newContent);
-            ctx.callbacks.afterNodeRemoved(oldNode);
-            return newContent;
-          } else {
-            if (ctx.callbacks.beforeNodeMorphed(oldNode, newContent) === false)
-              return oldNode;
-            if (oldNode instanceof HTMLHeadElement && ctx.head.ignore)
-              ;
-            else if (oldNode instanceof HTMLHeadElement && ctx.head.style !== "morph") {
-              handleHeadElement(newContent, oldNode, ctx);
-            } else {
-              syncNodeFrom(newContent, oldNode, ctx);
-              if (!ignoreValueOfActiveElement(oldNode, ctx)) {
-                morphChildren2(newContent, oldNode, ctx);
-              }
-            }
-            ctx.callbacks.afterNodeMorphed(oldNode, newContent);
-            return oldNode;
-          }
-        }
-        function morphChildren2(newParent, oldParent, ctx) {
-          let nextNewChild = newParent.firstChild;
-          let insertionPoint = oldParent.firstChild;
-          let newChild;
-          while (nextNewChild) {
-            newChild = nextNewChild;
-            nextNewChild = newChild.nextSibling;
-            if (insertionPoint == null) {
-              if (ctx.callbacks.beforeNodeAdded(newChild) === false)
-                return;
-              oldParent.appendChild(newChild);
-              ctx.callbacks.afterNodeAdded(newChild);
-              removeIdsFromConsideration(ctx, newChild);
-              continue;
-            }
-            if (isIdSetMatch(newChild, insertionPoint, ctx)) {
-              morphOldNodeTo(insertionPoint, newChild, ctx);
-              insertionPoint = insertionPoint.nextSibling;
-              removeIdsFromConsideration(ctx, newChild);
-              continue;
-            }
-            let idSetMatch = findIdSetMatch(newParent, oldParent, newChild, insertionPoint, ctx);
-            if (idSetMatch) {
-              insertionPoint = removeNodesBetween(insertionPoint, idSetMatch, ctx);
-              morphOldNodeTo(idSetMatch, newChild, ctx);
-              removeIdsFromConsideration(ctx, newChild);
-              continue;
-            }
-            let softMatch = findSoftMatch(newParent, oldParent, newChild, insertionPoint, ctx);
-            if (softMatch) {
-              insertionPoint = removeNodesBetween(insertionPoint, softMatch, ctx);
-              morphOldNodeTo(softMatch, newChild, ctx);
-              removeIdsFromConsideration(ctx, newChild);
-              continue;
-            }
-            if (ctx.callbacks.beforeNodeAdded(newChild) === false)
-              return;
-            oldParent.insertBefore(newChild, insertionPoint);
-            ctx.callbacks.afterNodeAdded(newChild);
-            removeIdsFromConsideration(ctx, newChild);
-          }
-          while (insertionPoint !== null) {
-            let tempNode = insertionPoint;
-            insertionPoint = insertionPoint.nextSibling;
-            removeNode(tempNode, ctx);
-          }
-        }
-        function ignoreAttribute(attr, to, updateType, ctx) {
-          if (attr === "value" && ctx.ignoreActiveValue && to === document.activeElement) {
-            return true;
-          }
-          return ctx.callbacks.beforeAttributeUpdated(attr, to, updateType) === false;
-        }
-        function syncNodeFrom(from, to, ctx) {
-          let type = from.nodeType;
-          if (type === 1) {
-            const fromAttributes = from.attributes;
-            const toAttributes = to.attributes;
-            for (const fromAttribute of fromAttributes) {
-              if (ignoreAttribute(fromAttribute.name, to, "update", ctx)) {
-                continue;
-              }
-              if (to.getAttribute(fromAttribute.name) !== fromAttribute.value) {
-                to.setAttribute(fromAttribute.name, fromAttribute.value);
-              }
-            }
-            for (let i5 = toAttributes.length - 1; 0 <= i5; i5--) {
-              const toAttribute = toAttributes[i5];
-              if (ignoreAttribute(toAttribute.name, to, "remove", ctx)) {
-                continue;
-              }
-              if (!from.hasAttribute(toAttribute.name)) {
-                to.removeAttribute(toAttribute.name);
-              }
-            }
-          }
-          if (type === 8 || type === 3) {
-            if (to.nodeValue !== from.nodeValue) {
-              to.nodeValue = from.nodeValue;
-            }
-          }
-          if (!ignoreValueOfActiveElement(to, ctx)) {
-            syncInputValue(from, to, ctx);
-          }
-        }
-        function syncBooleanAttribute(from, to, attributeName, ctx) {
-          if (from[attributeName] !== to[attributeName]) {
-            let ignoreUpdate = ignoreAttribute(attributeName, to, "update", ctx);
-            if (!ignoreUpdate) {
-              to[attributeName] = from[attributeName];
-            }
-            if (from[attributeName]) {
-              if (!ignoreUpdate) {
-                to.setAttribute(attributeName, from[attributeName]);
-              }
-            } else {
-              if (!ignoreAttribute(attributeName, to, "remove", ctx)) {
-                to.removeAttribute(attributeName);
-              }
-            }
-          }
-        }
-        function syncInputValue(from, to, ctx) {
-          if (from instanceof HTMLInputElement && to instanceof HTMLInputElement && from.type !== "file") {
-            let fromValue = from.value;
-            let toValue = to.value;
-            syncBooleanAttribute(from, to, "checked", ctx);
-            syncBooleanAttribute(from, to, "disabled", ctx);
-            if (!from.hasAttribute("value")) {
-              if (!ignoreAttribute("value", to, "remove", ctx)) {
-                to.value = "";
-                to.removeAttribute("value");
-              }
-            } else if (fromValue !== toValue) {
-              if (!ignoreAttribute("value", to, "update", ctx)) {
-                to.setAttribute("value", fromValue);
-                to.value = fromValue;
-              }
-            }
-          } else if (from instanceof HTMLOptionElement) {
-            syncBooleanAttribute(from, to, "selected", ctx);
-          } else if (from instanceof HTMLTextAreaElement && to instanceof HTMLTextAreaElement) {
-            let fromValue = from.value;
-            let toValue = to.value;
-            if (ignoreAttribute("value", to, "update", ctx)) {
-              return;
-            }
-            if (fromValue !== toValue) {
-              to.value = fromValue;
-            }
-            if (to.firstChild && to.firstChild.nodeValue !== fromValue) {
-              to.firstChild.nodeValue = fromValue;
-            }
-          }
-        }
-        function handleHeadElement(newHeadTag, currentHead, ctx) {
-          let added = [];
-          let removed = [];
-          let preserved = [];
-          let nodesToAppend = [];
-          let headMergeStyle = ctx.head.style;
-          let srcToNewHeadNodes = /* @__PURE__ */ new Map();
-          for (const newHeadChild of newHeadTag.children) {
-            srcToNewHeadNodes.set(newHeadChild.outerHTML, newHeadChild);
-          }
-          for (const currentHeadElt of currentHead.children) {
-            let inNewContent = srcToNewHeadNodes.has(currentHeadElt.outerHTML);
-            let isReAppended = ctx.head.shouldReAppend(currentHeadElt);
-            let isPreserved = ctx.head.shouldPreserve(currentHeadElt);
-            if (inNewContent || isPreserved) {
-              if (isReAppended) {
-                removed.push(currentHeadElt);
-              } else {
-                srcToNewHeadNodes.delete(currentHeadElt.outerHTML);
-                preserved.push(currentHeadElt);
-              }
-            } else {
-              if (headMergeStyle === "append") {
-                if (isReAppended) {
-                  removed.push(currentHeadElt);
-                  nodesToAppend.push(currentHeadElt);
-                }
-              } else {
-                if (ctx.head.shouldRemove(currentHeadElt) !== false) {
-                  removed.push(currentHeadElt);
-                }
-              }
-            }
-          }
-          nodesToAppend.push(...srcToNewHeadNodes.values());
-          let promises = [];
-          for (const newNode of nodesToAppend) {
-            let newElt = document.createRange().createContextualFragment(newNode.outerHTML).firstChild;
-            if (ctx.callbacks.beforeNodeAdded(newElt) !== false) {
-              if (newElt.href || newElt.src) {
-                let resolve3 = null;
-                let promise = new Promise(function(_resolve2) {
-                  resolve3 = _resolve2;
-                });
-                newElt.addEventListener("load", function() {
-                  resolve3();
-                });
-                promises.push(promise);
-              }
-              currentHead.appendChild(newElt);
-              ctx.callbacks.afterNodeAdded(newElt);
-              added.push(newElt);
-            }
-          }
-          for (const removedElement of removed) {
-            if (ctx.callbacks.beforeNodeRemoved(removedElement) !== false) {
-              currentHead.removeChild(removedElement);
-              ctx.callbacks.afterNodeRemoved(removedElement);
-            }
-          }
-          ctx.head.afterHeadMorphed(currentHead, { added, kept: preserved, removed });
-          return promises;
-        }
-        function noOp() {
-        }
-        function mergeDefaults(config) {
-          let finalConfig = {};
-          Object.assign(finalConfig, defaults4);
-          Object.assign(finalConfig, config);
-          finalConfig.callbacks = {};
-          Object.assign(finalConfig.callbacks, defaults4.callbacks);
-          Object.assign(finalConfig.callbacks, config.callbacks);
-          finalConfig.head = {};
-          Object.assign(finalConfig.head, defaults4.head);
-          Object.assign(finalConfig.head, config.head);
-          return finalConfig;
-        }
-        function createMorphContext(oldNode, newContent, config) {
-          config = mergeDefaults(config);
-          return {
-            target: oldNode,
-            newContent,
-            config,
-            morphStyle: config.morphStyle,
-            ignoreActive: config.ignoreActive,
-            ignoreActiveValue: config.ignoreActiveValue,
-            idMap: createIdMap(oldNode, newContent),
-            deadIds: /* @__PURE__ */ new Set(),
-            callbacks: config.callbacks,
-            head: config.head
-          };
-        }
-        function isIdSetMatch(node1, node2, ctx) {
-          if (node1 == null || node2 == null) {
-            return false;
-          }
-          if (node1.nodeType === node2.nodeType && node1.tagName === node2.tagName) {
-            if (node1.id !== "" && node1.id === node2.id) {
-              return true;
-            } else {
-              return getIdIntersectionCount(ctx, node1, node2) > 0;
-            }
-          }
-          return false;
-        }
-        function isSoftMatch(node1, node2) {
-          if (node1 == null || node2 == null) {
-            return false;
-          }
-          return node1.nodeType === node2.nodeType && node1.tagName === node2.tagName;
-        }
-        function removeNodesBetween(startInclusive, endExclusive, ctx) {
-          while (startInclusive !== endExclusive) {
-            let tempNode = startInclusive;
-            startInclusive = startInclusive.nextSibling;
-            removeNode(tempNode, ctx);
-          }
-          removeIdsFromConsideration(ctx, endExclusive);
-          return endExclusive.nextSibling;
-        }
-        function findIdSetMatch(newContent, oldParent, newChild, insertionPoint, ctx) {
-          let newChildPotentialIdCount = getIdIntersectionCount(ctx, newChild, oldParent);
-          let potentialMatch = null;
-          if (newChildPotentialIdCount > 0) {
-            let potentialMatch2 = insertionPoint;
-            let otherMatchCount = 0;
-            while (potentialMatch2 != null) {
-              if (isIdSetMatch(newChild, potentialMatch2, ctx)) {
-                return potentialMatch2;
-              }
-              otherMatchCount += getIdIntersectionCount(ctx, potentialMatch2, newContent);
-              if (otherMatchCount > newChildPotentialIdCount) {
-                return null;
-              }
-              potentialMatch2 = potentialMatch2.nextSibling;
-            }
-          }
-          return potentialMatch;
-        }
-        function findSoftMatch(newContent, oldParent, newChild, insertionPoint, ctx) {
-          let potentialSoftMatch = insertionPoint;
-          let nextSibling = newChild.nextSibling;
-          let siblingSoftMatchCount = 0;
-          while (potentialSoftMatch != null) {
-            if (getIdIntersectionCount(ctx, potentialSoftMatch, newContent) > 0) {
-              return null;
-            }
-            if (isSoftMatch(newChild, potentialSoftMatch)) {
-              return potentialSoftMatch;
-            }
-            if (isSoftMatch(nextSibling, potentialSoftMatch)) {
-              siblingSoftMatchCount++;
-              nextSibling = nextSibling.nextSibling;
-              if (siblingSoftMatchCount >= 2) {
-                return null;
-              }
-            }
-            potentialSoftMatch = potentialSoftMatch.nextSibling;
-          }
-          return potentialSoftMatch;
-        }
-        function parseContent(newContent) {
-          let parser = new DOMParser();
-          let contentWithSvgsRemoved = newContent.replace(/<svg(\s[^>]*>|>)([\s\S]*?)<\/svg>/gim, "");
-          if (contentWithSvgsRemoved.match(/<\/html>/) || contentWithSvgsRemoved.match(/<\/head>/) || contentWithSvgsRemoved.match(/<\/body>/)) {
-            let content = parser.parseFromString(newContent, "text/html");
-            if (contentWithSvgsRemoved.match(/<\/html>/)) {
-              content.generatedByIdiomorph = true;
-              return content;
-            } else {
-              let htmlElement = content.firstChild;
-              if (htmlElement) {
-                htmlElement.generatedByIdiomorph = true;
-                return htmlElement;
-              } else {
-                return null;
-              }
-            }
-          } else {
-            let responseDoc = parser.parseFromString("<body><template>" + newContent + "</template></body>", "text/html");
-            let content = responseDoc.body.querySelector("template").content;
-            content.generatedByIdiomorph = true;
-            return content;
-          }
-        }
-        function normalizeContent(newContent) {
-          if (newContent == null) {
-            const dummyParent = document.createElement("div");
-            return dummyParent;
-          } else if (newContent.generatedByIdiomorph) {
-            return newContent;
-          } else if (newContent instanceof Node) {
-            const dummyParent = document.createElement("div");
-            dummyParent.append(newContent);
-            return dummyParent;
-          } else {
-            const dummyParent = document.createElement("div");
-            for (const elt of [...newContent]) {
-              dummyParent.append(elt);
-            }
-            return dummyParent;
-          }
-        }
-        function insertSiblings(previousSibling, morphedNode, nextSibling) {
-          let stack = [];
-          let added = [];
-          while (previousSibling != null) {
-            stack.push(previousSibling);
-            previousSibling = previousSibling.previousSibling;
-          }
-          while (stack.length > 0) {
-            let node = stack.pop();
-            added.push(node);
-            morphedNode.parentElement.insertBefore(node, morphedNode);
-          }
-          added.push(morphedNode);
-          while (nextSibling != null) {
-            stack.push(nextSibling);
-            added.push(nextSibling);
-            nextSibling = nextSibling.nextSibling;
-          }
-          while (stack.length > 0) {
-            morphedNode.parentElement.insertBefore(stack.pop(), morphedNode.nextSibling);
-          }
-          return added;
-        }
-        function findBestNodeMatch(newContent, oldNode, ctx) {
-          let currentElement;
-          currentElement = newContent.firstChild;
-          let bestElement = currentElement;
-          let score = 0;
-          while (currentElement) {
-            let newScore = scoreElement(currentElement, oldNode, ctx);
-            if (newScore > score) {
-              bestElement = currentElement;
-              score = newScore;
-            }
-            currentElement = currentElement.nextSibling;
-          }
-          return bestElement;
-        }
-        function scoreElement(node1, node2, ctx) {
-          if (isSoftMatch(node1, node2)) {
-            return 0.5 + getIdIntersectionCount(ctx, node1, node2);
-          }
-          return 0;
-        }
-        function removeNode(tempNode, ctx) {
-          removeIdsFromConsideration(ctx, tempNode);
-          if (ctx.callbacks.beforeNodeRemoved(tempNode) === false)
-            return;
-          tempNode.remove();
-          ctx.callbacks.afterNodeRemoved(tempNode);
-        }
-        function isIdInConsideration(ctx, id) {
-          return !ctx.deadIds.has(id);
-        }
-        function idIsWithinNode(ctx, id, targetNode) {
-          let idSet = ctx.idMap.get(targetNode) || EMPTY_SET;
-          return idSet.has(id);
-        }
-        function removeIdsFromConsideration(ctx, node) {
-          let idSet = ctx.idMap.get(node) || EMPTY_SET;
-          for (const id of idSet) {
-            ctx.deadIds.add(id);
-          }
-        }
-        function getIdIntersectionCount(ctx, node1, node2) {
-          let sourceSet = ctx.idMap.get(node1) || EMPTY_SET;
-          let matchCount = 0;
-          for (const id of sourceSet) {
-            if (isIdInConsideration(ctx, id) && idIsWithinNode(ctx, id, node2)) {
-              ++matchCount;
-            }
-          }
-          return matchCount;
-        }
-        function populateIdMapForNode(node, idMap) {
-          let nodeParent = node.parentElement;
-          let idElements = node.querySelectorAll("[id]");
-          for (const elt of idElements) {
-            let current = elt;
-            while (current !== nodeParent && current != null) {
-              let idSet = idMap.get(current);
-              if (idSet == null) {
-                idSet = /* @__PURE__ */ new Set();
-                idMap.set(current, idSet);
-              }
-              idSet.add(elt.id);
-              current = current.parentElement;
-            }
-          }
-        }
-        function createIdMap(oldContent, newContent) {
-          let idMap = /* @__PURE__ */ new Map();
-          populateIdMapForNode(oldContent, idMap);
-          populateIdMapForNode(newContent, idMap);
-          return idMap;
-        }
-        return {
-          morph: morph2,
-          defaults: defaults4
-        };
-      }();
-      DefaultIdiomorphCallbacks = class {
-        #beforeNodeMorphed;
-        constructor({ beforeNodeMorphed } = {}) {
-          this.#beforeNodeMorphed = beforeNodeMorphed || (() => true);
-        }
-        beforeNodeAdded = (node) => {
-          return !(node.id && node.hasAttribute("data-turbo-permanent") && document.getElementById(node.id));
-        };
-        beforeNodeMorphed = (currentElement, newElement) => {
-          if (currentElement instanceof Element) {
-            if (!currentElement.hasAttribute("data-turbo-permanent") && this.#beforeNodeMorphed(currentElement, newElement)) {
-              const event = dispatch("turbo:before-morph-element", {
-                cancelable: true,
-                target: currentElement,
-                detail: { currentElement, newElement }
-              });
-              return !event.defaultPrevented;
-            } else {
-              return false;
-            }
-          }
-        };
-        beforeAttributeUpdated = (attributeName, target, mutationType) => {
-          const event = dispatch("turbo:before-morph-attribute", {
-            cancelable: true,
-            target,
-            detail: { attributeName, mutationType }
-          });
-          return !event.defaultPrevented;
-        };
-        beforeNodeRemoved = (node) => {
-          return this.beforeNodeMorphed(node);
-        };
-        afterNodeMorphed = (currentElement, newElement) => {
-          if (currentElement instanceof Element) {
-            dispatch("turbo:morph-element", {
-              target: currentElement,
-              detail: { currentElement, newElement }
-            });
-          }
-        };
-      };
-      MorphingFrameRenderer = class extends FrameRenderer {
-        static renderElement(currentElement, newElement) {
-          dispatch("turbo:before-frame-morph", {
-            target: currentElement,
-            detail: { currentElement, newElement }
-          });
-          morphChildren(currentElement, newElement);
-        }
-      };
       PageRenderer = class extends Renderer {
         static renderElement(currentElement, newElement) {
           if (document.body && newElement instanceof HTMLBodyElement) {
@@ -59504,7 +59620,7 @@
           });
           for (const frame of currentElement.querySelectorAll("turbo-frame")) {
             if (canRefreshFrame(frame))
-              refreshFrame(frame);
+              frame.reload();
           }
           dispatch("turbo:morph", { detail: { currentElement, newElement } });
         }
@@ -59572,7 +59688,7 @@
         renderPage(snapshot, isPreview = false, willRender = true, visit2) {
           const shouldMorphPage = this.isPageRefresh(visit2) && this.snapshot.shouldMorphPage;
           const rendererClass = shouldMorphPage ? MorphingPageRenderer : PageRenderer;
-          const renderer = new rendererClass(this.snapshot, snapshot, rendererClass.renderElement, isPreview, willRender);
+          const renderer = new rendererClass(this.snapshot, snapshot, isPreview, willRender);
           if (!renderer.shouldRender) {
             this.forceReloaded = true;
           } else {
@@ -59582,7 +59698,7 @@
         }
         renderError(snapshot, visit2) {
           visit2?.changeHistory();
-          const renderer = new ErrorRenderer(this.snapshot, snapshot, ErrorRenderer.renderElement, false);
+          const renderer = new ErrorRenderer(this.snapshot, snapshot, false);
           return this.render(renderer);
         }
         clearSnapshotCache() {
@@ -59703,11 +59819,8 @@
         frameRedirector = new FrameRedirector(this, document.documentElement);
         streamMessageRenderer = new StreamMessageRenderer();
         cache = new Cache(this);
-        drive = true;
         enabled = true;
-        progressBarDelay = 500;
         started = false;
-        formMode = "on";
         #pageRefreshDebouncePeriod = 150;
         constructor(recentRequests2) {
           this.recentRequests = recentRequests2;
@@ -59783,10 +59896,28 @@
           this.view.clearSnapshotCache();
         }
         setProgressBarDelay(delay) {
+          console.warn(
+            "Please replace `session.setProgressBarDelay(delay)` with `session.progressBarDelay = delay`. The function is deprecated and will be removed in a future version of Turbo.`"
+          );
           this.progressBarDelay = delay;
         }
-        setFormMode(mode) {
-          this.formMode = mode;
+        set progressBarDelay(delay) {
+          config.drive.progressBarDelay = delay;
+        }
+        get progressBarDelay() {
+          return config.drive.progressBarDelay;
+        }
+        set drive(value) {
+          config.drive.enabled = value;
+        }
+        get drive() {
+          return config.drive.enabled;
+        }
+        set formMode(value) {
+          config.forms.mode = value;
+        }
+        get formMode() {
+          return config.forms.mode;
         }
         get location() {
           return this.history.location;
@@ -59873,12 +60004,12 @@
         visitScrolledToSamePageLocation(oldURL, newURL) {
           this.notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL);
         }
-        willSubmitForm(form, submitter) {
-          const action = getAction$1(form, submitter);
-          return this.submissionIsNavigatable(form, submitter) && locationIsVisitable(expandURL(action), this.snapshot.rootLocation);
+        willSubmitForm(form, submitter2) {
+          const action = getAction$1(form, submitter2);
+          return this.submissionIsNavigatable(form, submitter2) && locationIsVisitable(expandURL(action), this.snapshot.rootLocation);
         }
-        formSubmitted(form, submitter) {
-          this.navigator.submitForm(form, submitter);
+        formSubmitted(form, submitter2) {
+          this.navigator.submitForm(form, submitter2);
         }
         pageBecameInteractive() {
           this.view.lastRenderedLocation = this.location;
@@ -59984,12 +60115,12 @@
             cancelable: true
           });
         }
-        submissionIsNavigatable(form, submitter) {
-          if (this.formMode == "off") {
+        submissionIsNavigatable(form, submitter2) {
+          if (config.forms.mode == "off") {
             return false;
           } else {
-            const submitterIsNavigatable = submitter ? this.elementIsNavigatable(submitter) : true;
-            if (this.formMode == "optin") {
+            const submitterIsNavigatable = submitter2 ? this.elementIsNavigatable(submitter2) : true;
+            if (config.forms.mode == "optin") {
               return submitterIsNavigatable && form.closest('[data-turbo="true"]') != null;
             } else {
               return submitterIsNavigatable && this.elementIsNavigatable(form);
@@ -59999,7 +60130,7 @@
         elementIsNavigatable(element) {
           const container = findClosestRecursively(element, "[data-turbo]");
           const withinFrame = findClosestRecursively(element, "turbo-frame");
-          if (this.drive || withinFrame) {
+          if (config.drive.enabled || withinFrame) {
             if (container) {
               return container.getAttribute("data-turbo") != "false";
             } else {
@@ -60038,6 +60169,7 @@
         PageSnapshot,
         FrameRenderer,
         fetch: fetchWithTurboHeaders,
+        config,
         start,
         registerAdapter,
         visit,
@@ -60059,6 +60191,7 @@
         #connected = false;
         #hasBeenLoaded = false;
         #ignoredAttributes = /* @__PURE__ */ new Set();
+        #shouldMorphFrame = false;
         action = null;
         constructor(element) {
           this.element = element;
@@ -60107,7 +60240,8 @@
           }
         }
         sourceURLReloaded() {
-          const { src } = this.element;
+          const { refresh, src } = this.element;
+          this.#shouldMorphFrame = src && refresh === "morph";
           this.element.removeAttribute("complete");
           this.element.src = null;
           this.element.src = src;
@@ -60145,6 +60279,7 @@
               }
             }
           } finally {
+            this.#shouldMorphFrame = false;
             this.fetchResponseLoaded = () => Promise.resolve();
           }
         }
@@ -60166,14 +60301,14 @@
         linkClickIntercepted(element, location2) {
           this.#navigateFrame(element, location2);
         }
-        willSubmitForm(element, submitter) {
-          return element.closest("turbo-frame") == this.element && this.#shouldInterceptNavigation(element, submitter);
+        willSubmitForm(element, submitter2) {
+          return element.closest("turbo-frame") == this.element && this.#shouldInterceptNavigation(element, submitter2);
         }
-        formSubmitted(element, submitter) {
+        formSubmitted(element, submitter2) {
           if (this.formSubmission) {
             this.formSubmission.stop();
           }
-          this.formSubmission = new FormSubmission(this, element, submitter);
+          this.formSubmission = new FormSubmission(this, element, submitter2);
           const { fetchRequest } = this.formSubmission;
           this.prepareRequest(fetchRequest);
           this.formSubmission.start();
@@ -60260,9 +60395,10 @@
         };
         async #loadFrameResponse(fetchResponse, document2) {
           const newFrameElement = await this.extractForeignFrameElement(document2.body);
+          const rendererClass = this.#shouldMorphFrame ? MorphingFrameRenderer : FrameRenderer;
           if (newFrameElement) {
             const snapshot = new Snapshot(newFrameElement);
-            const renderer = new FrameRenderer(this, this.view.snapshot, snapshot, FrameRenderer.renderElement, false, false);
+            const renderer = new rendererClass(this, this.view.snapshot, snapshot, false, false);
             if (this.view.renderPromise)
               await this.view.renderPromise;
             this.changeHistory();
@@ -60289,9 +60425,9 @@
             request.perform();
           });
         }
-        #navigateFrame(element, url, submitter) {
-          const frame = this.#findFrameElement(element, submitter);
-          frame.delegate.proposeVisitIfNavigatedWithAction(frame, getVisitAction(submitter, element, frame));
+        #navigateFrame(element, url, submitter2) {
+          const frame = this.#findFrameElement(element, submitter2);
+          frame.delegate.proposeVisitIfNavigatedWithAction(frame, getVisitAction(submitter2, element, frame));
           this.#withCurrentNavigationElement(element, () => {
             frame.src = url;
           });
@@ -60364,8 +60500,8 @@
           const { location: location2, redirected, statusCode } = wrapped;
           return session.visit(location2, { response: { redirected, statusCode, responseHTML } });
         }
-        #findFrameElement(element, submitter) {
-          const id = getAttribute("data-turbo-frame", submitter, element) || this.element.getAttribute("target");
+        #findFrameElement(element, submitter2) {
+          const id = getAttribute("data-turbo-frame", submitter2, element) || this.element.getAttribute("target");
           return getFrameElementById(id) ?? this.element;
         }
         async extractForeignFrameElement(container) {
@@ -60387,13 +60523,13 @@
           }
           return null;
         }
-        #formActionIsVisitable(form, submitter) {
-          const action = getAction$1(form, submitter);
+        #formActionIsVisitable(form, submitter2) {
+          const action = getAction$1(form, submitter2);
           return locationIsVisitable(expandURL(action), this.rootLocation);
         }
-        #shouldInterceptNavigation(element, submitter) {
-          const id = getAttribute("data-turbo-frame", submitter, element) || this.element.getAttribute("target");
-          if (element instanceof HTMLFormElement && !this.#formActionIsVisitable(element, submitter)) {
+        #shouldInterceptNavigation(element, submitter2) {
+          const id = getAttribute("data-turbo-frame", submitter2, element) || this.element.getAttribute("target");
+          if (element instanceof HTMLFormElement && !this.#formActionIsVisitable(element, submitter2)) {
             return false;
           }
           if (!this.enabled || id == "_top") {
@@ -60408,7 +60544,7 @@
           if (!session.elementIsNavigatable(element)) {
             return false;
           }
-          if (submitter && !session.elementIsNavigatable(submitter)) {
+          if (submitter2 && !session.elementIsNavigatable(submitter2)) {
             return false;
           }
           return true;
@@ -61304,6 +61440,13 @@
           disconnectStreamSource(this);
           if (this.subscription)
             this.subscription.unsubscribe();
+          this.subscriptionDisconnected();
+        }
+        attributeChangedCallback() {
+          if (this.subscription) {
+            this.disconnectedCallback();
+            this.connectedCallback();
+          }
         }
         dispatchMessageEvent(data) {
           const event = new MessageEvent("message", { data });
@@ -61321,6 +61464,7 @@
           return { channel, signed_stream_name, ...walk({ ...this.dataset }) };
         }
       };
+      __publicField(TurboCableStreamSourceElement, "observedAttributes", ["channel", "signed-stream-name"]);
       if (customElements.get("turbo-cable-stream-source") === void 0) {
         customElements.define("turbo-cable-stream-source", TurboCableStreamSourceElement);
       }
@@ -61331,9 +61475,9 @@
   function encodeMethodIntoRequestBody(event) {
     if (event.target instanceof HTMLFormElement) {
       const { target: form, detail: { fetchOptions } } = event;
-      form.addEventListener("turbo:submit-start", ({ detail: { formSubmission: { submitter } } }) => {
+      form.addEventListener("turbo:submit-start", ({ detail: { formSubmission: { submitter: submitter2 } } }) => {
         const body = isBodyInit(fetchOptions.body) ? fetchOptions.body : new URLSearchParams();
-        const method = determineFetchMethod(submitter, body, form);
+        const method = determineFetchMethod(submitter2, body, form);
         if (!/get/i.test(method)) {
           if (/post/i.test(method)) {
             body.delete("_method");
@@ -61345,8 +61489,8 @@
       }, { once: true });
     }
   }
-  function determineFetchMethod(submitter, body, form) {
-    const formMethod = determineFormMethod(submitter);
+  function determineFetchMethod(submitter2, body, form) {
+    const formMethod = determineFormMethod(submitter2);
     const overrideMethod = body.get("_method");
     const method = form.getAttribute("method") || "get";
     if (typeof formMethod == "string") {
@@ -61357,12 +61501,12 @@
       return method;
     }
   }
-  function determineFormMethod(submitter) {
-    if (submitter instanceof HTMLButtonElement || submitter instanceof HTMLInputElement) {
-      if (submitter.name === "_method") {
-        return submitter.value;
-      } else if (submitter.hasAttribute("formmethod")) {
-        return submitter.formMethod;
+  function determineFormMethod(submitter2) {
+    if (submitter2 instanceof HTMLButtonElement || submitter2 instanceof HTMLInputElement) {
+      if (submitter2.name === "_method") {
+        return submitter2.value;
+      } else if (submitter2.hasAttribute("formmethod")) {
+        return submitter2.formMethod;
       } else {
         return null;
       }
@@ -81688,11 +81832,11 @@
           mod(CodeMirror);
       })(function(CodeMirror3) {
         "use strict";
-        CodeMirror3.defineMode("css", function(config, parserConfig) {
+        CodeMirror3.defineMode("css", function(config2, parserConfig) {
           var inline = parserConfig.inline;
           if (!parserConfig.propertyKeywords)
             parserConfig = CodeMirror3.resolveMode("text/css");
-          var indentUnit = config.indentUnit, tokenHooks = parserConfig.tokenHooks, documentTypes2 = parserConfig.documentTypes || {}, mediaTypes2 = parserConfig.mediaTypes || {}, mediaFeatures2 = parserConfig.mediaFeatures || {}, mediaValueKeywords2 = parserConfig.mediaValueKeywords || {}, propertyKeywords2 = parserConfig.propertyKeywords || {}, nonStandardPropertyKeywords2 = parserConfig.nonStandardPropertyKeywords || {}, fontProperties2 = parserConfig.fontProperties || {}, counterDescriptors2 = parserConfig.counterDescriptors || {}, colorKeywords2 = parserConfig.colorKeywords || {}, valueKeywords2 = parserConfig.valueKeywords || {}, allowNested = parserConfig.allowNested, lineComment = parserConfig.lineComment, supportsAtComponent = parserConfig.supportsAtComponent === true, highlightNonStandardPropertyKeywords = config.highlightNonStandardPropertyKeywords !== false;
+          var indentUnit = config2.indentUnit, tokenHooks = parserConfig.tokenHooks, documentTypes2 = parserConfig.documentTypes || {}, mediaTypes2 = parserConfig.mediaTypes || {}, mediaFeatures2 = parserConfig.mediaFeatures || {}, mediaValueKeywords2 = parserConfig.mediaValueKeywords || {}, propertyKeywords2 = parserConfig.propertyKeywords || {}, nonStandardPropertyKeywords2 = parserConfig.nonStandardPropertyKeywords || {}, fontProperties2 = parserConfig.fontProperties || {}, counterDescriptors2 = parserConfig.counterDescriptors || {}, colorKeywords2 = parserConfig.colorKeywords || {}, valueKeywords2 = parserConfig.valueKeywords || {}, allowNested = parserConfig.allowNested, lineComment = parserConfig.lineComment, supportsAtComponent = parserConfig.supportsAtComponent === true, highlightNonStandardPropertyKeywords = config2.highlightNonStandardPropertyKeywords !== false;
           var type, override;
           function ret(style2, tp) {
             type = tp;
@@ -83500,11 +83644,11 @@
       })(function(CodeMirror3) {
         "use strict";
         CodeMirror3.defineSimpleMode = function(name, states) {
-          CodeMirror3.defineMode(name, function(config) {
-            return CodeMirror3.simpleMode(config, states);
+          CodeMirror3.defineMode(name, function(config2) {
+            return CodeMirror3.simpleMode(config2, states);
           });
         };
-        CodeMirror3.simpleMode = function(config, states) {
+        CodeMirror3.simpleMode = function(config2, states) {
           ensureState(states, "start");
           var states_ = {}, meta = states.meta || {}, hasIndentation = false;
           for (var state in states)
@@ -83548,7 +83692,7 @@
                 };
               return s6;
             },
-            token: tokenFunction(states_, config),
+            token: tokenFunction(states_, config2),
             innerMode: function(state2) {
               return state2.local && { mode: state2.local.mode, state: state2.localState };
             },
@@ -83597,7 +83741,7 @@
           this.token = asToken(data.token);
           this.data = data;
         }
-        function tokenFunction(states, config) {
+        function tokenFunction(states, config2) {
           return function(stream, state) {
             if (state.pending) {
               var pend = state.pending.shift();
@@ -83632,9 +83776,9 @@
                   state.state = state.stack.pop();
                 }
                 if (rule.data.mode)
-                  enterLocalMode(config, state, rule.data.mode, rule.token);
+                  enterLocalMode(config2, state, rule.data.mode, rule.token);
                 if (rule.data.indent)
-                  state.indent.push(stream.indentation() + config.indentUnit);
+                  state.indent.push(stream.indentation() + config2.indentUnit);
                 if (rule.data.dedent)
                   state.indent.pop();
                 var token = rule.token;
@@ -83675,14 +83819,14 @@
               props--;
           return props == 0;
         }
-        function enterLocalMode(config, state, spec, token) {
+        function enterLocalMode(config2, state, spec, token) {
           var pers;
           if (spec.persistent) {
             for (var p4 = state.persistentStates; p4 && !pers; p4 = p4.next)
               if (spec.spec ? cmp2(spec.spec, p4.spec) : spec.mode == p4.mode)
                 pers = p4;
           }
-          var mode = pers ? pers.mode : spec.mode || CodeMirror3.getMode(config, spec.spec);
+          var mode = pers ? pers.mode : spec.mode || CodeMirror3.getMode(config2, spec.spec);
           var lState = pers ? pers.state : CodeMirror3.startState(mode);
           if (spec.persistent && !pers)
             state.persistentStates = { mode, spec: spec.spec, state: lState, next: state.persistentStates };
@@ -84045,12 +84189,12 @@
         };
         CodeMirror3.defineMode("xml", function(editorConf, config_) {
           var indentUnit = editorConf.indentUnit;
-          var config = {};
+          var config2 = {};
           var defaults4 = config_.htmlMode ? htmlConfig : xmlConfig;
           for (var prop in defaults4)
-            config[prop] = defaults4[prop];
+            config2[prop] = defaults4[prop];
           for (var prop in config_)
-            config[prop] = config_[prop];
+            config2[prop] = config_[prop];
           var type, setStyle3;
           function inText(stream, state) {
             function chain(parser) {
@@ -84174,7 +84318,7 @@
             this.tagName = tagName || "";
             this.indent = state.indented;
             this.startOfLine = startOfLine;
-            if (config.doNotIndent.hasOwnProperty(tagName) || state.context && state.context.noIndent)
+            if (config2.doNotIndent.hasOwnProperty(tagName) || state.context && state.context.noIndent)
               this.noIndent = true;
           }
           function popContext(state) {
@@ -84188,7 +84332,7 @@
                 return;
               }
               parentTagName = state.context.tagName;
-              if (!config.contextGrabbers.hasOwnProperty(parentTagName) || !config.contextGrabbers[parentTagName].hasOwnProperty(nextTagName)) {
+              if (!config2.contextGrabbers.hasOwnProperty(parentTagName) || !config2.contextGrabbers[parentTagName].hasOwnProperty(nextTagName)) {
                 return;
               }
               popContext(state);
@@ -84209,7 +84353,7 @@
               state.tagName = stream.current();
               setStyle3 = "tag";
               return attrState;
-            } else if (config.allowMissingTagName && type2 == "endTag") {
+            } else if (config2.allowMissingTagName && type2 == "endTag") {
               setStyle3 = "tag bracket";
               return attrState(type2, stream, state);
             } else {
@@ -84220,16 +84364,16 @@
           function closeTagNameState(type2, stream, state) {
             if (type2 == "word") {
               var tagName = stream.current();
-              if (state.context && state.context.tagName != tagName && config.implicitlyClosed.hasOwnProperty(state.context.tagName))
+              if (state.context && state.context.tagName != tagName && config2.implicitlyClosed.hasOwnProperty(state.context.tagName))
                 popContext(state);
-              if (state.context && state.context.tagName == tagName || config.matchClosing === false) {
+              if (state.context && state.context.tagName == tagName || config2.matchClosing === false) {
                 setStyle3 = "tag";
                 return closeState;
               } else {
                 setStyle3 = "tag error";
                 return closeStateErr;
               }
-            } else if (config.allowMissingTagName && type2 == "endTag") {
+            } else if (config2.allowMissingTagName && type2 == "endTag") {
               setStyle3 = "tag bracket";
               return closeState(type2, stream, state);
             } else {
@@ -84256,7 +84400,7 @@
             } else if (type2 == "endTag" || type2 == "selfcloseTag") {
               var tagName = state.tagName, tagStart = state.tagStart;
               state.tagName = state.tagStart = null;
-              if (type2 == "selfcloseTag" || config.autoSelfClosers.hasOwnProperty(tagName)) {
+              if (type2 == "selfcloseTag" || config2.autoSelfClosers.hasOwnProperty(tagName)) {
                 maybePopContext(state, tagName);
               } else {
                 maybePopContext(state, tagName);
@@ -84270,14 +84414,14 @@
           function attrEqState(type2, stream, state) {
             if (type2 == "equals")
               return attrValueState;
-            if (!config.allowMissing)
+            if (!config2.allowMissing)
               setStyle3 = "error";
             return attrState(type2, stream, state);
           }
           function attrValueState(type2, stream, state) {
             if (type2 == "string")
               return attrContinuedState;
-            if (type2 == "word" && config.allowUnquoted) {
+            if (type2 == "word" && config2.allowUnquoted) {
               setStyle3 = "string";
               return attrState;
             }
@@ -84331,12 +84475,12 @@
               if (state.tokenize != inTag && state.tokenize != inText)
                 return fullLine ? fullLine.match(/^(\s*)/)[0].length : 0;
               if (state.tagName) {
-                if (config.multilineTagIndentPastTag !== false)
+                if (config2.multilineTagIndentPastTag !== false)
                   return state.tagStart + state.tagName.length + 2;
                 else
-                  return state.tagStart + indentUnit * (config.multilineTagIndentFactor || 1);
+                  return state.tagStart + indentUnit * (config2.multilineTagIndentFactor || 1);
               }
-              if (config.alignCDATA && /<!\[CDATA\[/.test(textAfter))
+              if (config2.alignCDATA && /<!\[CDATA\[/.test(textAfter))
                 return 0;
               var tagAfter = textAfter && /^<(\/)?([\w_:\.-]*)/.exec(textAfter);
               if (tagAfter && tagAfter[1]) {
@@ -84344,7 +84488,7 @@
                   if (context.tagName == tagAfter[2]) {
                     context = context.prev;
                     break;
-                  } else if (config.implicitlyClosed.hasOwnProperty(context.tagName)) {
+                  } else if (config2.implicitlyClosed.hasOwnProperty(context.tagName)) {
                     context = context.prev;
                   } else {
                     break;
@@ -84352,7 +84496,7 @@
                 }
               } else if (tagAfter) {
                 while (context) {
-                  var grabbers = config.contextGrabbers[context.tagName];
+                  var grabbers = config2.contextGrabbers[context.tagName];
                   if (grabbers && grabbers.hasOwnProperty(tagAfter[2]))
                     context = context.prev;
                   else
@@ -84369,8 +84513,8 @@
             electricInput: /<\/[\s\w:]+>$/,
             blockCommentStart: "<!--",
             blockCommentEnd: "-->",
-            configuration: config.htmlMode ? "html" : "xml",
-            helperType: config.htmlMode ? "html" : "xml",
+            configuration: config2.htmlMode ? "html" : "xml",
+            helperType: config2.htmlMode ? "html" : "xml",
             skipAttribute: function(state) {
               if (state.state == attrValueState)
                 state.state = attrState;
@@ -84406,8 +84550,8 @@
           mod(CodeMirror);
       })(function(CodeMirror3) {
         "use strict";
-        CodeMirror3.defineMode("javascript", function(config, parserConfig) {
-          var indentUnit = config.indentUnit;
+        CodeMirror3.defineMode("javascript", function(config2, parserConfig) {
+          var indentUnit = config2.indentUnit;
           var statementIndent = parserConfig.statementIndent;
           var jsonldMode = parserConfig.jsonld;
           var jsonMode = parserConfig.json || jsonldMode;
@@ -85626,8 +85770,8 @@
               return spec[2];
           }
         }
-        CodeMirror3.defineMode("htmlmixed", function(config, parserConfig) {
-          var htmlMode = CodeMirror3.getMode(config, {
+        CodeMirror3.defineMode("htmlmixed", function(config2, parserConfig) {
+          var htmlMode = CodeMirror3.getMode(config2, {
             name: "xml",
             htmlMode: true,
             multilineTagIndentFactor: parserConfig.multilineTagIndentFactor,
@@ -85650,7 +85794,7 @@
               var inTag = /^([\S]+) (.*)/.exec(state.inTag);
               state.inTag = null;
               var modeSpec = stream.current() == ">" && findMatchingMode(tags[inTag[1]], inTag[2]);
-              var mode = CodeMirror3.getMode(config, modeSpec);
+              var mode = CodeMirror3.getMode(config2, modeSpec);
               var endTagA = getTagRegexp(inTag[1], true), endTag = getTagRegexp(inTag[1], false);
               state.token = function(stream2, state2) {
                 if (stream2.match(endTagA, false)) {
@@ -86741,7 +86885,7 @@
           mod(CodeMirror);
       })(function(CodeMirror3) {
         "use strict";
-        CodeMirror3.defineMode("nginx", function(config) {
+        CodeMirror3.defineMode("nginx", function(config2) {
           function words(str) {
             var obj = {}, words2 = str.split(" ");
             for (var i5 = 0; i5 < words2.length; ++i5)
@@ -86757,7 +86901,7 @@
           var keywords_important = words(
             "include root server server_name listen internal proxy_pass memcached_pass fastcgi_pass try_files"
           );
-          var indentUnit = config.indentUnit, type;
+          var indentUnit = config2.indentUnit, type;
           function ret(style2, tp) {
             type = tp;
             return style2;
@@ -86942,8 +87086,8 @@
             context = context.prev;
           }
         }
-        CodeMirror3.defineMode("clike", function(config, parserConfig) {
-          var indentUnit = config.indentUnit, statementIndentUnit = parserConfig.statementIndentUnit || indentUnit, dontAlignCalls = parserConfig.dontAlignCalls, keywords = parserConfig.keywords || {}, types = parserConfig.types || {}, builtin = parserConfig.builtin || {}, blockKeywords = parserConfig.blockKeywords || {}, defKeywords = parserConfig.defKeywords || {}, atoms = parserConfig.atoms || {}, hooks = parserConfig.hooks || {}, multiLineStrings = parserConfig.multiLineStrings, indentStatements = parserConfig.indentStatements !== false, indentSwitch = parserConfig.indentSwitch !== false, namespaceSeparator = parserConfig.namespaceSeparator, isPunctuationChar = parserConfig.isPunctuationChar || /[\[\]{}\(\),;\:\.]/, numberStart = parserConfig.numberStart || /[\d\.]/, number = parserConfig.number || /^(?:0x[a-f\d]+|0b[01]+|(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(u|ll?|l|f)?/i, isOperatorChar = parserConfig.isOperatorChar || /[+\-*&%=<>!?|\/]/, isIdentifierChar = parserConfig.isIdentifierChar || /[\w\$_\xa1-\uffff]/, isReservedIdentifier = parserConfig.isReservedIdentifier || false;
+        CodeMirror3.defineMode("clike", function(config2, parserConfig) {
+          var indentUnit = config2.indentUnit, statementIndentUnit = parserConfig.statementIndentUnit || indentUnit, dontAlignCalls = parserConfig.dontAlignCalls, keywords = parserConfig.keywords || {}, types = parserConfig.types || {}, builtin = parserConfig.builtin || {}, blockKeywords = parserConfig.blockKeywords || {}, defKeywords = parserConfig.defKeywords || {}, atoms = parserConfig.atoms || {}, hooks = parserConfig.hooks || {}, multiLineStrings = parserConfig.multiLineStrings, indentStatements = parserConfig.indentStatements !== false, indentSwitch = parserConfig.indentSwitch !== false, namespaceSeparator = parserConfig.namespaceSeparator, isPunctuationChar = parserConfig.isPunctuationChar || /[\[\]{}\(\),;\:\.]/, numberStart = parserConfig.numberStart || /[\d\.]/, number = parserConfig.number || /^(?:0x[a-f\d]+|0b[01]+|(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(u|ll?|l|f)?/i, isOperatorChar = parserConfig.isOperatorChar || /[+\-*&%=<>!?|\/]/, isIdentifierChar = parserConfig.isIdentifierChar || /[\w\$_\xa1-\uffff]/, isReservedIdentifier = parserConfig.isReservedIdentifier || false;
           var curPunc, isDefKeyword;
           function tokenBase(stream, state) {
             var ch = stream.next();
@@ -87792,9 +87936,9 @@
             }
           }
         };
-        CodeMirror3.defineMode("php", function(config, parserConfig) {
-          var htmlMode = CodeMirror3.getMode(config, parserConfig && parserConfig.htmlMode || "text/html");
-          var phpMode = CodeMirror3.getMode(config, phpConfig);
+        CodeMirror3.defineMode("php", function(config2, parserConfig) {
+          var htmlMode = CodeMirror3.getMode(config2, parserConfig && parserConfig.htmlMode || "text/html");
+          var phpMode = CodeMirror3.getMode(config2, phpConfig);
           function dispatch3(stream, state) {
             var isPHP = state.curMode == phpMode;
             if (stream.sol() && state.pending && state.pending != '"' && state.pending != "'")
@@ -87981,7 +88125,7 @@
         var dedentWords = wordObj(["end", "until"]);
         var opening = { "[": "]", "{": "}", "(": ")" };
         var closing = { "]": "[", "}": "{", ")": "(" };
-        CodeMirror3.defineMode("ruby", function(config) {
+        CodeMirror3.defineMode("ruby", function(config2) {
           var curPunc;
           function chain(newtok, stream, state) {
             state.tokenize.push(newtok);
@@ -88199,7 +88343,7 @@
               return {
                 tokenize: [tokenBase],
                 indented: 0,
-                context: { type: "top", indented: -config.indentUnit },
+                context: { type: "top", indented: -config2.indentUnit },
                 continuedLine: false,
                 lastTok: null,
                 varList: false
@@ -88244,7 +88388,7 @@
               var firstChar = textAfter && textAfter.charAt(0);
               var ct2 = state.context;
               var closed = ct2.type == closing[firstChar] || ct2.type == "keyword" && /^(?:end|until|else|elsif|when|rescue)\b/.test(textAfter);
-              return ct2.indented + (closed ? 0 : config.indentUnit) + (state.continuedLine ? config.indentUnit : 0);
+              return ct2.indented + (closed ? 0 : config2.indentUnit) + (state.continuedLine ? config2.indentUnit : 0);
             },
             electricInput: /^\s*(?:end|rescue|elsif|else|\})$/,
             lineComment: "#",
@@ -88269,7 +88413,7 @@
           mod(CodeMirror);
       })(function(CodeMirror3) {
         "use strict";
-        CodeMirror3.defineMode("sass", function(config) {
+        CodeMirror3.defineMode("sass", function(config2) {
           var cssMode = CodeMirror3.mimeModes["text/css"];
           var propertyKeywords = cssMode.propertyKeywords || {}, colorKeywords = cssMode.colorKeywords || {}, valueKeywords = cssMode.valueKeywords || {}, fontProperties = cssMode.fontProperties || {};
           function tokenRegexp(words) {
@@ -88383,7 +88527,7 @@
             if (state.indentCount == 0) {
               state.indentCount++;
               var lastScopeOffset = state.scopes[0].offset;
-              var currentOffset = lastScopeOffset + config.indentUnit;
+              var currentOffset = lastScopeOffset + config2.indentUnit;
               state.scopes.unshift({ offset: currentOffset });
             }
           }
@@ -88602,7 +88746,7 @@
             }
             if (style2 !== null) {
               var startOfToken = stream.pos - current.length;
-              var withCurrentIndent = startOfToken + config.indentUnit * state.indentCount;
+              var withCurrentIndent = startOfToken + config2.indentUnit * state.indentCount;
               var newScopes = [];
               for (var i5 = 0; i5 < state.scopes.length; i5++) {
                 var scope = state.scopes[i5];
@@ -88897,7 +89041,7 @@
           mod(CodeMirror);
       })(function(CodeMirror3) {
         "use strict";
-        CodeMirror3.defineMode("sql", function(config, parserConfig) {
+        CodeMirror3.defineMode("sql", function(config2, parserConfig) {
           var client = parserConfig.client || {}, atoms = parserConfig.atoms || { "false": true, "true": true, "null": true }, builtin = parserConfig.builtin || set2(defaultBuiltin), keywords = parserConfig.keywords || set2(sqlKeywords), operatorChars = parserConfig.operatorChars || /^[*+\-%<>!=&|~^\/]/, support = parserConfig.support || {}, hooks = parserConfig.hooks || {}, dateSQL = parserConfig.dateSQL || { "date": true, "time": true, "timestamp": true }, backslashStringEscapes = parserConfig.backslashStringEscapes !== false, brackets = parserConfig.brackets || /^[\{}\(\)\[\]]/, punctuation = parserConfig.punctuation || /^[;.,:]/;
           function tokenBase(stream, state) {
             var ch = stream.next();
@@ -89040,7 +89184,7 @@
               if (cx.align)
                 return cx.col + (closing ? 0 : 1);
               else
-                return cx.indent + (closing ? 0 : config.indentUnit);
+                return cx.indent + (closing ? 0 : config2.indentUnit);
             },
             blockCommentStart: "/*",
             blockCommentEnd: "*/",
@@ -89680,8 +89824,8 @@
           mod(CodeMirror);
       })(function(CodeMirror3) {
         "use strict";
-        CodeMirror3.defineMode("stylus", function(config) {
-          var indentUnit = config.indentUnit, indentUnitString = "", tagKeywords = keySet(tagKeywords_), tagVariablesRegexp = /^(a|b|i|s|col|em)$/i, propertyKeywords = keySet(propertyKeywords_), nonStandardPropertyKeywords = keySet(nonStandardPropertyKeywords_), valueKeywords = keySet(valueKeywords_), colorKeywords = keySet(colorKeywords_), documentTypes = keySet(documentTypes_), documentTypesRegexp = wordRegexp(documentTypes_), mediaFeatures = keySet(mediaFeatures_), mediaTypes = keySet(mediaTypes_), fontProperties = keySet(fontProperties_), operatorsRegexp = /^\s*([.]{2,3}|&&|\|\||\*\*|[?!=:]?=|[-+*\/%<>]=?|\?:|\~)/, wordOperatorKeywordsRegexp = wordRegexp(wordOperatorKeywords_), blockKeywords = keySet(blockKeywords_), vendorPrefixesRegexp = new RegExp(/^\-(moz|ms|o|webkit)-/i), commonAtoms = keySet(commonAtoms_), firstWordMatch = "", states = {}, ch, style2, type, override;
+        CodeMirror3.defineMode("stylus", function(config2) {
+          var indentUnit = config2.indentUnit, indentUnitString = "", tagKeywords = keySet(tagKeywords_), tagVariablesRegexp = /^(a|b|i|s|col|em)$/i, propertyKeywords = keySet(propertyKeywords_), nonStandardPropertyKeywords = keySet(nonStandardPropertyKeywords_), valueKeywords = keySet(valueKeywords_), colorKeywords = keySet(colorKeywords_), documentTypes = keySet(documentTypes_), documentTypesRegexp = wordRegexp(documentTypes_), mediaFeatures = keySet(mediaFeatures_), mediaTypes = keySet(mediaTypes_), fontProperties = keySet(fontProperties_), operatorsRegexp = /^\s*([.]{2,3}|&&|\|\||\*\*|[?!=:]?=|[-+*\/%<>]=?|\?:|\~)/, wordOperatorKeywordsRegexp = wordRegexp(wordOperatorKeywords_), blockKeywords = keySet(blockKeywords_), vendorPrefixesRegexp = new RegExp(/^\-(moz|ms|o|webkit)-/i), commonAtoms = keySet(commonAtoms_), firstWordMatch = "", states = {}, ch, style2, type, override;
           while (indentUnitString.length < indentUnit)
             indentUnitString += " ";
           function tokenBase(stream, state) {
@@ -90298,7 +90442,7 @@
           mod(CodeMirror);
       })(function(CodeMirror3) {
         "use strict";
-        CodeMirror3.defineMode("pug", function(config) {
+        CodeMirror3.defineMode("pug", function(config2) {
           var KEYWORD = "keyword";
           var DOCTYPE = "meta";
           var ID = "builtin";
@@ -90308,7 +90452,7 @@
             "(": ")",
             "[": "]"
           };
-          var jsMode = CodeMirror3.getMode(config, "javascript");
+          var jsMode = CodeMirror3.getMode(config2, "javascript");
           function State2() {
             this.javaScriptLine = false;
             this.javaScriptLineExcludesColon = false;
@@ -90567,14 +90711,14 @@
           function filter2(stream, state) {
             if (stream.match(/^:([\w\-]+)/)) {
               var innerMode2;
-              if (config && config.innerModes) {
-                innerMode2 = config.innerModes(stream.current().substring(1));
+              if (config2 && config2.innerModes) {
+                innerMode2 = config2.innerModes(stream.current().substring(1));
               }
               if (!innerMode2) {
                 innerMode2 = stream.current().substring(1);
               }
               if (typeof innerMode2 === "string") {
-                innerMode2 = CodeMirror3.getMode(config, innerMode2);
+                innerMode2 = CodeMirror3.getMode(config2, innerMode2);
               }
               setInnerMode(stream, state, innerMode2);
               return "atom";
@@ -90700,9 +90844,9 @@
           }
           function setInnerMode(stream, state, mode) {
             mode = CodeMirror3.mimeModes[mode] || mode;
-            mode = config.innerModes ? config.innerModes(mode) || mode : mode;
+            mode = config2.innerModes ? config2.innerModes(mode) || mode : mode;
             mode = CodeMirror3.mimeModes[mode] || mode;
-            mode = CodeMirror3.getMode(config, mode);
+            mode = CodeMirror3.getMode(config2, mode);
             state.indentOf = stream.indentation();
             if (mode && mode.name !== "null") {
               state.innerMode = mode;
@@ -90934,12 +91078,12 @@
             blockCommentEnd: "--}}"
           }
         });
-        CodeMirror3.defineMode("handlebars", function(config, parserConfig) {
-          var handlebars = CodeMirror3.getMode(config, "handlebars-tags");
+        CodeMirror3.defineMode("handlebars", function(config2, parserConfig) {
+          var handlebars = CodeMirror3.getMode(config2, "handlebars-tags");
           if (!parserConfig || !parserConfig.base)
             return handlebars;
           return CodeMirror3.multiplexingMode(
-            CodeMirror3.getMode(config, parserConfig.base),
+            CodeMirror3.getMode(config2, parserConfig.base),
             { open: "{{", close: /\}\}\}?/, mode: handlebars, parseDelimiters: true }
           );
         });
@@ -91010,7 +91154,7 @@
             [null, null, "vue-template"]
           ]
         };
-        CodeMirror3.defineMode("vue-template", function(config, parserConfig) {
+        CodeMirror3.defineMode("vue-template", function(config2, parserConfig) {
           var mustacheOverlay = {
             token: function(stream) {
               if (stream.match(/^\{\{.*?\}\}/))
@@ -91020,10 +91164,10 @@
               return null;
             }
           };
-          return CodeMirror3.overlayMode(CodeMirror3.getMode(config, parserConfig.backdrop || "text/html"), mustacheOverlay);
+          return CodeMirror3.overlayMode(CodeMirror3.getMode(config2, parserConfig.backdrop || "text/html"), mustacheOverlay);
         });
-        CodeMirror3.defineMode("vue", function(config) {
-          return CodeMirror3.getMode(config, { name: "htmlmixed", tags: tagLanguages });
+        CodeMirror3.defineMode("vue", function(config2) {
+          return CodeMirror3.getMode(config2, { name: "htmlmixed", tags: tagLanguages });
         }, "htmlmixed", "xml", "javascript", "coffeescript", "css", "sass", "stylus", "pug", "handlebars");
         CodeMirror3.defineMIME("script/x-vue", "vue");
         CodeMirror3.defineMIME("text/x-vue", "vue");
@@ -93640,16 +93784,16 @@
       ];
       reverseUnits = orderedUnits.slice(0).reverse();
       Duration = class {
-        constructor(config) {
-          const accurate = config.conversionAccuracy === "longterm" || false;
+        constructor(config2) {
+          const accurate = config2.conversionAccuracy === "longterm" || false;
           let matrix = accurate ? accurateMatrix : casualMatrix;
-          if (config.matrix) {
-            matrix = config.matrix;
+          if (config2.matrix) {
+            matrix = config2.matrix;
           }
-          this.values = config.values;
-          this.loc = config.loc || Locale.create();
+          this.values = config2.values;
+          this.loc = config2.loc || Locale.create();
           this.conversionAccuracy = accurate ? "longterm" : "casual";
-          this.invalid = config.invalid || null;
+          this.invalid = config2.invalid || null;
           this.matrix = matrix;
           this.isLuxonDuration = true;
         }
@@ -94029,10 +94173,10 @@
       init_formats();
       INVALID2 = "Invalid Interval";
       Interval = class {
-        constructor(config) {
-          this.s = config.start;
-          this.e = config.end;
-          this.invalid = config.invalid || null;
+        constructor(config2) {
+          this.s = config2.start;
+          this.e = config2.end;
+          this.invalid = config2.invalid || null;
           this.isLuxonInterval = true;
         }
         static invalid(reason, explanation = null) {
@@ -95203,17 +95347,17 @@
       orderedOrdinalUnits = ["year", "ordinal", "hour", "minute", "second", "millisecond"];
       zoneOffsetGuessCache = {};
       DateTime = class {
-        constructor(config) {
-          const zone = config.zone || Settings.defaultZone;
-          let invalid = config.invalid || (Number.isNaN(config.ts) ? new Invalid("invalid input") : null) || (!zone.isValid ? unsupportedZone(zone) : null);
-          this.ts = isUndefined(config.ts) ? Settings.now() : config.ts;
+        constructor(config2) {
+          const zone = config2.zone || Settings.defaultZone;
+          let invalid = config2.invalid || (Number.isNaN(config2.ts) ? new Invalid("invalid input") : null) || (!zone.isValid ? unsupportedZone(zone) : null);
+          this.ts = isUndefined(config2.ts) ? Settings.now() : config2.ts;
           let c4 = null, o5 = null;
           if (!invalid) {
-            const unchanged = config.old && config.old.ts === this.ts && config.old.zone.equals(zone);
+            const unchanged = config2.old && config2.old.ts === this.ts && config2.old.zone.equals(zone);
             if (unchanged) {
-              [c4, o5] = [config.old.c, config.old.o];
+              [c4, o5] = [config2.old.c, config2.old.o];
             } else {
-              const ot2 = isNumber2(config.o) && !config.old ? config.o : zone.offset(this.ts);
+              const ot2 = isNumber2(config2.o) && !config2.old ? config2.o : zone.offset(this.ts);
               c4 = tsToObj(this.ts, ot2);
               invalid = Number.isNaN(c4.year) ? new Invalid("invalid input") : null;
               c4 = invalid ? null : c4;
@@ -95221,7 +95365,7 @@
             }
           }
           this._zone = zone;
-          this.loc = config.loc || Locale.create();
+          this.loc = config2.loc || Locale.create();
           this.invalid = invalid;
           this.weekData = null;
           this.localWeekData = null;
@@ -96459,14 +96603,14 @@
     }
     return date1.getTime() - date2.getTime();
   }
-  function getDefaultHours(config) {
-    var hours = config.defaultHour;
-    var minutes = config.defaultMinute;
-    var seconds = config.defaultSeconds;
-    if (config.minDate !== void 0) {
-      var minHour = config.minDate.getHours();
-      var minMinutes = config.minDate.getMinutes();
-      var minSeconds = config.minDate.getSeconds();
+  function getDefaultHours(config2) {
+    var hours = config2.defaultHour;
+    var minutes = config2.defaultMinute;
+    var seconds = config2.defaultSeconds;
+    if (config2.minDate !== void 0) {
+      var minHour = config2.minDate.getHours();
+      var minMinutes = config2.minDate.getMinutes();
+      var minSeconds = config2.minDate.getSeconds();
       if (hours < minHour) {
         hours = minHour;
       }
@@ -96474,16 +96618,16 @@
         minutes = minMinutes;
       }
       if (hours === minHour && minutes === minMinutes && seconds < minSeconds)
-        seconds = config.minDate.getSeconds();
+        seconds = config2.minDate.getSeconds();
     }
-    if (config.maxDate !== void 0) {
-      var maxHr = config.maxDate.getHours();
-      var maxMinutes = config.maxDate.getMinutes();
+    if (config2.maxDate !== void 0) {
+      var maxHr = config2.maxDate.getHours();
+      var maxMinutes = config2.maxDate.getMinutes();
       hours = Math.min(hours, maxHr);
       if (hours === maxHr)
         minutes = Math.min(maxMinutes, minutes);
       if (hours === maxHr && minutes === maxMinutes)
-        seconds = config.maxDate.getSeconds();
+        seconds = config2.maxDate.getSeconds();
     }
     return { hours, minutes, seconds };
   }
@@ -96494,19 +96638,19 @@
       init_options();
       init_default();
       createDateFormatter = function(_a) {
-        var _b = _a.config, config = _b === void 0 ? defaults2 : _b, _c = _a.l10n, l10n = _c === void 0 ? english : _c, _d = _a.isMobile, isMobile = _d === void 0 ? false : _d;
+        var _b = _a.config, config2 = _b === void 0 ? defaults2 : _b, _c = _a.l10n, l10n = _c === void 0 ? english : _c, _d = _a.isMobile, isMobile = _d === void 0 ? false : _d;
         return function(dateObj, frmt, overrideLocale) {
           var locale2 = overrideLocale || l10n;
-          if (config.formatDate !== void 0 && !isMobile) {
-            return config.formatDate(dateObj, frmt, locale2);
+          if (config2.formatDate !== void 0 && !isMobile) {
+            return config2.formatDate(dateObj, frmt, locale2);
           }
           return frmt.split("").map(function(c4, i5, arr) {
-            return formats[c4] && arr[i5 - 1] !== "\\" ? formats[c4](dateObj, locale2, config) : c4 !== "\\" ? c4 : "";
+            return formats[c4] && arr[i5 - 1] !== "\\" ? formats[c4](dateObj, locale2, config2) : c4 !== "\\" ? c4 : "";
           }).join("");
         };
       };
       createDateParser = function(_a) {
-        var _b = _a.config, config = _b === void 0 ? defaults2 : _b, _c = _a.l10n, l10n = _c === void 0 ? english : _c;
+        var _b = _a.config, config2 = _b === void 0 ? defaults2 : _b, _c = _a.l10n, l10n = _c === void 0 ? english : _c;
         return function(date, givenFormat, timeless, customLocale) {
           if (date !== 0 && !date)
             return void 0;
@@ -96518,13 +96662,13 @@
           else if (typeof date !== "string" && date.toFixed !== void 0)
             parsedDate = new Date(date);
           else if (typeof date === "string") {
-            var format2 = givenFormat || (config || defaults2).dateFormat;
+            var format2 = givenFormat || (config2 || defaults2).dateFormat;
             var datestr = String(date).trim();
             if (datestr === "today") {
               parsedDate = new Date();
               timeless = true;
-            } else if (config && config.parseDate) {
-              parsedDate = config.parseDate(date, format2);
+            } else if (config2 && config2.parseDate) {
+              parsedDate = config2.parseDate(date, format2);
             } else if (/Z$/.test(datestr) || /GMT$/.test(datestr)) {
               parsedDate = new Date(date);
             } else {
@@ -96545,7 +96689,7 @@
                 } else if (!isBackSlash)
                   regexStr += ".";
               }
-              parsedDate = !config || !config.noCalendar ? new Date(new Date().getFullYear(), 0, 1, 0, 0, 0, 0) : new Date(new Date().setHours(0, 0, 0, 0));
+              parsedDate = !config2 || !config2.noCalendar ? new Date(new Date().getFullYear(), 0, 1, 0, 0, 0, 0) : new Date(new Date().setHours(0, 0, 0, 0));
               ops.forEach(function(_a2) {
                 var fn3 = _a2.fn, val = _a2.val;
                 return parsedDate = fn3(parsedDate, val, locale2) || parsedDate;
@@ -96554,7 +96698,7 @@
             }
           }
           if (!(parsedDate instanceof Date && !isNaN(parsedDate.getTime()))) {
-            config.errorHandler(new Error("Invalid date provided: " + dateOrig));
+            config2.errorHandler(new Error("Invalid date provided: " + dateOrig));
             return void 0;
           }
           if (timeless === true)
@@ -96684,17 +96828,17 @@
       return fn3.bind(self2);
     }
     function setCalendarWidth() {
-      var config = self2.config;
-      if (config.weekNumbers === false && config.showMonths === 1) {
+      var config2 = self2.config;
+      if (config2.weekNumbers === false && config2.showMonths === 1) {
         return;
-      } else if (config.noCalendar !== true) {
+      } else if (config2.noCalendar !== true) {
         window.requestAnimationFrame(function() {
           if (self2.calendarContainer !== void 0) {
             self2.calendarContainer.style.visibility = "hidden";
             self2.calendarContainer.style.display = "block";
           }
           if (self2.daysContainer !== void 0) {
-            var daysWidth = (self2.days.offsetWidth + 1) * config.showMonths;
+            var daysWidth = (self2.days.offsetWidth + 1) * config2.showMonths;
             self2.daysContainer.style.width = daysWidth + "px";
             self2.calendarContainer.style.width = daysWidth + (self2.weekWrapper !== void 0 ? self2.weekWrapper.offsetWidth : 0) + "px";
             self2.calendarContainer.style.removeProperty("visibility");
@@ -98309,7 +98453,7 @@
     init3();
     return self2;
   }
-  function _flatpickr(nodeList, config) {
+  function _flatpickr(nodeList, config2) {
     var nodes = Array.prototype.slice.call(nodeList).filter(function(x4) {
       return x4 instanceof HTMLElement;
     });
@@ -98323,7 +98467,7 @@
           node._flatpickr.destroy();
           node._flatpickr = void 0;
         }
-        node._flatpickr = FlatpickrInstance(node, config || {});
+        node._flatpickr = FlatpickrInstance(node, config2 || {});
         instances2.push(node._flatpickr);
       } catch (e5) {
         console.error(e5);
@@ -98363,20 +98507,20 @@
       };
       DEBOUNCED_CHANGE_MS = 300;
       if (typeof HTMLElement !== "undefined" && typeof HTMLCollection !== "undefined" && typeof NodeList !== "undefined") {
-        HTMLCollection.prototype.flatpickr = NodeList.prototype.flatpickr = function(config) {
-          return _flatpickr(this, config);
+        HTMLCollection.prototype.flatpickr = NodeList.prototype.flatpickr = function(config2) {
+          return _flatpickr(this, config2);
         };
-        HTMLElement.prototype.flatpickr = function(config) {
-          return _flatpickr([this], config);
+        HTMLElement.prototype.flatpickr = function(config2) {
+          return _flatpickr([this], config2);
         };
       }
-      flatpickr = function(selector, config) {
+      flatpickr = function(selector, config2) {
         if (typeof selector === "string") {
-          return _flatpickr(window.document.querySelectorAll(selector), config);
+          return _flatpickr(window.document.querySelectorAll(selector), config2);
         } else if (selector instanceof Node) {
-          return _flatpickr([selector], config);
+          return _flatpickr([selector], config2);
         } else {
-          return _flatpickr(selector, config);
+          return _flatpickr(selector, config2);
         }
       };
       flatpickr.defaultConfig = {};
@@ -98387,15 +98531,15 @@
       flatpickr.localize = function(l10n) {
         flatpickr.l10ns.default = __assign(__assign({}, flatpickr.l10ns.default), l10n);
       };
-      flatpickr.setDefaults = function(config) {
-        flatpickr.defaultConfig = __assign(__assign({}, flatpickr.defaultConfig), config);
+      flatpickr.setDefaults = function(config2) {
+        flatpickr.defaultConfig = __assign(__assign({}, flatpickr.defaultConfig), config2);
       };
       flatpickr.parseDate = createDateParser({});
       flatpickr.formatDate = createDateFormatter({});
       flatpickr.compareDates = compareDates;
       if (typeof jQuery !== "undefined" && typeof jQuery.fn !== "undefined") {
-        jQuery.fn.flatpickr = function(config) {
-          return _flatpickr(this, config);
+        jQuery.fn.flatpickr = function(config2) {
+          return _flatpickr(this, config2);
         };
       }
       Date.prototype.fp_incr = function(days) {
@@ -109618,12 +109762,12 @@
         };
         CodeMirror3.defineMode("xml", function(editorConf, config_) {
           var indentUnit = editorConf.indentUnit;
-          var config = {};
+          var config2 = {};
           var defaults4 = config_.htmlMode ? htmlConfig : xmlConfig;
           for (var prop in defaults4)
-            config[prop] = defaults4[prop];
+            config2[prop] = defaults4[prop];
           for (var prop in config_)
-            config[prop] = config_[prop];
+            config2[prop] = config_[prop];
           var type, setStyle3;
           function inText(stream, state) {
             function chain(parser) {
@@ -109750,7 +109894,7 @@
             this.tagName = tagName || "";
             this.indent = state.indented;
             this.startOfLine = startOfLine;
-            if (config.doNotIndent.hasOwnProperty(tagName) || state.context && state.context.noIndent)
+            if (config2.doNotIndent.hasOwnProperty(tagName) || state.context && state.context.noIndent)
               this.noIndent = true;
           }
           function popContext(state) {
@@ -109764,7 +109908,7 @@
                 return;
               }
               parentTagName = state.context.tagName;
-              if (!config.contextGrabbers.hasOwnProperty(lower(parentTagName)) || !config.contextGrabbers[lower(parentTagName)].hasOwnProperty(lower(nextTagName))) {
+              if (!config2.contextGrabbers.hasOwnProperty(lower(parentTagName)) || !config2.contextGrabbers[lower(parentTagName)].hasOwnProperty(lower(nextTagName))) {
                 return;
               }
               popContext(state);
@@ -109785,7 +109929,7 @@
               state.tagName = stream.current();
               setStyle3 = "tag";
               return attrState;
-            } else if (config.allowMissingTagName && type2 == "endTag") {
+            } else if (config2.allowMissingTagName && type2 == "endTag") {
               setStyle3 = "tag bracket";
               return attrState(type2, stream, state);
             } else {
@@ -109796,16 +109940,16 @@
           function closeTagNameState(type2, stream, state) {
             if (type2 == "word") {
               var tagName = stream.current();
-              if (state.context && state.context.tagName != tagName && config.implicitlyClosed.hasOwnProperty(lower(state.context.tagName)))
+              if (state.context && state.context.tagName != tagName && config2.implicitlyClosed.hasOwnProperty(lower(state.context.tagName)))
                 popContext(state);
-              if (state.context && state.context.tagName == tagName || config.matchClosing === false) {
+              if (state.context && state.context.tagName == tagName || config2.matchClosing === false) {
                 setStyle3 = "tag";
                 return closeState;
               } else {
                 setStyle3 = "tag error";
                 return closeStateErr;
               }
-            } else if (config.allowMissingTagName && type2 == "endTag") {
+            } else if (config2.allowMissingTagName && type2 == "endTag") {
               setStyle3 = "tag bracket";
               return closeState(type2, stream, state);
             } else {
@@ -109832,7 +109976,7 @@
             } else if (type2 == "endTag" || type2 == "selfcloseTag") {
               var tagName = state.tagName, tagStart = state.tagStart;
               state.tagName = state.tagStart = null;
-              if (type2 == "selfcloseTag" || config.autoSelfClosers.hasOwnProperty(lower(tagName))) {
+              if (type2 == "selfcloseTag" || config2.autoSelfClosers.hasOwnProperty(lower(tagName))) {
                 maybePopContext(state, tagName);
               } else {
                 maybePopContext(state, tagName);
@@ -109846,14 +109990,14 @@
           function attrEqState(type2, stream, state) {
             if (type2 == "equals")
               return attrValueState;
-            if (!config.allowMissing)
+            if (!config2.allowMissing)
               setStyle3 = "error";
             return attrState(type2, stream, state);
           }
           function attrValueState(type2, stream, state) {
             if (type2 == "string")
               return attrContinuedState;
-            if (type2 == "word" && config.allowUnquoted) {
+            if (type2 == "word" && config2.allowUnquoted) {
               setStyle3 = "string";
               return attrState;
             }
@@ -109907,12 +110051,12 @@
               if (state.tokenize != inTag && state.tokenize != inText)
                 return fullLine ? fullLine.match(/^(\s*)/)[0].length : 0;
               if (state.tagName) {
-                if (config.multilineTagIndentPastTag !== false)
+                if (config2.multilineTagIndentPastTag !== false)
                   return state.tagStart + state.tagName.length + 2;
                 else
-                  return state.tagStart + indentUnit * (config.multilineTagIndentFactor || 1);
+                  return state.tagStart + indentUnit * (config2.multilineTagIndentFactor || 1);
               }
-              if (config.alignCDATA && /<!\[CDATA\[/.test(textAfter))
+              if (config2.alignCDATA && /<!\[CDATA\[/.test(textAfter))
                 return 0;
               var tagAfter = textAfter && /^<(\/)?([\w_:\.-]*)/.exec(textAfter);
               if (tagAfter && tagAfter[1]) {
@@ -109920,7 +110064,7 @@
                   if (context.tagName == tagAfter[2]) {
                     context = context.prev;
                     break;
-                  } else if (config.implicitlyClosed.hasOwnProperty(lower(context.tagName))) {
+                  } else if (config2.implicitlyClosed.hasOwnProperty(lower(context.tagName))) {
                     context = context.prev;
                   } else {
                     break;
@@ -109928,7 +110072,7 @@
                 }
               } else if (tagAfter) {
                 while (context) {
-                  var grabbers = config.contextGrabbers[lower(context.tagName)];
+                  var grabbers = config2.contextGrabbers[lower(context.tagName)];
                   if (grabbers && grabbers.hasOwnProperty(lower(tagAfter[2])))
                     context = context.prev;
                   else
@@ -109945,8 +110089,8 @@
             electricInput: /<\/[\s\w:]+>$/,
             blockCommentStart: "<!--",
             blockCommentEnd: "-->",
-            configuration: config.htmlMode ? "html" : "xml",
-            helperType: config.htmlMode ? "html" : "xml",
+            configuration: config2.htmlMode ? "html" : "xml",
+            helperType: config2.htmlMode ? "html" : "xml",
             skipAttribute: function(state) {
               if (state.state == attrValueState)
                 state.state = attrState;
@@ -111662,7 +111806,7 @@
       })(function(CodeMirror3) {
         "use strict";
         var urlRE = /^((?:(?:aaas?|about|acap|adiumxtra|af[ps]|aim|apt|attachment|aw|beshare|bitcoin|bolo|callto|cap|chrome(?:-extension)?|cid|coap|com-eventbrite-attendee|content|crid|cvs|data|dav|dict|dlna-(?:playcontainer|playsingle)|dns|doi|dtn|dvb|ed2k|facetime|feed|file|finger|fish|ftp|geo|gg|git|gizmoproject|go|gopher|gtalk|h323|hcp|https?|iax|icap|icon|im|imap|info|ipn|ipp|irc[6s]?|iris(?:\.beep|\.lwz|\.xpc|\.xpcs)?|itms|jar|javascript|jms|keyparc|lastfm|ldaps?|magnet|mailto|maps|market|message|mid|mms|ms-help|msnim|msrps?|mtqp|mumble|mupdate|mvn|news|nfs|nih?|nntp|notes|oid|opaquelocktoken|palm|paparazzi|platform|pop|pres|proxy|psyc|query|res(?:ource)?|rmi|rsync|rtmp|rtsp|secondlife|service|session|sftp|sgn|shttp|sieve|sips?|skype|sm[bs]|snmp|soap\.beeps?|soldat|spotify|ssh|steam|svn|tag|teamspeak|tel(?:net)?|tftp|things|thismessage|tip|tn3270|tv|udp|unreal|urn|ut2004|vemmi|ventrilo|view-source|webcal|wss?|wtai|wyciwyg|xcon(?:-userid)?|xfire|xmlrpc\.beeps?|xmpp|xri|ymsgr|z39\.50[rs]?):(?:\/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]|\([^\s()<>]*\))+(?:\([^\s()<>]*\)|[^\s`*!()\[\]{};:'".,<>?«»“”‘’]))/i;
-        CodeMirror3.defineMode("gfm", function(config, modeConfig) {
+        CodeMirror3.defineMode("gfm", function(config2, modeConfig) {
           var codeDepth = 0;
           function blankLine(state) {
             state.code = false;
@@ -111753,7 +111897,7 @@
             markdownConfig[attr] = modeConfig[attr];
           }
           markdownConfig.name = "markdown";
-          return CodeMirror3.overlayMode(CodeMirror3.getMode(config, markdownConfig), gfmOverlay);
+          return CodeMirror3.overlayMode(CodeMirror3.getMode(config2, markdownConfig), gfmOverlay);
         }, "markdown");
         CodeMirror3.defineMIME("text/x-gfm", "gfm");
       });
@@ -112355,7 +112499,7 @@
             return String.prototype.indexOf.apply(this, arguments) !== -1;
           };
         }
-        options.codeMirrorInstance.defineMode("spell-checker", function(config) {
+        options.codeMirrorInstance.defineMode("spell-checker", function(config2) {
           if (!CodeMirrorSpellChecker.aff_loading) {
             CodeMirrorSpellChecker.aff_loading = true;
             var xhr_aff = new XMLHttpRequest();
@@ -112409,8 +112553,8 @@
             }
           };
           var mode = options.codeMirrorInstance.getMode(
-            config,
-            config.backdrop || "text/plain"
+            config2,
+            config2.backdrop || "text/plain"
           );
           return options.codeMirrorInstance.overlayMode(mode, overlay, true);
         });
@@ -116280,8 +116424,8 @@
         document.addEventListener("keydown", this.documentOnKeyDown, false);
         var mode, backdrop;
         if (options.overlayMode) {
-          CodeMirror3.defineMode("overlay-mode", function(config) {
-            return CodeMirror3.overlayMode(CodeMirror3.getMode(config, options.spellChecker !== false ? "spell-checker" : "gfm"), options.overlayMode.mode, options.overlayMode.combine);
+          CodeMirror3.defineMode("overlay-mode", function(config2) {
+            return CodeMirror3.overlayMode(CodeMirror3.getMode(config2, options.spellChecker !== false ? "spell-checker" : "gfm"), options.overlayMode.mode, options.overlayMode.combine);
           });
           mode = "overlay-mode";
           backdrop = options.parsingConfig;
@@ -117364,7 +117508,7 @@
         const mathMlDisallowed = freeze(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]);
         const text = freeze(["#text"]);
         const html = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "pattern", "placeholder", "playsinline", "popover", "popovertarget", "popovertargetaction", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "wrap", "xmlns", "slot"]);
-        const svg = freeze(["accent-height", "accumulate", "additive", "alignment-baseline", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]);
+        const svg = freeze(["accent-height", "accumulate", "additive", "alignment-baseline", "amplitude", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "exponent", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "intercept", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "slope", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "tablevalues", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]);
         const mathMl = freeze(["accent", "accentunder", "align", "bevelled", "close", "columnsalign", "columnlines", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lspace", "lquote", "mathbackground", "mathcolor", "mathsize", "mathvariant", "maxsize", "minsize", "movablelimits", "notation", "numalign", "open", "rowalign", "rowlines", "rowspacing", "rowspan", "rspace", "rquote", "scriptlevel", "scriptminsize", "scriptsizemultiplier", "selection", "separator", "separators", "stretchy", "subscriptshift", "supscriptshift", "symmetric", "voffset", "width", "xmlns"]);
         const xml = freeze(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]);
         const MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm);
@@ -117438,7 +117582,7 @@
         function createDOMPurify() {
           let window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
           const DOMPurify2 = (root) => createDOMPurify(root);
-          DOMPurify2.version = "3.1.6";
+          DOMPurify2.version = "3.1.7";
           DOMPurify2.removed = [];
           if (!window2 || !window2.document || window2.document.nodeType !== NODE_TYPE.document) {
             DOMPurify2.isSupported = false;
@@ -117702,7 +117846,7 @@
             CONFIG = cfg;
           };
           const MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
-          const HTML_INTEGRATION_POINTS = addToSet({}, ["foreignobject", "annotation-xml"]);
+          const HTML_INTEGRATION_POINTS = addToSet({}, ["annotation-xml"]);
           const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ["title", "style", "font", "a", "script"]);
           const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
           const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
@@ -117977,10 +118121,6 @@
               hookEvent.forceKeepAttr = void 0;
               _executeHook("uponSanitizeAttribute", currentNode, hookEvent);
               value = hookEvent.attrValue;
-              if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|title)/i, value)) {
-                _removeAttribute(name, currentNode);
-                continue;
-              }
               if (hookEvent.forceKeepAttr) {
                 continue;
               }
@@ -118005,6 +118145,10 @@
                 _removeAttribute(name, currentNode);
                 value = SANITIZE_NAMED_PROPS_PREFIX + value;
               }
+              if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|title)/i, value)) {
+                _removeAttribute(name, currentNode);
+                continue;
+              }
               if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function") {
                 if (namespaceURI)
                   ;
@@ -138230,24 +138374,24 @@
       };
       baseFields = [
         new FieldDesc("doc", {
-          init(config) {
-            return config.doc || config.schema.topNodeType.createAndFill();
+          init(config2) {
+            return config2.doc || config2.schema.topNodeType.createAndFill();
           },
           apply(tr2) {
             return tr2.doc;
           }
         }),
         new FieldDesc("selection", {
-          init(config, instance) {
-            return config.selection || Selection.atStart(instance.doc);
+          init(config2, instance) {
+            return config2.selection || Selection.atStart(instance.doc);
           },
           apply(tr2) {
             return tr2.selection;
           }
         }),
         new FieldDesc("storedMarks", {
-          init(config) {
-            return config.storedMarks || null;
+          init(config2) {
+            return config2.storedMarks || null;
           },
           apply(tr2, _marks, _old, state) {
             return state.selection.$cursor ? tr2.storedMarks : null;
@@ -138280,8 +138424,8 @@
         }
       };
       EditorState = class {
-        constructor(config) {
-          this.config = config;
+        constructor(config2) {
+          this.config = config2;
         }
         get schema() {
           return this.config.schema;
@@ -138344,19 +138488,19 @@
         get tr() {
           return new Transaction(this);
         }
-        static create(config) {
-          let $config = new Configuration(config.doc ? config.doc.type.schema : config.schema, config.plugins);
+        static create(config2) {
+          let $config = new Configuration(config2.doc ? config2.doc.type.schema : config2.schema, config2.plugins);
           let instance = new EditorState($config);
           for (let i5 = 0; i5 < $config.fields.length; i5++)
-            instance[$config.fields[i5].name] = $config.fields[i5].init(config, instance);
+            instance[$config.fields[i5].name] = $config.fields[i5].init(config2, instance);
           return instance;
         }
-        reconfigure(config) {
-          let $config = new Configuration(this.schema, config.plugins);
+        reconfigure(config2) {
+          let $config = new Configuration(this.schema, config2.plugins);
           let fields = $config.fields, instance = new EditorState($config);
           for (let i5 = 0; i5 < fields.length; i5++) {
             let name = fields[i5].name;
-            instance[name] = this.hasOwnProperty(name) ? this[name] : fields[i5].init(config, instance);
+            instance[name] = this.hasOwnProperty(name) ? this[name] : fields[i5].init(config2, instance);
           }
           return instance;
         }
@@ -138374,31 +138518,31 @@
             }
           return result;
         }
-        static fromJSON(config, json, pluginFields) {
+        static fromJSON(config2, json, pluginFields) {
           if (!json)
             throw new RangeError("Invalid input for EditorState.fromJSON");
-          if (!config.schema)
+          if (!config2.schema)
             throw new RangeError("Required config field 'schema' missing");
-          let $config = new Configuration(config.schema, config.plugins);
+          let $config = new Configuration(config2.schema, config2.plugins);
           let instance = new EditorState($config);
           $config.fields.forEach((field) => {
             if (field.name == "doc") {
-              instance.doc = Node2.fromJSON(config.schema, json.doc);
+              instance.doc = Node2.fromJSON(config2.schema, json.doc);
             } else if (field.name == "selection") {
               instance.selection = Selection.fromJSON(instance.doc, json.selection);
             } else if (field.name == "storedMarks") {
               if (json.storedMarks)
-                instance.storedMarks = json.storedMarks.map(config.schema.markFromJSON);
+                instance.storedMarks = json.storedMarks.map(config2.schema.markFromJSON);
             } else {
               if (pluginFields)
                 for (let prop in pluginFields) {
                   let plugin = pluginFields[prop], state = plugin.spec.state;
                   if (plugin.key == field.name && state && state.fromJSON && Object.prototype.hasOwnProperty.call(json, prop)) {
-                    instance[field.name] = state.fromJSON.call(plugin, config, json[prop], instance);
+                    instance[field.name] = state.fromJSON.call(plugin, config2, json[prop], instance);
                     return;
                   }
                 }
-              instance[field.name] = field.init(config, instance);
+              instance[field.name] = field.init(config2, instance);
             }
           });
           return instance;
@@ -139110,14 +139254,14 @@
       try {
         let pos = doc4.caretPositionFromPoint(x4, y4);
         if (pos)
-          return { node: pos.offsetNode, offset: pos.offset };
+          return { node: pos.offsetNode, offset: Math.min(nodeSize(pos.offsetNode), pos.offset) };
       } catch (_3) {
       }
     }
     if (doc4.caretRangeFromPoint) {
       let range2 = doc4.caretRangeFromPoint(x4, y4);
       if (range2)
-        return { node: range2.startContainer, offset: range2.startOffset };
+        return { node: range2.startContainer, offset: Math.min(nodeSize(range2.startContainer), range2.startOffset) };
     }
   }
   function windowRect(doc4) {
@@ -139548,6 +139692,8 @@
       return false;
     let offset3 = $head.parentOffset, atStart = !offset3, atEnd = offset3 == $head.parent.content.size;
     let sel = view.domSelection();
+    if (!sel)
+      return $head.pos == $head.start() || $head.pos == $head.end();
     if (!maybeRTL.test($head.parent.textContent) || !sel.modify)
       return dir == "left" || dir == "backward" ? atStart : atEnd;
     return withFlushedState(view, state, () => {
@@ -139871,9 +140017,9 @@
     let head = view.docView.posFromDOM(domSel.focusNode, domSel.focusOffset, 1);
     if (head < 0)
       return null;
-    let $head = doc4.resolve(head), $anchor, selection;
+    let $head = doc4.resolve(head), anchor, selection;
     if (selectionCollapsed(domSel)) {
-      $anchor = $head;
+      anchor = head;
       while (nearestDesc && !nearestDesc.node)
         nearestDesc = nearestDesc.parent;
       let nearestDescNode = nearestDesc.node;
@@ -139882,11 +140028,24 @@
         selection = new NodeSelection(head == pos ? $head : doc4.resolve(pos));
       }
     } else {
-      let anchor = view.docView.posFromDOM(domSel.anchorNode, domSel.anchorOffset, 1);
+      if (domSel instanceof view.dom.ownerDocument.defaultView.Selection && domSel.rangeCount > 1) {
+        let min2 = head, max2 = head;
+        for (let i5 = 0; i5 < domSel.rangeCount; i5++) {
+          let range2 = domSel.getRangeAt(i5);
+          min2 = Math.min(min2, view.docView.posFromDOM(range2.startContainer, range2.startOffset, 1));
+          max2 = Math.max(max2, view.docView.posFromDOM(range2.endContainer, range2.endOffset, -1));
+        }
+        if (min2 < 0)
+          return null;
+        [anchor, head] = max2 == view.state.selection.anchor ? [max2, min2] : [min2, max2];
+        $head = doc4.resolve(head);
+      } else {
+        anchor = view.docView.posFromDOM(domSel.anchorNode, domSel.anchorOffset, 1);
+      }
       if (anchor < 0)
         return null;
-      $anchor = doc4.resolve(anchor);
     }
+    let $anchor = doc4.resolve(anchor);
     if (!selection) {
       let bias = origin == "pointer" || view.state.selection.head < $head.pos && !inWidget ? 1 : -1;
       selection = selectionBetween(view, $anchor, $head, bias);
@@ -139983,12 +140142,14 @@
   }
   function selectCursorWrapper(view) {
     let domSel = view.domSelection(), range2 = document.createRange();
+    if (!domSel)
+      return;
     let node = view.cursorWrapper.dom, img = node.nodeName == "IMG";
     if (img)
-      range2.setEnd(node.parentNode, domIndex(node) + 1);
+      range2.setStart(node.parentNode, domIndex(node) + 1);
     else
-      range2.setEnd(node, 0);
-    range2.collapse(false);
+      range2.setStart(node, 0);
+    range2.collapse(true);
     domSel.removeAllRanges();
     domSel.addRange(range2);
     if (!img && !view.state.selection.visible && ie && ie_version <= 11) {
@@ -140234,6 +140395,8 @@
       }
     }
     let sel = view.domSelection();
+    if (!sel)
+      return;
     if (selectionCollapsed(sel)) {
       let range2 = document.createRange();
       range2.setEnd(node, offset3);
@@ -140538,6 +140701,12 @@
   function detachedDoc() {
     return _detachedDoc || (_detachedDoc = document.implementation.createHTMLDocument("title"));
   }
+  function maybeWrapTrusted(html) {
+    let trustedTypes = window.trustedTypes;
+    if (!trustedTypes)
+      return html;
+    return trustedTypes.createPolicy("detachedDocument", { createHTML: (s6) => s6 }).createHTML(html);
+  }
   function readHTML(html) {
     let metas = /^(\s*<meta [^>]*>)*/.exec(html);
     if (metas)
@@ -140546,7 +140715,7 @@
     let firstTag = /<([a-z][^>\s]+)/i.exec(html), wrap3;
     if (wrap3 = firstTag && wrapMap[firstTag[1].toLowerCase()])
       html = wrap3.map((n7) => "<" + n7 + ">").join("") + html + wrap3.map((n7) => "</" + n7 + ">").reverse().join("");
-    elt.innerHTML = html;
+    elt.innerHTML = maybeWrapTrusted(html);
     if (wrap3)
       for (let i5 = 0; i5 < wrap3.length; i5++)
         elt = elt.querySelector(wrap3[i5]) || elt;
@@ -140650,6 +140819,8 @@
   function updateSelection(view, selection, origin) {
     if (!view.focused)
       view.focus();
+    if (view.state.selection.eq(selection))
+      return;
     let tr2 = view.state.tr.setSelection(selection);
     if (origin == "pointer")
       tr2.setMeta("pointer", true);
@@ -140772,15 +140943,17 @@
     event.initEvent("event", true, true);
     return event.timeStamp;
   }
-  function endComposition(view, forceUpdate = false) {
+  function endComposition(view, restarting = false) {
     if (android && view.domObserver.flushingSoon >= 0)
       return;
     view.domObserver.forceFlush();
     clearComposition(view);
-    if (forceUpdate || view.docView && view.docView.dirty) {
+    if (restarting || view.docView && view.docView.dirty) {
       let sel = selectionFromDOM(view);
       if (sel && !sel.eq(view.state.selection))
         view.dispatch(view.state.tr.setSelection(sel));
+      else if ((view.markCursor || restarting) && !view.state.selection.empty)
+        view.dispatch(view.state.tr.deleteSelection());
       else
         view.updateState(view.state);
       return true;
@@ -141181,6 +141354,8 @@
     }
     view.input.lastKeyCode = null;
     let change = findDiff(compare.content, parse4.doc.content, parse4.from, preferredPos, preferredSide);
+    if (change)
+      view.input.domChangeCount++;
     if ((ios && view.input.lastIOSEnter > Date.now() - 225 || android) && addedNodes.some((n7) => n7.nodeType == 1 && !isInline.test(n7.nodeName)) && (!change || change.endA >= change.endB) && view.someProp("handleKeyDown", (f4) => f4(view, keyEvent(13, "Enter")))) {
       view.input.lastIOSEnter = 0;
       return;
@@ -141201,7 +141376,6 @@
         return;
       }
     }
-    view.input.domChangeCount++;
     if (view.state.selection.from < view.state.selection.to && change.start == change.endB && view.state.selection instanceof TextSelection) {
       if (change.start > view.state.selection.from && change.start <= view.state.selection.from + 2 && view.state.selection.from >= parse4.from) {
         change.start = view.state.selection.from;
@@ -141395,7 +141569,7 @@
       dom.className = "ProseMirror-separator";
       dom.setAttribute("mark-placeholder", "true");
       dom.setAttribute("alt", "");
-      view.cursorWrapper = { dom, deco: Decoration.widget(view.state.selection.head, dom, { raw: true, marks: view.markCursor }) };
+      view.cursorWrapper = { dom, deco: Decoration.widget(view.state.selection.from, dom, { raw: true, marks: view.markCursor }) };
     } else {
       view.cursorWrapper = null;
     }
@@ -142388,6 +142562,7 @@
                 this.index++;
                 return true;
               } else if (!locked && (updated = this.recreateWrapper(next, node, outerDeco, innerDeco, view, pos))) {
+                this.destroyBetween(this.index, i5);
                 this.top.children[this.index] = updated;
                 if (updated.contentDOM) {
                   updated.dirty = CONTENT_DIRTY;
@@ -142404,7 +142579,7 @@
           return false;
         }
         recreateWrapper(next, node, outerDeco, innerDeco, view, pos) {
-          if (next.dirty || node.isAtom || !next.children.length || !next.node.content.eq(node.content))
+          if (next.dirty || node.isAtom || !next.children.length || !next.node.content.eq(node.content) || !sameOuterDeco(outerDeco, next.outerDeco) || !innerDeco.eq(next.innerDeco))
             return null;
           let wrapper = NodeViewDesc.create(this.top, node, outerDeco, innerDeco, view, pos);
           if (wrapper.contentDOM) {
@@ -142520,7 +142695,9 @@
         view.input.lastKeyCodeTime = Date.now();
         if (android && chrome2 && event.keyCode == 13)
           return;
-        if (event.keyCode != 229)
+        if (view.domObserver.selectionChanged(view.domSelectionRange()))
+          view.domObserver.flush();
+        else if (event.keyCode != 229)
           view.domObserver.forceFlush();
         if (ios && event.keyCode == 13 && !event.ctrlKey && !event.altKey && !event.metaKey) {
           let now3 = Date.now();
@@ -142688,13 +142865,13 @@
       editHandlers.compositionstart = editHandlers.compositionupdate = (view) => {
         if (!view.composing) {
           view.domObserver.flush();
-          let { state } = view, $pos = state.selection.$from;
-          if (state.selection.empty && (state.storedMarks || !$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some((m4) => m4.type.spec.inclusive === false))) {
+          let { state } = view, $pos = state.selection.$to;
+          if (state.selection instanceof TextSelection && (state.storedMarks || !$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some((m4) => m4.type.spec.inclusive === false))) {
             view.markCursor = view.state.storedMarks || $pos.marks();
             endComposition(view, true);
             view.markCursor = null;
           } else {
-            endComposition(view);
+            endComposition(view, !state.selection.empty);
             if (gecko && state.selection.empty && $pos.parentOffset && !$pos.textOffset && $pos.nodeBefore.marks.length) {
               let sel = view.domSelectionRange();
               for (let node = sel.focusNode, offset3 = sel.focusOffset; node && node.nodeType == 1 && offset3 != 0; ) {
@@ -142702,7 +142879,9 @@
                 if (!before)
                   break;
                 if (before.nodeType == 3) {
-                  view.domSelection().collapse(before, before.nodeValue.length);
+                  let sel2 = view.domSelection();
+                  if (sel2)
+                    sel2.collapse(before, before.nodeValue.length);
                   break;
                 } else {
                   node = before;
@@ -143179,6 +143358,9 @@
           }
           return result;
         }
+        forEachSet(f4) {
+          f4(this);
+        }
       };
       DecorationSet.empty = new DecorationSet([], []);
       DecorationSet.removeOverlap = removeOverlap;
@@ -143243,6 +143425,10 @@
               return new DecorationGroup(members.every((m4) => m4 instanceof DecorationSet) ? members : members.reduce((r6, m4) => r6.concat(m4 instanceof DecorationSet ? m4 : m4.members), []));
           }
         }
+        forEachSet(f4) {
+          for (let i5 = 0; i5 < this.members.length; i5++)
+            this.members[i5].forEachSet(f4);
+        }
       };
       observeOptions = {
         childList: true,
@@ -143388,6 +143574,9 @@
               this.queue.push(mut);
           return this.queue;
         }
+        selectionChanged(sel) {
+          return !this.suppressingSelectionUpdates && !this.currentSelection.eq(sel) && hasFocusAndSelection(this.view) && !this.ignoreSelectionChange(sel);
+        }
         flush() {
           let { view } = this;
           if (!view.docView || this.flushingSoon > -1)
@@ -143395,8 +143584,7 @@
           let mutations = this.pendingRecords();
           if (mutations.length)
             this.queue = [];
-          let sel = view.domSelectionRange();
-          let newSel = !this.suppressingSelectionUpdates && !this.currentSelection.eq(sel) && hasFocusAndSelection(view) && !this.ignoreSelectionChange(sel);
+          let sel = view.domSelectionRange(), newSel = this.selectionChanged(sel);
           let from = -1, to = -1, typeOver = false, added = [];
           if (view.editable) {
             for (let i5 = 0; i5 < mutations.length; i5++) {
@@ -143791,6 +143979,8 @@
         }
         domSelectionRange() {
           let sel = this.domSelection();
+          if (!sel)
+            return { focusNode: null, focusOffset: 0, anchorNode: null, anchorOffset: 0 };
           return safari && this.root.nodeType === 11 && deepActiveElement(this.dom.ownerDocument) == this.dom && safariShadowSelectionRange(this, sel) || sel;
         }
         domSelection() {
@@ -144248,7 +144438,8 @@
       throw new RangeError("Type given to setBlockType should be a textblock");
     let mapFrom = tr2.steps.length;
     tr2.doc.nodesBetween(from, to, (node, pos) => {
-      if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType2(tr2.doc, tr2.mapping.slice(mapFrom).map(pos), type)) {
+      let attrsHere = typeof attrs == "function" ? attrs(node) : attrs;
+      if (node.isTextblock && !node.hasMarkup(type, attrsHere) && canChangeType2(tr2.doc, tr2.mapping.slice(mapFrom).map(pos), type)) {
         let convertNewlines = null;
         if (type.schema.linebreakReplacement) {
           let pre = type.whitespace == "pre", supportLinebreak = !!type.contentMatch.matchType(type.schema.linebreakReplacement);
@@ -144262,7 +144453,7 @@
         clearIncompatible2(tr2, tr2.mapping.slice(mapFrom).map(pos, 1), type, void 0, convertNewlines === null);
         let mapping = tr2.mapping.slice(mapFrom);
         let startM = mapping.map(pos, 1), endM = mapping.map(pos + node.nodeSize, 1);
-        tr2.step(new ReplaceAroundStep3(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true));
+        tr2.step(new ReplaceAroundStep3(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrsHere, null, node.marks)), 0, 0), 1, true));
         if (convertNewlines === true)
           replaceNewlines(tr2, node, pos, mapFrom);
         return false;
@@ -145563,7 +145754,7 @@
         if (state.selection instanceof TextSelection || state.selection instanceof AllSelection)
           tr2.deleteSelection();
         let deflt = $from.depth == 0 ? null : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
-        let splitType = splitNode && splitNode($to.parent, atEnd);
+        let splitType = splitNode && splitNode($to.parent, atEnd, $from);
         let types = splitType ? [splitType] : atEnd && deflt ? [{ type: deflt }] : void 0;
         let can = canSplit(tr2.doc, tr2.mapping.map($from.pos), 1, types);
         if (!types && !can && canSplit(tr2.doc, tr2.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : void 0)) {
@@ -145599,13 +145790,12 @@
       dispatch3(state.tr.clearIncompatible($pos.pos, before.type, before.contentMatchAt(before.childCount)).join($pos.pos).scrollIntoView());
     return true;
   }
-  function deleteBarrier(state, $cut, dispatch3) {
+  function deleteBarrier(state, $cut, dispatch3, dir) {
     let before = $cut.nodeBefore, after = $cut.nodeAfter, conn, match3;
-    if (before.type.spec.isolating || after.type.spec.isolating)
-      return false;
-    if (joinMaybeClear(state, $cut, dispatch3))
+    let isolated = before.type.spec.isolating || after.type.spec.isolating;
+    if (!isolated && joinMaybeClear(state, $cut, dispatch3))
       return true;
-    let canDelAfter = $cut.parent.canReplace($cut.index(), $cut.index() + 1);
+    let canDelAfter = !isolated && $cut.parent.canReplace($cut.index(), $cut.index() + 1);
     if (canDelAfter && (conn = (match3 = before.contentMatchAt(before.childCount)).findWrapping(after.type)) && match3.matchType(conn[0] || after.type).validEnd) {
       if (dispatch3) {
         let end2 = $cut.pos + after.nodeSize, wrap3 = Fragment.empty;
@@ -145620,7 +145810,7 @@
       }
       return true;
     }
-    let selAfter = Selection.findFrom($cut, 1);
+    let selAfter = after.type.spec.isolating || dir > 0 && isolated ? null : Selection.findFrom($cut, 1);
     let range2 = selAfter && selAfter.$from.blockRange(selAfter.$to), target = range2 && liftTarget(range2);
     if (target != null && target >= $cut.depth) {
       if (dispatch3)
@@ -145744,17 +145934,21 @@
           return true;
         }
         let before = $cut.nodeBefore;
-        if (!before.type.spec.isolating && deleteBarrier(state, $cut, dispatch3))
+        if (deleteBarrier(state, $cut, dispatch3, -1))
           return true;
         if ($cursor.parent.content.size == 0 && (textblockAt(before, "end") || NodeSelection.isSelectable(before))) {
-          let delStep = replaceStep(state.doc, $cursor.before(), $cursor.after(), Slice.empty);
-          if (delStep && delStep.slice.size < delStep.to - delStep.from) {
-            if (dispatch3) {
-              let tr2 = state.tr.step(delStep);
-              tr2.setSelection(textblockAt(before, "end") ? Selection.findFrom(tr2.doc.resolve(tr2.mapping.map($cut.pos, -1)), -1) : NodeSelection.create(tr2.doc, $cut.pos - before.nodeSize));
-              dispatch3(tr2.scrollIntoView());
+          for (let depth = $cursor.depth; ; depth--) {
+            let delStep = replaceStep(state.doc, $cursor.before(depth), $cursor.after(depth), Slice.empty);
+            if (delStep && delStep.slice.size < delStep.to - delStep.from) {
+              if (dispatch3) {
+                let tr2 = state.tr.step(delStep);
+                tr2.setSelection(textblockAt(before, "end") ? Selection.findFrom(tr2.doc.resolve(tr2.mapping.map($cut.pos, -1)), -1) : NodeSelection.create(tr2.doc, $cut.pos - before.nodeSize));
+                dispatch3(tr2.scrollIntoView());
+              }
+              return true;
             }
-            return true;
+            if (depth == 1 || $cursor.node(depth - 1).childCount > 1)
+              break;
           }
         }
         if (before.isAtom && $cut.depth == $cursor.depth - 1) {
@@ -145802,7 +145996,7 @@
         if (!$cut)
           return false;
         let after = $cut.nodeAfter;
-        if (deleteBarrier(state, $cut, dispatch3))
+        if (deleteBarrier(state, $cut, dispatch3, 1))
           return true;
         if ($cursor.parent.content.size == 0 && (textblockAt(after, "start") || NodeSelection.isSelectable(after))) {
           let delStep = replaceStep(state.doc, $cursor.before(), $cursor.after(), Slice.empty);
@@ -146119,8 +146313,8 @@
   });
 
   // node_modules/@tiptap/core/dist/index.js
-  function createChainableState(config) {
-    const { state, transaction } = config;
+  function createChainableState(config2) {
+    const { state, transaction } = config2;
     let { selection } = transaction;
     let { doc: doc4 } = transaction;
     let { storedMarks } = transaction;
@@ -146266,7 +146460,18 @@
           const insertClasses = valueClasses.filter((valueClass) => !existingClasses.includes(valueClass));
           mergedAttributes[key] = [...existingClasses, ...insertClasses].join(" ");
         } else if (key === "style") {
-          mergedAttributes[key] = [mergedAttributes[key], value].join("; ");
+          const newStyles = value ? value.split(";").map((style2) => style2.trim()).filter(Boolean) : [];
+          const existingStyles = mergedAttributes[key] ? mergedAttributes[key].split(";").map((style2) => style2.trim()).filter(Boolean) : [];
+          const styleMap = /* @__PURE__ */ new Map();
+          existingStyles.forEach((style2) => {
+            const [property, val] = style2.split(":").map((part) => part.trim());
+            styleMap.set(property, val);
+          });
+          newStyles.forEach((style2) => {
+            const [property, val] = style2.split(":").map((part) => part.trim());
+            styleMap.set(property, val);
+          });
+          mergedAttributes[key] = Array.from(styleMap.entries()).map(([property, val]) => `${property}: ${val}`).join("; ");
         } else {
           mergedAttributes[key] = value;
         }
@@ -146275,7 +146480,7 @@
     }, {});
   }
   function getRenderedAttributes(nodeOrMark, extensionAttributes) {
-    return extensionAttributes.filter((item) => item.attribute.rendered).map((item) => {
+    return extensionAttributes.filter((attribute) => attribute.type === nodeOrMark.type.name).filter((item) => item.attribute.rendered).map((item) => {
       if (!item.attribute.renderHTML) {
         return {
           [item.name]: nodeOrMark.attrs[item.name]
@@ -146465,9 +146670,9 @@
   function isRegExp(value) {
     return Object.prototype.toString.call(value) === "[object RegExp]";
   }
-  function run$1(config) {
+  function run$1(config2) {
     var _a;
-    const { editor, from, to, text, rules, plugin } = config;
+    const { editor, from, to, text, rules, plugin } = config2;
     const { view } = editor;
     if (view.composing) {
       return false;
@@ -146606,8 +146811,8 @@
   function isNumber3(value) {
     return typeof value === "number";
   }
-  function run(config) {
-    const { editor, state, from, to, rule, pasteEvent, dropEvent } = config;
+  function run(config2) {
+    const { editor, state, from, to, rule, pasteEvent, dropEvent } = config2;
     const { commands: commands2, chain, can } = new CommandManager({
       editor,
       state
@@ -147447,11 +147652,11 @@
     document.getElementsByTagName("head")[0].appendChild(styleNode);
     return styleNode;
   }
-  function markInputRule(config) {
+  function markInputRule(config2) {
     return new InputRule({
-      find: config.find,
+      find: config2.find,
       handler: ({ state, range: range2, match: match3 }) => {
-        const attributes = callOrReturn(config.getAttributes, void 0, match3);
+        const attributes = callOrReturn(config2.getAttributes, void 0, match3);
         if (attributes === false || attributes === null) {
           return null;
         }
@@ -147464,7 +147669,7 @@
           const textEnd = textStart + captureGroup.length;
           const excludedMarks = getMarksBetween(range2.from, range2.to, state.doc).filter((item) => {
             const excluded = item.mark.type.excluded;
-            return excluded.find((type) => type === config.type && type !== item.mark.type);
+            return excluded.find((type) => type === config2.type && type !== item.mark.type);
           }).filter((item) => item.to > textStart);
           if (excludedMarks.length) {
             return null;
@@ -147476,50 +147681,50 @@
             tr2.delete(range2.from + startSpaces, textStart);
           }
           const markEnd = range2.from + startSpaces + captureGroup.length;
-          tr2.addMark(range2.from + startSpaces, markEnd, config.type.create(attributes || {}));
-          tr2.removeStoredMark(config.type);
+          tr2.addMark(range2.from + startSpaces, markEnd, config2.type.create(attributes || {}));
+          tr2.removeStoredMark(config2.type);
         }
       }
     });
   }
-  function wrappingInputRule(config) {
+  function wrappingInputRule(config2) {
     return new InputRule({
-      find: config.find,
+      find: config2.find,
       handler: ({ state, range: range2, match: match3, chain }) => {
-        const attributes = callOrReturn(config.getAttributes, void 0, match3) || {};
+        const attributes = callOrReturn(config2.getAttributes, void 0, match3) || {};
         const tr2 = state.tr.delete(range2.from, range2.to);
         const $start = tr2.doc.resolve(range2.from);
         const blockRange = $start.blockRange();
-        const wrapping = blockRange && findWrapping2(blockRange, config.type, attributes);
+        const wrapping = blockRange && findWrapping2(blockRange, config2.type, attributes);
         if (!wrapping) {
           return null;
         }
         tr2.wrap(blockRange, wrapping);
-        if (config.keepMarks && config.editor) {
+        if (config2.keepMarks && config2.editor) {
           const { selection, storedMarks } = state;
-          const { splittableMarks } = config.editor.extensionManager;
+          const { splittableMarks } = config2.editor.extensionManager;
           const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
           if (marks) {
             const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
             tr2.ensureMarks(filteredMarks);
           }
         }
-        if (config.keepAttributes) {
-          const nodeType = config.type.name === "bulletList" || config.type.name === "orderedList" ? "listItem" : "taskList";
+        if (config2.keepAttributes) {
+          const nodeType = config2.type.name === "bulletList" || config2.type.name === "orderedList" ? "listItem" : "taskList";
           chain().updateAttributes(nodeType, attributes).run();
         }
         const before = tr2.doc.resolve(range2.from - 1).nodeBefore;
-        if (before && before.type === config.type && canJoin2(tr2.doc, range2.from - 1) && (!config.joinPredicate || config.joinPredicate(match3, before))) {
+        if (before && before.type === config2.type && canJoin2(tr2.doc, range2.from - 1) && (!config2.joinPredicate || config2.joinPredicate(match3, before))) {
           tr2.join(range2.from - 1);
         }
       }
     });
   }
-  function markPasteRule(config) {
+  function markPasteRule(config2) {
     return new PasteRule({
-      find: config.find,
+      find: config2.find,
       handler: ({ state, range: range2, match: match3, pasteEvent }) => {
-        const attributes = callOrReturn(config.getAttributes, void 0, match3, pasteEvent);
+        const attributes = callOrReturn(config2.getAttributes, void 0, match3, pasteEvent);
         if (attributes === false || attributes === null) {
           return null;
         }
@@ -147533,7 +147738,7 @@
           const textEnd = textStart + captureGroup.length;
           const excludedMarks = getMarksBetween(range2.from, range2.to, state.doc).filter((item) => {
             const excluded = item.mark.type.excluded;
-            return excluded.find((type) => type === config.type && type !== item.mark.type);
+            return excluded.find((type) => type === config2.type && type !== item.mark.type);
           }).filter((item) => item.to > textStart);
           if (excludedMarks.length) {
             return null;
@@ -147545,13 +147750,13 @@
             tr2.delete(range2.from + startSpaces, textStart);
           }
           markEnd = range2.from + startSpaces + captureGroup.length;
-          tr2.addMark(range2.from + startSpaces, markEnd, config.type.create(attributes || {}));
-          tr2.removeStoredMark(config.type);
+          tr2.addMark(range2.from + startSpaces, markEnd, config2.type.create(attributes || {}));
+          tr2.removeStoredMark(config2.type);
         }
       }
     });
   }
-  var CommandManager, EventEmitter, getTextContentFromNodes, InputRule, inputRuleMatcherHandler, PasteRule, pasteRuleMatcherHandler, createClipboardPasteEvent, ExtensionManager, Extension, ClipboardTextSerializer, blur, clearContent, clearNodes, command, createParagraphNear2, cut, deleteCurrentNode, deleteNode, deleteRange3, deleteSelection2, enter2, exitCode2, extendMarkRange, first2, focus, forEach, insertContent, removeWhitespaces, isFragment, insertContentAt, joinUp2, joinDown2, joinBackward2, joinForward2, joinItemBackward, joinItemForward, joinTextblockBackward2, joinTextblockForward2, keyboardShortcut, lift4, liftEmptyBlock2, liftListItem2, newlineInCode2, resetAttributes, scrollIntoView, selectAll2, selectNodeBackward2, selectNodeForward2, selectParentNode2, selectTextblockEnd2, selectTextblockStart2, setContent2, setMark, setMeta, setNode, setNodeSelection, setTextSelection, sinkListItem2, splitBlock2, splitListItem, joinListBackwards, joinListForwards, toggleList, toggleMark, toggleNode, toggleWrap, undoInputRule, unsetAllMarks, unsetMark, updateAttributes, wrapIn2, wrapInList2, commands, Commands, Editable, FocusEvents, Keymap, Tabindex, NodePos, style, Editor, Mark2, Node3;
+  var CommandManager, EventEmitter, getTextContentFromNodes, InputRule, inputRuleMatcherHandler, PasteRule, pasteRuleMatcherHandler, createClipboardPasteEvent, ExtensionManager, Extension, ClipboardTextSerializer, blur, clearContent, clearNodes, command, createParagraphNear2, cut, deleteCurrentNode, deleteNode, deleteRange3, deleteSelection2, enter2, exitCode2, extendMarkRange, first2, focus, forEach, insertContent, removeWhitespaces, isFragment, insertContentAt, joinUp2, joinDown2, joinBackward2, joinForward2, joinItemBackward, joinItemForward, joinTextblockBackward2, joinTextblockForward2, keyboardShortcut, lift4, liftEmptyBlock2, liftListItem2, newlineInCode2, resetAttributes, scrollIntoView, selectAll2, selectNodeBackward2, selectNodeForward2, selectParentNode2, selectTextblockEnd2, selectTextblockStart2, setContent2, setMark, setMeta, setNode, setNodeSelection, setTextSelection, sinkListItem2, splitBlock2, splitListItem, joinListBackwards, joinListForwards, toggleList, toggleMark, toggleNode, toggleWrap, undoInputRule, unsetAllMarks, unsetMark, updateAttributes, wrapIn2, wrapInList2, commands, Commands, Editable, FocusEvents, Keymap, Tabindex, NodePos, DropPlugin, PastePlugin, style, Editor, Mark2, Node3;
   var init_dist18 = __esm({
     "node_modules/@tiptap/core/dist/index.js"() {
       init_dist5();
@@ -147706,9 +147911,9 @@
         return textBefore;
       };
       InputRule = class {
-        constructor(config) {
-          this.find = config.find;
-          this.handler = config.handler;
+        constructor(config2) {
+          this.find = config2.find;
+          this.handler = config2.handler;
         }
       };
       inputRuleMatcherHandler = (text, find2) => {
@@ -147732,9 +147937,9 @@
         return result;
       };
       PasteRule = class {
-        constructor(config) {
-          this.find = config.find;
-          this.handler = config.handler;
+        constructor(config2) {
+          this.find = config2.find;
+          this.handler = config2.handler;
         }
       };
       pasteRuleMatcherHandler = (text, find2, event) => {
@@ -147903,15 +148108,17 @@
             if (!addNodeView) {
               return [];
             }
-            const nodeview = (node, view, getPos, decorations) => {
+            const nodeview = (node, view, getPos, decorations, innerDecorations) => {
               const HTMLAttributes = getRenderedAttributes(node, extensionAttributes);
               return addNodeView()({
-                editor,
                 node,
+                view,
                 getPos,
                 decorations,
-                HTMLAttributes,
-                extension
+                innerDecorations,
+                editor,
+                extension,
+                HTMLAttributes
               });
             };
             return [extension.name, nodeview];
@@ -147970,7 +148177,7 @@
         }
       };
       Extension = class {
-        constructor(config = {}) {
+        constructor(config2 = {}) {
           this.type = "extension";
           this.name = "extension";
           this.parent = null;
@@ -147981,10 +148188,10 @@
           };
           this.config = {
             ...this.config,
-            ...config
+            ...config2
           };
           this.name = this.config.name;
-          if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
+          if (config2.defaultOptions && Object.keys(config2.defaultOptions).length > 0) {
             console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
           }
           this.options = this.config.defaultOptions;
@@ -147998,8 +148205,8 @@
             options: this.options
           })) || {};
         }
-        static create(config = {}) {
-          return new Extension(config);
+        static create(config2 = {}) {
+          return new Extension(config2);
         }
         configure(options = {}) {
           const extension = this.extend({
@@ -148800,10 +149007,14 @@
         const type = getNodeType(typeOrName, state.schema);
         const toggleType = getNodeType(toggleTypeOrName, state.schema);
         const isActive2 = isNodeActive(state, type, attributes);
+        let attributesToCopy;
+        if (state.selection.$anchor.sameParent(state.selection.$head)) {
+          attributesToCopy = state.selection.$anchor.parent.attrs;
+        }
         if (isActive2) {
-          return commands2.setNode(toggleType);
+          return commands2.setNode(toggleType, attributesToCopy);
         }
-        return commands2.setNode(type, attributes);
+        return commands2.setNode(type, { ...attributesToCopy, ...attributes });
       };
       toggleWrap = (typeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
         const type = getNodeType(typeOrName, state.schema);
@@ -149103,7 +149314,8 @@
               key: new PluginKey("clearDocument"),
               appendTransaction: (transactions, oldState, newState) => {
                 const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
-                if (!docChanges) {
+                const ignoreTr = transactions.some((transaction) => transaction.getMeta("preventClearDocument"));
+                if (!docChanges || ignoreTr) {
                   return;
                 }
                 const { empty: empty2, from, to } = oldState.selection;
@@ -149113,7 +149325,7 @@
                 if (empty2 || !allWasSelected) {
                   return;
                 }
-                const isEmpty = newState.doc.textBetween(0, newState.doc.content.size, " ", " ").length === 0;
+                const isEmpty = isNodeEmpty(newState.doc);
                 if (!isEmpty) {
                   return;
                 }
@@ -149316,6 +149528,26 @@
           this.editor.chain().setTextSelection(this.from).updateAttributes(this.node.type.name, attributes).setTextSelection(oldSelection.from).run();
         }
       };
+      DropPlugin = (onDrop) => {
+        return new Plugin({
+          key: new PluginKey("tiptapDrop"),
+          props: {
+            handleDrop: (_3, e5, slice, moved) => {
+              onDrop(e5, slice, moved);
+            }
+          }
+        });
+      };
+      PastePlugin = (onPaste) => {
+        return new Plugin({
+          key: new PluginKey("tiptapPaste"),
+          props: {
+            handlePaste: (_view, e5, slice) => {
+              onPaste(e5, slice);
+            }
+          }
+        });
+      };
       style = `.ProseMirror {
   position: relative;
 }
@@ -149422,7 +149654,9 @@ img.ProseMirror-separator {
             onDestroy: () => null,
             onContentError: ({ error: error2 }) => {
               throw error2;
-            }
+            },
+            onPaste: () => null,
+            onDrop: () => null
           };
           this.isCapturingTransaction = false;
           this.capturedTransaction = null;
@@ -149442,6 +149676,12 @@ img.ProseMirror-separator {
           this.on("focus", this.options.onFocus);
           this.on("blur", this.options.onBlur);
           this.on("destroy", this.options.onDestroy);
+          if (this.options.onPaste) {
+            this.registerPlugin(PastePlugin(this.options.onPaste));
+          }
+          if (this.options.onDrop) {
+            this.registerPlugin(DropPlugin(this.options.onDrop));
+          }
           window.setTimeout(() => {
             if (this.isDestroyed) {
               return;
@@ -149497,16 +149737,18 @@ img.ProseMirror-separator {
           const plugins2 = isFunction2(handlePlugins) ? handlePlugins(plugin, [...this.state.plugins]) : [...this.state.plugins, plugin];
           const state = this.state.reconfigure({ plugins: plugins2 });
           this.view.updateState(state);
+          return state;
         }
         unregisterPlugin(nameOrPluginKey) {
           if (this.isDestroyed) {
-            return;
+            return void 0;
           }
           const name = typeof nameOrPluginKey === "string" ? `${nameOrPluginKey}$` : nameOrPluginKey.key;
           const state = this.state.reconfigure({
             plugins: this.state.plugins.filter((plugin) => !plugin.key.startsWith(name))
           });
           this.view.updateState(state);
+          return state;
         }
         createExtensionManager() {
           var _a, _b;
@@ -149519,7 +149761,12 @@ img.ProseMirror-separator {
             FocusEvents,
             Keymap,
             Tabindex
-          ] : [];
+          ].filter((ext) => {
+            if (typeof this.options.enableCoreExtensions === "object") {
+              return this.options.enableCoreExtensions[ext.name] !== false;
+            }
+            return true;
+          }) : [];
           const allExtensions = [...coreExtensions, ...this.options.extensions].filter((extension) => {
             return ["extension", "node", "mark"].includes(extension === null || extension === void 0 ? void 0 : extension.type);
           });
@@ -149679,6 +149926,10 @@ img.ProseMirror-separator {
         destroy() {
           this.emit("destroy");
           if (this.view) {
+            const dom = this.view.dom;
+            if (dom && dom.editor) {
+              delete dom.editor;
+            }
             this.view.destroy();
           }
           this.removeAllListeners();
@@ -149704,7 +149955,7 @@ img.ProseMirror-separator {
         }
       };
       Mark2 = class {
-        constructor(config = {}) {
+        constructor(config2 = {}) {
           this.type = "mark";
           this.name = "mark";
           this.parent = null;
@@ -149715,10 +149966,10 @@ img.ProseMirror-separator {
           };
           this.config = {
             ...this.config,
-            ...config
+            ...config2
           };
           this.name = this.config.name;
-          if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
+          if (config2.defaultOptions && Object.keys(config2.defaultOptions).length > 0) {
             console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
           }
           this.options = this.config.defaultOptions;
@@ -149732,8 +149983,8 @@ img.ProseMirror-separator {
             options: this.options
           })) || {};
         }
-        static create(config = {}) {
-          return new Mark2(config);
+        static create(config2 = {}) {
+          return new Mark2(config2);
         }
         configure(options = {}) {
           const extension = this.extend({
@@ -149785,7 +150036,7 @@ img.ProseMirror-separator {
         }
       };
       Node3 = class {
-        constructor(config = {}) {
+        constructor(config2 = {}) {
           this.type = "node";
           this.name = "node";
           this.parent = null;
@@ -149796,10 +150047,10 @@ img.ProseMirror-separator {
           };
           this.config = {
             ...this.config,
-            ...config
+            ...config2
           };
           this.name = this.config.name;
-          if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
+          if (config2.defaultOptions && Object.keys(config2.defaultOptions).length > 0) {
             console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
           }
           this.options = this.config.defaultOptions;
@@ -149813,8 +150064,8 @@ img.ProseMirror-separator {
             options: this.options
           })) || {};
         }
-        static create(config = {}) {
-          return new Node3(config);
+        static create(config2 = {}) {
+          return new Node3(config2);
         }
         configure(options = {}) {
           const extension = this.extend({
@@ -158534,7 +158785,7 @@ img.ProseMirror-separator {
  * Licensed under the MIT license.
  */
 /*!
-Turbo 8.0.5
+Turbo 8.0.10
 Copyright © 2024 37signals LLC
  */
 /*! *****************************************************************************
@@ -158551,7 +158802,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/*! @license DOMPurify 3.1.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.1.6/LICENSE */
+/*! @license DOMPurify 3.1.7 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.1.7/LICENSE */
 /*! https://mths.be/punycode v1.4.0 by @mathias */
 /*! js-cookie v3.0.5 | MIT */
 /**