unpoly-rails 3.10.2 → 3.11.0.rc12

data/assets/unpoly/unpoly.js

@@ -5,7 +5,7 @@
 /***/ (() => {
 
 window.up = {
-    version: '3.10.2'
+    version: '3.11.0-rc12'
 };
 
 
@@ -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,18 @@ up.util = (function () {
             block(item, i++);
         }
     }
-    function isNull(object) {
-        return object === null;
+    function isNull(value) {
+        return value === null;
+    }
+    function isTruthy(value) {
+        return !!value;
     }
-    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 +179,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 +388,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];
@@ -425,7 +426,7 @@ up.util = (function () {
         const filtered = {};
         for (let key in object) {
             const value = object[key];
-            if (tester(value, key, object)) {
+            if (tester(value, key)) {
                 filtered[key] = object[key];
             }
         }
@@ -462,7 +463,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 +492,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 = [];
@@ -528,34 +529,36 @@ up.util = (function () {
         return Object.prototype.hasOwnProperty(k);
     }
     function isEqual(a, b) {
+        if (a === b) {
+            return true;
+        }
         if (a?.valueOf) {
             a = a.valueOf();
         }
         if (b?.valueOf) {
             b = b.valueOf();
         }
+        if (a === b) {
+            return true;
+        }
         if (typeof (a) !== typeof (b)) {
             return false;
         }
-        else if (isList(a) && isList(b)) {
+        if (isList(a) && isList(b)) {
             return isEqualList(a, b);
         }
-        else if (isObject(a) && a[isEqual.key]) {
+        if (isObject(a) && a[isEqual.key]) {
             return a[isEqual.key](b);
         }
-        else if (isOptions(a) && isOptions(b)) {
-            const aKeys = Object.keys(a);
-            const bKeys = Object.keys(b);
-            if (isEqualList(aKeys, bKeys)) {
-                return every(aKeys, aKey => isEqual(a[aKey], b[aKey]));
-            }
-            else {
-                return false;
-            }
-        }
-        else {
-            return a === b;
+        if (isOptions(a) && isOptions(b)) {
+            return isEqualOptions(a, b);
         }
+        return false;
+    }
+    function isEqualOptions(a, b) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        return isEqualList(aKeys, bKeys) && every(aKeys, (key) => isEqual(a[key], b[key]));
     }
     isEqual.key = 'up.util.isEqual';
     function isEqualList(a, b) {
@@ -611,7 +614,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);
@@ -794,36 +797,39 @@ up.util = (function () {
     }
     function maskPattern(str, patterns, { keepDelimiters = false } = {}) {
         let maskCount = 0;
-        let maskPattern = /§(\d+)/g;
-        let matches = [];
-        let replaceLayers = 0;
-        let replace = (replacePattern) => {
+        let maskPattern = /§\d+/g;
+        let maskings = {};
+        let replaceLayers = [];
+        let replace = (replacePattern, allowRestoreTransform) => {
             let didReplace = false;
             str = str.replaceAll(replacePattern, function (match) {
                 didReplace = true;
-                let glyph = '§' + (maskCount++);
-                let mask;
+                let mask = '§' + (maskCount++);
+                let remain;
                 let masked;
                 if (keepDelimiters) {
                     let startDelimiter = match[0];
                     let endDelimiter = match.slice(-1);
                     masked = match.slice(1, -1);
-                    mask = startDelimiter + glyph + endDelimiter;
+                    remain = startDelimiter + mask + endDelimiter;
                 }
                 else {
                     masked = match;
-                    mask = glyph;
+                    remain = mask;
                 }
-                matches.push(masked);
-                return mask;
+                maskings[mask] = masked;
+                return remain;
             });
             if (didReplace)
-                replaceLayers++;
+                replaceLayers.unshift({ allowRestoreTransform });
         };
-        [maskPattern, ...patterns].forEach(replace);
+        replace(maskPattern, false);
+        for (let pattern of patterns)
+            replace(pattern, true);
         let restore = (s, transform = identity) => {
-            for (let i = 0; i < replaceLayers; i++) {
-                s = s.replace(maskPattern, (match, placeholderIndex) => transform(matches[placeholderIndex]));
+            for (let { allowRestoreTransform } of replaceLayers) {
+                let iterationTransform = allowRestoreTransform ? transform : identity;
+                s = s.replace(maskPattern, (match) => iterationTransform(assert(maskings[match], isString)));
             }
             return s;
         };
@@ -837,6 +843,7 @@ up.util = (function () {
     function ensureDoubleQuotes(str) {
         if (str[0] === '"')
             return str;
+        assert(str[0] === "'");
         str = str.slice(1, -1);
         let transformed = str.replace(/(\\\\)|(\\')|(\\")|(")/g, function (_match, escapedBackslash, escapedSingleQuote, _doubleQuote) {
             return escapedBackslash
@@ -865,6 +872,17 @@ up.util = (function () {
             ];
         });
     }
+    function spanObject(keys, value) {
+        return mapObject(keys, (key) => [key, value]);
+    }
+    function assert(value, testFn = isTruthy) {
+        if (testFn(value)) {
+            return value;
+        }
+        else {
+            throw "assert failed";
+        }
+    }
     return {
         parseURL,
         normalizeURL,
@@ -882,6 +900,7 @@ up.util = (function () {
         map,
         flatMap,
         mapObject,
+        spanObject,
         findResult,
         some,
         every,
@@ -972,6 +991,7 @@ up.util = (function () {
         maskPattern,
         expressionOutline,
         parseString,
+        assert,
     };
 })();
 
@@ -1085,12 +1105,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 +1217,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 +1327,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 +1355,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));
@@ -1532,7 +1555,7 @@ up.element = (function () {
     }
     function extractFromStyleObject(style, keyOrKeys) {
         if (up.migrate.loaded)
-            keyOrKeys = up.migrate.fixStyleProps(keyOrKeys);
+            keyOrKeys = up.migrate.fixGetStyleProps(keyOrKeys);
         if (u.isString(keyOrKeys)) {
             return style.getPropertyValue(keyOrKeys);
         }
@@ -1542,7 +1565,7 @@ up.element = (function () {
     }
     function setInlineStyle(element, props, unit = '') {
         if (up.migrate.loaded)
-            props = up.migrate.fixStyleProps(props, unit);
+            props = up.migrate.fixSetStyleProps(props, unit);
         if (u.isString(props)) {
             element.setAttribute('style', props);
         }
@@ -1644,7 +1667,7 @@ up.element = (function () {
         attrSelector,
         tagName: elementTagName,
         createBrokenDocumentFromHTML,
-        fixParserDamage,
+        revivedClone,
         createNodesFromHTML,
         createFromHTML,
         extractSingular,
@@ -1779,7 +1802,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 +1881,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 +1948,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 +1961,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 +1989,7 @@ up.OptionsParser = class OptionsParser {
 
 
 /***/ }),
-/* 20 */
+/* 21 */
 /***/ (() => {
 
 const u = up.util;
@@ -1969,7 +2018,7 @@ up.FIFOCache = class FIFOCache {
 
 
 /***/ }),
-/* 21 */
+/* 22 */
 /***/ (() => {
 
 up.Rect = class Rect extends up.Record {
@@ -2000,7 +2049,7 @@ up.Rect = class Rect extends up.Record {
 
 
 /***/ }),
-/* 22 */
+/* 23 */
 /***/ (() => {
 
 const e = up.element;
@@ -2048,7 +2097,7 @@ up.BodyShifter = class BodyShifter {
 
 
 /***/ }),
-/* 23 */
+/* 24 */
 /***/ (() => {
 
 const u = up.util;
@@ -2074,7 +2123,7 @@ up.Change = class Change {
 
 
 /***/ }),
-/* 24 */
+/* 25 */
 /***/ (() => {
 
 const u = up.util;
@@ -2142,21 +2191,21 @@ up.Change.Addition = class Addition extends up.Change {
     _responseOptions() {
         return { response: this._response };
     }
-    executeSteps(steps, responseDoc, noneOptions) {
-        return new up.Change.UpdateSteps({ steps, noneOptions }).execute(responseDoc);
+    executeSteps({ steps, responseDoc, noneOptions, passRenderOptions = this.options }) {
+        return new up.Change.UpdateSteps({ steps, noneOptions, passRenderOptions }).execute(responseDoc);
     }
 };
 
 
 /***/ }),
-/* 25 */
+/* 26 */
 /***/ (() => {
 
 var _a;
 const u = up.util;
 up.RenderJob = (_a = class RenderJob {
-        constructor(options) {
-            this.options = options;
+        constructor(renderOptions) {
+            this.renderOptions = renderOptions;
         }
         execute() {
             this._rendered = this._executePromise();
@@ -2165,9 +2214,9 @@ up.RenderJob = (_a = class RenderJob {
         async _executePromise() {
             try {
                 this._emitGuardEvent();
-                this.options = up.RenderOptions.preprocess(this.options);
-                up.browser.assertConfirmed(this.options);
-                up.RenderOptions.assertContentGiven(this.options);
+                this.renderOptions = up.RenderOptions.preprocess(this.renderOptions);
+                up.browser.assertConfirmed(this.renderOptions);
+                up.RenderOptions.assertContentGiven(this.renderOptions);
                 let result = await this._getChange().execute();
                 this._handleResult(result);
                 return result;
@@ -2179,7 +2228,7 @@ up.RenderJob = (_a = class RenderJob {
         }
         _handleResult(result) {
             if (result instanceof up.RenderResult) {
-                let { onRendered, onFinished } = result.options;
+                let { onRendered, onFinished } = result.renderOptions;
                 if (!result.none)
                     up.error.guard(() => onRendered?.(result));
                 let guardedOnFinished = function (result) {
@@ -2192,7 +2241,7 @@ up.RenderJob = (_a = class RenderJob {
         _handleError(error) {
             let prefix = error instanceof up.Aborted ? 'Rendering was aborted' : 'Error while rendering';
             up.puts('up.render()', `${prefix}: ${error.name}: ${error.message}`);
-            up.error.guard(() => this.options.onError?.(error));
+            up.error.guard(() => this.renderOptions.onError?.(error));
         }
         get finished() {
             return this._awaitFinished();
@@ -2213,7 +2262,7 @@ up.RenderJob = (_a = class RenderJob {
         }
         _getChange() {
             let handleAbort = u.memoize((request) => this._handleAbortOption(request));
-            let renderOptions = { ...this.options, handleAbort };
+            let renderOptions = { ...this.renderOptions, handleAbort };
             if (renderOptions.url) {
                 return new up.Change.FromURL(renderOptions);
             }
@@ -2225,16 +2274,16 @@ up.RenderJob = (_a = class RenderJob {
             }
         }
         _emitGuardEvent() {
-            let guardEvent = u.pluckKey(this.options, 'guardEvent');
+            let guardEvent = u.pluckKey(this.renderOptions, 'guardEvent');
             if (guardEvent) {
-                guardEvent.renderOptions = this.options;
-                if (up.emit(guardEvent, { target: this.options.origin }).defaultPrevented) {
+                guardEvent.renderOptions = this.renderOptions;
+                if (up.emit(guardEvent, { target: this.renderOptions.origin }).defaultPrevented) {
                     throw new up.Aborted(`Rendering was prevented by ${guardEvent.type} listener`);
                 }
             }
         }
         _handleAbortOption(request) {
-            let { abort } = this.options;
+            let { abort } = this.renderOptions;
             if (!abort || !up.network.isBusy())
                 return;
             let { bindFragments, bindLayer, origin, layer } = this._getChange().getPreflightProps();
@@ -2272,7 +2321,7 @@ up.RenderJob = (_a = class RenderJob {
 
 
 /***/ }),
-/* 26 */
+/* 27 */
 /***/ (() => {
 
 up.Change.DestroyFragment = class DestroyFragment extends up.Change {
@@ -2297,18 +2346,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 +2372,7 @@ up.Change.DestroyFragment = class DestroyFragment extends up.Change {
 
 
 /***/ }),
-/* 27 */
+/* 28 */
 /***/ (() => {
 
 let u = up.util;
@@ -2377,6 +2426,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         this._assertOpenEventEmitted();
         this.layer = this._buildLayer();
         this._baseLayer.peel({ history: !this.layer.history });
+        this._baseLayer.saveHistory();
         up.layer.stack.push(this.layer);
         this.layer.createElements();
         this.layer.setupHandlers();
@@ -2386,14 +2436,15 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         this.handleLayerChangeRequests();
         this.responseDoc.commitElement(this._content);
         this.layer.setContent(this._content);
-        this.setReloadAttrs({ newElement: this._content, source: this.options.source });
         this.responseDoc.finalizeElement(this._content);
+        this.setReloadAttrs({ newElement: this._content, source: this.options.source });
+        up.hello(this.layer.element, { ...this.options, layer: this.layer, dataRoot: this._content });
         this._newOverlayResult = new up.RenderResult({
             layer: this.layer,
             fragments: [this._content],
             target: this.target,
+            renderOptions: this.options,
         });
-        up.hello(this.layer.element, { ...this.options, layer: this.layer, dataRoot: this._content });
         this._handleScroll();
         this._newOverlayResult.finished = this._finish();
         this.layer.opening = false;
@@ -2404,7 +2455,10 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         if (this._otherLayersResult)
             return;
         let otherLayerSteps = this._getHungrySteps().other;
-        this._otherLayersResult = this.executeSteps(otherLayerSteps, this.responseDoc);
+        this._otherLayersResult = this.executeSteps({
+            steps: otherLayerSteps,
+            responseDoc: this.responseDoc,
+        });
     }
     async _finish() {
         await this.layer.startOpenAnimation();
@@ -2414,7 +2468,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);
@@ -2423,9 +2477,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         if (this.layer.history === 'auto') {
             this.layer.history = up.fragment.hasAutoHistory([this._content], this.layer);
         }
-        let { parent } = this.layer;
-        this.layer.history &&= parent.history;
-        parent.saveHistory();
+        this.layer.history &&= this._baseLayer.history;
         this.layer.updateHistory(this.options);
     }
     _handleFocus() {
@@ -2478,7 +2530,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
 
 
 /***/ }),
-/* 28 */
+/* 29 */
 /***/ (() => {
 
 var _a;
@@ -2550,13 +2602,20 @@ up.Change.UpdateLayer = (_a = class UpdateLayer extends up.Change.Addition {
                 this.layer.updateHistory(this.options);
             }
             this.handleLayerChangeRequests();
-            this._currentLayerResult = this.executeSteps(this._steps, this.responseDoc, this.options);
+            this._currentLayerResult = this.executeSteps({
+                steps: this._steps,
+                responseDoc: this.responseDoc,
+                noneOptions: this.options,
+            });
         }
         _renderOtherLayers() {
             if (this._otherLayersResult)
                 return;
             let otherLayerSteps = this._getHungrySteps().other;
-            this._otherLayersResult = this.executeSteps(otherLayerSteps, this.responseDoc);
+            this._otherLayersResult = this.executeSteps({
+                steps: otherLayerSteps,
+                responseDoc: this.responseDoc,
+            });
         }
         _matchPreflight() {
             this._matchOldElements();
@@ -2629,7 +2688,7 @@ up.Change.UpdateLayer = (_a = class UpdateLayer extends up.Change.Addition {
 
 
 /***/ }),
-/* 29 */
+/* 30 */
 /***/ (() => {
 
 const u = up.util;
@@ -2637,30 +2696,30 @@ const e = up.element;
 up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
     constructor(options) {
         super(options);
+        this._steps = u.copy(u.assert(options.steps));
+        this._passRenderOptions = u.assert(options.passRenderOptions);
         this._noneOptions = options.noneOptions || {};
-        this._steps = u.copy(options.steps);
     }
     execute(responseDoc) {
         this.responseDoc = responseDoc;
         this._steps = responseDoc.selectSteps(this._steps);
         this._steps = responseDoc.commitSteps(this._steps);
-        if (!this._steps.length) {
-            return this._executeNone();
-        }
         this.renderResult = new up.RenderResult({
-            layer: this._steps[0]?.layer,
+            layer: this._passRenderOptions.layer,
             target: up.fragment.targetForSteps(this._steps),
+            renderOptions: this._passRenderOptions,
         });
-        this._steps.reverse();
-        const motionEndPromises = this._steps.map(step => this._executeStep(step));
-        this.renderResult.finished = this._finish(motionEndPromises);
+        if (!this._steps.length) {
+            this._handleFocus(null, this._noneOptions);
+            this._handleScroll(null, this._noneOptions);
+        }
+        else {
+            this._steps.reverse();
+            const motionEndPromises = this._steps.map((step) => this._executeStep(step));
+            this.renderResult.finished = this._finish(motionEndPromises);
+        }
         return this.renderResult;
     }
-    _executeNone() {
-        this._handleFocus(null, this._noneOptions);
-        this._handleScroll(null, this._noneOptions);
-        return up.RenderResult.buildNone();
-    }
     async _finish(motionEndPromises) {
         await Promise.all(motionEndPromises);
         for (let step of this._steps) {
@@ -2673,17 +2732,16 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
         this.renderResult.fragments.unshift(...newFragments);
     }
     _executeStep(step) {
-        this.setReloadAttrs(step);
         switch (step.placement) {
             case 'swap': {
-                let keepPlan = this._findKeepPlan(step);
+                let keepPlan = up.fragment.keepPlan(step);
                 if (keepPlan) {
                     this._handleFocus(step.oldElement, step);
                     this._handleScroll(step.oldElement, step);
                     return Promise.resolve();
                 }
                 else {
-                    this._preserveKeepables(step);
+                    this._preserveDescendantKeepables(step);
                     const parent = step.oldElement.parentNode;
                     const morphOptions = {
                         ...step,
@@ -2691,11 +2749,9 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                             up.fragment.markAsDestroying(step.oldElement);
                         },
                         afterInsert: () => {
-                            this._restoreKeepables(step);
-                            this.responseDoc.finalizeElement(step.newElement);
-                            this._unmarkKeepables(step);
-                            up.hello(step.newElement, step);
-                            this._addToResult(step.newElement);
+                            this._restoreDescendantKeepables(step);
+                            this._welcomeElement(step.newElement, step);
+                            this._finalizeDescendantKeepables(step);
                         },
                         beforeDetach: () => {
                             up.script.clean(step.oldElement, { layer: step.layer });
@@ -2732,90 +2788,64 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                 let wrapper = e.wrapChildren(step.newElement);
                 let position = step.placement === 'before' ? 'afterbegin' : 'beforeend';
                 step.oldElement.insertAdjacentElement(position, wrapper);
-                this.responseDoc.finalizeElement(wrapper);
-                up.hello(wrapper, step);
-                this._addToResult(wrapper);
+                this._welcomeElement(wrapper, step);
                 this._handleFocus(wrapper, step);
                 this._handleScroll(wrapper, step);
-                return up.animate(wrapper, step.transition, step).then(() => e.unwrap(wrapper));
+                return up.animate(wrapper, step.animation, step).then(() => e.unwrap(wrapper));
             }
             default: {
                 up.fail('Unknown placement: %o', step.placement);
             }
         }
     }
-    _findKeepPlan(options) {
-        if (!options.keep) {
-            return;
-        }
-        const { oldElement, newElement } = options;
-        let doKeep = e.booleanAttr(oldElement, 'up-keep');
-        if (!doKeep) {
-            return;
-        }
-        let partner;
-        let partnerSelector = up.fragment.toTarget(oldElement);
-        const lookupOpts = { layer: options.layer };
-        if (options.descendantsOnly) {
-            partner = up.fragment.get(newElement, partnerSelector, lookupOpts);
-        }
-        else {
-            partner = e.subtreeFirst(newElement, partnerSelector, lookupOpts);
-        }
-        if (partner && e.booleanAttr(partner, 'up-keep') !== false) {
-            const plan = {
-                oldElement,
-                newElement: partner,
-                newData: up.script.data(partner),
-                renderOptions: options,
-            };
-            if (!up.fragment.emitKeep(plan).defaultPrevented) {
-                return plan;
-            }
-        }
+    _welcomeElement(element, step) {
+        this.responseDoc.finalizeElement(element);
+        this.setReloadAttrs(step);
+        up.hello(element, step);
+        this._addToResult(element);
     }
-    _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 });
+                let keepPlan = up.fragment.keepPlan({ ...step, oldElement: keepable, descendantsOnly: true });
                 if (keepPlan) {
                     const keepableClone = keepable.cloneNode(true);
                     keepable.insertAdjacentElement('beforebegin', keepableClone);
                     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);
                     }
-                    keepPlans.push(keepPlan);
+                    descendantKeepPlans.push(keepPlan);
                 }
             }
         }
-        step.keepPlans = keepPlans;
+        step.descendantKeepPlans = descendantKeepPlans;
     }
-    _restoreKeepables(step) {
-        for (let keepPlan of step.keepPlans) {
+    _restoreDescendantKeepables(step) {
+        for (let keepPlan of step.descendantKeepPlans) {
             keepPlan.newElement.replaceWith(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 +2867,7 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
 
 
 /***/ }),
-/* 30 */
+/* 31 */
 /***/ (() => {
 
 const u = up.util;
@@ -2915,7 +2945,7 @@ up.Change.CloseLayer = class CloseLayer extends up.Change {
 
 
 /***/ }),
-/* 31 */
+/* 32 */
 /***/ (() => {
 
 var _a;
@@ -2934,7 +2964,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)) {
@@ -2992,7 +3022,7 @@ up.Change.FromURL = (_a = class FromURL extends up.Change {
 
 
 /***/ }),
-/* 32 */
+/* 33 */
 /***/ (() => {
 
 var _a;
@@ -3027,7 +3057,7 @@ up.Change.FromResponse = (_a = class FromResponse extends up.Change {
             this.options.failTarget = ':none';
         }
         _updateContentFromResponse(finalRenderOptions) {
-            if (finalRenderOptions.failPrefixForced) {
+            if (finalRenderOptions.didForceFailOptions) {
                 up.puts('up.render()', 'Rendering failed response using fail-prefixed options (https://unpoly.com/failed-responses)');
             }
             this._augmentOptionsFromResponse(finalRenderOptions);
@@ -3110,6 +3140,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;
@@ -3124,7 +3165,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;
         }
@@ -3138,7 +3179,7 @@ up.Change.FromResponse = (_a = class FromResponse extends up.Change {
 
 
 /***/ }),
-/* 33 */
+/* 34 */
 /***/ (() => {
 
 var _a;
@@ -3183,9 +3224,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
             return this._seekPlan(this._executePlan.bind(this)) || this._cannotMatchPostflightTarget();
         }
         _executePlan(matchedPlan) {
-            let result = matchedPlan.execute(this._getResponseDoc(), this._onPlanApplicable.bind(this, matchedPlan));
-            result.options = this.options;
-            return result;
+            return matchedPlan.execute(this._getResponseDoc(), this._onPlanApplicable.bind(this, matchedPlan));
         }
         _isApplicablePlanError(error) {
             return !(error instanceof up.CannotMatch);
@@ -3210,7 +3249,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
                 'fragment',
                 'document',
                 'html',
-                'cspNonces',
+                'cspInfo',
                 'origin',
                 'data',
             ]);
@@ -3241,7 +3280,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() {
@@ -3259,7 +3298,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
             else if (this._layers.length === 0) {
                 this._cannotMatchLayer();
             }
-            else if (this.options.failPrefixForced) {
+            else if (this.options.didForceFailOptions) {
                 throw new up.CannotMatch('No target selector given for failed responses (https://unpoly.com/failed-responses)');
             }
             else {
@@ -3293,7 +3332,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
 
 
 /***/ }),
-/* 34 */
+/* 35 */
 /***/ (() => {
 
 const u = up.util;
@@ -3388,7 +3427,7 @@ up.CompilerPass = class CompilerPass {
 
 
 /***/ }),
-/* 35 */
+/* 36 */
 /***/ (() => {
 
 const u = up.util;
@@ -3493,7 +3532,7 @@ up.CSSTransition = class CSSTransition {
 
 
 /***/ }),
-/* 36 */
+/* 37 */
 /***/ (() => {
 
 const u = up.util;
@@ -3516,7 +3555,7 @@ up.DestructorPass = class DestructorPass {
 
 
 /***/ }),
-/* 37 */
+/* 38 */
 /***/ (() => {
 
 const u = up.util;
@@ -3615,7 +3654,7 @@ up.EventEmitter = class EventEmitter extends up.Record {
 
 
 /***/ }),
-/* 38 */
+/* 39 */
 /***/ (() => {
 
 const u = up.util;
@@ -3666,7 +3705,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;
@@ -3719,7 +3759,7 @@ up.EventListener = class EventListener extends up.Record {
 
 
 /***/ }),
-/* 39 */
+/* 40 */
 /***/ (() => {
 
 const u = up.util;
@@ -3765,7 +3805,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;
@@ -3785,14 +3825,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;
@@ -3800,40 +3889,49 @@ 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)');
+        }
+        if (up.form.isField(this._root) && !this._root.name) {
+            fail('%s can only watch fields with a name (%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;
@@ -3858,7 +3956,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);
@@ -3903,20 +4001,114 @@ up.FieldWatcher = class FieldWatcher {
     _readFieldValues() {
         return up.Params.fromContainer(this._root).toObject();
     }
-    _check(fieldOptions = {}) {
+    _check(event, fieldOptions = {}) {
         const values = this._readFieldValues();
         if (this._isNewValues(values)) {
+            up.log.putsEvent(event);
             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, fieldTokens, log });
+    }
+    _findSwitchees() {
+        let scope = this._scope;
+        return scope ? up.fragment.subtree(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 values = up.Params.fromContainer(this._root).values();
+        let tokens = [...values];
+        let anyPresent = u.some(values, u.isPresent);
+        tokens.push(anyPresent ? ':present' : ':blank');
+        let fields = up.form.fields(this._root);
+        if (fields[0]?.matches('[type=radio], [type=checkbox]')) {
+            let anyChecked = u.some(fields, 'checked');
+            tokens.push(anyChecked ? ':checked' : ':unchecked');
+        }
+        return tokens;
+    }
+};
+
+
+/***/ }),
+/* 44 */
 /***/ (() => {
 
 const u = up.util;
@@ -3927,41 +4119,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;
     }
@@ -4013,9 +4215,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;
@@ -4035,33 +4234,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;
@@ -4089,15 +4308,11 @@ 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 {
@@ -4136,7 +4351,7 @@ up.FocusCapsule = class FocusCapsule {
 
 
 /***/ }),
-/* 43 */
+/* 46 */
 /***/ (() => {
 
 const u = up.util;
@@ -4179,7 +4394,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') {
@@ -4201,7 +4416,7 @@ up.FragmentProcessor = class FragmentProcessor extends up.Record {
 
 
 /***/ }),
-/* 44 */
+/* 47 */
 /***/ (() => {
 
 const u = up.util;
@@ -4250,7 +4465,7 @@ up.FragmentFinder = class FragmentFinder {
 
 
 /***/ }),
-/* 45 */
+/* 48 */
 /***/ (() => {
 
 const u = up.util;
@@ -4260,6 +4475,7 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
     keys() {
         return super.keys().concat([
             'hash',
+            'focusVisible',
             'focusCapsule',
             'inputDevice',
         ]);
@@ -4316,7 +4532,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;
         }
     }
@@ -4333,7 +4554,7 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
 
 
 /***/ }),
-/* 46 */
+/* 49 */
 /***/ (() => {
 
 const e = up.element;
@@ -4373,7 +4594,7 @@ up.FragmentPolling = class FragmentPolling {
         if (this._state === 'started') {
             this._clearReloadTimer();
             this._state = 'stopped';
-            this.unbindEvents?.();
+            this._unbindEvents?.();
         }
     }
     forceStart(options) {
@@ -4386,8 +4607,8 @@ up.FragmentPolling = class FragmentPolling {
         this.forceStarted = false;
     }
     _ensureEventsBound() {
-        if (!this.unbindEvents) {
-            this.unbindEvents = up.on('visibilitychange up:layer:opened up:layer:dismissed up:layer:accepted', this._onVisibilityChange.bind(this));
+        if (!this._unbindEvents) {
+            this._unbindEvents = up.on('visibilitychange up:layer:opened up:layer:dismissed up:layer:accepted', this._onVisibilityChange.bind(this));
         }
     }
     _onVisibilityChange() {
@@ -4419,6 +4640,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;
@@ -4488,7 +4714,7 @@ up.FragmentPolling = class FragmentPolling {
 
 
 /***/ }),
-/* 47 */
+/* 50 */
 /***/ (() => {
 
 const u = up.util;
@@ -4505,8 +4731,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':
@@ -4541,9 +4769,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 });
@@ -4552,7 +4779,7 @@ up.FragmentScrolling = class FragmentScrolling extends up.FragmentProcessor {
 
 
 /***/ }),
-/* 48 */
+/* 51 */
 /***/ (() => {
 
 const e = up.element;
@@ -4578,14 +4805,15 @@ up.Layer = class Layer extends up.Record {
     }
     constructor(options = {}) {
         super(options);
-        if (!this.mode) {
-            throw "missing { mode } option";
-        }
+        u.assert(this.mode);
     }
     setupHandlers() {
         up.link.convertClicks(this);
+        this._unbindLocationChanged = up.on('up:location:changed', (event) => this._onBrowserLocationChanged(event));
+    }
+    teardownHandlers() {
+        this._unbindLocationChanged?.();
     }
-    teardownHandlers() { }
     mainTargets() {
         return up.layer.mainTargets(this.mode);
     }
@@ -4684,28 +4912,28 @@ up.Layer = class Layer extends up.Record {
         return !this.element.isConnected;
     }
     saveHistory() {
-        if (this.history) {
-            this.savedTitle = document.title;
-            this.savedMetaTags = up.history.findMetaTags();
-            this.savedLocation = up.history.location;
-            this.savedLang = up.history.getLang();
-        }
+        u.assert(this.isFront());
+        if (!this.showsLiveHistory())
+            return;
+        this._savedTitle = this.title;
+        this._savedMetaTags = this.metaTags;
+        this._savedLocation = this.location;
+        this._savedLang = this.lang;
     }
     restoreHistory() {
-        if (!this.showsLiveHistory()) {
+        if (!this.showsLiveHistory())
             return;
+        if (this._savedLocation) {
+            up.history.push(this._savedLocation);
         }
-        if (this.savedLocation) {
-            up.history.push(this.savedLocation);
-        }
-        if (this.savedTitle) {
-            document.title = this.savedTitle;
+        if (this._savedTitle) {
+            document.title = this._savedTitle;
         }
-        if (this.savedMetaTags) {
-            up.history.updateMetaTags(this.savedMetaTags);
+        if (this._savedMetaTags) {
+            up.history.updateMetaTags(this._savedMetaTags);
         }
-        if (u.isString(this.savedLang)) {
-            up.history.updateLang(this.savedLang);
+        if (u.isString(this._savedLang)) {
+            up.history.updateLang(this._savedLang);
         }
     }
     asCurrent(fn) {
@@ -4713,32 +4941,37 @@ up.Layer = class Layer extends up.Record {
     }
     updateHistory(options) {
         if (u.isString(options.location)) {
-            this.location = options.location;
+            this._updateLocation(options.location, { push: true });
         }
         if (up.history.config.updateMetaTags && u.isList(options.metaTags)) {
             up.migrate?.warnOfHungryMetaTags?.(options.metaTags);
-            this.metaTags = options.metaTags;
+            this._updateMetaTags(options.metaTags);
         }
         if (u.isString(options.title)) {
-            this.title = options.title;
+            this._updateTitle(options.title);
         }
         if (u.isString(options.lang)) {
-            this.lang = options.lang;
+            this._updateLang(options.lang);
         }
     }
     showsLiveHistory() {
         return this.history && this.isFront();
     }
+    _onBrowserLocationChanged({ location }) {
+        if (this.showsLiveHistory()) {
+            this._updateLocation(location, { push: false });
+        }
+    }
     get title() {
         if (this.showsLiveHistory()) {
             return document.title;
         }
         else {
-            return this.savedTitle;
+            return this._savedTitle;
         }
     }
-    set title(title) {
-        this.savedTitle = title;
+    _updateTitle(title) {
+        this._savedTitle = title;
         if (this.showsLiveHistory()) {
             document.title = title;
         }
@@ -4748,11 +4981,11 @@ up.Layer = class Layer extends up.Record {
             return up.history.findMetaTags();
         }
         else {
-            return this.savedMetaTags;
+            return this._savedMetaTags;
         }
     }
-    set metaTags(metaTags) {
-        this.savedMetaTags = metaTags;
+    _updateMetaTags(metaTags) {
+        this._savedMetaTags = metaTags;
         if (this.showsLiveHistory()) {
             up.history.updateMetaTags(metaTags);
         }
@@ -4762,11 +4995,11 @@ up.Layer = class Layer extends up.Record {
             return up.history.getLang();
         }
         else {
-            return this.savedLang;
+            return this._savedLang;
         }
     }
-    set lang(lang) {
-        this.savedLang = lang;
+    _updateLang(lang) {
+        this._savedLang = lang;
         if (this.showsLiveHistory()) {
             up.history.updateLang(lang);
         }
@@ -4776,20 +5009,18 @@ up.Layer = class Layer extends up.Record {
             return up.history.location;
         }
         else {
-            return this.savedLocation;
+            return this._savedLocation;
         }
     }
-    set location(location) {
-        const previousLocation = this.location;
-        location = u.normalizeURL(location);
-        if (previousLocation !== location || this.opening) {
-            this.savedLocation = location;
-            if (this.showsLiveHistory()) {
-                up.history.push(location);
-            }
-            if (!this.opening) {
-                this.emit('up:layer:location:changed', { location });
-            }
+    _updateLocation(newLocation, { push }) {
+        let prevSavedLocation = this._savedLocation;
+        let liveLocation = up.history.location;
+        this._savedLocation = newLocation;
+        if (newLocation !== liveLocation && this.showsLiveHistory() && push) {
+            up.history.push(newLocation);
+        }
+        if (newLocation !== prevSavedLocation && !this.opening) {
+            this.emit('up:layer:location:changed', { location: newLocation, previousLocation: prevSavedLocation, log: false });
         }
     }
     selector(part) {
@@ -4818,7 +5049,7 @@ up.Layer = class Layer extends up.Record {
 
 
 /***/ }),
-/* 49 */
+/* 52 */
 /***/ (() => {
 
 var _a;
@@ -4918,14 +5149,14 @@ 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);
                         }
                     });
                 }
                 else {
-                    this.unbindParentClicked = this.parent.on('up:click', (event, element) => {
+                    this._unbindParentClicked = this.parent.on('up:click', (event, element) => {
                         if (!up.layer.isWithinForeignOverlay(element)) {
                             const originClicked = this.origin && this.origin.contains(element);
                             this._onOutsideClicked(event, originClicked);
@@ -4934,17 +5165,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) {
@@ -4979,26 +5210,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 }));
             });
@@ -5018,8 +5261,8 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
         }
         teardownHandlers() {
             super.teardownHandlers();
-            this.unbindParentClicked?.();
-            this.unbindEscapePressed?.();
+            this._unbindParentClicked?.();
+            this._unbindEscapePressed?.();
             this.overlayFocus.teardown();
         }
         destroyElements(options) {
@@ -5101,11 +5344,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 {
@@ -5144,7 +5388,7 @@ up.Layer.OverlayWithTether = class OverlayWithTether extends up.Layer.Overlay {
 
 
 /***/ }),
-/* 51 */
+/* 54 */
 /***/ (() => {
 
 up.Layer.OverlayWithViewport = class OverlayWithViewport extends up.Layer.Overlay {
@@ -5173,7 +5417,7 @@ up.Layer.OverlayWithViewport = class OverlayWithViewport extends up.Layer.Overla
 
 
 /***/ }),
-/* 52 */
+/* 55 */
 /***/ (() => {
 
 var _a;
@@ -5219,7 +5463,7 @@ up.Layer.Root = (_a = class Root extends up.Layer {
 
 
 /***/ }),
-/* 53 */
+/* 56 */
 /***/ (() => {
 
 var _a;
@@ -5230,7 +5474,7 @@ up.Layer.Modal = (_a = class Modal extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 54 */
+/* 57 */
 /***/ (() => {
 
 var _a;
@@ -5241,7 +5485,7 @@ up.Layer.Popup = (_a = class Popup extends up.Layer.OverlayWithTether {
 
 
 /***/ }),
-/* 55 */
+/* 58 */
 /***/ (() => {
 
 var _a;
@@ -5252,7 +5496,7 @@ up.Layer.Drawer = (_a = class Drawer extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 56 */
+/* 59 */
 /***/ (() => {
 
 var _a;
@@ -5263,7 +5507,7 @@ up.Layer.Cover = (_a = class Cover extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 57 */
+/* 60 */
 /***/ (() => {
 
 var _a;
@@ -5279,7 +5523,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;
@@ -5294,7 +5538,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);
@@ -5376,7 +5620,7 @@ up.LayerLookup = (_a = class LayerLookup {
 
 
 /***/ }),
-/* 58 */
+/* 61 */
 /***/ (() => {
 
 const u = up.util;
@@ -5490,7 +5734,7 @@ up.LayerStack = class LayerStack {
 
 
 /***/ }),
-/* 59 */
+/* 62 */
 /***/ (() => {
 
 const u = up.util;
@@ -5520,11 +5764,16 @@ up.LinkCurrentURLs = class LinkCurrentURLs {
             this._upHREF === normalizedLocation ||
             this._aliasPattern?.test?.(normalizedLocation, false));
     }
+    isAnyCurrent(normalizedLocations) {
+        return normalizedLocations.some((normalizedLocation) => (this._href === normalizedLocation ||
+            this._upHREF === normalizedLocation ||
+            this._aliasPattern?.test?.(normalizedLocation, false)));
+    }
 };
 
 
 /***/ }),
-/* 60 */
+/* 63 */
 /***/ (() => {
 
 const u = up.util;
@@ -5565,13 +5814,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;
@@ -5613,7 +5864,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);
@@ -5667,10 +5918,9 @@ up.MotionController = class MotionController {
 
 
 /***/ }),
-/* 62 */
+/* 65 */
 /***/ (() => {
 
-const u = up.util;
 const e = up.element;
 up.NonceableCallback = class NonceableCallback {
     constructor(script, nonce) {
@@ -5724,37 +5974,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;
@@ -5776,7 +6000,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]');
         }
@@ -5827,7 +6051,7 @@ up.OverlayFocus = class OverlayFocus {
 
 
 /***/ }),
-/* 64 */
+/* 67 */
 /***/ (() => {
 
 const u = up.util;
@@ -5873,15 +6097,12 @@ up.Params = class Params {
         return formData;
     }
     toQuery() {
-        let parts = u.map(this.entries, this._arrayEntryToQuery.bind(this));
-        parts = u.compact(parts);
+        let simpleEntries = this.withoutBinaryEntries().entries;
+        let parts = simpleEntries.map(this._arrayEntryToQuery);
         return parts.join('&');
     }
     _arrayEntryToQuery(entry) {
         const { value } = entry;
-        if (this._isBinaryValue(value)) {
-            return;
-        }
         let query = encodeURIComponent(entry.name);
         if (u.isGiven(value)) {
             query += "=";
@@ -5889,12 +6110,15 @@ up.Params = class Params {
         }
         return query;
     }
-    _isBinaryValue(value) {
+    _isBinaryEntry({ value }) {
         return value instanceof Blob;
     }
-    hasBinaryValues() {
-        const values = u.map(this.entries, 'value');
-        return u.some(values, this._isBinaryValue);
+    hasBinaryEntries() {
+        return u.some(this.entries, this._isBinaryEntry);
+    }
+    withoutBinaryEntries() {
+        let simpleEntries = u.reject(this.entries, this._isBinaryEntry);
+        return new this.constructor(simpleEntries);
     }
     toURL(base) {
         let parts = [base, this.toQuery()];
@@ -5924,9 +6148,15 @@ up.Params = class Params {
             this._addAllFromObject(raw);
         }
         else {
-            up.fail("Unsupport params type: %o", raw);
+            up.fail("Unsupported params type: %o", raw);
         }
     }
+    keys() {
+        return u.map(this.entries, 'name');
+    }
+    values() {
+        return u.map(this.entries, 'value');
+    }
     _addAllFromObject(object) {
         for (let key in object) {
             const value = object[key];
@@ -5964,7 +6194,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)) {
@@ -5979,16 +6209,11 @@ up.Params = class Params {
         return entry?.value;
     }
     getAll(name) {
-        if (this._isArrayKey(name)) {
-            return this.getAll(name);
-        }
-        else {
-            const entries = u.map(this.entries, this._matchEntryFn(name));
-            return u.map(entries, 'value');
-        }
+        const entries = u.filter(this.entries, this._matchEntryFn(name));
+        return u.map(entries, 'value');
     }
     _isArrayKey(key) {
-        return key.endsWith('[]');
+        return u.evalOption(up.form.config.arrayParam, key);
     }
     [u.isBlank.key]() {
         return this.entries.length === 0;
@@ -6051,17 +6276,21 @@ up.Params = class Params {
     static stripURL(url) {
         return u.normalizeURL(url, { search: false });
     }
-    static merge(...objects) {
-        return objects.reduce(function (allParams, params) {
-            allParams.addAll(params);
-            return allParams;
-        }, new up.Params());
+    static merge(start, ...objects) {
+        let merged = u.copy(start);
+        for (let object of objects) {
+            let other = u.wrapValue(this, object);
+            for (let key of other.keys())
+                merged.delete(key);
+            merged.addAll(other);
+        }
+        return merged;
     }
 };
 
 
 /***/ }),
-/* 65 */
+/* 68 */
 /***/ (() => {
 
 const u = up.util;
@@ -6132,7 +6361,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');
@@ -6195,7 +6424,7 @@ up.Preview = class Preview {
 
 
 /***/ }),
-/* 66 */
+/* 69 */
 /***/ (() => {
 
 const e = up.element;
@@ -6245,7 +6474,7 @@ up.ProgressBar = class ProgressBar {
 
 
 /***/ }),
-/* 67 */
+/* 70 */
 /***/ (() => {
 
 const u = up.util;
@@ -6341,7 +6570,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 = '';
             }
@@ -6362,19 +6591,22 @@ up.RenderOptions = (function () {
         return overrides;
     }
     function deriveFailOptions(preprocessedOptions) {
+        let markFailure = { didFail: true };
         let overrides = failOverrides(preprocessedOptions);
         if (preprocessedOptions.failOptions) {
             return {
                 ...preprocessedOptions.defaults,
                 ...u.pick(preprocessedOptions, SHARED_KEYS),
                 ...overrides,
-                ...{ failPrefixForced: true }
+                didForceFailOptions: true,
+                ...markFailure,
             };
         }
         else {
             return {
                 ...preprocessedOptions,
                 ...overrides,
+                ...markFailure,
             };
         }
     }
@@ -6391,7 +6623,7 @@ up.RenderOptions = (function () {
 
 
 /***/ }),
-/* 68 */
+/* 71 */
 /***/ (() => {
 
 up.RenderResult = class RenderResult extends up.Record {
@@ -6400,13 +6632,14 @@ up.RenderResult = class RenderResult extends up.Record {
             'fragments',
             'layer',
             'target',
-            'options',
+            'renderOptions',
             'finished',
         ];
     }
     defaults() {
         return {
             fragments: [],
+            finished: Promise.resolve(),
         };
     }
     get none() {
@@ -6415,13 +6648,15 @@ up.RenderResult = class RenderResult extends up.Record {
     get fragment() {
         return this.fragments[0];
     }
+    get ok() {
+        return !this.renderOptions.didFail;
+    }
     static both(main, extension, mergeFinished = true) {
-        if (!extension)
+        if (!extension) {
             return main;
+        }
         return new this({
-            target: main.target,
-            layer: main.layer,
-            options: main.options,
+            ...main,
             fragments: main.fragments.concat(extension.fragments),
             finished: (mergeFinished && this.mergeFinished(main, extension))
         });
@@ -6429,17 +6664,11 @@ up.RenderResult = class RenderResult extends up.Record {
     static async mergeFinished(main, extension) {
         return this.both(await main.finished, await extension.finished, false);
     }
-    static buildNone() {
-        return new this({
-            target: ':none',
-            finished: Promise.resolve(),
-        });
-    }
 };
 
 
 /***/ }),
-/* 69 */
+/* 72 */
 /***/ (() => {
 
 var _a;
@@ -6466,6 +6695,8 @@ up.Request = (_a = class Request extends up.Record {
                 'failMode',
                 'failContext',
                 'origin',
+                'originLayer',
+                'originMode',
                 'builtAt',
                 'wrapMethod',
                 'contentType',
@@ -6478,30 +6709,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;
@@ -6548,8 +6780,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;
             });
@@ -6703,6 +6936,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),
@@ -6756,7 +6990,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;
@@ -6817,7 +7051,7 @@ up.Request = (_a = class Request extends up.Record {
 
 
 /***/ }),
-/* 70 */
+/* 73 */
 /***/ (() => {
 
 const u = up.util;
@@ -6898,15 +7132,6 @@ up.Request.Cache = class Cache {
         this._requests.push(request);
         this._limitSize();
     }
-    alias(existingCachedRequest, newRequest) {
-        existingCachedRequest = this.get(existingCachedRequest);
-        if (!existingCachedRequest)
-            return;
-        newRequest = this._wrap(newRequest);
-        this.track(existingCachedRequest, newRequest, { force: true });
-        this.put(newRequest);
-        return newRequest;
-    }
     async track(existingRequest, newRequest, options = {}) {
         newRequest.trackedRequest = existingRequest;
         newRequest.state = 'tracking';
@@ -6982,7 +7207,7 @@ up.Request.Cache = class Cache {
 
 
 /***/ }),
-/* 71 */
+/* 74 */
 /***/ (() => {
 
 const u = up.util;
@@ -7000,7 +7225,7 @@ up.Request.Queue = class Queue {
     }
     asap(request) {
         request.runQueuedCallbacks();
-        u.always(request, responseOrError => this._onRequestSettled(request, responseOrError));
+        u.always(request, () => this._onRequestSettled(request));
         this._scheduleSlowTimer(request);
         this._queueRequest(request);
         queueMicrotask(() => this._poke());
@@ -7031,7 +7256,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);
     }
@@ -7040,11 +7265,8 @@ up.Request.Queue = class Queue {
             this._currentRequests.push(request);
         }
     }
-    _onRequestSettled(request, responseOrError) {
+    _onRequestSettled(request) {
         u.remove(this._currentRequests, request) || u.remove(this._queuedRequests, request);
-        if ((responseOrError instanceof up.Response) && responseOrError.ok) {
-            up.network.registerAliasForRedirect(request, responseOrError);
-        }
         queueMicrotask(() => this._poke());
         u.task(() => this._checkForRecover());
     }
@@ -7093,7 +7315,7 @@ up.Request.Queue = class Queue {
 
 
 /***/ }),
-/* 72 */
+/* 75 */
 /***/ (() => {
 
 const u = up.util;
@@ -7104,7 +7326,7 @@ up.Request.FormRenderer = class FormRenderer {
         this._request = request;
     }
     buildAndSubmit() {
-        this.params = u.copy(this._request.params);
+        this.params = this._request.params.withoutBinaryEntries();
         let action = this._request.url;
         let { method } = this._request;
         const paramsFromQuery = up.Params.fromURL(action);
@@ -7132,7 +7354,7 @@ up.Request.FormRenderer = class FormRenderer {
 
 
 /***/ }),
-/* 73 */
+/* 76 */
 /***/ (() => {
 
 var _a;
@@ -7181,7 +7403,7 @@ up.Request.XHRRenderer = (_a = class XHRRenderer {
             this._contentType = this._request.contentType;
             if (!this._payload && this._request.allowsPayload()) {
                 if (!this._contentType) {
-                    this._contentType = this._params.hasBinaryValues() ? CONTENT_TYPE_FORM_DATA : CONTENT_TYPE_URL_ENCODED;
+                    this._contentType = this._params.hasBinaryEntries() ? CONTENT_TYPE_FORM_DATA : CONTENT_TYPE_URL_ENCODED;
                 }
                 if (this._contentType === CONTENT_TYPE_FORM_DATA) {
                     this._contentType = null;
@@ -7203,7 +7425,7 @@ up.Request.XHRRenderer = (_a = class XHRRenderer {
 
 
 /***/ }),
-/* 74 */
+/* 77 */
 /***/ (() => {
 
 const u = up.util;
@@ -7218,6 +7440,7 @@ up.Response = class Response extends up.Record {
             'xhr',
             'target',
             'title',
+            'openLayer',
             'acceptLayer',
             'dismissLayer',
             'eventPlans',
@@ -7232,7 +7455,7 @@ up.Response = class Response extends up.Record {
     defaults() {
         return {
             headers: {},
-            loadedAt: new Date()
+            loadedAt: new Date(),
         };
     }
     get ok() {
@@ -7251,8 +7474,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');
@@ -7277,19 +7501,33 @@ up.Response = class Response extends up.Record {
     get description() {
         return `HTTP ${this.status} response to ${this.request.description}`;
     }
+    get redirect() {
+        return (this.url !== this.request.url) || (this.method !== this.request.method);
+    }
+    get redirectRequest() {
+        if (!this.redirect)
+            return;
+        let finalRequest = u.variant(this.request, {
+            method: this.method,
+            url: this.url,
+            cacheRoute: null,
+        });
+        up.cache.track(this.request, finalRequest, { force: true });
+        return finalRequest;
+    }
 };
 
 
 /***/ }),
-/* 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);
             }
@@ -7299,7 +7537,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) {
@@ -7328,9 +7566,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);
@@ -7368,7 +7603,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) {
@@ -7420,21 +7662,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);
         }
     },
     (() => {
@@ -7446,7 +7710,7 @@ up.ResponseDoc = (_a = class ResponseDoc {
 
 
 /***/ }),
-/* 76 */
+/* 79 */
 /***/ (() => {
 
 const e = up.element;
@@ -7536,7 +7800,7 @@ up.RevealMotion = class RevealMotion {
 
 
 /***/ }),
-/* 77 */
+/* 80 */
 /***/ (() => {
 
 const u = up.util;
@@ -7558,7 +7822,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 });
@@ -7593,7 +7857,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));
@@ -7605,7 +7869,7 @@ up.Selector = class Selector {
 
 
 /***/ }),
-/* 78 */
+/* 81 */
 /***/ (() => {
 
 const u = up.util;
@@ -7725,7 +7989,7 @@ up.Tether = class Tether {
 
 
 /***/ }),
-/* 79 */
+/* 82 */
 /***/ (() => {
 
 const u = up.util;
@@ -7798,7 +8062,7 @@ up.URLPattern = class URLPattern {
 
 
 /***/ }),
-/* 80 */
+/* 83 */
 /***/ (() => {
 
 up.framework = (function () {
@@ -7806,7 +8070,7 @@ up.framework = (function () {
     function emitReset() {
         up.emit('up:framework:reset', { log: false });
     }
-    function boot() {
+    function boot({ mode = 'manual' } = {}) {
         if (readyState !== 'configuring') {
             console.error('Unpoly has already booted');
             return;
@@ -7814,9 +8078,9 @@ up.framework = (function () {
         let issue = supportIssue();
         if (!issue) {
             readyState = 'booting';
-            up.emit('up:framework:boot', { log: false });
+            up.emit('up:framework:boot', { mode, log: false });
             readyState = 'booted';
-            up.emit('up:framework:booted', { log: false });
+            up.emit('up:framework:booted', { mode, log: false });
         }
         else {
             console.error("Unpoly cannot boot: %s", issue);
@@ -7840,7 +8104,7 @@ up.framework = (function () {
             console.debug('Call up.boot() after you have configured Unpoly');
         }
         else {
-            document.addEventListener('DOMContentLoaded', boot);
+            document.addEventListener('DOMContentLoaded', () => boot({ mode: 'auto' }));
         }
         readyState = 'configuring';
     }
@@ -7887,7 +8151,7 @@ up.boot = up.framework.boot;
 
 
 /***/ }),
-/* 81 */
+/* 84 */
 /***/ (() => {
 
 up.event = (function () {
@@ -7939,9 +8203,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);
@@ -7962,7 +8225,7 @@ up.event = (function () {
         return newEvent;
     }
     function executeEmitAttr(event, element) {
-        if (!isUnmodified(event)) {
+        if (isModified(event)) {
             return;
         }
         const eventType = e.attr(element, 'up-emit');
@@ -7991,7 +8254,7 @@ up.event = (function () {
         assertEmitted,
         onEscape,
         halt,
-        isUnmodified,
+        isModified,
         isSyntheticClick,
         fork,
         keyModifiers,
@@ -8004,14 +8267,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) {
@@ -8049,6 +8312,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);
     }
@@ -8084,21 +8350,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);
@@ -8110,6 +8381,7 @@ up.protocol = (function () {
         titleFromXHR,
         targetFromXHR,
         methodFromXHR,
+        openLayerFromXHR,
         acceptLayerFromXHR,
         contextFromXHR,
         dismissLayerFromXHR,
@@ -8123,13 +8395,13 @@ up.protocol = (function () {
         initialRequestMethod,
         headerize,
         wrapMethod,
-        cspNoncesFromHeader,
+        cspInfoFromHeader,
     };
 })();
 
 
 /***/ }),
-/* 83 */
+/* 86 */
 /***/ (() => {
 
 up.log = (function () {
@@ -8142,24 +8414,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() {
@@ -8210,7 +8484,7 @@ up.warn = up.log.warn;
 
 
 /***/ }),
-/* 84 */
+/* 87 */
 /***/ (() => {
 
 up.script = (function () {
@@ -8261,6 +8535,7 @@ up.script = (function () {
         '[up-expand]': -300,
         '[data-method]': -400,
         '[data-confirm]': -400,
+        '[up-keep]': 9999999999,
     };
     let registeredCompilers = [];
     let registeredMacros = [];
@@ -8392,16 +8667,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');
@@ -8419,6 +8719,7 @@ up.script = (function () {
         findAssets,
         assertAssetsOK,
         disableSubtree: disableScriptsInSubtree,
+        adoptNoncesInSubtree,
         isScript,
     };
 })();
@@ -8431,7 +8732,7 @@ up.attribute = up.script.attrCompiler;
 
 
 /***/ }),
-/* 85 */
+/* 88 */
 /***/ (() => {
 
 up.history = (function () {
@@ -8457,59 +8758,77 @@ 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) {
+        if (isLocation(location))
+            return;
+        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,
@@ -8527,28 +8846,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(location.hash, { strong: true });
+        }
+    }
     function findMetaTags(head = document.head) {
         return head.querySelectorAll(config.selector('metaTagSelectors'));
     }
@@ -8570,6 +8884,61 @@ 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 ({ mode }) {
+        trackCurrentLocation({ reason: null, alreadyHandled: true });
+        patchHistoryAPI();
+        adoptInitialHistoryEntry();
+        if (mode === 'auto') {
+            up.viewport.revealHash(location.hash, { strong: true });
+        }
+    });
+    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, {
@@ -8597,10 +8966,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 () {
@@ -8645,6 +9014,7 @@ up.fragment = (function () {
             saveScroll: true,
             saveFocus: true,
             focus: 'keep',
+            focusVisible: 'auto',
             abort: 'target',
             failOptions: true,
             feedback: true,
@@ -8659,12 +9029,13 @@ 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'],
         autoRevalidate: (response) => response.expired,
         skipResponse: defaultSkipResponse,
+        normalizeKeepHTML: defaultNormalizeKeepHTML
     }));
     u.delegate(config, ['mainTargets'], () => up.layer.config.any);
     function defaultSkipResponse({ response, expiredResponse }) {
@@ -8700,17 +9071,84 @@ up.fragment = (function () {
         const options = parseTargetAndOptions(args);
         return render({ ...options, navigate: true });
     });
+    function emitFragmentKeep(keepPlan) {
+        let { oldElement, newElement: newFragment, newData, renderOptions } = keepPlan;
+        const log = ['Keeping fragment %o', oldElement];
+        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 findKeepPlan(options) {
+        if (options.keep === false)
+            return;
+        const { oldElement, newElement } = options;
+        let oldElementMode = keepMode(oldElement);
+        if (!oldElementMode) {
+            return;
+        }
+        let partner;
+        let partnerSelector = up.fragment.toTarget(oldElement);
+        const lookupOpts = { layer: options.layer };
+        if (options.descendantsOnly) {
+            partner = up.fragment.get(newElement, partnerSelector, lookupOpts);
+        }
+        else {
+            partner = e.subtreeFirst(newElement, partnerSelector, lookupOpts);
+        }
+        if (!partner)
+            return;
+        let partnerMode = keepMode(partner);
+        if (partnerMode === false)
+            return;
+        let oldIdentity = keepIdentity(oldElement, oldElementMode);
+        let partnerIdentity = keepIdentity(partner, oldElementMode);
+        if (!u.isEqual(oldIdentity, partnerIdentity))
+            return;
+        const plan = {
+            oldElement,
+            newElement: partner,
+            newData: up.script.data(partner),
+            renderOptions: options,
+        };
+        if (emitFragmentKeep(plan).defaultPrevented)
+            return;
+        return plan;
+    }
+    function keepIdentity(element, mode = keepMode(element)) {
+        return element.upKeepIdentity ??= u.copy(buildKeepIdentity(element, mode));
+    }
+    function defaultNormalizeKeepHTML(html) {
+        let tagPattern = /<[^<]+>/g;
+        let attrs = ['up-etag', 'up-source', 'up-time', 'nonce', ...up.script.config.nonceableAttributes];
+        let attrPattern = new RegExp(`\\s+(${attrs.join('|')})="[^"]*"`, 'g');
+        let cleanTag = (match) => match.replace(attrPattern, '');
+        html = html.replace(tagPattern, cleanTag);
+        html = html.replace(/^[ \t]+/mg, '');
+        return html;
+    }
+    function buildKeepIdentity(element, mode) {
+        if (mode === 'same-html') {
+            return config.normalizeKeepHTML(element.outerHTML);
+        }
+        else if (mode === 'same-data') {
+            return up.data(element);
+        }
+        else {
+            return true;
+        }
+    }
+    up.macro('[up-keep]', (element) => keepIdentity(element));
+    function keepMode(element) {
+        return e.booleanOrStringAttr(element, 'up-keep');
+    }
     function emitFragmentInserted(element) {
+        if (element.upInserted)
+            return;
+        element.upInserted = true;
         return up.emit(element, 'up:fragment:inserted', {
             log: ['Inserted fragment %o', element],
         });
     }
-    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 });
-    }
     function emitFragmentDestroyed(fragment, options) {
         const log = options.log ?? ['Destroyed fragment %o', fragment];
         const parent = options.parent || document;
@@ -8786,7 +9224,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);
@@ -8843,8 +9281,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.`;
@@ -9064,7 +9502,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) {
@@ -9161,10 +9599,15 @@ 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));
         up.hello(documentElement);
+        documentElement.setAttribute('up-source', normalizeSource(location.href));
         if (!up.browser.canPushState()) {
             return up.warn('Cannot push history changes. Next render pass with history will load a full page.');
         }
@@ -9188,6 +9631,8 @@ up.fragment = (function () {
         emitInserted: emitFragmentInserted,
         emitDestroyed: emitFragmentDestroyed,
         emitKeep: emitFragmentKeep,
+        keepPlan: findKeepPlan,
+        defaultNormalizeKeepHTML,
         successKey,
         failKey,
         expandTargets,
@@ -9213,6 +9658,7 @@ up.fragment = (function () {
         insertTemp,
         provideNodes,
         cloneTemplate,
+        trackSelector,
     };
 })();
 up.reload = up.fragment.reload;
@@ -9225,7 +9671,7 @@ u.delegate(up, ['context'], () => up.layer.current);
 
 
 /***/ }),
-/* 87 */
+/* 90 */
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -9234,10 +9680,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;
@@ -9299,10 +9745,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, { 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() {
@@ -9374,7 +9835,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;
         }
@@ -9420,14 +9881,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 = {}) {
@@ -9468,7 +9931,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)
@@ -9496,22 +9960,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,
@@ -9524,7 +9976,7 @@ up.viewport = (function () {
         rootScrollbarWidth,
         saveScroll,
         restoreScroll,
-        resetScroll,
+        scrollTo,
         saveFocus,
         restoreFocus,
         absolutize,
@@ -9541,7 +9993,7 @@ up.reveal = up.viewport.reveal;
 
 
 /***/ }),
-/* 89 */
+/* 92 */
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -9550,27 +10002,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;
@@ -9601,7 +10048,7 @@ up.motion = (function () {
     }
     function animateNow(element, lastFrame, options) {
         if (up.migrate.loaded)
-            lastFrame = up.migrate.fixStyleProps(lastFrame);
+            lastFrame = up.migrate.fixSetStyleProps(lastFrame);
         options = { ...options, finishEvent: motionController.finishEvent };
         const cssTransition = new up.CSSTransition(element, lastFrame, options);
         return cssTransition.start();
@@ -9610,9 +10057,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);
     }
@@ -9663,27 +10107,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) {
@@ -9696,21 +10134,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) {
@@ -9725,16 +10160,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');
@@ -9744,9 +10169,8 @@ up.motion = (function () {
         return !animationOrTransition || animationOrTransition === 'none';
     }
     function registerOpacityAnimation(name, from, to) {
-        registerAnimation(name, function (element, options) {
-            element.style.opacity = 0;
-            e.setStyle(element, { opacity: from });
+        namedAnimations.put(name, function (element, options) {
+            element.style.opacity = from;
             return animateNow(element, { opacity: to }, options);
         });
     }
@@ -9765,12 +10189,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);
@@ -9793,19 +10217,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,
@@ -9821,10 +10245,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(() => ({
@@ -9836,7 +10260,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,
@@ -9863,6 +10287,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) {
@@ -9888,28 +10314,27 @@ 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 });
-            }
-            let hasCacheEntry = cache.get(request);
+            cache.expire(responseOrError.expireCache ?? false, { except: request });
+            cache.evict(responseOrError.evictCache ?? false, { except: request });
             let isResponse = responseOrError instanceof up.Response;
             let isNetworkError = !isResponse;
             let isSuccessResponse = isResponse && responseOrError.ok;
             let isErrorResponse = isResponse && !responseOrError.ok;
             let isEmptyResponse = isResponse && responseOrError.none;
+            let redirectRequest = isResponse && responseOrError.redirectRequest;
             if (isErrorResponse) {
                 cache.evict(request.url);
             }
             else if (isNetworkError || isEmptyResponse) {
                 cache.evict(request);
             }
-            else if (isSuccessResponse && hasCacheEntry) {
-                cache.put(request);
+            else if (isSuccessResponse) {
+                if (cache.get(request)) {
+                    cache.put(request);
+                }
+                if (redirectRequest && (redirectRequest.willCache() || cache.get(redirectRequest))) {
+                    cache.put(redirectRequest);
+                }
             }
         });
     }
@@ -9923,16 +10348,6 @@ up.network = (function () {
         up.migrate.preprocessAbortArgs?.(args);
         queue.abort(...args);
     }
-    function registerAliasForRedirect(request, response) {
-        if (request.cache && response.url && request.url !== response.url) {
-            const newRequest = u.variant(request, {
-                method: response.method,
-                url: response.url,
-                cacheRoute: null,
-            });
-            cache.alias(request, newRequest);
-        }
-    }
     function isSafeMethod(method) {
         return u.contains(['GET', 'OPTIONS', 'HEAD'], u.normalizeMethod(method));
     }
@@ -9954,7 +10369,6 @@ up.network = (function () {
         isSafeMethod,
         config,
         abort: abortRequests,
-        registerAliasForRedirect,
         queue,
         loadPage,
     };
@@ -9964,7 +10378,7 @@ up.cache = up.network.cache;
 
 
 /***/ }),
-/* 92 */
+/* 95 */
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -9973,10 +10387,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 () {
@@ -10151,7 +10565,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)) {
@@ -10221,7 +10635,7 @@ up.layer = (function () {
 
 
 /***/ }),
-/* 94 */
+/* 97 */
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -10230,14 +10644,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';
@@ -10267,7 +10683,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));
@@ -10289,6 +10707,7 @@ up.link = (function () {
         parser.string('contentType');
         parser.booleanOrNumber('lateDelay');
         parser.number('timeout');
+        parser.booleanOrString('fail');
         return options;
     }
     function followOptions(link, options, parserOptions) {
@@ -10297,7 +10716,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');
@@ -10331,9 +10749,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');
@@ -10363,9 +10784,9 @@ up.link = (function () {
             abortable: false,
             background: true,
             cache: true,
+            ...options,
             ...up.RenderOptions.NO_INPUT_INTERFERENCE,
             ...up.RenderOptions.NO_PREVIEWS,
-            ...options,
             guardEvent,
             preload: true,
         });
@@ -10424,27 +10845,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);
     }
@@ -10540,7 +10971,7 @@ up.deferred = { load: up.link.loadDeferred };
 
 
 /***/ }),
-/* 96 */
+/* 99 */
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -10549,7 +10980,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 /***/ }),
-/* 97 */
+/* 100 */
 /***/ (() => {
 
 up.form = (function () {
@@ -10562,12 +10993,15 @@ 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'],
+        arrayParam: (name) => name.endsWith('[]'),
     }));
     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());
@@ -10578,11 +11012,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());
     }
@@ -10617,8 +11057,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;
@@ -10632,15 +11074,22 @@ 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.json('params');
+        parser.json('headers');
+        parser.include(watchOptions, { defaults: { event: 'change' } });
+        return options;
     }
-    function disableControl(control) {
+    function disableContainerTemp(container) {
+        let controls = findFieldsAndButtons(container);
+        return u.sequence(u.map(controls, disableControlTemp));
+    }
+    function disableControlTemp(control) {
         if (control.disabled)
             return;
         let focusFallback;
@@ -10655,7 +11104,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()];
         }
@@ -10680,6 +11129,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);
@@ -10693,8 +11147,7 @@ up.form = (function () {
             options.method ||= submitButton.getAttribute('formmethod');
             options.url ||= submitButton.getAttribute('formaction');
         }
-        params.addAll(options.params);
-        options.params = params;
+        options.params = up.Params.merge(params, options.params);
         parser.string('url', { attr: 'action', default: up.fragment.source(form) });
         parser.string('method', {
             attr: ['up-method', 'data-method', 'method'],
@@ -10711,8 +11164,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');
@@ -10722,7 +11174,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;
@@ -10750,7 +11202,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) {
@@ -10763,88 +11216,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;
         }
@@ -10852,6 +11237,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 region = getRegion(root);
+            return u.filter(fields, function (field) {
+                return (root === region || root.contains(field))
+                    && (getRegion(field) === region)
+                    && (!guard || guard(field));
+            });
+        };
+        const live = true;
+        return up.fragment.trackSelector(fieldSelector(), { filter, live }, callback);
+    }
     function focusedField() {
         return u.presence(document.activeElement, isField);
     }
@@ -10866,49 +11264,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;
@@ -10918,13 +11306,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'],
@@ -10932,30 +11319,39 @@ up.status = (function () {
         navSelectors: ['[up-nav]', 'nav'],
         noNavSelectors: ['[up-nav=false]'],
     }));
-    function reset() {
-        up.layer.root.feedbackLocation = null;
-        namedPreviewFns = u.pickBy(namedPreviewFns, 'isDefault');
-    }
+    let namedPreviewFns = new up.Registry('preview');
     const SELECTOR_LINK = 'a, [up-href]';
     function linkCurrentURLs(link) {
         return link.upCurrentURLs ||= new up.LinkCurrentURLs(link);
     }
-    function updateFragment(fragment, { layer } = {}) {
-        layer ||= up.layer.get(fragment);
-        let layerLocation = getMatchableLayerLocation(layer);
-        const navSelector = config.selector('navSelectors');
-        const navLinkSelector = `${navSelector} :is(${SELECTOR_LINK}), ${navSelector}:is(${SELECTOR_LINK})`;
-        const links = up.fragment.all(navLinkSelector, { layer });
-        for (let link of links) {
-            const isCurrent = linkCurrentURLs(link).isCurrent(layerLocation);
-            for (let currentClass of config.currentClasses) {
-                link.classList.toggle(currentClass, isCurrent);
+    function getNavLocations(nav) {
+        let layerRef = e.attr(nav, 'up-layer') || 'origin';
+        let layers = up.layer.getAll(layerRef, { origin: nav });
+        return u.compact(layers.map(getMatchableLayerLocation));
+    }
+    function updateNav(nav, links, { newLinks, anyLocationChanged }) {
+        let currentLocations = (!anyLocationChanged && nav.upNavLocations) || getNavLocations(nav);
+        if (newLinks || !u.isEqual(nav.upNavLocations, currentLocations)) {
+            for (let link of links) {
+                const isCurrent = linkCurrentURLs(link).isAnyCurrent(currentLocations);
+                for (let currentClass of config.currentClasses) {
+                    link.classList.toggle(currentClass, isCurrent);
+                }
+                e.setAttrPresence(link, 'aria-current', 'page', isCurrent);
             }
-            e.setAttrPresence(link, 'aria-current', 'page', isCurrent);
+            nav.upNavLocations = currentLocations;
+        }
+    }
+    function updateNavsAround(root, opts) {
+        const navSelector = config.selector('navSelectors');
+        const fullNavs = e.around(root, navSelector);
+        for (let fullNav of fullNavs) {
+            let links = e.subtree(fullNav, SELECTOR_LINK);
+            updateNav(fullNav, links, opts);
         }
     }
     function getMatchableLayerLocation(layer) {
-        return layer.feedbackLocation || u.matchableURL(layer.location);
+        return u.matchableURL(layer.location);
     }
     function findActivatableArea(element) {
         return e.ancestor(element, SELECTOR_LINK) || element;
@@ -11010,7 +11406,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);
@@ -11021,10 +11417,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;
@@ -11043,33 +11435,15 @@ up.status = (function () {
         parser.string('placeholder');
         return options;
     }
-    function updateLayerIfLocationChanged(layer) {
-        const processedLocation = layer.feedbackLocation;
-        const layerLocation = getMatchableLayerLocation(layer.location);
-        if (!processedLocation || (processedLocation !== layerLocation)) {
-            layer.feedbackLocation = layerLocation;
-            updateFragment(layer.element, { layer });
-        }
-    }
-    function onBrowserLocationChanged() {
-        const frontLayer = up.layer.front;
-        if (frontLayer.showsLiveHistory()) {
-            updateLayerIfLocationChanged(frontLayer);
-        }
-    }
-    up.on('up:location:changed', (_event) => {
-        onBrowserLocationChanged();
-    });
     up.on('up:fragment:compile', (_event, newFragment) => {
-        updateFragment(newFragment);
+        updateNavsAround(newFragment, { newLinks: true, anyLocationChanged: false });
     });
-    up.on('up:layer:location:changed', (event) => {
-        updateLayerIfLocationChanged(event.layer);
+    up.on('up:layer:location:changed up:layer:opened up:layer:dismissed up:layer:accepted', () => {
+        updateNavsAround(document.body, { newLinks: false, anyLocationChanged: true });
     });
-    up.on('up:framework:reset', reset);
     return {
         config,
-        preview: registerPreview,
+        preview: namedPreviewFns.put,
         resolvePreviewFns,
         runPreviews,
         statusOptions,
@@ -11079,7 +11453,7 @@ up.preview = up.status.preview;
 
 
 /***/ }),
-/* 99 */
+/* 102 */
 /***/ (() => {
 
 up.radio = (function () {
@@ -11173,7 +11547,7 @@ up.radio = (function () {
 
 
 /***/ }),
-/* 100 */
+/* 103 */
 /***/ (() => {
 
 (function () {
@@ -11236,7 +11610,7 @@ up.radio = (function () {
 /******/ 	
 /************************************************************************/
 var __webpack_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
 (() => {
 __webpack_require__(1);
 __webpack_require__(2);
@@ -11323,15 +11697,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();
 
 })();