unpoly-rails 3.10.0 → 3.11.0.rc1

data/assets/unpoly/unpoly.js

@@ -5,7 +5,7 @@
 /***/ (() => {
 
 window.up = {
-    version: '3.10.0'
+    version: '3.11.0-rc1'
 };
 
 
@@ -116,7 +116,7 @@ up.util = (function () {
     }
     function iteratee(block) {
         if (isString(block)) {
-            return item => item[block];
+            return (item) => item[block];
         }
         else {
             return block;
@@ -135,11 +135,7 @@ up.util = (function () {
         return mapped;
     }
     function mapObject(array, pairer) {
-        const merger = function (object, pair) {
-            object[pair[0]] = pair[1];
-            return object;
-        };
-        return map(array, pairer).reduce(merger, {});
+        return Object.fromEntries(array.map(pairer));
     }
     function each(array, block) {
         let i = 0;
@@ -147,15 +143,15 @@ up.util = (function () {
             block(item, i++);
         }
     }
-    function isNull(object) {
-        return object === null;
+    function isNull(value) {
+        return value === null;
     }
-    function isUndefined(object) {
-        return object === undefined;
+    function isUndefined(value) {
+        return value === undefined;
     }
     const isDefined = negate(isUndefined);
-    function isMissing(object) {
-        return isUndefined(object) || isNull(object);
+    function isMissing(value) {
+        return isUndefined(value) || isNull(value);
     }
     const isGiven = negate(isMissing);
     function isBlank(value) {
@@ -180,49 +176,49 @@ up.util = (function () {
         }
     }
     const isPresent = negate(isBlank);
-    function isFunction(object) {
-        return typeof (object) === 'function';
+    function isFunction(value) {
+        return typeof (value) === 'function';
     }
-    function isString(object) {
-        return (typeof (object) === 'string') || object instanceof String;
+    function isString(value) {
+        return (typeof (value) === 'string') || value instanceof String;
     }
-    function isBoolean(object) {
-        return (typeof (object) === 'boolean') || object instanceof Boolean;
+    function isBoolean(value) {
+        return (typeof (value) === 'boolean') || value instanceof Boolean;
     }
-    function isNumber(object) {
-        return (typeof (object) === 'number') || object instanceof Number;
+    function isNumber(value) {
+        return (typeof (value) === 'number') || value instanceof Number;
     }
-    function isOptions(object) {
-        return (typeof (object) === 'object') && !isNull(object) && (isUndefined(object.constructor) || (object.constructor === Object));
+    function isOptions(value) {
+        return (typeof (value) === 'object') && !isNull(value) && (isUndefined(value.constructor) || (value.constructor === Object));
     }
-    function isObject(object) {
-        const typeOfResult = typeof (object);
-        return ((typeOfResult === 'object') && !isNull(object)) || (typeOfResult === 'function');
+    function isObject(value) {
+        const typeOfResult = typeof (value);
+        return ((typeOfResult === 'object') && !isNull(value)) || (typeOfResult === 'function');
     }
-    function isElement(object) {
-        return object instanceof Element;
+    function isElement(value) {
+        return value instanceof Element;
     }
-    function isTextNode(object) {
-        return object instanceof Text;
+    function isTextNode(value) {
+        return value instanceof Text;
     }
-    function isRegExp(object) {
-        return object instanceof RegExp;
+    function isRegExp(value) {
+        return value instanceof RegExp;
     }
-    function isError(object) {
-        return object instanceof Error;
+    function isError(value) {
+        return value instanceof Error;
     }
-    function isJQuery(object) {
-        return up.browser.canJQuery() && object instanceof jQuery;
+    function isJQuery(value) {
+        return up.browser.canJQuery() && value instanceof jQuery;
     }
-    function isElementLike(object) {
-        return !!(object && (object.addEventListener || (isJQuery(object) && object[0]?.addEventListener)));
+    function isElementLike(value) {
+        return !!(value && (value.addEventListener || (isJQuery(value) && value[0]?.addEventListener)));
     }
-    function isPromise(object) {
-        return isObject(object) && isFunction(object.then);
+    function isPromise(value) {
+        return isObject(value) && isFunction(value.then);
     }
     const { isArray } = Array;
-    function isFormData(object) {
-        return object instanceof FormData;
+    function isFormData(value) {
+        return value instanceof FormData;
     }
     function toArray(value) {
         return isArray(value) ? value : copyArrayLike(value);
@@ -389,13 +385,15 @@ up.util = (function () {
         return filterList(list, tester);
     }
     function intersect(array1, array2) {
-        return filterList(array1, element => contains(array2, element));
+        return filterList(array1, (element) => contains(array2, element));
     }
     function scheduleTimer(millis, callback) {
         return setTimeout(callback, millis);
     }
     function queueTask(task) {
-        return setTimeout(task);
+        const channel = new MessageChannel();
+        channel.port1.onmessage = () => task();
+        channel.port2.postMessage(0);
     }
     function last(value) {
         return value[value.length - 1];
@@ -462,7 +460,7 @@ up.util = (function () {
         "'": '''
     };
     function escapeHTML(string) {
-        return string.replace(/[&<>"']/g, char => ESCAPE_HTML_ENTITY_MAP[char]);
+        return string.replace(/[&<>"']/g, (char) => ESCAPE_HTML_ENTITY_MAP[char]);
     }
     function escapeRegExp(string) {
         return string.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
@@ -491,9 +489,9 @@ up.util = (function () {
     function identity(arg) {
         return arg;
     }
-    function sequence(functions) {
-        functions = compact(functions);
-        return (...args) => map(functions, fn => fn(...args));
+    function sequence(...args) {
+        let functions = scanFunctions(...args);
+        return (...args) => map(functions, (fn) => fn(...args));
     }
     function flatten(array) {
         const flattened = [];
@@ -547,7 +545,7 @@ up.util = (function () {
             const aKeys = Object.keys(a);
             const bKeys = Object.keys(b);
             if (isEqualList(aKeys, bKeys)) {
-                return every(aKeys, aKey => isEqual(a[aKey], b[aKey]));
+                return every(aKeys, (aKey) => isEqual(a[aKey], b[aKey]));
             }
             else {
                 return false;
@@ -611,7 +609,7 @@ up.util = (function () {
         return renamed;
     }
     function camelToKebabCase(str) {
-        return str.replace(/[A-Z]/g, char => '-' + char.toLowerCase());
+        return str.replace(/[A-Z]/g, (char) => '-' + char.toLowerCase());
     }
     function lowerCaseFirst(str) {
         return str[0].toLowerCase() + str.slice(1);
@@ -637,8 +635,8 @@ up.util = (function () {
             });
         }
     }
-    function delegatePromise(object, promiseProp) {
-        return defineDelegates(object, ['then', 'catch', 'finally'], function () { return this[promiseProp]; });
+    function delegatePromise(object, targetProvider) {
+        return defineDelegates(object, ['then', 'catch', 'finally'], targetProvider);
     }
     function stringifyArg(arg, placeholder = '%o') {
         let string;
@@ -865,6 +863,9 @@ up.util = (function () {
             ];
         });
     }
+    function spanObject(keys, value) {
+        return mapObject(keys, (key) => [key, value]);
+    }
     return {
         parseURL,
         normalizeURL,
@@ -882,6 +883,7 @@ up.util = (function () {
         map,
         flatMap,
         mapObject,
+        spanObject,
         findResult,
         some,
         every,
@@ -1085,12 +1087,13 @@ up.element = (function () {
         return root.querySelector(selector);
     }
     function subtree(root, selector) {
-        const results = [];
+        const descendantMatches = root.querySelectorAll(selector);
         if (elementLikeMatches(root, selector)) {
-            results.push(root);
+            return [root, ...descendantMatches];
+        }
+        else {
+            return descendantMatches;
         }
-        results.push(...root.querySelectorAll(selector));
-        return results;
     }
     function subtreeFirst(root, selector) {
         return elementLikeMatches(root, selector) ? root : root.querySelector(selector);
@@ -1196,7 +1199,7 @@ up.element = (function () {
     }
     function metaContent(name) {
         const selector = "meta" + attrSelector('name', name);
-        return first(selector)?.getAttribute('content');
+        return document.head.querySelector(selector)?.getAttribute('content');
     }
     function insertBefore(existingNode, newNode) {
         existingNode.parentNode.insertBefore(newNode, existingNode);
@@ -1306,7 +1309,7 @@ up.element = (function () {
         return element;
     }
     const SINGLETON_TAG_NAMES = ['HTML', 'BODY', 'HEAD', 'TITLE'];
-    const isSingleton = up.mockable(element => element.matches(SINGLETON_TAG_NAMES.join()));
+    const isSingleton = up.mockable((element) => element.matches(SINGLETON_TAG_NAMES.join()));
     function elementTagName(element) {
         return element.tagName.toLowerCase();
     }
@@ -1334,9 +1337,11 @@ up.element = (function () {
     function createBrokenDocumentFromHTML(html) {
         return new DOMParser().parseFromString(html, 'text/html');
     }
-    function fixParserDamage(scriptish) {
-        let clone = createFromHTML(scriptish.outerHTML);
-        scriptish.replaceWith(clone);
+    function revivedClone(element) {
+        let clone = createFromHTML(element.outerHTML);
+        if ('nonce' in element)
+            clone.nonce = element.nonce;
+        return clone;
     }
     function createFromHTML(html) {
         return extractSingular(createNodesFromHTML(html));
@@ -1618,6 +1623,18 @@ up.element = (function () {
             return [element.parentElement, 'beforeend'];
         }
     }
+    function moveBefore(parent, movedElement, referenceElement) {
+        let fn = parent.moveBefore || parent.insertBefore;
+        fn.call(parent, movedElement, referenceElement);
+    }
+    function preservingAppend(parent, newNode) {
+        moveBefore(parent, newNode, null);
+    }
+    function preservingReplace(oldElement, newElement) {
+        let parent = oldElement.parentElement;
+        moveBefore(parent, newElement, oldElement);
+        oldElement.remove();
+    }
     return {
         subtree,
         subtreeFirst,
@@ -1644,7 +1661,7 @@ up.element = (function () {
         attrSelector,
         tagName: elementTagName,
         createBrokenDocumentFromHTML,
-        fixParserDamage,
+        revivedClone,
         createNodesFromHTML,
         createFromHTML,
         extractSingular,
@@ -1686,6 +1703,8 @@ up.element = (function () {
         matchSelectorMap,
         elementLikeMatches,
         documentPosition,
+        preservingAppend,
+        preservingReplace,
     };
 })();
 
@@ -1779,7 +1798,7 @@ up.Record = class Record {
         return {};
     }
     constructor(options) {
-        Object.assign(this, this.defaults(options), this.attributes(options));
+        Object.assign(this, u.mergeDefined(this.defaults(options), this.attributes(options)));
     }
     attributes(source = this) {
         return u.pick(source, this.keys());
@@ -1858,13 +1877,39 @@ up.LogConfig = class LogConfig extends up.Config {
 /* 19 */
 /***/ (() => {
 
+const u = up.util;
+up.Registry = class Registry {
+    constructor(valueDescription, normalize = u.identity) {
+        this._data = {};
+        this._normalize = normalize;
+        this._valueDescription = valueDescription;
+        this.put = this.put.bind(this);
+        document.addEventListener('up:framework:reset', () => this.reset());
+    }
+    put(key, object) {
+        object = this._normalize(object);
+        object.isDefault = up.framework.evaling;
+        this._data[key] = object;
+    }
+    get(name) {
+        return this._data[name] || up.fail("Unknown %s %o", this._valueDescription, name);
+    }
+    reset() {
+        this._data = u.pickBy(this._data, 'isDefault');
+    }
+};
+
+
+/***/ }),
+/* 20 */
+/***/ (() => {
+
 const u = up.util;
 const e = up.element;
 up.OptionsParser = class OptionsParser {
     constructor(element, options, parserOptions = {}) {
         this._options = options;
         this._element = element;
-        this._parserOptions = parserOptions;
         this._fail = parserOptions.fail;
         this._closest = parserOptions.closest;
         this._attrPrefix = parserOptions.attrPrefix || 'up-';
@@ -1899,11 +1944,11 @@ up.OptionsParser = class OptionsParser {
             value ??= this._parseFromAttr(attrValueFn, this._element, attrName);
         }
         value ??= keyOptions.default ?? this._defaults[key];
-        let normalizeFn = keyOptions.normalize;
-        if (normalizeFn) {
-            value = normalizeFn(value);
-        }
         if (u.isDefined(value)) {
+            let normalizeFn = keyOptions.normalize;
+            if (normalizeFn) {
+                value = normalizeFn(value);
+            }
             this._options[key] = value;
         }
         let failKey;
@@ -1912,8 +1957,8 @@ up.OptionsParser = class OptionsParser {
             this.parse(attrValueFn, failKey, { ...keyOptions, attr: failAttrNames });
         }
     }
-    include(optionsFn) {
-        let fnResult = optionsFn(this._element, this._options, this._parserOptions);
+    include(optionsFn, parserOptions) {
+        let fnResult = optionsFn(this._element, this._options, { defaults: this._defaults, ...parserOptions });
         Object.assign(this._options, fnResult);
     }
     _parseFromAttr(attrValueFn, element, attrName) {
@@ -1940,7 +1985,7 @@ up.OptionsParser = class OptionsParser {
 
 
 /***/ }),
-/* 20 */
+/* 21 */
 /***/ (() => {
 
 const u = up.util;
@@ -1969,7 +2014,7 @@ up.FIFOCache = class FIFOCache {
 
 
 /***/ }),
-/* 21 */
+/* 22 */
 /***/ (() => {
 
 up.Rect = class Rect extends up.Record {
@@ -2000,7 +2045,7 @@ up.Rect = class Rect extends up.Record {
 
 
 /***/ }),
-/* 22 */
+/* 23 */
 /***/ (() => {
 
 const e = up.element;
@@ -2048,7 +2093,7 @@ up.BodyShifter = class BodyShifter {
 
 
 /***/ }),
-/* 23 */
+/* 24 */
 /***/ (() => {
 
 const u = up.util;
@@ -2074,7 +2119,7 @@ up.Change = class Change {
 
 
 /***/ }),
-/* 24 */
+/* 25 */
 /***/ (() => {
 
 const u = up.util;
@@ -2149,7 +2194,7 @@ up.Change.Addition = class Addition extends up.Change {
 
 
 /***/ }),
-/* 25 */
+/* 26 */
 /***/ (() => {
 
 var _a;
@@ -2262,7 +2307,7 @@ up.RenderJob = (_a = class RenderJob {
         }
     },
     (() => {
-        u.delegatePromise(_a.prototype, '_rendered');
+        u.delegatePromise(_a.prototype, function () { return this._rendered; });
         u.memoizeMethod(_a.prototype, {
             _awaitFinished: true,
             _getChange: true,
@@ -2272,7 +2317,7 @@ up.RenderJob = (_a = class RenderJob {
 
 
 /***/ }),
-/* 26 */
+/* 27 */
 /***/ (() => {
 
 up.Change.DestroyFragment = class DestroyFragment extends up.Change {
@@ -2297,18 +2342,18 @@ up.Change.DestroyFragment = class DestroyFragment extends up.Change {
     async _destroyAfterAnimation() {
         this._emitDestroyed();
         await this._animate();
-        this._wipe();
+        this._erase();
         this._onFinished?.();
     }
     _destroyNow() {
-        this._wipe();
+        this._erase();
         this._emitDestroyed();
         this._onFinished?.();
     }
     _animate() {
         return up.motion.animate(this._element, this._animation, this.options);
     }
-    _wipe() {
+    _erase() {
         this._layer.asCurrent(() => {
             up.fragment.abort(this._element);
             up.script.clean(this._element, { layer: this._layer });
@@ -2323,7 +2368,7 @@ up.Change.DestroyFragment = class DestroyFragment extends up.Change {
 
 
 /***/ }),
-/* 27 */
+/* 28 */
 /***/ (() => {
 
 let u = up.util;
@@ -2414,7 +2459,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
     }
     _buildLayer() {
         const buildOptions = { ...this.options, opening: true };
-        const beforeNew = optionsWithLayerDefaults => {
+        const beforeNew = (optionsWithLayerDefaults) => {
             return this.options = up.RenderOptions.finalize(optionsWithLayerDefaults);
         };
         return up.layer.build(buildOptions, beforeNew);
@@ -2478,7 +2523,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
 
 
 /***/ }),
-/* 28 */
+/* 29 */
 /***/ (() => {
 
 var _a;
@@ -2629,7 +2674,7 @@ up.Change.UpdateLayer = (_a = class UpdateLayer extends up.Change.Addition {
 
 
 /***/ }),
-/* 29 */
+/* 30 */
 /***/ (() => {
 
 const u = up.util;
@@ -2652,7 +2697,7 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
             target: up.fragment.targetForSteps(this._steps),
         });
         this._steps.reverse();
-        const motionEndPromises = this._steps.map(step => this._executeStep(step));
+        const motionEndPromises = this._steps.map((step) => this._executeStep(step));
         this.renderResult.finished = this._finish(motionEndPromises);
         return this.renderResult;
     }
@@ -2683,7 +2728,7 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                     return Promise.resolve();
                 }
                 else {
-                    this._preserveKeepables(step);
+                    this._preserveDescendantKeepables(step);
                     const parent = step.oldElement.parentNode;
                     const morphOptions = {
                         ...step,
@@ -2691,9 +2736,9 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                             up.fragment.markAsDestroying(step.oldElement);
                         },
                         afterInsert: () => {
-                            this._restoreKeepables(step);
+                            this._restoreDescendantKeepables(step);
                             this.responseDoc.finalizeElement(step.newElement);
-                            this._unmarkKeepables(step);
+                            this._finalizeDescendantKeepables(step);
                             up.hello(step.newElement, step);
                             this._addToResult(step.newElement);
                         },
@@ -2774,8 +2819,8 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
             }
         }
     }
-    _preserveKeepables(step) {
-        const keepPlans = [];
+    _preserveDescendantKeepables(step) {
+        const descendantKeepPlans = [];
         if (step.keep) {
             for (let keepable of step.oldElement.querySelectorAll('[up-keep]')) {
                 let keepPlan = this._findKeepPlan({ ...step, oldElement: keepable, descendantsOnly: true });
@@ -2785,37 +2830,42 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                     keepable.classList.add('up-keeping');
                     up.script.disableSubtree(keepPlan.newElement);
                     let viewports = up.viewport.subtree(keepPlan.oldElement);
-                    keepPlan.revivers = viewports.map(function (viewport) {
+                    keepPlan.revivers = u.map(viewports, function (viewport) {
                         let cursorProps = up.viewport.copyCursorProps(viewport);
                         return () => up.viewport.copyCursorProps(cursorProps, viewport);
                     });
-                    if (this._willChangeElement(document.body)) {
+                    if (this._willChangeBody()) {
                         keepPlan.newElement.replaceWith(keepable);
                     }
                     else {
-                        document.body.append(keepable);
+                        e.preservingAppend(document.body, keepable);
                     }
-                    keepPlans.push(keepPlan);
+                    descendantKeepPlans.push(keepPlan);
                 }
             }
         }
-        step.keepPlans = keepPlans;
+        step.descendantKeepPlans = descendantKeepPlans;
     }
-    _restoreKeepables(step) {
-        for (let keepPlan of step.keepPlans) {
-            keepPlan.newElement.replaceWith(keepPlan.oldElement);
+    _restoreDescendantKeepables(step) {
+        for (let keepPlan of step.descendantKeepPlans) {
+            if (this._willChangeBody()) {
+                keepPlan.newElement.replaceWith(keepPlan.oldElement);
+            }
+            else {
+                e.preservingReplace(keepPlan.newElement, keepPlan.oldElement);
+            }
             for (let reviver of keepPlan.revivers) {
                 reviver();
             }
         }
     }
-    _unmarkKeepables(step) {
-        for (let keepPlan of step.keepPlans) {
+    _finalizeDescendantKeepables(step) {
+        for (let keepPlan of step.descendantKeepPlans) {
             keepPlan.oldElement.classList.remove('up-keeping');
         }
     }
-    _willChangeElement(element) {
-        return u.some(this._steps, (step) => step.oldElement.contains(element));
+    _willChangeBody() {
+        return u.some(this._steps, (step) => step.oldElement.matches('body'));
     }
     _handleFocus(fragment, options) {
         const fragmentFocus = new up.FragmentFocus({
@@ -2837,7 +2887,7 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
 
 
 /***/ }),
-/* 30 */
+/* 31 */
 /***/ (() => {
 
 const u = up.util;
@@ -2853,9 +2903,8 @@ up.Change.CloseLayer = class CloseLayer extends up.Change {
         this._history = options.history ?? true;
     }
     execute() {
-        if (!this._layer.isOpen()) {
-            return Promise.resolve();
-        }
+        if (!this._layer.isOpen())
+            return;
         up.browser.assertConfirmed(this.options);
         if (this._emitCloseEvent().defaultPrevented && this._preventable) {
             throw new up.Aborted('Close event was prevented');
@@ -2904,16 +2953,19 @@ up.Change.CloseLayer = class CloseLayer extends up.Change {
         });
     }
     _handleFocus(formerParent) {
+        let hadFocus = this._layer.hasFocus();
         this._layer.overlayFocus.teardown();
         formerParent.overlayFocus?.moveToFront();
-        let newFocusElement = this._layer.origin || formerParent.element;
-        up.focus(newFocusElement, { preventScroll: true });
+        if (hadFocus) {
+            let newFocusElement = this._layer.origin || formerParent.element;
+            up.focus(newFocusElement, { preventScroll: true });
+        }
     }
 };
 
 
 /***/ }),
-/* 31 */
+/* 32 */
 /***/ (() => {
 
 var _a;
@@ -2932,7 +2984,7 @@ up.Change.FromURL = (_a = class FromURL extends up.Change {
                 return request;
             this.options.handleAbort?.(request);
             request.runPreviews(this.options);
-            return await u.always(request, responseOrError => this._onRequestSettled(responseOrError));
+            return await u.always(request, (responseOrError) => this._onRequestSettled(responseOrError));
         }
         _newPageReason() {
             if (u.isCrossOrigin(this.options.url)) {
@@ -2990,7 +3042,7 @@ up.Change.FromURL = (_a = class FromURL extends up.Change {
 
 
 /***/ }),
-/* 32 */
+/* 33 */
 /***/ (() => {
 
 var _a;
@@ -3108,6 +3160,17 @@ up.Change.FromResponse = (_a = class FromResponse extends up.Change {
                 renderOptions.source = this.improveHistoryValue(renderOptions.source, 'keep');
                 renderOptions.history = !!renderOptions.location;
             }
+            let openLayerOptions = this._response.openLayer;
+            if (openLayerOptions) {
+                Object.assign(renderOptions, {
+                    ...up.Layer.Overlay.UNSET_VISUALS,
+                    target: undefined,
+                    ...up.fragment.config.navigateOptions,
+                    ...openLayerOptions,
+                    layer: 'new',
+                });
+                Object.assign(renderOptions, openLayerOptions);
+            }
             renderOptions.location = this.improveHistoryValue(renderOptions.location, serverLocation);
             renderOptions.title = this.improveHistoryValue(renderOptions.title, this._response.title);
             renderOptions.eventPlans = this._response.eventPlans;
@@ -3122,7 +3185,7 @@ up.Change.FromResponse = (_a = class FromResponse extends up.Change {
                 renderOptions.target = ':none';
             }
             renderOptions.context = u.merge(renderOptions.context, this._response.context);
-            renderOptions.cspNonces = this._response.cspNonces;
+            renderOptions.cspInfo = this._response.cspInfo;
             renderOptions.time ??= this._response.lastModified;
             renderOptions.etag ??= this._response.etag;
         }
@@ -3136,7 +3199,7 @@ up.Change.FromResponse = (_a = class FromResponse extends up.Change {
 
 
 /***/ }),
-/* 33 */
+/* 34 */
 /***/ (() => {
 
 var _a;
@@ -3208,7 +3271,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
                 'fragment',
                 'document',
                 'html',
-                'cspNonces',
+                'cspInfo',
                 'origin',
                 'data',
             ]);
@@ -3239,7 +3302,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
             return this._expandTargets(target || ':main', layer)[0];
         }
         getPreflightProps(opts = {}) {
-            const getPlanProps = plan => plan.getPreflightProps();
+            const getPlanProps = (plan) => plan.getPreflightProps();
             return this._seekPlan(getPlanProps) || opts.optional || this._cannotMatchPreflightTarget();
         }
         _cannotMatchPreflightTarget() {
@@ -3291,7 +3354,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
 
 
 /***/ }),
-/* 34 */
+/* 35 */
 /***/ (() => {
 
 const u = up.util;
@@ -3386,7 +3449,7 @@ up.CompilerPass = class CompilerPass {
 
 
 /***/ }),
-/* 35 */
+/* 36 */
 /***/ (() => {
 
 const u = up.util;
@@ -3491,7 +3554,7 @@ up.CSSTransition = class CSSTransition {
 
 
 /***/ }),
-/* 36 */
+/* 37 */
 /***/ (() => {
 
 const u = up.util;
@@ -3514,7 +3577,7 @@ up.DestructorPass = class DestructorPass {
 
 
 /***/ }),
-/* 37 */
+/* 38 */
 /***/ (() => {
 
 const u = up.util;
@@ -3613,7 +3676,7 @@ up.EventEmitter = class EventEmitter extends up.Record {
 
 
 /***/ }),
-/* 38 */
+/* 39 */
 /***/ (() => {
 
 const u = up.util;
@@ -3664,7 +3727,8 @@ up.EventListener = class EventListener extends up.Record {
         }
         let element = event.target;
         if (this.selector) {
-            element = element.closest(u.evalOption(this.selector));
+            let selector = u.evalOption(this.selector);
+            element = element.closest(selector);
         }
         if (this.guard && !this.guard(event)) {
             return;
@@ -3717,7 +3781,7 @@ up.EventListener = class EventListener extends up.Record {
 
 
 /***/ }),
-/* 39 */
+/* 40 */
 /***/ (() => {
 
 const u = up.util;
@@ -3763,7 +3827,7 @@ up.EventListenerGroup = class EventListenerGroup extends up.Record {
             }
         });
     }
-    static fromBindArgs(args, defaults) {
+    static fromBindArgs(args, overrides) {
         args = u.copy(args);
         const callback = args.pop();
         let elements;
@@ -3783,14 +3847,63 @@ up.EventListenerGroup = class EventListenerGroup extends up.Record {
         }
         const options = u.extractOptions(args);
         const selector = args[0];
-        const attributes = { elements, eventTypes, selector, callback, ...options, ...defaults };
+        const attributes = { elements, eventTypes, selector, callback, ...options, ...overrides };
         return new (this)(attributes);
     }
 };
 
 
 /***/ }),
-/* 40 */
+/* 41 */
+/***/ (() => {
+
+const u = up.util;
+up.SelectorTracker = class SelectorTracker {
+    constructor(selector, options, addCallback) {
+        this._selector = selector;
+        this._addCallback = addCallback;
+        this._layer = options.layer || 'any';
+        this._filter = options.filter || u.identity;
+        this._live = options.live ?? true;
+        this._knownMatches = new Map();
+    }
+    start() {
+        this._sync();
+        return u.sequence(this._trackFragments(), () => this._removeAllMatches());
+    }
+    _trackFragments() {
+        if (this._live) {
+            return up.on('up:fragment:inserted up:fragment:destroyed', () => this._sync());
+        }
+    }
+    _sync() {
+        let removeMap = new Map(this._knownMatches);
+        this._knownMatches.clear();
+        for (let newMatch of this._currentMatches) {
+            let knownRemoveCallback = removeMap.get(newMatch);
+            removeMap.delete(newMatch);
+            let removeCallback = knownRemoveCallback || this._addCallback(newMatch) || u.noop;
+            this._knownMatches.set(newMatch, removeCallback);
+        }
+        this._runRemoveCallbacks(removeMap);
+    }
+    get _currentMatches() {
+        let allMatches = up.fragment.all(this._selector, { layer: this._layer });
+        return this._filter(allMatches);
+    }
+    _removeAllMatches() {
+        this._runRemoveCallbacks(this._knownMatches);
+    }
+    _runRemoveCallbacks(map) {
+        for (let [element, removeCallback] of map) {
+            removeCallback(element);
+        }
+    }
+};
+
+
+/***/ }),
+/* 42 */
 /***/ (() => {
 
 const u = up.util;
@@ -3798,40 +3911,46 @@ up.FieldWatcher = class FieldWatcher {
     constructor(root, options, callback) {
         this._options = options;
         this._root = root;
-        this._scope = up.form.getScope(root);
         this._callback = callback;
         this._batch = options.batch;
+        this._logPrefix = options.logPrefix ?? 'up.watch()';
+        this._ensureWatchable();
     }
     start() {
         this._scheduledValues = null;
         this._processedValues = this._readFieldValues();
         this._currentTimer = null;
         this._callbackRunning = false;
-        this._cleaner = u.cleaner();
-        this._watchFieldsWithin(this._root);
-        this._root.addEventListener('up:fragment:inserted', ({ target }) => {
-            if (target !== this._root)
-                this._watchFieldsWithin(target);
-        });
-        this._cleaner(up.fragment.onAborted(this._scope, () => this._abort()));
-        this._cleaner(up.on(this._scope, 'reset', () => this._onFormReset()));
+        return u.sequence(up.form.trackFields(this._root, (field) => this._watchField(field)), this._trackAbort(), this._trackReset(), () => this._abort());
     }
-    stop() {
-        this._abort();
-        this._cleaner.clean();
+    _ensureWatchable() {
+        const fail = (message) => up.fail(message, this._logPrefix, this._root);
+        if (!this._callback) {
+            fail('No callback provided for %s (%o)');
+        }
+        if (this._root.matches('input[type=radio]')) {
+            fail('Use %s with the container of a radio group, not with an individual radio button (%o)');
+        }
+    }
+    _trackAbort() {
+        let guard = ({ target }) => target.contains(this._region);
+        return up.on('up:fragment:aborted', { guard }, () => this._abort());
+    }
+    _trackReset() {
+        let guard = ({ target }) => target === this._region;
+        return up.on('reset', { guard }, (event) => this._onFormReset(event));
+    }
+    get _region() {
+        return up.form.getRegion(this._root);
     }
     _fieldOptions(field) {
         let rootOptions = u.copy(this._options);
         return up.form.watchOptions(field, rootOptions, { defaults: { event: 'input' } });
     }
-    _watchFieldsWithin(container) {
-        for (let field of up.form.fields(container)) {
-            this._watchField(field);
-        }
-    }
     _watchField(field) {
         let fieldOptions = this._fieldOptions(field);
-        this._cleaner(up.on(field, fieldOptions.event, () => this._check(fieldOptions)));
+        let eventType = fieldOptions.event;
+        return up.on(field, eventType, (event) => this._check(event, fieldOptions));
     }
     _abort() {
         this._scheduledValues = null;
@@ -3856,7 +3975,7 @@ up.FieldWatcher = class FieldWatcher {
             return;
         if (this._currentTimer)
             return;
-        if (!this._scope.isConnected)
+        if (!up.fragment.isAlive(this._region))
             return;
         let callbackOptions = u.omit(this._scheduledFieldOptions, ['event', 'delay']);
         const diff = this._changedValues(this._processedValues, this._scheduledValues);
@@ -3901,20 +4020,141 @@ up.FieldWatcher = class FieldWatcher {
     _readFieldValues() {
         return up.Params.fromContainer(this._root).toObject();
     }
-    _check(fieldOptions = {}) {
+    _check(event, fieldOptions = {}) {
+        up.log.putsEvent(event);
         const values = this._readFieldValues();
         if (this._isNewValues(values)) {
             this._scheduleValues(values, fieldOptions);
         }
     }
-    _onFormReset() {
-        u.task(() => this._check());
+    _onFormReset(event) {
+        u.task(() => this._check(event));
     }
 };
 
 
 /***/ }),
-/* 41 */
+/* 43 */
+/***/ (() => {
+
+const u = up.util;
+const e = up.element;
+const BUILTIN_SWITCH_EFFECTS = [
+    { attr: 'up-hide-for', toggle(target, active) { e.toggle(target, !active); } },
+    { attr: 'up-show-for', toggle(target, active) { e.toggle(target, active); } },
+    { attr: 'up-disable-for', toggle(target, active) { up.form.setDisabled(target, active); } },
+    { attr: 'up-enable-for', toggle(target, active) { up.form.setDisabled(target, !active); } },
+];
+up.Switcher = class Switcher {
+    constructor(root) {
+        this._root = root;
+        this._switcheeSelector = root.getAttribute('up-switch') || up.fail("No switch target given for %o", root);
+        this._regionSelector = root.getAttribute('up-switch-region');
+    }
+    start() {
+        this._switchRegion();
+        return u.sequence(this._trackFieldChanges(), this._trackNewSwitchees());
+    }
+    _trackFieldChanges() {
+        let callback = () => this._onFieldChanged();
+        return up.migrate.watchForSwitch?.(this._root, callback)
+            || up.watch(this._root, { logPrefix: '[up-switch]' }, callback);
+    }
+    _trackNewSwitchees() {
+        let filter = (matches) => {
+            let scope = this._scope;
+            return u.filter(matches, (match) => scope.contains(match));
+        };
+        let onSwitcheeAdded = (switchee) => this._switchSwitchee(switchee);
+        return up.fragment.trackSelector(this._switcheeSelector, { filter }, onSwitcheeAdded);
+    }
+    _onFieldChanged() {
+        this._switchRegion();
+    }
+    _switchRegion() {
+        const fieldTokens = this._buildFieldTokens();
+        for (let switchee of this._findSwitchees()) {
+            this._switchSwitchee(switchee, fieldTokens);
+        }
+    }
+    _switchSwitchee(switchee, fieldTokens = this._buildFieldTokens()) {
+        let previousValues = switchee.upSwitchValues;
+        if (!u.isEqual(previousValues, fieldTokens)) {
+            switchee.upSwitchValues = fieldTokens;
+            this._switchSwitcheeNow(switchee, fieldTokens);
+        }
+    }
+    _switchSwitcheeNow(switchee, fieldTokens) {
+        for (let { attr, toggle } of BUILTIN_SWITCH_EFFECTS) {
+            let attrValue = switchee.getAttribute(attr);
+            if (attrValue) {
+                let activeTokens = this._parseSwitcheeTokens(attrValue);
+                let isActive = u.intersect(fieldTokens, activeTokens).length > 0;
+                toggle(switchee, isActive);
+            }
+        }
+        let log = ['Switching %o', switchee];
+        up.emit(switchee, 'up:form:switch', { field: this._root, tokens: fieldTokens, log });
+    }
+    _findSwitchees() {
+        return up.fragment.subtree(this._scope, this._switcheeSelector);
+    }
+    get _scope() {
+        if (this._regionSelector) {
+            return up.fragment.get(this._regionSelector, { origin: this._root });
+        }
+        else {
+            return up.form.getRegion(this._root);
+        }
+    }
+    _parseSwitcheeTokens(str) {
+        return u.getSimpleTokens(str, { json: true });
+    }
+    _buildFieldTokens() {
+        let fields = up.form.fields(this._root);
+        let field = fields[0];
+        let value;
+        let meta;
+        if (field.matches('input[type=checkbox]')) {
+            if (field.checked) {
+                value = field.value;
+                meta = ':checked';
+            }
+            else {
+                meta = ':unchecked';
+            }
+        }
+        else if (field.matches('input[type=radio]')) {
+            let checkedButton = up.migrate.checkedRadioButtonForSwitch?.(field) || u.find(fields, 'checked');
+            if (checkedButton) {
+                meta = ':checked';
+                value = checkedButton.value;
+            }
+            else {
+                meta = ':unchecked';
+            }
+        }
+        else {
+            value = field.value;
+        }
+        const values = [];
+        if (u.isPresent(value)) {
+            values.push(value);
+            values.push(':present');
+        }
+        else {
+            values.push(':blank');
+        }
+        if (u.isPresent(meta)) {
+            values.push(meta);
+        }
+        return values;
+    }
+};
+
+
+/***/ }),
+/* 44 */
 /***/ (() => {
 
 const u = up.util;
@@ -3925,41 +4165,51 @@ up.FormValidator = class FormValidator {
         this._dirtySolutions = [];
         this._nextRenderTimer = null;
         this._rendering = false;
-        this._resetNextRenderPromise();
         this._honorAbort();
     }
+    start() {
+        let guard = (field) => this._isValidatingField(field);
+        let callback = (field) => this._onFieldAdded(field);
+        return up.form.trackFields(this._form, { guard }, callback);
+    }
+    _isValidatingField(field) {
+        return field.closest('[up-validate]:not([up-validate=false])');
+    }
+    _onFieldAdded(field) {
+        let eventType = up.form.validateOptions(field).event;
+        return up.on(field, eventType, (event) => {
+            up.log.putsEvent(event);
+            up.error.muteUncriticalRejection(this.validate({ origin: field }));
+        });
+    }
     _honorAbort() {
         up.fragment.onAborted(this._form, (event) => this._onAborted(event));
     }
     _onAborted(event) {
-        if (this._dirtySolutions.length) {
-            this._dirtySolutions = [];
-            this._nextRenderPromise.reject(new up.Aborted(event.reason));
-            this._resetNextRenderPromise();
+        let abortedError = new up.Aborted(event.reason);
+        let solution;
+        while (solution = this._dirtySolutions.shift()) {
+            solution.deferred.reject(abortedError);
         }
     }
-    _resetNextRenderPromise() {
-        this._nextRenderPromise = u.newDeferred();
-    }
-    watchContainer(fieldOrForm) {
-        let { event } = this._originOptions(fieldOrForm);
-        let guard = () => up.fragment.isAlive(fieldOrForm);
-        let callback = () => up.error.muteUncriticalRejection(this.validate({ origin: fieldOrForm }));
-        up.on(fieldOrForm, event, { guard }, callback);
-    }
     validate(options = {}) {
-        let solutions = this._getSolutions(options);
-        this._dirtySolutions.push(...solutions);
+        let newSolutions = this._getSolutions(options);
+        this._dirtySolutions.push(...newSolutions);
         this._scheduleNextRender();
-        return this._nextRenderPromise;
+        return newSolutions[0]?.deferred;
     }
     _getSolutions(options) {
         let solutions = this._getTargetSelectorSolutions(options)
             || this._getFieldSolutions(options)
             || this._getElementSolutions(options.origin);
+        let deferred = u.newDeferred();
         for (let solution of solutions) {
-            solution.renderOptions = this._originOptions(solution.origin, options);
+            let renderOptions = up.form.validateOptions(solution.origin, options);
+            solution.batch = u.pluckKey(renderOptions, 'batch');
+            solution.renderOptions = renderOptions;
+            solution.destination = `${renderOptions.method} ${renderOptions.url}`;
             solution.target = up.fragment.resolveOrigin(solution.target, solution);
+            solution.deferred = deferred;
         }
         return solutions;
     }
@@ -4011,9 +4261,6 @@ up.FormValidator = class FormValidator {
             return this._getTargetSelectorSolutions({ target, origin: field });
         }
     }
-    _originOptions(element, overrideOptions) {
-        return up.form.watchOptions(element, overrideOptions, { defaults: { event: 'change' } });
-    }
     _scheduleNextRender() {
         let solutionDelays = this._dirtySolutions.map((solution) => solution.renderOptions.delay);
         let shortestDelay = Math.min(...solutionDelays) || 0;
@@ -4033,33 +4280,53 @@ up.FormValidator = class FormValidator {
             return;
         if (this._nextRenderTimer)
             return;
-        let options = this._mergeRenderOptions(this._dirtySolutions);
-        this._dirtySolutions = [];
+        let solutionsBatch = this._selectDirtySolutionsBatch();
+        let renderOptions = this._mergeRenderOptions(solutionsBatch);
         this._rendering = true;
-        let renderingPromise = this._nextRenderPromise;
-        this._resetNextRenderPromise();
         try {
-            renderingPromise.resolve(up.render(options));
-            await renderingPromise;
+            let renderPromise = up.render(renderOptions);
+            for (let solution of solutionsBatch) {
+                solution.deferred.resolve(renderPromise);
+            }
+            await renderPromise;
         }
         finally {
             this._rendering = false;
             this._renderDirtySolutions();
         }
     }
+    _selectDirtySolutionsBatch() {
+        let batch = [];
+        let i = 0;
+        while (i < this._dirtySolutions.length) {
+            let solution = this._dirtySolutions[i];
+            if (batch.length === 0 || this._canBatchSolutions(batch[0], solution)) {
+                batch.push(solution);
+                this._dirtySolutions.splice(i, 1);
+            }
+            else {
+                i++;
+            }
+        }
+        return batch;
+    }
+    _canBatchSolutions(s1, s2) {
+        return s1.destination === s2.destination && s1.batch && s2.batch;
+    }
     _mergeRenderOptions(dirtySolutions) {
         let dirtyOrigins = u.map(dirtySolutions, 'origin');
         let dirtyFields = u.flatMap(dirtyOrigins, up.form.fields);
         let dirtyNames = u.uniq(u.map(dirtyFields, 'name'));
         let dirtyRenderOptionsList = u.map(dirtySolutions, 'renderOptions');
-        let options = u.mergeDefined(...dirtyRenderOptionsList, up.form.destinationOptions(this._form));
+        let formDestinationOptions = up.form.destinationOptions(this._form);
+        let options = u.mergeDefined(formDestinationOptions, ...dirtyRenderOptionsList);
         options.target = u.map(dirtySolutions, 'target').join(', ');
         options.origin = this._form;
         options.focus ??= 'keep';
         options.failOptions = false;
         options.defaultMaybe = true;
-        options.params = up.Params.merge(options.params, ...u.map(dirtyRenderOptionsList, 'params'));
-        options.headers = u.merge(options.headers, ...u.map(dirtyRenderOptionsList, 'headers'));
+        options.params = up.Params.merge(formDestinationOptions.params, ...u.map(dirtyRenderOptionsList, 'params'));
+        options.headers = u.merge(formDestinationOptions.headers, ...u.map(dirtyRenderOptionsList, 'headers'));
         this._addValidateHeader(options.headers, dirtyNames);
         options.feedback = u.some(dirtyRenderOptionsList, 'feedback');
         options.data = undefined;
@@ -4087,27 +4354,29 @@ up.FormValidator = class FormValidator {
             value = ':unknown';
         headers[key] = value;
     }
-    static forElement(element) {
-        let form = up.form.get(element);
-        return form.upFormValidator ||= new this(form);
-    }
 };
 
 
 /***/ }),
-/* 42 */
+/* 45 */
 /***/ (() => {
 
 up.FocusCapsule = class FocusCapsule {
-    constructor(element, target, cursorProps) {
+    constructor(element, target) {
         this._element = element;
         this._target = target;
-        this._cursorProps = cursorProps;
+        this._cursorProps = up.viewport.copyCursorProps(this._element);
     }
     wasLost() {
-        return document.activeElement !== this._element;
+        return document.activeElement !== this._element && !this._voided;
+    }
+    autoVoid() {
+        up.on('focusin', { once: true }, () => this._voided = true);
     }
     restore(layer, focusOptions) {
+        if (!this.wasLost()) {
+            return false;
+        }
         let rediscoveredElement = up.fragment.get(this._target, { layer });
         if (rediscoveredElement) {
             up.viewport.copyCursorProps(this._cursorProps, rediscoveredElement);
@@ -4122,14 +4391,13 @@ up.FocusCapsule = class FocusCapsule {
         let target = up.fragment.tryToTarget(focusedElement);
         if (!target)
             return;
-        const cursorProps = up.viewport.copyCursorProps(focusedElement);
-        return new this(focusedElement, target, cursorProps);
+        return new this(focusedElement, target);
     }
 };
 
 
 /***/ }),
-/* 43 */
+/* 46 */
 /***/ (() => {
 
 const u = up.util;
@@ -4172,7 +4440,7 @@ up.FragmentProcessor = class FragmentProcessor extends up.Record {
         return this.processPrimitive(opt);
     }
     processArray(array) {
-        return u.find(array, opt => this.tryProcess(opt));
+        return u.find(array, (opt) => this.tryProcess(opt));
     }
     resolveCondition(condition) {
         if (condition === 'main') {
@@ -4194,7 +4462,7 @@ up.FragmentProcessor = class FragmentProcessor extends up.Record {
 
 
 /***/ }),
-/* 44 */
+/* 47 */
 /***/ (() => {
 
 const u = up.util;
@@ -4243,7 +4511,7 @@ up.FragmentFinder = class FragmentFinder {
 
 
 /***/ }),
-/* 45 */
+/* 48 */
 /***/ (() => {
 
 const u = up.util;
@@ -4253,6 +4521,7 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
     keys() {
         return super.keys().concat([
             'hash',
+            'focusVisible',
             'focusCapsule',
             'inputDevice',
         ]);
@@ -4296,9 +4565,7 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
         return this._focusElement(match);
     }
     _restoreLostFocus() {
-        if (this._wasFocusLost()) {
-            return this.focusCapsule?.restore(this.layer, PREVENT_SCROLL_OPTIONS);
-        }
+        return this.focusCapsule?.restore(this.layer, PREVENT_SCROLL_OPTIONS);
     }
     _restorePreviousFocusForLocation() {
         return up.viewport.restoreFocus({ layer: this.layer });
@@ -4311,7 +4578,12 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
     }
     _focusElement(element) {
         if (element) {
-            up.focus(element, { force: true, ...PREVENT_SCROLL_OPTIONS, inputDevice: this.inputDevice });
+            up.focus(element, {
+                force: true,
+                ...PREVENT_SCROLL_OPTIONS,
+                inputDevice: this.inputDevice,
+                focusVisible: this.focusVisible,
+            });
             return true;
         }
     }
@@ -4328,7 +4600,7 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
 
 
 /***/ }),
-/* 46 */
+/* 49 */
 /***/ (() => {
 
 const e = up.element;
@@ -4414,6 +4686,11 @@ up.FragmentPolling = class FragmentPolling {
         if (this._state !== 'started') {
             return;
         }
+        if (!up.fragment.isAlive(this._fragment)) {
+            this._stop();
+            up.puts('[up-poll]', 'Stopped polling a detached fragment');
+            return;
+        }
         if (!this._isFragmentVisible()) {
             up.puts('[up-poll]', 'Will not poll hidden fragment');
             return;
@@ -4483,7 +4760,7 @@ up.FragmentPolling = class FragmentPolling {
 
 
 /***/ }),
-/* 47 */
+/* 50 */
 /***/ (() => {
 
 const u = up.util;
@@ -4500,8 +4777,10 @@ up.FragmentScrolling = class FragmentScrolling extends up.FragmentProcessor {
     }
     processPrimitive(opt) {
         switch (opt) {
-            case 'reset':
-                return this._reset();
+            case 'top':
+                return this._scrollTo(0);
+            case 'bottom':
+                return this._scrollTo(99999999);
             case 'layer':
                 return this._revealLayer();
             case 'main':
@@ -4536,9 +4815,8 @@ up.FragmentScrolling = class FragmentScrolling extends up.FragmentProcessor {
     _revealLayer() {
         return this._revealElement(this.layer.getBoxElement());
     }
-    _reset() {
-        up.viewport.resetScroll({ ...this.attributes(), around: this.fragment });
-        return true;
+    _scrollTo(position) {
+        return up.viewport.scrollTo(position, { ...this.attributes(), around: this.fragment });
     }
     _restore() {
         return up.viewport.restoreScroll({ ...this.attributes(), around: this.fragment });
@@ -4547,7 +4825,7 @@ up.FragmentScrolling = class FragmentScrolling extends up.FragmentProcessor {
 
 
 /***/ }),
-/* 48 */
+/* 51 */
 /***/ (() => {
 
 const e = up.element;
@@ -4783,7 +5061,7 @@ up.Layer = class Layer extends up.Record {
                 up.history.push(location);
             }
             if (!this.opening) {
-                this.emit('up:layer:location:changed', { location });
+                this.emit('up:layer:location:changed', { location, log: false });
             }
         }
     }
@@ -4813,7 +5091,7 @@ up.Layer = class Layer extends up.Record {
 
 
 /***/ }),
-/* 49 */
+/* 52 */
 /***/ (() => {
 
 var _a;
@@ -4913,7 +5191,7 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
             }
             if (this._supportsDismissMethod('outside')) {
                 if (this.viewportElement) {
-                    up.on(this.viewportElement, 'up:click', event => {
+                    up.on(this.viewportElement, 'up:click', (event) => {
                         if (event.target === this.viewportElement) {
                             this._onOutsideClicked(event, true);
                         }
@@ -4929,17 +5207,17 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
                 }
             }
             if (this._supportsDismissMethod('key')) {
-                this.unbindEscapePressed = up.event.onEscape(event => this.onEscapePressed(event));
+                this.unbindEscapePressed = up.event.onEscape((event) => this.onEscapePressed(event));
             }
-            this.registerClickCloser('up-accept', (value, closeOptions) => {
+            this.registerAttrCloser('up-accept', (value, closeOptions) => {
                 this.accept(value, closeOptions);
             });
-            this.registerClickCloser('up-dismiss', (value, closeOptions) => {
+            this.registerAttrCloser('up-dismiss', (value, closeOptions) => {
                 this.dismiss(value, closeOptions);
             });
             up.migrate.registerLayerCloser?.(this);
-            this._registerEventCloser(this.acceptEvent, this.accept);
-            this._registerEventCloser(this.dismissEvent, this.dismiss);
+            this._registerExternalEventCloser(this.acceptEvent, this.accept);
+            this._registerExternalEventCloser(this.dismissEvent, this.dismiss);
             this.on('up:click', 'label[for]', (event, label) => this._onLabelClicked(event, label));
         }
         _onLabelClicked(event, label) {
@@ -4974,26 +5252,38 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
                 }
             }
         }
-        registerClickCloser(attribute, closeFn) {
-            let selector = `[${attribute}]`;
-            this.on('up:click', selector, function (event) {
+        registerAttrCloser(attribute, closeFn) {
+            this._registerClickCloser(attribute, closeFn);
+            this._registerSubmitCloser(attribute, closeFn);
+        }
+        _registerClickCloser(attribute, closeFn) {
+            this.on('up:click', `[${attribute}]:not(form)`, (event, link) => {
+                up.event.halt(event, { log: true });
+                const value = e.jsonAttr(link, attribute);
+                this._onAttrCloserActivated(link, value, closeFn);
+            });
+        }
+        _registerSubmitCloser(attribute, closeFn) {
+            this.on('submit', `[${attribute}]`, (event, form) => {
                 up.event.halt(event, { log: true });
-                const origin = event.target.closest(selector);
-                const value = e.jsonAttr(origin, attribute);
-                const closeOptions = { origin };
-                const parser = new up.OptionsParser(origin, closeOptions);
-                parser.booleanOrString('animation');
-                parser.string('easing');
-                parser.number('duration');
-                parser.string('confirm');
-                up.error.muteUncriticalSync(() => closeFn(value, closeOptions));
+                const value = up.Params.fromForm(form);
+                this._onAttrCloserActivated(form, value, closeFn);
             });
         }
-        _registerEventCloser(eventTypes, closeFn) {
+        _onAttrCloserActivated(origin, value, closeFn) {
+            const closeOptions = { origin };
+            const parser = new up.OptionsParser(origin, closeOptions);
+            parser.booleanOrString('animation');
+            parser.string('easing');
+            parser.number('duration');
+            parser.string('confirm');
+            up.error.muteUncriticalSync(() => closeFn(value, closeOptions));
+        }
+        _registerExternalEventCloser(eventTypes, closeFn) {
             if (!eventTypes) {
                 return;
             }
-            return this.on(eventTypes, event => {
+            return this.on(eventTypes, (event) => {
                 event.preventDefault();
                 up.error.muteUncriticalSync(() => closeFn.call(this, event, { response: event.response }));
             });
@@ -5096,11 +5386,12 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
         'closeEasing',
         'trapFocus',
     ],
+    _a.UNSET_VISUALS = u.spanObject(_a.VISUAL_KEYS, undefined),
     _a);
 
 
 /***/ }),
-/* 50 */
+/* 53 */
 /***/ (() => {
 
 up.Layer.OverlayWithTether = class OverlayWithTether extends up.Layer.Overlay {
@@ -5139,7 +5430,7 @@ up.Layer.OverlayWithTether = class OverlayWithTether extends up.Layer.Overlay {
 
 
 /***/ }),
-/* 51 */
+/* 54 */
 /***/ (() => {
 
 up.Layer.OverlayWithViewport = class OverlayWithViewport extends up.Layer.Overlay {
@@ -5168,7 +5459,7 @@ up.Layer.OverlayWithViewport = class OverlayWithViewport extends up.Layer.Overla
 
 
 /***/ }),
-/* 52 */
+/* 55 */
 /***/ (() => {
 
 var _a;
@@ -5214,7 +5505,7 @@ up.Layer.Root = (_a = class Root extends up.Layer {
 
 
 /***/ }),
-/* 53 */
+/* 56 */
 /***/ (() => {
 
 var _a;
@@ -5225,7 +5516,7 @@ up.Layer.Modal = (_a = class Modal extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 54 */
+/* 57 */
 /***/ (() => {
 
 var _a;
@@ -5236,7 +5527,7 @@ up.Layer.Popup = (_a = class Popup extends up.Layer.OverlayWithTether {
 
 
 /***/ }),
-/* 55 */
+/* 58 */
 /***/ (() => {
 
 var _a;
@@ -5247,7 +5538,7 @@ up.Layer.Drawer = (_a = class Drawer extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 56 */
+/* 59 */
 /***/ (() => {
 
 var _a;
@@ -5258,7 +5549,7 @@ up.Layer.Cover = (_a = class Cover extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 57 */
+/* 60 */
 /***/ (() => {
 
 var _a;
@@ -5274,7 +5565,7 @@ up.LayerLookup = (_a = class LayerLookup {
             this._values = u.getSimpleTokens(options.layer);
         }
         all() {
-            let results = u.flatMap(this._values, value => this._resolveValue(value));
+            let results = u.flatMap(this._values, (value) => this._resolveValue(value));
             results = u.compact(results);
             results = u.uniq(results);
             return results;
@@ -5289,7 +5580,7 @@ up.LayerLookup = (_a = class LayerLookup {
         }
         _forElement(element) {
             element = e.get(element);
-            return u.find(this._stack.reversed(), layer => layer.contains(element));
+            return u.find(this._stack.reversed(), (layer) => layer.contains(element));
         }
         _forIndex(value) {
             return this._stack.at(value);
@@ -5371,7 +5662,7 @@ up.LayerLookup = (_a = class LayerLookup {
 
 
 /***/ }),
-/* 58 */
+/* 61 */
 /***/ (() => {
 
 const u = up.util;
@@ -5485,7 +5776,7 @@ up.LayerStack = class LayerStack {
 
 
 /***/ }),
-/* 59 */
+/* 62 */
 /***/ (() => {
 
 const u = up.util;
@@ -5519,7 +5810,7 @@ up.LinkCurrentURLs = class LinkCurrentURLs {
 
 
 /***/ }),
-/* 60 */
+/* 63 */
 /***/ (() => {
 
 const u = up.util;
@@ -5560,13 +5851,15 @@ up.LinkFollowIntent = class LinkFollowIntent {
     }
     _runCallback(event) {
         up.log.putsEvent(event);
+        if (!up.fragment.isAlive(this._link))
+            return;
         this._callback({ onRequestKnown: (request) => this._lastRequest = request });
     }
 };
 
 
 /***/ }),
-/* 61 */
+/* 64 */
 /***/ (() => {
 
 const u = up.util;
@@ -5608,7 +5901,7 @@ up.MotionController = class MotionController {
     }
     _expandFinishRequest(elements) {
         if (elements) {
-            return u.flatMap(elements, el => e.list(el.closest(this._selector), el.querySelectorAll(this._selector)));
+            return u.flatMap(elements, (el) => e.list(el.closest(this._selector), el.querySelectorAll(this._selector)));
         }
         else {
             return document.querySelectorAll(this._selector);
@@ -5662,10 +5955,9 @@ up.MotionController = class MotionController {
 
 
 /***/ }),
-/* 62 */
+/* 65 */
 /***/ (() => {
 
-const u = up.util;
 const e = up.element;
 up.NonceableCallback = class NonceableCallback {
     constructor(script, nonce) {
@@ -5719,37 +6011,11 @@ up.NonceableCallback = class NonceableCallback {
             }
         }
     }
-    _allowedBy(allowedNonces) {
-        return this.nonce && u.contains(allowedNonces, this.nonce);
-    }
-    static adoptNonces(element, allowedNonces) {
-        if (!allowedNonces?.length) {
-            return;
-        }
-        const getPageNonce = u.memoize(up.protocol.cspNonce);
-        u.each(up.script.config.nonceableAttributes, (attribute) => {
-            let matches = e.subtree(element, `[${attribute}^="nonce-"]`);
-            u.each(matches, (match) => {
-                let attributeValue = match.getAttribute(attribute);
-                let callback = this.fromString(attributeValue);
-                let warn = (message, ...args) => up.log.warn('up.render()', `Cannot use callback [${attribute}="${attributeValue}"]: ${message}`, ...args);
-                if (!callback._allowedBy(allowedNonces)) {
-                    return warn("Callback's CSP nonce (%o) does not match response header (%o)", callback.nonce, allowedNonces);
-                }
-                let pageNonce = getPageNonce();
-                if (!pageNonce) {
-                    return warn("Current page's CSP nonce is unknown");
-                }
-                callback.nonce = pageNonce;
-                match.setAttribute(attribute, callback.toString());
-            });
-        });
-    }
 };
 
 
 /***/ }),
-/* 63 */
+/* 66 */
 /***/ (() => {
 
 const e = up.element;
@@ -5771,7 +6037,7 @@ up.OverlayFocus = class OverlayFocus {
             'aria-modal': this._trapFocus.toString()
         });
         if (this._trapFocus) {
-            this._untrapFocus = up.on('focusin', event => this._onFocus(event));
+            this._untrapFocus = up.on('focusin', (event) => this._onFocus(event));
             this._focusTrapBefore = e.affix(this._focusElement, 'beforebegin', 'up-focus-trap[tabindex=0]');
             this._focusTrapAfter = e.affix(this._focusElement, 'afterend', 'up-focus-trap[tabindex=0]');
         }
@@ -5822,7 +6088,7 @@ up.OverlayFocus = class OverlayFocus {
 
 
 /***/ }),
-/* 64 */
+/* 67 */
 /***/ (() => {
 
 const u = up.util;
@@ -5959,7 +6225,7 @@ up.Params = class Params {
         this.entries = u.reject(this.entries, this._matchEntryFn(name));
     }
     _matchEntryFn(name) {
-        return entry => entry.name === name;
+        return (entry) => entry.name === name;
     }
     get(name) {
         if (this._isArrayKey(name)) {
@@ -6056,7 +6322,7 @@ up.Params = class Params {
 
 
 /***/ }),
-/* 65 */
+/* 68 */
 /***/ (() => {
 
 const u = up.util;
@@ -6127,7 +6393,7 @@ up.Preview = class Preview {
     }
     disable(...args) {
         let [element] = this._parseMutatorArgs(args, 'val');
-        this.undo(up.form.disable(element));
+        this.undo(up.form.disableTemp(element));
     }
     insert(...args) {
         let [reference, position = 'beforeend', tempValue] = this._parseMutatorArgs(args, 'val', u.isAdjacentPosition, 'val');
@@ -6190,7 +6456,7 @@ up.Preview = class Preview {
 
 
 /***/ }),
-/* 66 */
+/* 69 */
 /***/ (() => {
 
 const e = up.element;
@@ -6240,7 +6506,7 @@ up.ProgressBar = class ProgressBar {
 
 
 /***/ }),
-/* 67 */
+/* 70 */
 /***/ (() => {
 
 const u = up.util;
@@ -6336,7 +6602,7 @@ up.RenderOptions = (function () {
         return u.merge(preprocessedOptions.defaults, lateDefaults, preprocessedOptions);
     }
     function assertContentGiven(options) {
-        if (!u.some(CONTENT_KEYS, contentKey => u.isGiven(options[contentKey]))) {
+        if (!u.some(CONTENT_KEYS, (contentKey) => u.isGiven(options[contentKey]))) {
             if (options.defaultToEmptyContent) {
                 options.content = '';
             }
@@ -6386,7 +6652,7 @@ up.RenderOptions = (function () {
 
 
 /***/ }),
-/* 68 */
+/* 71 */
 /***/ (() => {
 
 up.RenderResult = class RenderResult extends up.Record {
@@ -6434,7 +6700,7 @@ up.RenderResult = class RenderResult extends up.Record {
 
 
 /***/ }),
-/* 69 */
+/* 72 */
 /***/ (() => {
 
 var _a;
@@ -6461,6 +6727,8 @@ up.Request = (_a = class Request extends up.Record {
                 'failMode',
                 'failContext',
                 'origin',
+                'originLayer',
+                'originMode',
                 'builtAt',
                 'wrapMethod',
                 'contentType',
@@ -6473,30 +6741,31 @@ up.Request = (_a = class Request extends up.Record {
             ];
         }
         defaults() {
+            let config = up.network.config;
             return {
                 state: 'new',
                 abortable: true,
                 headers: {},
-                timeout: up.network.config.timeout,
+                timeout: config.timeout,
                 builtAt: new Date(),
                 previews: [],
+                wrapMethod: config.wrapMethod,
             };
         }
         constructor(options) {
             super(options);
             this.params = new up.Params(this.params);
-            if (this.wrapMethod == null) {
-                this.wrapMethod = up.network.config.wrapMethod;
-            }
             this._normalize();
             if ((this.target || this.layer || this.origin) && !options.basic) {
                 const layerLookupOptions = { origin: this.origin };
                 this.layer = up.layer.get(this.layer, layerLookupOptions);
-                this.failLayer = up.layer.get(this.failLayer, layerLookupOptions);
                 this.context ||= this.layer.context || {};
-                this.failContext ||= this.failLayer?.context || {};
                 this.mode ||= this.layer.mode;
+                this.failLayer = up.layer.get(this.failLayer, layerLookupOptions);
+                this.failContext ||= this.failLayer?.context || {};
                 this.failMode ||= this.failLayer?.mode;
+                this.originLayer ||= up.layer.get(this.origin) || up.layer.current;
+                this.originMode ||= this.originLayer?.mode;
             }
             this.bindLayer = options.bindLayer || this.layer;
             this._fragments = options.fragments;
@@ -6543,8 +6812,9 @@ up.Request = (_a = class Request extends up.Record {
             u.task(() => {
                 this.layer = undefined;
                 this.failLayer = undefined;
-                this._bindLayer = undefined;
+                this.bindLayer = undefined;
                 this.origin = undefined;
+                this.originLayer = undefined;
                 this._fragments = undefined;
                 this._bindFragments = undefined;
             });
@@ -6698,6 +6968,7 @@ up.Request = (_a = class Request extends up.Record {
                 status: this.xhr.status,
                 title: up.protocol.titleFromXHR(this.xhr),
                 target: up.protocol.targetFromXHR(this.xhr),
+                openLayer: up.protocol.openLayerFromXHR(this.xhr),
                 acceptLayer: up.protocol.acceptLayerFromXHR(this.xhr),
                 dismissLayer: up.protocol.dismissLayerFromXHR(this.xhr),
                 eventPlans: up.protocol.eventPlansFromXHR(this.xhr),
@@ -6751,7 +7022,7 @@ up.Request = (_a = class Request extends up.Record {
             return this.headers[name];
         }
         _setAutoHeaders() {
-            for (let key of ['target', 'failTarget', 'mode', 'failMode', 'context', 'failContext']) {
+            for (let key of ['target', 'failTarget', 'mode', 'failMode', 'context', 'failContext', 'originMode']) {
                 this._setPropertyHeader(key);
             }
             let csrfHeader, csrfToken;
@@ -6806,13 +7077,13 @@ up.Request = (_a = class Request extends up.Record {
         }
     },
     (() => {
-        u.delegatePromise(_a.prototype, '_deferred');
+        u.delegatePromise(_a.prototype, function () { return this._deferred; });
     })(),
     _a);
 
 
 /***/ }),
-/* 70 */
+/* 73 */
 /***/ (() => {
 
 const u = up.util;
@@ -6954,14 +7225,14 @@ up.Request.Cache = class Cache {
     _isUsable(request) {
         return request.age < up.network.config.cacheEvictAge;
     }
-    get _size() {
+    get currentSize() {
         return this._requests.length;
     }
     get _capacity() {
         return up.network.config.cacheSize;
     }
     _limitSize() {
-        for (let i = 0; i < (this._size - this._capacity); i++) {
+        for (let i = 0; i < (this.currentSize - this._capacity); i++) {
             this._delete(this._requests[0]);
         }
     }
@@ -6977,7 +7248,7 @@ up.Request.Cache = class Cache {
 
 
 /***/ }),
-/* 71 */
+/* 74 */
 /***/ (() => {
 
 const u = up.util;
@@ -6995,7 +7266,7 @@ up.Request.Queue = class Queue {
     }
     asap(request) {
         request.runQueuedCallbacks();
-        u.always(request, responseOrError => this._onRequestSettled(request, responseOrError));
+        u.always(request, (responseOrError) => this._onRequestSettled(request, responseOrError));
         this._scheduleSlowTimer(request);
         this._queueRequest(request);
         queueMicrotask(() => this._poke());
@@ -7026,7 +7297,7 @@ up.Request.Queue = class Queue {
         this._queuedRequests.push(request);
     }
     _pluckNextRequest() {
-        let request = u.find(this._queuedRequests, request => !request.background);
+        let request = u.find(this._queuedRequests, (request) => !request.background);
         request ||= this._queuedRequests[0];
         return u.remove(this._queuedRequests, request);
     }
@@ -7088,7 +7359,7 @@ up.Request.Queue = class Queue {
 
 
 /***/ }),
-/* 72 */
+/* 75 */
 /***/ (() => {
 
 const u = up.util;
@@ -7127,7 +7398,7 @@ up.Request.FormRenderer = class FormRenderer {
 
 
 /***/ }),
-/* 73 */
+/* 76 */
 /***/ (() => {
 
 var _a;
@@ -7198,7 +7469,7 @@ up.Request.XHRRenderer = (_a = class XHRRenderer {
 
 
 /***/ }),
-/* 74 */
+/* 77 */
 /***/ (() => {
 
 const u = up.util;
@@ -7213,6 +7484,7 @@ up.Response = class Response extends up.Record {
             'xhr',
             'target',
             'title',
+            'openLayer',
             'acceptLayer',
             'dismissLayer',
             'eventPlans',
@@ -7227,7 +7499,7 @@ up.Response = class Response extends up.Record {
     defaults() {
         return {
             headers: {},
-            loadedAt: new Date()
+            loadedAt: new Date(),
         };
     }
     get ok() {
@@ -7246,8 +7518,9 @@ up.Response = class Response extends up.Record {
     get contentType() {
         return this.header('Content-Type');
     }
-    get cspNonces() {
-        return up.protocol.cspNoncesFromHeader(this.header('Content-Security-Policy') || this.header('Content-Security-Policy-Report-Only'));
+    get cspInfo() {
+        let policy = this.header('Content-Security-Policy') || this.header('Content-Security-Policy-Report-Only');
+        return up.protocol.cspInfoFromHeader(policy);
     }
     get lastModified() {
         let header = this.header('Last-Modified');
@@ -7276,15 +7549,15 @@ up.Response = class Response extends up.Record {
 
 
 /***/ }),
-/* 75 */
+/* 78 */
 /***/ (() => {
 
 var _a;
 const u = up.util;
 const e = up.element;
-const FULL_DOCUMENT_PATTERN = /^\s*<(html|!DOCTYPE)\b/i;
+const FULL_DOCUMENT_PATTERN = /^\s*(<!--[^-]*.*?-->\s*)*<(html|!DOCTYPE)\b/i;
 up.ResponseDoc = (_a = class ResponseDoc {
-        constructor({ document, fragment, content, target, origin, data, cspNonces, match }) {
+        constructor({ document, fragment, content, target, origin, data, cspInfo, match }) {
             if (document) {
                 this._parseDocument(document, origin, data);
             }
@@ -7294,7 +7567,7 @@ up.ResponseDoc = (_a = class ResponseDoc {
             else {
                 this._parseContent(content || '', origin, target, data);
             }
-            this._cspNonces = cspNonces;
+            this._cspInfo = cspInfo || {};
             if (origin) {
                 let originSelector = up.fragment.tryToTarget(origin);
                 if (originSelector) {
@@ -7323,9 +7596,6 @@ up.ResponseDoc = (_a = class ResponseDoc {
                 this._document = this._buildFauxDocument(value);
             }
         }
-        _parseDocumentFromHTML(html) {
-            return e.createBrokenDocumentFromHTML(html);
-        }
         _parseFragment(value, origin, data) {
             let element = e.extractSingular(up.fragment.provideNodes(value, { origin, data }));
             this._document = this._buildFauxDocument(element);
@@ -7363,7 +7633,14 @@ up.ResponseDoc = (_a = class ResponseDoc {
             return this._fromHead(up.history.findMetaTags);
         }
         get assets() {
-            return this._fromHead(up.script.findAssets);
+            return this._fromHead((head) => {
+                let assets = up.script.findAssets(head);
+                return u.map(assets, (asset) => {
+                    this._adoptNoncesInSubtree(asset);
+                    let clone = this._reviveElementAsClone(asset);
+                    return clone;
+                });
+            });
         }
         get lang() {
             if (this._isFullDocument) {
@@ -7415,21 +7692,43 @@ up.ResponseDoc = (_a = class ResponseDoc {
                 throw new up.CannotMatch();
             }
         }
+        _disableScriptsInSubtree(element) {
+            let pageNonce = up.protocol.cspNonce();
+            up.script.disableSubtree(element, (script) => !this._isScriptAllowed(script, pageNonce));
+        }
+        _isScriptAllowed(scriptElement, pageNonce) {
+            let strategy = up.fragment.config.runScripts;
+            if (strategy === true && this._cspInfo.declaration?.includes("'strict-dynamic'")) {
+                return pageNonce && (pageNonce === scriptElement.nonce);
+            }
+            else {
+                return u.evalOption(strategy, scriptElement);
+            }
+        }
+        _reviveElementAsClone(element) {
+            return e.revivedClone(element);
+        }
+        _reviveSubtreeInPlace(element) {
+            if (this._document instanceof Document) {
+                for (let brokenElement of e.subtree(element, ':is(noscript, script, audio, video):not(.up-keeping, .up-keeping *)')) {
+                    let clone = this._reviveElementAsClone(brokenElement);
+                    brokenElement.replaceWith(clone);
+                }
+            }
+        }
+        _adoptNoncesInSubtree(element) {
+            up.script.adoptNoncesInSubtree(element, this._cspInfo.nonces);
+        }
         commitElement(element) {
             if (this._document.contains(element)) {
-                if (!up.fragment.config.runScripts) {
-                    up.script.disableSubtree(element);
-                }
+                this._adoptNoncesInSubtree(element);
+                this._disableScriptsInSubtree(element);
                 element.remove();
                 return true;
             }
         }
         finalizeElement(element) {
-            up.NonceableCallback.adoptNonces(element, this._cspNonces);
-            if (this._document instanceof Document) {
-                let brokenElements = e.subtree(element, ':is(noscript,script,audio,video):not(.up-keeping, .up-keeping *)');
-                u.each(brokenElements, e.fixParserDamage);
-            }
+            this._reviveSubtreeInPlace(element);
         }
     },
     (() => {
@@ -7441,7 +7740,7 @@ up.ResponseDoc = (_a = class ResponseDoc {
 
 
 /***/ }),
-/* 76 */
+/* 79 */
 /***/ (() => {
 
 const e = up.element;
@@ -7531,7 +7830,7 @@ up.RevealMotion = class RevealMotion {
 
 
 /***/ }),
-/* 77 */
+/* 80 */
 /***/ (() => {
 
 const u = up.util;
@@ -7553,7 +7852,7 @@ up.Selector = class Selector {
             this._layers = up.layer.getAll(options);
             if (!this._layers.length)
                 throw new up.CannotMatch(["Unknown layer: %o", options.layer]);
-            this._filters.push(match => u.some(this._layers, layer => layer.contains(match)));
+            this._filters.push((match) => u.some(this._layers, (layer) => layer.contains(match)));
             expandTargetLayer = this._layers[0];
         }
         this._selectors = up.fragment.expandTargets(selector, { ...options, layer: expandTargetLayer });
@@ -7588,7 +7887,7 @@ up.Selector = class Selector {
         });
     }
     _passesFilter(element) {
-        return element && u.every(this._filters, filter => filter(element));
+        return element && u.every(this._filters, (filter) => filter(element));
     }
     _filterOne(element) {
         return u.presence(element, this._passesFilter.bind(this));
@@ -7600,7 +7899,7 @@ up.Selector = class Selector {
 
 
 /***/ }),
-/* 78 */
+/* 81 */
 /***/ (() => {
 
 const u = up.util;
@@ -7720,7 +8019,7 @@ up.Tether = class Tether {
 
 
 /***/ }),
-/* 79 */
+/* 82 */
 /***/ (() => {
 
 const u = up.util;
@@ -7793,7 +8092,7 @@ up.URLPattern = class URLPattern {
 
 
 /***/ }),
-/* 80 */
+/* 83 */
 /***/ (() => {
 
 up.framework = (function () {
@@ -7882,7 +8181,7 @@ up.boot = up.framework.boot;
 
 
 /***/ }),
-/* 81 */
+/* 84 */
 /***/ (() => {
 
 up.event = (function () {
@@ -7934,9 +8233,8 @@ up.event = (function () {
         event.preventDefault();
     }
     const keyModifiers = ['metaKey', 'shiftKey', 'ctrlKey', 'altKey'];
-    function isUnmodified(event) {
-        return (u.isUndefined(event.button) || (event.button === 0)) &&
-            !u.some(keyModifiers, modifier => event[modifier]);
+    function isModified(event) {
+        return (event.button > 0) || u.some(keyModifiers, (modifier) => event[modifier]);
     }
     function isSyntheticClick(event) {
         return u.isMissing(event.clientX);
@@ -7957,7 +8255,7 @@ up.event = (function () {
         return newEvent;
     }
     function executeEmitAttr(event, element) {
-        if (!isUnmodified(event)) {
+        if (isModified(event)) {
             return;
         }
         const eventType = e.attr(element, 'up-emit');
@@ -7986,7 +8284,7 @@ up.event = (function () {
         assertEmitted,
         onEscape,
         halt,
-        isUnmodified,
+        isModified,
         isSyntheticClick,
         fork,
         keyModifiers,
@@ -7999,14 +8297,14 @@ up.emit = up.event.emit;
 
 
 /***/ }),
-/* 82 */
+/* 85 */
 /***/ (() => {
 
 up.protocol = (function () {
     const u = up.util;
     const e = up.element;
     const headerize = function (camel) {
-        const header = camel.replace(/(^.|[A-Z])/g, char => '-' + char.toUpperCase());
+        const header = camel.replace(/(^.|[A-Z])/g, (char) => '-' + char.toUpperCase());
         return 'X-Up' + header;
     };
     const extractHeader = function (xhr, shortHeader, parseFn = u.identity) {
@@ -8044,6 +8342,9 @@ up.protocol = (function () {
     function eventPlansFromXHR(xhr) {
         return extractHeader(xhr, 'events', u.parseRelaxedJSON);
     }
+    function openLayerFromXHR(xhr) {
+        return extractHeader(xhr, 'openLayer', u.parseRelaxedJSON);
+    }
     function acceptLayerFromXHR(xhr) {
         return extractHeader(xhr, 'acceptLayer', u.parseRelaxedJSON);
     }
@@ -8079,21 +8380,26 @@ up.protocol = (function () {
     function cspNonce() {
         return u.evalOption(config.cspNonce);
     }
-    function cspNoncesFromHeader(cspHeader) {
-        let nonces = [];
+    const NONCE_PATTERN = /'nonce-([^']+)'/g;
+    function findNonces(cspPart) {
+        let matches = cspPart.matchAll(NONCE_PATTERN);
+        return u.map(matches, '1');
+    }
+    function cspInfoFromHeader(cspHeader) {
+        let results = {};
         if (cspHeader) {
-            let parts = cspHeader.split(/\s*;\s*/);
-            for (let part of parts) {
-                if (part.indexOf('script-src') === 0) {
-                    let noncePattern = /'nonce-([^']+)'/g;
-                    let match;
-                    while (match = noncePattern.exec(part)) {
-                        nonces.push(match[1]);
-                    }
+            let declarations = cspHeader.split(/\s*;\s*/);
+            for (let declaration of declarations) {
+                let directive = declaration.match(/^(script|default)-src:/)?.[1];
+                if (directive) {
+                    results[directive] = {
+                        declaration: declaration,
+                        nonces: findNonces(declaration)
+                    };
                 }
             }
         }
-        return nonces;
+        return results.script || results.default || {};
     }
     function wrapMethod(method, params) {
         params.add(config.methodParam, method);
@@ -8105,6 +8411,7 @@ up.protocol = (function () {
         titleFromXHR,
         targetFromXHR,
         methodFromXHR,
+        openLayerFromXHR,
         acceptLayerFromXHR,
         contextFromXHR,
         dismissLayerFromXHR,
@@ -8118,13 +8425,13 @@ up.protocol = (function () {
         initialRequestMethod,
         headerize,
         wrapMethod,
-        cspNoncesFromHeader,
+        cspInfoFromHeader,
     };
 })();
 
 
 /***/ }),
-/* 83 */
+/* 86 */
 /***/ (() => {
 
 up.log = (function () {
@@ -8137,24 +8444,26 @@ up.log = (function () {
     }
     const printToWarn = (...args) => printToStream('warn', ...args);
     const printToError = (...args) => printToStream('error', ...args);
-    function printToStream(stream, trace, message, ...args) {
-        printToStreamStyled(stream, trace, '', message, ...args);
+    function printToStream(stream, prefix, message, ...args) {
+        printToStreamStyled(stream, prefix, '', message, ...args);
     }
-    function printToStreamStyled(stream, trace, customStyles, message, ...args) {
+    function printToStreamStyled(stream, prefix, customStyles, message, ...args) {
         if (message) {
             if (config.format) {
-                console[stream](`%c${trace}%c ${message}`, 'color: #666666; padding: 1px 3px; border: 1px solid #bbbbbb; border-radius: 2px; font-size: 90%; display: inline-block;' + customStyles, '', ...args);
+                console[stream](`%c${prefix}%c ${message}`, 'color: #666666; padding: 1px 3px; border: 1px solid #bbbbbb; border-radius: 2px; font-size: 90%; display: inline-block;' + customStyles, '', ...args);
             }
             else {
-                console[stream](`[${trace}] ${u.sprintf(message, ...args)}`);
+                console[stream](`[${prefix}] ${u.sprintf(message, ...args)}`);
             }
         }
     }
+    let lastPrintedUserEvent;
     function printUserEvent(event) {
-        if (config.enabled) {
-            event = event.originalEvent || event;
+        if (config.enabled && lastPrintedUserEvent !== event) {
+            lastPrintedUserEvent = event;
+            let originalEvent = event.originalEvent || event;
             let color = '#5566cc';
-            printToStreamStyled('log', event.type, `color: white; border-color: ${color}; background-color: ${color}`, 'Interaction on %o', event.target);
+            printToStreamStyled('log', originalEvent.type, `color: white; border-color: ${color}; background-color: ${color}`, 'Interaction on %o', originalEvent.target);
         }
     }
     function printBanner() {
@@ -8205,7 +8514,7 @@ up.warn = up.log.warn;
 
 
 /***/ }),
-/* 84 */
+/* 87 */
 /***/ (() => {
 
 up.script = (function () {
@@ -8387,16 +8696,41 @@ up.script = (function () {
             up.event.assertEmitted('up:assets:changed', { oldAssets, newAssets, renderOptions });
         }
     }
-    function disableScript(scriptElement) {
-        scriptElement.type = 'up-disabled-script';
+    function disableScriptsInSubtree(root, guard = () => true) {
+        for (let script of findScripts(root)) {
+            if (guard(script)) {
+                script.type = 'up-disabled-script';
+            }
+        }
     }
-    function disableScriptsInSubtree(root) {
-        let selector = config.selector('scriptSelectors');
-        u.each(e.subtree(root, selector), disableScript);
+    function findScripts(root, selectorSuffix = '') {
+        let selector = config.selector('scriptSelectors') + selectorSuffix;
+        return e.subtree(root, selector);
     }
     function isScript(value) {
         return config.matches(value, 'scriptSelectors');
     }
+    function adoptNoncesInSubtree(root, responseNonces) {
+        let pageNonce = up.protocol.cspNonce();
+        if (!responseNonces?.length || !pageNonce)
+            return;
+        for (let script of findScripts(root, '[nonce]')) {
+            if (responseNonces.includes(script.nonce)) {
+                script.nonce = pageNonce;
+            }
+        }
+        for (let attribute of config.nonceableAttributes) {
+            let matches = e.subtree(root, `[${attribute}^="nonce-"]`);
+            for (let match of matches) {
+                let attributeValue = match.getAttribute(attribute);
+                let callback = up.NonceableCallback.fromString(attributeValue);
+                if (responseNonces.includes(callback.nonce)) {
+                    callback.nonce = pageNonce;
+                    match.setAttribute(attribute, callback.toString());
+                }
+            }
+        }
+    }
     function reset() {
         registeredCompilers = u.filter(registeredCompilers, 'isDefault');
         registeredMacros = u.filter(registeredMacros, 'isDefault');
@@ -8414,6 +8748,7 @@ up.script = (function () {
         findAssets,
         assertAssetsOK,
         disableSubtree: disableScriptsInSubtree,
+        adoptNoncesInSubtree,
         isScript,
     };
 })();
@@ -8426,7 +8761,7 @@ up.attribute = up.script.attrCompiler;
 
 
 /***/ }),
-/* 85 */
+/* 88 */
 /***/ (() => {
 
 up.history = (function () {
@@ -8452,59 +8787,75 @@ up.history = (function () {
     }));
     let previousLocation;
     let nextPreviousLocation;
+    let nextTrackOptions;
+    let adoptedBases = new up.FIFOCache({ capacity: 100, normalizeKey: getBase });
+    function isAdopted(location) {
+        return !!adoptedBases.get(location);
+    }
     function reset() {
         previousLocation = undefined;
         nextPreviousLocation = undefined;
-        trackCurrentLocation();
+        nextTrackOptions = undefined;
+        adoptedBases.clear();
+        trackCurrentLocation({ reason: null, alreadyHandled: true });
+        adopt();
     }
     function currentLocation() {
         return u.normalizeURL(location.href);
     }
-    function trackCurrentLocation() {
-        const url = currentLocation();
-        if (nextPreviousLocation !== url) {
+    function trackCurrentLocation(trackOptions) {
+        let { reason, alreadyHandled } = nextTrackOptions || trackOptions;
+        let location = currentLocation();
+        if (nextPreviousLocation !== location) {
             previousLocation = nextPreviousLocation;
-            nextPreviousLocation = url;
+            nextPreviousLocation = location;
+            if (reason === 'detect') {
+                reason = (getBase(location) === getBase(previousLocation)) ? 'hash' : 'pop';
+            }
+            let willHandle = !alreadyHandled && isAdopted(location);
+            let locationChangedEvent = up.event.build('up:location:changed', {
+                reason,
+                location,
+                previousLocation,
+                alreadyHandled,
+                willHandle,
+                log: `New location is ${location}`
+            });
+            up.migrate.prepareLocationChangedEvent?.(locationChangedEvent);
+            if (reason) {
+                up.emit(locationChangedEvent);
+                reactToChange(locationChangedEvent);
+            }
         }
     }
-    trackCurrentLocation();
+    function splitLocation(location) {
+        return location?.split(/(?=#)/) || [];
+    }
+    function getBase(location) {
+        return splitLocation(location)[0];
+    }
     function isLocation(url, options) {
         return u.matchURLs(url, location.href, { hash: true, ...options });
     }
-    function replace(location, options = {}) {
-        location = u.normalizeURL(location);
-        if (manipulate('replaceState', location) && (options.event !== false)) {
-            emitLocationChanged({ location, reason: 'replace', log: `Replaced state for ${location}` });
-        }
-    }
-    function push(location) {
-        location = u.normalizeURL(location);
-        if (!isLocation(location) && manipulate('pushState', location)) {
-            emitLocationChanged({ location, reason: 'push', log: `Advanced to location ${location}` });
-        }
+    function replace(location, trackOptions) {
+        placeAdoptedHistoryEntry('replaceState', location, trackOptions);
     }
-    function emitLocationChanged(props) {
-        let event = up.event.build('up:location:changed', props);
-        up.migrate?.renamedProperty?.(event, 'url', 'location');
-        up.emit(event);
+    function push(location, trackOptions) {
+        placeAdoptedHistoryEntry('pushState', location, trackOptions);
     }
-    function manipulate(method, url) {
+    function placeAdoptedHistoryEntry(method, location, trackOptions) {
+        adopt(location);
         if (config.enabled) {
-            const state = buildState();
-            window.history[method](state, '', url);
-            trackCurrentLocation();
-            return true;
+            nextTrackOptions = trackOptions;
+            history[method](null, '', location);
+            nextTrackOptions = undefined;
         }
     }
-    function buildState() {
-        return { up: {} };
+    function adopt(location = currentLocation()) {
+        location = u.normalizeURL(location);
+        adoptedBases.set(location, true);
     }
-    function restoreStateOnPop(state) {
-        if (!state?.up) {
-            up.puts('popstate', 'Ignoring a history state not owned by Unpoly');
-            return;
-        }
-        let location = currentLocation();
+    function restoreLocation(location) {
         up.error.muteUncriticalRejection(up.render({
             guardEvent: up.event.build('up:location:restore', { location, log: `Restoring location ${location}` }),
             url: location,
@@ -8522,28 +8873,23 @@ up.history = (function () {
             focus: ['restore', 'auto'],
         }));
     }
-    function onPop(event) {
-        trackCurrentLocation();
-        let location = currentLocation();
-        emitLocationChanged({ location, reason: 'pop', log: `Navigated to history entry ${location}` });
-        up.viewport.saveFocus({ location: previousLocation });
-        up.viewport.saveScroll({ location: previousLocation });
-        restoreStateOnPop(event.state);
-    }
-    function register() {
-        window.addEventListener('popstate', onPop);
-        if (up.protocol.initialRequestMethod() === 'GET') {
-            replace(currentLocation(), { event: false });
+    function reactToChange(event) {
+        if (event.alreadyHandled) {
+            return;
         }
-    }
-    up.on('up:framework:boot', function () {
-        if ('jasmine' in window) {
-            register();
+        if (!event.willHandle) {
+            up.puts('up.history', 'Ignoring history entry owned by foreign script');
+            return;
         }
-        else {
-            setTimeout(register, 100);
+        if (event.reason === 'pop') {
+            up.viewport.saveFocus({ location: event.previousLocation });
+            up.viewport.saveScroll({ location: event.previousLocation });
+            restoreLocation(event.location);
         }
-    });
+        else if (event.reason === 'hash') {
+            up.viewport.revealHash(event.hash, { strong: true });
+        }
+    }
     function findMetaTags(head = document.head) {
         return head.querySelectorAll(config.selector('metaTagSelectors'));
     }
@@ -8565,6 +8911,62 @@ up.history = (function () {
     function updateLang(newLang) {
         e.setAttrPresence(e.root, 'lang', newLang, !!newLang);
     }
+    function patchHistoryAPI() {
+        const originalPushState = history.pushState;
+        history.pushState = function (...args) {
+            originalPushState.apply(this, args);
+            trackCurrentLocation({ reason: 'push', alreadyHandled: true });
+        };
+        const originalReplaceState = history.replaceState;
+        history.replaceState = function (...args) {
+            originalReplaceState.apply(this, args);
+            trackCurrentLocation({ reason: 'replace', alreadyHandled: true });
+        };
+    }
+    function adoptInitialHistoryEntry() {
+        if (up.protocol.initialRequestMethod() === 'GET') {
+            adopt();
+        }
+    }
+    up.on('up:framework:boot', function () {
+        trackCurrentLocation({ reason: null, alreadyHandled: true });
+        patchHistoryAPI();
+        adoptInitialHistoryEntry();
+    });
+    up.on('DOMContentLoaded', function () {
+        up.viewport.revealHash({ strong: true });
+        u.task(up.viewport.revealHash);
+    });
+    up.on(window, 'hashchange, popstate', () => {
+        trackCurrentLocation({ reason: 'detect', alreadyHandled: false });
+    });
+    function onJumpLinkClicked(event, link) {
+        if (event.defaultPrevented)
+            return;
+        if (up.event.isModified(event))
+            return;
+        let [currentBase, currentHash] = splitLocation(up.layer.current.location);
+        let [linkBase, linkHash] = splitLocation(u.normalizeURL(link));
+        let verbatimHREF = link.getAttribute('href');
+        let isJumpLink = (currentBase === linkBase) || verbatimHREF.startsWith('#');
+        if (!isJumpLink)
+            return;
+        let behavior = link.getAttribute('up-scroll-behavior') ?? 'auto';
+        let layer = up.layer.get(link);
+        let revealFn = up.viewport.revealHashFn(linkHash, { layer, behavior });
+        if (revealFn) {
+            up.event.halt(event);
+            up.log.putsEvent(event);
+            if (linkHash !== currentHash && layer.showsLiveHistory()) {
+                let newHREF = currentBase + linkHash;
+                push(newHREF, { reason: 'hash', alreadyHandled: true });
+            }
+            revealFn();
+        }
+        else {
+        }
+    }
+    up.on('up:click', 'a[href*="#"]', onJumpLinkClicked);
     up.macro('[up-back]', function (link) {
         if (previousLocation) {
             e.setMissingAttrs(link, {
@@ -8592,10 +8994,10 @@ up.history = (function () {
 
 
 /***/ }),
-/* 86 */
+/* 89 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
-__webpack_require__(87);
+__webpack_require__(90);
 const u = up.util;
 const e = up.element;
 up.fragment = (function () {
@@ -8640,6 +9042,7 @@ up.fragment = (function () {
             saveScroll: true,
             saveFocus: true,
             focus: 'keep',
+            focusVisible: 'auto',
             abort: 'target',
             failOptions: true,
             feedback: true,
@@ -8654,7 +9057,7 @@ up.fragment = (function () {
             peel: true,
         },
         match: 'region',
-        runScripts: true,
+        runScripts: false,
         autoHistoryTargets: [':main'],
         autoFocus: ['hash', 'autofocus', 'main-if-main', 'keep', 'target-if-lost'],
         autoScroll: ['hash', 'layer-if-main'],
@@ -8696,6 +9099,9 @@ up.fragment = (function () {
         return render({ ...options, navigate: true });
     });
     function emitFragmentInserted(element) {
+        if (element.upInserted)
+            return;
+        element.upInserted = true;
         return up.emit(element, 'up:fragment:inserted', {
             log: ['Inserted fragment %o', element],
         });
@@ -8703,8 +9109,9 @@ up.fragment = (function () {
     function emitFragmentKeep(keepPlan) {
         let { oldElement, newElement: newFragment, newData, renderOptions } = keepPlan;
         const log = ['Keeping fragment %o', oldElement];
-        const callback = e.callbackAttr(oldElement, 'up-on-keep', { exposedKeys: ['newFragment', 'newData'] });
-        return up.emit(oldElement, 'up:fragment:keep', { newFragment, newData, renderOptions, log, callback });
+        const callback = e.callbackAttr(keepPlan.oldElement, 'up-on-keep', { exposedKeys: ['newFragment', 'newData'] });
+        const event = up.event.build('up:fragment:keep', { newFragment, newData, renderOptions });
+        return up.emit(oldElement, event, { log, callback });
     }
     function emitFragmentDestroyed(fragment, options) {
         const log = options.log ?? ['Destroyed fragment %o', fragment];
@@ -8781,7 +9188,7 @@ up.fragment = (function () {
     }
     function markFragmentAsDestroying(element) {
         element.classList.add('up-destroying');
-        element.setAttribute('aria-hidden', 'true');
+        element.setAttribute('inert', '');
     }
     function reload(...args) {
         const options = parseTargetAndOptions(args);
@@ -8838,8 +9245,8 @@ up.fragment = (function () {
     function toTarget(element, options) {
         return u.presence(element, u.isString) || tryToTarget(element, options) || cannotTarget(element);
     }
-    function isTargetable(element) {
-        return !!tryToTarget(element);
+    function isTargetable(element, options) {
+        return !!tryToTarget(element, options);
     }
     function untargetableMessage(element) {
         return `Cannot derive good target selector from a <${e.tagName(element)}> element without identifying attributes. Try setting an [id] or configure up.fragment.config.targetDerivers.`;
@@ -9059,7 +9466,7 @@ up.fragment = (function () {
         if (steps.length < 2)
             return steps;
         let compressed = u.uniqBy(steps, 'oldElement');
-        compressed = u.reject(compressed, step => isContainedByRivalStep(compressed, step));
+        compressed = u.reject(compressed, (step) => isContainedByRivalStep(compressed, step));
         return compressed;
     }
     function abort(...args) {
@@ -9156,6 +9563,11 @@ up.fragment = (function () {
             return () => up.destroy(tempElement);
         }
     }
+    function trackSelector(...args) {
+        let parsedArgs = u.args(args, 'val', 'options', 'callback');
+        let tracker = new up.SelectorTracker(...parsedArgs);
+        return tracker.start();
+    }
     up.on('up:framework:boot', function () {
         const { documentElement } = document;
         documentElement.setAttribute('up-source', normalizeSource(location.href));
@@ -9208,6 +9620,7 @@ up.fragment = (function () {
         insertTemp,
         provideNodes,
         cloneTemplate,
+        trackSelector,
     };
 })();
 up.reload = up.fragment.reload;
@@ -9220,7 +9633,7 @@ u.delegate(up, ['context'], () => up.layer.current);
 
 
 /***/ }),
-/* 87 */
+/* 90 */
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -9229,10 +9642,10 @@ __webpack_require__.r(__webpack_exports__);
 
 
 /***/ }),
-/* 88 */
+/* 91 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
-__webpack_require__(89);
+__webpack_require__(92);
 up.viewport = (function () {
     const u = up.util;
     const e = up.element;
@@ -9294,10 +9707,25 @@ up.viewport = (function () {
         doFocus(element, options);
         return element === document.activeElement;
     }
-    function revealHash(hash = location.hash, options) {
-        let match = firstHashTarget(hash, options);
+    function revealHash(...args) {
+        return revealHashFn(...args)?.();
+    }
+    function revealHashFn(hash = location.hash, { strong, layer, origin, behavior = 'instant' } = {}) {
+        if (!hash)
+            return;
+        let match = firstHashTarget(hash, { layer, origin });
         if (match) {
-            return reveal(match, { top: true });
+            return () => {
+                let doReveal = () => reveal(match, { top: true, behavior });
+                if (strong)
+                    u.task(doReveal);
+                return doReveal();
+            };
+        }
+        else if (hash === '#top') {
+            return () => {
+                return scrollTo(0, { behavior });
+            };
         }
     }
     function allSelector() {
@@ -9369,7 +9797,7 @@ up.viewport = (function () {
         const { location } = options.layer;
         const locationScrollTops = options.layer.lastScrollTops.get(location);
         if (locationScrollTops) {
-            setScrollTops(viewports, locationScrollTops);
+            setScrollPositions(viewports, locationScrollTops, 0);
             up.puts('up.viewport.restoreScroll()', 'Restored scroll positions to %o', locationScrollTops);
             return true;
         }
@@ -9415,14 +9843,16 @@ up.viewport = (function () {
         }
         return [viewports, options];
     }
-    function resetScroll(...args) {
-        const [viewports, _options] = parseOptions(args);
-        setScrollTops(viewports, {});
+    function scrollTo(position, ...args) {
+        const [viewports, options] = parseOptions(args);
+        setScrollPositions(viewports, {}, position, options.behavior);
+        return true;
     }
-    function setScrollTops(viewports, tops) {
+    function setScrollPositions(viewports, tops, defaultTop, behavior = 'instant') {
         for (let viewport of viewports) {
             const key = scrollTopKey(viewport);
-            viewport.scrollTop = tops[key] || 0;
+            const top = tops[key] || defaultTop;
+            viewport.scrollTo({ top, behavior });
         }
     }
     function absolutize(element, options = {}) {
@@ -9463,7 +9893,8 @@ up.viewport = (function () {
         };
     }
     function firstHashTarget(hash, options = {}) {
-        if (hash = pureHash(hash)) {
+        hash = pureHash(hash);
+        if (hash) {
             const selector = [
                 e.idSelector(hash),
                 'a' + e.attrSelector('name', hash)
@@ -9491,22 +9922,10 @@ up.viewport = (function () {
         }
         return to;
     }
-    document.addEventListener('DOMContentLoaded', function () {
-        revealHash();
-        u.task(revealHash);
-    });
-    up.on(window, 'hashchange', () => revealHash());
-    up.on('up:click', 'a[href^="#"]', function (event, link) {
-        if (link.hash !== location.hash)
-            return;
-        if (up.link.isFollowable(link))
-            return;
-        if (revealHash(link.hash))
-            up.event.halt(event);
-    });
     return {
         reveal,
         revealHash,
+        revealHashFn,
         firstHashTarget,
         config,
         get: closest,
@@ -9519,7 +9938,7 @@ up.viewport = (function () {
         rootScrollbarWidth,
         saveScroll,
         restoreScroll,
-        resetScroll,
+        scrollTo,
         saveFocus,
         restoreFocus,
         absolutize,
@@ -9536,7 +9955,7 @@ up.reveal = up.viewport.reveal;
 
 
 /***/ }),
-/* 89 */
+/* 92 */
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -9545,27 +9964,22 @@ __webpack_require__.r(__webpack_exports__);
 
 
 /***/ }),
-/* 90 */
+/* 93 */
 /***/ (() => {
 
 up.motion = (function () {
     const u = up.util;
     const e = up.element;
-    let namedAnimations = {};
-    let namedTransitions = {};
     const motionController = new up.MotionController('motion');
     const config = new up.Config(() => ({
         duration: 175,
         easing: 'ease',
         enabled: !matchMedia('(prefers-reduced-motion: reduce)').matches
     }));
-    function pickDefault(registry) {
-        return u.pickBy(registry, 'isDefault');
-    }
+    let namedAnimations = new up.Registry('animation', findAnimationFn);
+    let namedTransitions = new up.Registry('transition', findTransitionFn);
     function reset() {
         motionController.reset();
-        namedAnimations = pickDefault(namedAnimations);
-        namedTransitions = pickDefault(namedTransitions);
     }
     function isEnabled() {
         return config.enabled;
@@ -9605,9 +10019,6 @@ up.motion = (function () {
         options.easing ??= config.easing;
         options.duration ??= config.duration;
     }
-    function findNamedAnimation(name) {
-        return namedAnimations[name] || up.fail("Unknown animation %o", name);
-    }
     function finish(element) {
         return motionController.finish(element);
     }
@@ -9658,27 +10069,21 @@ up.motion = (function () {
             return Promise.resolve();
         }
     }
-    function findTransitionFn(object) {
-        if (isNone(object)) {
+    function findTransitionFn(value) {
+        if (isNone(value)) {
             return undefined;
         }
-        else if (u.isFunction(object)) {
-            return object;
+        else if (u.isFunction(value)) {
+            return value;
         }
-        else if (u.isArray(object)) {
-            return composeTransitionFn(...object);
+        else if (u.isArray(value)) {
+            return composeTransitionFn(...value);
         }
-        else if (u.isString(object)) {
-            let namedTransition;
-            if (object.indexOf('/') >= 0) {
-                return composeTransitionFn(...object.split('/'));
-            }
-            else if (namedTransition = namedTransitions[object]) {
-                return findTransitionFn(namedTransition);
-            }
+        else if (u.isString(value) && value.includes('/')) {
+            return composeTransitionFn(...value.split('/'));
         }
         else {
-            up.fail("Unknown transition %o", object);
+            return namedTransitions.get(value);
         }
     }
     function composeTransitionFn(oldAnimation, newAnimation) {
@@ -9691,21 +10096,18 @@ up.motion = (function () {
             ]);
         }
     }
-    function findAnimationFn(object) {
-        if (isNone(object)) {
+    function findAnimationFn(value) {
+        if (isNone(value)) {
             return undefined;
         }
-        else if (u.isFunction(object)) {
-            return object;
-        }
-        else if (u.isString(object)) {
-            return findNamedAnimation(object);
+        else if (u.isFunction(value)) {
+            return value;
         }
-        else if (u.isOptions(object)) {
-            return (element, options) => animateNow(element, object, options);
+        else if (u.isOptions(value)) {
+            return (element, options) => animateNow(element, value, options);
         }
         else {
-            up.fail('Unknown animation %o', object);
+            return namedAnimations.get(value);
         }
     }
     const swapElementsDirectly = up.mockable(function (oldElement, newElement) {
@@ -9720,16 +10122,6 @@ up.motion = (function () {
         parser.number('duration');
         return options;
     }
-    function registerTransition(name, transition) {
-        const fn = findTransitionFn(transition);
-        fn.isDefault = up.framework.evaling;
-        namedTransitions[name] = fn;
-    }
-    function registerAnimation(name, animation) {
-        const fn = findAnimationFn(animation);
-        fn.isDefault = up.framework.evaling;
-        namedAnimations[name] = fn;
-    }
     up.on('up:framework:boot', function () {
         if (!isEnabled()) {
             up.puts('up.motion', 'Animations are disabled');
@@ -9739,7 +10131,7 @@ up.motion = (function () {
         return !animationOrTransition || animationOrTransition === 'none';
     }
     function registerOpacityAnimation(name, from, to) {
-        registerAnimation(name, function (element, options) {
+        namedAnimations.put(name, function (element, options) {
             element.style.opacity = 0;
             e.setStyle(element, { opacity: from });
             return animateNow(element, { opacity: to }, options);
@@ -9760,12 +10152,12 @@ up.motion = (function () {
     function registerMoveAnimations(direction, boxToTransform) {
         const animationToName = `move-to-${direction}`;
         const animationFromName = `move-from-${direction}`;
-        registerAnimation(animationToName, function (element, options) {
+        namedAnimations.put(animationToName, function (element, options) {
             const box = untranslatedBox(element);
             const transform = boxToTransform(box);
             return animateNow(element, transform, options);
         });
-        registerAnimation(animationFromName, function (element, options) {
+        namedAnimations.put(animationFromName, function (element, options) {
             const box = untranslatedBox(element);
             const transform = boxToTransform(box);
             e.setStyle(element, transform);
@@ -9788,19 +10180,19 @@ up.motion = (function () {
         const travelDistance = up.viewport.rootWidth() - box.left;
         return translateCSS(travelDistance, 0);
     });
-    registerTransition('cross-fade', ['fade-out', 'fade-in']);
-    registerTransition('move-left', ['move-to-left', 'move-from-right']);
-    registerTransition('move-right', ['move-to-right', 'move-from-left']);
-    registerTransition('move-up', ['move-to-top', 'move-from-bottom']);
-    registerTransition('move-down', ['move-to-bottom', 'move-from-top']);
+    namedTransitions.put('cross-fade', ['fade-out', 'fade-in']);
+    namedTransitions.put('move-left', ['move-to-left', 'move-from-right']);
+    namedTransitions.put('move-right', ['move-to-right', 'move-from-left']);
+    namedTransitions.put('move-up', ['move-to-top', 'move-from-bottom']);
+    namedTransitions.put('move-down', ['move-to-bottom', 'move-from-top']);
     up.on('up:framework:reset', reset);
     return {
         morph,
         animate,
         finish,
         finishCount() { return motionController.finishCount; },
-        transition: registerTransition,
-        animation: registerAnimation,
+        transition: namedTransitions.put,
+        animation: namedAnimations.put,
         config,
         isEnabled,
         isNone,
@@ -9816,10 +10208,10 @@ up.animate = up.motion.animate;
 
 
 /***/ }),
-/* 91 */
+/* 94 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
-__webpack_require__(92);
+__webpack_require__(95);
 const u = up.util;
 up.network = (function () {
     const config = new up.Config(() => ({
@@ -9831,7 +10223,7 @@ up.network = (function () {
         lateDelay: 400,
         fail(response) { return (response.status < 200 || response.status > 299) && response.status !== 304; },
         autoCache(request) { return request.isSafe(); },
-        expireCache(request, _response) { return !request.isSafe(); },
+        expireCache(request) { return !request.isSafe(); },
         evictCache: false,
         progressBar: true,
         timeout: 90000,
@@ -9858,6 +10250,8 @@ up.network = (function () {
         return options;
     }
     function processRequest(request) {
+        cache.expire(request.expireCache ?? u.evalOption(config.expireCache, request) ?? false);
+        cache.evict(request.evictCache ?? u.evalOption(config.evictCache, request) ?? false);
         useCachedRequest(request) || queueRequest(request);
     }
     function useCachedRequest(newRequest) {
@@ -9883,14 +10277,8 @@ up.network = (function () {
             request.onLoading = () => cache.reindex(request);
         }
         u.always(request, function (responseOrError) {
-            let expireCache = responseOrError.expireCache ?? request.expireCache ?? u.evalOption(config.expireCache, request, responseOrError);
-            if (expireCache) {
-                cache.expire(expireCache, { except: request });
-            }
-            let evictCache = responseOrError.evictCache ?? request.evictCache ?? u.evalOption(config.evictCache, request, responseOrError);
-            if (evictCache) {
-                cache.evict(evictCache, { except: request });
-            }
+            cache.expire(responseOrError.expireCache ?? false, { except: request });
+            cache.evict(responseOrError.evictCache ?? false, { except: request });
             let hasCacheEntry = cache.get(request);
             let isResponse = responseOrError instanceof up.Response;
             let isNetworkError = !isResponse;
@@ -9959,7 +10347,7 @@ up.cache = up.network.cache;
 
 
 /***/ }),
-/* 92 */
+/* 95 */
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -9968,10 +10356,10 @@ __webpack_require__.r(__webpack_exports__);
 
 
 /***/ }),
-/* 93 */
+/* 96 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
-__webpack_require__(94);
+__webpack_require__(97);
 const u = up.util;
 const e = up.element;
 up.layer = (function () {
@@ -10146,7 +10534,7 @@ up.layer = (function () {
         });
     }
     function anySelector() {
-        return u.map(LAYER_CLASSES, Class => Class.selector()).join();
+        return u.map(LAYER_CLASSES, (Class) => Class.selector()).join();
     }
     function optionToString(option) {
         if (u.isString(option)) {
@@ -10216,7 +10604,7 @@ up.layer = (function () {
 
 
 /***/ }),
-/* 94 */
+/* 97 */
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -10225,14 +10613,16 @@ __webpack_require__.r(__webpack_exports__);
 
 
 /***/ }),
-/* 95 */
+/* 98 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
-__webpack_require__(96);
+__webpack_require__(99);
 up.link = (function () {
     const u = up.util;
     const e = up.element;
+    let lastTouchstartTarget = null;
     let lastMousedownTarget = null;
+    let lastInstantTarget = null;
     const ATTRS_WITH_LOCAL_HTML = '[up-content], [up-fragment], [up-document]';
     const ATTRS_SUGGESTING_FOLLOW = `${ATTRS_WITH_LOCAL_HTML}, [up-target], [up-layer], [up-transition], [up-preload]`;
     const DEFAULT_INTERACTIVE_ELEMENT = 'a[href], button';
@@ -10262,7 +10652,9 @@ up.link = (function () {
         }
     }
     function reset() {
+        lastTouchstartTarget = null;
         lastMousedownTarget = null;
+        lastInstantTarget = null;
     }
     const follow = up.mockable(function (link, options, parserOptions) {
         return up.render(followOptions(link, options, parserOptions));
@@ -10284,6 +10676,7 @@ up.link = (function () {
         parser.string('contentType');
         parser.booleanOrNumber('lateDelay');
         parser.number('timeout');
+        parser.booleanOrString('fail');
         return options;
     }
     function followOptions(link, options, parserOptions) {
@@ -10292,7 +10685,6 @@ up.link = (function () {
         const parser = new up.OptionsParser(link, options, { fail: true, ...parserOptions });
         parser.include(parseRequestOptions);
         options.origin ||= link;
-        parser.boolean('fail');
         parser.boolean('navigate', { default: true });
         parser.string('confirm', { attr: ['up-confirm', 'data-confirm'] });
         parser.string('target');
@@ -10326,9 +10718,12 @@ up.link = (function () {
         parser.string('dismissEvent');
         parser.string('acceptLocation');
         parser.string('dismissLocation');
-        parser.booleanOrString('history');
+        parser.booleanOrString('closeAnimation');
+        parser.string('closeEasing');
+        parser.number('closeDuration');
         parser.include(up.status.statusOptions);
         parser.booleanOrString('focus');
+        parser.booleanOrString('focusVisible');
         parser.boolean('saveScroll');
         parser.boolean('saveFocus');
         parser.booleanOrString('scroll');
@@ -10358,9 +10753,9 @@ up.link = (function () {
             abortable: false,
             background: true,
             cache: true,
+            ...options,
             ...up.RenderOptions.NO_INPUT_INTERFERENCE,
             ...up.RenderOptions.NO_PREVIEWS,
-            ...options,
             guardEvent,
             preload: true,
         });
@@ -10419,27 +10814,37 @@ up.link = (function () {
     }
     function convertClicks(layer) {
         layer.on('click', function (event, element) {
-            if (!up.event.isUnmodified(event)) {
+            if (up.event.isModified(event)) {
                 return;
             }
-            if (isInstant(element) && lastMousedownTarget) {
+            if (isInstant(element) && lastInstantTarget === element) {
                 up.event.halt(event);
             }
             else if (up.event.inputDevice === 'key' || up.event.isSyntheticClick(event) || (layer.wasHitByMouseEvent(event) && !didUserDragAway(event))) {
                 forkEventAsUpClick(event);
             }
-            return lastMousedownTarget = null;
+            lastMousedownTarget = null;
+            lastInstantTarget = null;
+        });
+        layer.on('touchstart', { passive: true }, function (event, element) {
+            lastTouchstartTarget = element;
         });
         layer.on('mousedown', function (event, element) {
-            if (!up.event.isUnmodified(event)) {
+            if (up.event.isModified(event)) {
                 return;
             }
-            lastMousedownTarget = event.target;
-            if (isInstant(element)) {
+            lastMousedownTarget = element;
+            if (isInstant(element) && !isLongPressPossible(event)) {
+                lastInstantTarget = element;
                 forkEventAsUpClick(event);
             }
+            lastTouchstartTarget = null;
         });
     }
+    function isLongPressPossible(mousedownEvent) {
+        let mousedownTarget = mousedownEvent.target;
+        return (lastTouchstartTarget === mousedownTarget) && mousedownTarget.closest('[href]');
+    }
     function didUserDragAway(clickEvent) {
         return lastMousedownTarget && (lastMousedownTarget !== clickEvent.target);
     }
@@ -10535,7 +10940,7 @@ up.deferred = { load: up.link.loadDeferred };
 
 
 /***/ }),
-/* 96 */
+/* 99 */
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -10544,7 +10949,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 /***/ }),
-/* 97 */
+/* 100 */
 /***/ (() => {
 
 up.form = (function () {
@@ -10557,12 +10962,14 @@ up.form = (function () {
         noSubmitSelectors: ['[up-submit=false]', '[target]', e.crossOriginSelector('action')],
         submitButtonSelectors: ['input[type=submit]', 'input[type=image]', 'button[type=submit]', 'button:not([type])'],
         genericButtonSelectors: ['input[type=button]', 'button[type=button]'],
+        validateBatch: true,
         watchInputEvents: ['input', 'change'],
         watchInputDelay: 0,
         watchChangeEvents: ['change'],
+        watchableEvents: ['input', 'change'],
     }));
     function fieldSelector(suffix = '') {
-        return config.fieldSelectors.map(field => field + suffix).join();
+        return config.fieldSelectors.map((field) => field + suffix).join();
     }
     function isField(element) {
         return element.matches(fieldSelector());
@@ -10573,11 +10980,17 @@ up.form = (function () {
         if (root.matches('form[id]')) {
             const outsideFieldSelector = fieldSelector(e.attrSelector('form', root.getAttribute('id')));
             const outsideFields = up.fragment.all(outsideFieldSelector, { layer: root });
-            fields.push(...outsideFields);
-            fields = u.uniq(fields);
+            fields = u.uniq([...fields, ...outsideFields]);
         }
         return fields;
     }
+    function findFieldsAndButtons(container) {
+        return [
+            ...findFields(container),
+            ...findSubmitButtons(container),
+            ...findGenericButtons(container),
+        ];
+    }
     function findSubmitButtons(root) {
         return e.subtree(root, submitButtonSelector());
     }
@@ -10612,8 +11025,10 @@ up.form = (function () {
     }
     function watchOptions(field, options, parserOptions = {}) {
         options = u.options(options);
-        let parser = new up.OptionsParser(field, options, { ...parserOptions, closest: true, attrPrefix: 'up-watch-' });
-        parser.include(up.status.statusOptions);
+        parserOptions.closest ??= true;
+        parserOptions.attrPrefix ??= 'up-watch-';
+        let parser = new up.OptionsParser(field, options, parserOptions);
+        parser.include(up.status.statusOptions, parserOptions);
         parser.string('event');
         parser.number('delay');
         let config = up.form.config;
@@ -10627,15 +11042,20 @@ up.form = (function () {
         options.origin ||= field;
         return options;
     }
-    function disableContainer(container) {
-        let controls = [
-            ...findFields(container),
-            ...findSubmitButtons(container),
-            ...findGenericButtons(container),
-        ];
-        return u.sequence(u.map(controls, disableControl));
+    function validateOptions(field, options, parserOptions = {}) {
+        options = u.options(options);
+        let parser = new up.OptionsParser(field, options, { ...parserOptions, closest: true, attrPrefix: 'up-validate-' });
+        parser.string('url');
+        parser.string('method', { normalize: u.normalizeMethod });
+        parser.boolean('batch', { default: config.validateBatch });
+        parser.include(watchOptions, { defaults: { event: 'change' } });
+        return options;
+    }
+    function disableContainerTemp(container) {
+        let controls = findFieldsAndButtons(container);
+        return u.sequence(u.map(controls, disableControlTemp));
     }
-    function disableControl(control) {
+    function disableControlTemp(control) {
         if (control.disabled)
             return;
         let focusFallback;
@@ -10650,7 +11070,7 @@ up.form = (function () {
         return () => { control.disabled = false; };
     }
     function getDisableContainers(disable, origin) {
-        let originScope = () => getScope(origin);
+        let originScope = () => getRegion(origin);
         if (disable === true) {
             return [originScope()];
         }
@@ -10675,6 +11095,11 @@ up.form = (function () {
             }
         };
     }
+    function setContainerDisabled(container, disabled) {
+        for (let control of findFieldsAndButtons(container)) {
+            control.disabled = disabled;
+        }
+    }
     function destinationOptions(form, options, parserOptions) {
         options = u.options(options);
         form = getForm(form);
@@ -10706,8 +11131,7 @@ up.form = (function () {
         root = up.element.get(root);
         callback ||= watchCallbackFromElement(root) || up.fail('No callback given for up.watch()');
         const watcher = new up.FieldWatcher(root, options, callback);
-        watcher.start();
-        return () => watcher.stop();
+        return watcher.start();
     }
     function watchCallbackFromElement(element) {
         let rawCallback = element.getAttribute('up-watch');
@@ -10717,7 +11141,7 @@ up.form = (function () {
     }
     function autosubmit(target, options = {}) {
         const onChange = (_diff, renderOptions) => submit(target, renderOptions);
-        return watch(target, { ...options, batch: true }, onChange);
+        return watch(target, { logPrefix: 'up.autosubmit()', ...options, batch: true }, onChange);
     }
     function getGroupSelectors() {
         return up.migrate.migratedFormGroupSelectors?.() || config.groupSelectors;
@@ -10745,7 +11169,8 @@ up.form = (function () {
     }
     function validate(...args) {
         let options = parseValidateArgs(...args);
-        let validator = up.FormValidator.forElement(options.origin);
+        let form = getForm(options.origin);
+        let validator = getFormValidator(form);
         return validator.validate(options);
     }
     function parseValidateArgs(originOrTarget, ...args) {
@@ -10758,88 +11183,20 @@ up.form = (function () {
         }
         return options;
     }
-    function switcherValues(field) {
-        let value;
-        let meta;
-        if (field.matches('input[type=checkbox]')) {
-            if (field.checked) {
-                value = field.value;
-                meta = ':checked';
-            }
-            else {
-                meta = ':unchecked';
-            }
-        }
-        else if (field.matches('input[type=radio]')) {
-            const form = getScope(field);
-            const groupName = field.getAttribute('name');
-            const checkedButton = form.querySelector(`input[type=radio]${e.attrSelector('name', groupName)}:checked`);
-            if (checkedButton) {
-                meta = ':checked';
-                value = checkedButton.value;
-            }
-            else {
-                meta = ':unchecked';
-            }
-        }
-        else {
-            value = field.value;
-        }
-        const values = [];
-        if (u.isPresent(value)) {
-            values.push(value);
-            values.push(':present');
-        }
-        else {
-            values.push(':blank');
-        }
-        if (u.isPresent(meta)) {
-            values.push(meta);
-        }
-        return values;
-    }
-    function switchTargets(switcher, options = {}) {
-        const targetSelector = options.target || options.target || switcher.getAttribute('up-switch');
-        const form = getScope(switcher);
-        targetSelector || up.fail("No switch target given for %o", switcher);
-        const fieldValues = switcherValues(switcher);
-        for (let target of up.fragment.all(form, targetSelector)) {
-            switchTarget(target, fieldValues);
-        }
-    }
-    const switchTarget = up.mockable(function (target, fieldValues) {
-        let show;
-        fieldValues ||= switcherValues(findSwitcherForTarget(target));
-        let hideValues = target.getAttribute('up-hide-for');
-        if (hideValues) {
-            hideValues = parseSwitchTokens(hideValues);
-            show = u.intersect(fieldValues, hideValues).length === 0;
-        }
-        else {
-            let showValues = target.getAttribute('up-show-for');
-            showValues = showValues ? parseSwitchTokens(showValues) : [':present', ':checked'];
-            show = u.intersect(fieldValues, showValues).length > 0;
-        }
-        e.toggle(target, show);
-        target.classList.add('up-switched');
-    });
-    function parseSwitchTokens(str) {
-        return u.getSimpleTokens(str, { json: true });
-    }
-    function findSwitcherForTarget(target) {
-        const form = getScope(target);
-        const switchers = form.querySelectorAll('[up-switch]');
-        const switcher = u.find(switchers, function (switcher) {
-            const targetSelector = switcher.getAttribute('up-switch');
-            return target.matches(targetSelector);
-        });
-        return switcher || up.fail('Could not find [up-switch] field for %o', target);
-    }
     function getForm(elementOrSelector, options = {}) {
         const element = up.fragment.get(elementOrSelector, options);
         return element.form || element.closest('form');
     }
-    function getScope(origin, options) {
+    function getFormValidator(form) {
+        return form.upFormValidator ||= setupFormValidator(form);
+    }
+    function setupFormValidator(form) {
+        const validator = new up.FormValidator(form);
+        const stop = validator.start();
+        up.destructor(form, stop);
+        return validator;
+    }
+    function getRegion(origin, options) {
         if (origin) {
             return getForm(origin, options) || up.layer.get(origin).element;
         }
@@ -10847,6 +11204,19 @@ up.form = (function () {
             return up.layer.current.element;
         }
     }
+    function trackFields(...args) {
+        let [root, { guard }, callback] = u.args(args, 'val', 'options', 'callback');
+        let filter = function (fields) {
+            let scope = getRegion(root);
+            return u.filter(fields, function (field) {
+                return (root === scope || root.contains(field))
+                    && (getForm(field) === scope)
+                    && (!guard || guard(field));
+            });
+        };
+        const live = true;
+        return up.fragment.trackSelector(fieldSelector(), { filter, live }, callback);
+    }
     function focusedField() {
         return u.presence(document.activeElement, isField);
     }
@@ -10861,49 +11231,39 @@ up.form = (function () {
         up.event.halt(event, { log: true });
         up.error.muteUncriticalRejection(submit(form, { submitButton }));
     });
-    up.compiler(validatingFieldSelector, function (fieldOrForm) {
-        let validator = up.FormValidator.forElement(fieldOrForm);
-        validator.watchContainer(fieldOrForm);
+    up.compiler('form', function (form) {
+        getFormValidator(form);
     });
-    function validatingFieldSelector() {
-        let includes = config.fieldSelectors.map((selector) => `${selector}[up-validate], [up-validate] ${selector}`);
-        let excludes = ['[up-validate=false]'];
-        return e.unionSelector(includes, excludes);
-    }
     up.compiler('[up-switch]', (switcher) => {
-        switchTargets(switcher);
-    });
-    up.on('change', '[up-switch]', (_event, switcher) => {
-        switchTargets(switcher);
-    });
-    up.compiler('[up-show-for]:not(.up-switched), [up-hide-for]:not(.up-switched)', (element) => {
-        switchTarget(element);
+        return new up.Switcher(switcher).start();
     });
     up.attribute('up-watch', (formOrField) => watch(formOrField));
-    up.attribute('up-autosubmit', (formOrField) => autosubmit(formOrField));
+    up.attribute('up-autosubmit', (formOrField) => autosubmit(formOrField, { logPrefix: '[up-autosubmit]' }));
     return {
         config,
         submit,
         submitOptions,
         destinationOptions,
         watchOptions,
+        validateOptions,
         isSubmittable,
         watch,
         validate,
         autosubmit,
         fieldSelector,
         fields: findFields,
+        trackFields,
         isField,
         submitButtons: findSubmitButtons,
         focusedField,
-        switchTarget,
-        disable: disableContainer,
+        disableTemp: disableContainerTemp,
+        setDisabled: setContainerDisabled,
         getDisablePreviewFn,
         group: findGroup,
         groupSolution: findGroupSolution,
         groupSelectors: getGroupSelectors,
         get: getForm,
-        getScope,
+        getRegion,
     };
 })();
 up.submit = up.form.submit;
@@ -10913,13 +11273,12 @@ up.validate = up.form.validate;
 
 
 /***/ }),
-/* 98 */
+/* 101 */
 /***/ (() => {
 
 up.status = (function () {
     const u = up.util;
     const e = up.element;
-    let namedPreviewFns = {};
     const config = new up.Config(() => ({
         currentClasses: ['up-current'],
         activeClasses: ['up-active'],
@@ -10927,9 +11286,9 @@ up.status = (function () {
         navSelectors: ['[up-nav]', 'nav'],
         noNavSelectors: ['[up-nav=false]'],
     }));
+    let namedPreviewFns = new up.Registry('preview');
     function reset() {
         up.layer.root.feedbackLocation = null;
-        namedPreviewFns = u.pickBy(namedPreviewFns, 'isDefault');
     }
     const SELECTOR_LINK = 'a, [up-href]';
     function linkCurrentURLs(link) {
@@ -10960,7 +11319,7 @@ up.status = (function () {
         let focusCapsule = up.FocusCapsule.preserve(bindLayer);
         let applyPreviews = () => doRunPreviews(request, renderOptions);
         let revertPreviews = bindLayer.asCurrent(applyPreviews);
-        up.on('focusin', { once: true }, () => focusCapsule = null);
+        focusCapsule?.autoVoid();
         return () => {
             bindLayer.asCurrent(revertPreviews);
             focusCapsule?.restore(bindLayer, { preventScroll: true });
@@ -11005,7 +11364,7 @@ up.status = (function () {
     }
     function resolvePreviewString(str) {
         return u.map(u.parseScalarJSONPairs(str), ([name, parsedOptions]) => {
-            let previewFn = namedPreviewFns[name] || up.fail('Unknown preview "%s"', name);
+            let previewFn = namedPreviewFns.get(name);
             return function (preview, runOptions) {
                 up.puts('[up-preview]', 'Showing preview %o', name);
                 return previewFn(preview, parsedOptions || runOptions);
@@ -11016,10 +11375,6 @@ up.status = (function () {
         activeElements ||= u.wrapList(origin);
         return activeElements.map(findActivatableArea);
     }
-    function registerPreview(name, previewFn) {
-        previewFn.isDefault = up.framework.evaling;
-        namedPreviewFns[name] = previewFn;
-    }
     function getFeedbackClassesPreviewFn(feedbackOption, fragments) {
         if (!feedbackOption)
             return;
@@ -11064,7 +11419,7 @@ up.status = (function () {
     up.on('up:framework:reset', reset);
     return {
         config,
-        preview: registerPreview,
+        preview: namedPreviewFns.put,
         resolvePreviewFns,
         runPreviews,
         statusOptions,
@@ -11074,7 +11429,7 @@ up.preview = up.status.preview;
 
 
 /***/ }),
-/* 99 */
+/* 102 */
 /***/ (() => {
 
 up.radio = (function () {
@@ -11168,7 +11523,7 @@ up.radio = (function () {
 
 
 /***/ }),
-/* 100 */
+/* 103 */
 /***/ (() => {
 
 (function () {
@@ -11318,15 +11673,18 @@ __webpack_require__(83);
 __webpack_require__(84);
 __webpack_require__(85);
 __webpack_require__(86);
+__webpack_require__(87);
 __webpack_require__(88);
-__webpack_require__(90);
+__webpack_require__(89);
 __webpack_require__(91);
 __webpack_require__(93);
-__webpack_require__(95);
-__webpack_require__(97);
+__webpack_require__(94);
+__webpack_require__(96);
 __webpack_require__(98);
-__webpack_require__(99);
 __webpack_require__(100);
+__webpack_require__(101);
+__webpack_require__(102);
+__webpack_require__(103);
 up.framework.onEvaled();
 
 })();