unpoly-rails 3.10.2 → 3.11.0.rc12

data/assets/unpoly/unpoly.es6.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,50 +179,50 @@ 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) {
+    function isElementLike(value) {
         var _a;
-        return !!(object && (object.addEventListener || (isJQuery(object) && ((_a = object[0]) === null || _a === void 0 ? void 0 : _a.addEventListener))));
+        return !!(value && (value.addEventListener || (isJQuery(value) && ((_a = value[0]) === null || _a === void 0 ? void 0 : _a.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);
@@ -390,13 +389,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];
@@ -426,7 +427,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];
             }
         }
@@ -463,7 +464,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, '\\$&');
@@ -492,9 +493,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 = [];
@@ -529,34 +530,36 @@ up.util = (function () {
         return Object.prototype.hasOwnProperty(k);
     }
     function isEqual(a, b) {
+        if (a === b) {
+            return true;
+        }
         if (a === null || a === void 0 ? void 0 : a.valueOf) {
             a = a.valueOf();
         }
         if (b === null || b === void 0 ? void 0 : 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) {
@@ -613,7 +616,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);
@@ -797,36 +800,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;
         };
@@ -840,6 +846,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
@@ -868,6 +875,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,
@@ -885,6 +903,7 @@ up.util = (function () {
         map,
         flatMap,
         mapObject,
+        spanObject,
         findResult,
         some,
         every,
@@ -975,6 +994,7 @@ up.util = (function () {
         maskPattern,
         expressionOutline,
         parseString,
+        assert,
     };
 })();
 
@@ -1089,12 +1109,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);
@@ -1202,7 +1223,7 @@ up.element = (function () {
     function metaContent(name) {
         var _a;
         const selector = "meta" + attrSelector('name', name);
-        return (_a = first(selector)) === null || _a === void 0 ? void 0 : _a.getAttribute('content');
+        return (_a = document.head.querySelector(selector)) === null || _a === void 0 ? void 0 : _a.getAttribute('content');
     }
     function insertBefore(existingNode, newNode) {
         existingNode.parentNode.insertBefore(newNode, existingNode);
@@ -1312,7 +1333,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();
     }
@@ -1340,9 +1361,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));
@@ -1539,7 +1562,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);
         }
@@ -1549,7 +1572,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);
         }
@@ -1651,7 +1674,7 @@ up.element = (function () {
         attrSelector,
         tagName: elementTagName,
         createBrokenDocumentFromHTML,
-        fixParserDamage,
+        revivedClone,
         createNodesFromHTML,
         createFromHTML,
         extractSingular,
@@ -1783,7 +1806,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());
@@ -1862,13 +1885,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-';
@@ -1904,11 +1953,11 @@ up.OptionsParser = class OptionsParser {
             value !== null && value !== void 0 ? value : (value = this._parseFromAttr(attrValueFn, this._element, attrName));
         }
         value !== null && value !== void 0 ? value : (value = (_b = keyOptions.default) !== null && _b !== void 0 ? _b : 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;
@@ -1917,8 +1966,8 @@ up.OptionsParser = class OptionsParser {
             this.parse(attrValueFn, failKey, Object.assign(Object.assign({}, keyOptions), { attr: failAttrNames }));
         }
     }
-    include(optionsFn) {
-        let fnResult = optionsFn(this._element, this._options, this._parserOptions);
+    include(optionsFn, parserOptions) {
+        let fnResult = optionsFn(this._element, this._options, Object.assign({ defaults: this._defaults }, parserOptions));
         Object.assign(this._options, fnResult);
     }
     _parseFromAttr(attrValueFn, element, attrName) {
@@ -1945,7 +1994,7 @@ up.OptionsParser = class OptionsParser {
 
 
 /***/ }),
-/* 20 */
+/* 21 */
 /***/ (() => {
 
 const u = up.util;
@@ -1974,7 +2023,7 @@ up.FIFOCache = class FIFOCache {
 
 
 /***/ }),
-/* 21 */
+/* 22 */
 /***/ (() => {
 
 up.Rect = class Rect extends up.Record {
@@ -2005,7 +2054,7 @@ up.Rect = class Rect extends up.Record {
 
 
 /***/ }),
-/* 22 */
+/* 23 */
 /***/ (() => {
 
 const e = up.element;
@@ -2053,7 +2102,7 @@ up.BodyShifter = class BodyShifter {
 
 
 /***/ }),
-/* 23 */
+/* 24 */
 /***/ (() => {
 
 const u = up.util;
@@ -2079,7 +2128,7 @@ up.Change = class Change {
 
 
 /***/ }),
-/* 24 */
+/* 25 */
 /***/ (() => {
 
 const u = up.util;
@@ -2147,14 +2196,14 @@ 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 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -2169,8 +2218,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 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();
@@ -2180,9 +2229,9 @@ up.RenderJob = (_a = class RenderJob {
             return __awaiter(this, void 0, void 0, function* () {
                 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 = yield this._getChange().execute();
                     this._handleResult(result);
                     return result;
@@ -2195,7 +2244,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 === null || onRendered === void 0 ? void 0 : onRendered(result));
                 let guardedOnFinished = function (result) {
@@ -2208,7 +2257,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(() => { var _b, _c; return (_c = (_b = this.options).onError) === null || _c === void 0 ? void 0 : _c.call(_b, error); });
+            up.error.guard(() => { var _b, _c; return (_c = (_b = this.renderOptions).onError) === null || _c === void 0 ? void 0 : _c.call(_b, error); });
         }
         get finished() {
             return this._awaitFinished();
@@ -2231,7 +2280,7 @@ up.RenderJob = (_a = class RenderJob {
         }
         _getChange() {
             let handleAbort = u.memoize((request) => this._handleAbortOption(request));
-            let renderOptions = Object.assign(Object.assign({}, this.options), { handleAbort });
+            let renderOptions = Object.assign(Object.assign({}, this.renderOptions), { handleAbort });
             if (renderOptions.url) {
                 return new up.Change.FromURL(renderOptions);
             }
@@ -2243,16 +2292,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();
@@ -2290,7 +2339,7 @@ up.RenderJob = (_a = class RenderJob {
 
 
 /***/ }),
-/* 26 */
+/* 27 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -2326,20 +2375,20 @@ up.Change.DestroyFragment = class DestroyFragment extends up.Change {
         return __awaiter(this, void 0, void 0, function* () {
             this._emitDestroyed();
             yield this._animate();
-            this._wipe();
+            this._erase();
             (_a = this._onFinished) === null || _a === void 0 ? void 0 : _a.call(this);
         });
     }
     _destroyNow() {
         var _a;
-        this._wipe();
+        this._erase();
         this._emitDestroyed();
         (_a = this._onFinished) === null || _a === void 0 ? void 0 : _a.call(this);
     }
     _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 });
@@ -2354,7 +2403,7 @@ up.Change.DestroyFragment = class DestroyFragment extends up.Change {
 
 
 /***/ }),
-/* 27 */
+/* 28 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -2417,6 +2466,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();
@@ -2426,14 +2476,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, Object.assign(Object.assign({}, 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, Object.assign(Object.assign({}, this.options), { layer: this.layer, dataRoot: this._content }));
         this._handleScroll();
         this._newOverlayResult.finished = this._finish();
         this.layer.opening = false;
@@ -2444,7 +2495,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,
+        });
     }
     _finish() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -2456,7 +2510,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
     }
     _buildLayer() {
         const buildOptions = Object.assign(Object.assign({}, this.options), { opening: true });
-        const beforeNew = optionsWithLayerDefaults => {
+        const beforeNew = (optionsWithLayerDefaults) => {
             return this.options = up.RenderOptions.finalize(optionsWithLayerDefaults);
         };
         return up.layer.build(buildOptions, beforeNew);
@@ -2466,9 +2520,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;
-        (_a = this.layer).history && (_a.history = parent.history);
-        parent.saveHistory();
+        (_a = this.layer).history && (_a.history = this._baseLayer.history);
         this.layer.updateHistory(this.options);
     }
     _handleFocus() {
@@ -2513,7 +2565,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
 
 
 /***/ }),
-/* 28 */
+/* 29 */
 /***/ (() => {
 
 var _a;
@@ -2585,13 +2637,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();
@@ -2660,7 +2719,7 @@ up.Change.UpdateLayer = (_a = class UpdateLayer extends up.Change.Addition {
 
 
 /***/ }),
-/* 29 */
+/* 30 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -2677,31 +2736,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) {
-        var _a;
         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: (_a = this._steps[0]) === null || _a === void 0 ? void 0 : _a.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();
-    }
     _finish(motionEndPromises) {
         return __awaiter(this, void 0, void 0, function* () {
             yield Promise.all(motionEndPromises);
@@ -2716,26 +2774,23 @@ 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 = Object.assign(Object.assign({}, step), { beforeStart() {
                             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 });
                         }, afterDetach() {
@@ -2762,90 +2817,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(Object.assign(Object.assign({}, step), { oldElement: keepable, descendantsOnly: true }));
+                let keepPlan = up.fragment.keepPlan(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, options), { fragment, autoMeans: up.fragment.config.autoFocus }));
@@ -2859,7 +2888,7 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
 
 
 /***/ }),
-/* 30 */
+/* 31 */
 /***/ (() => {
 
 const u = up.util;
@@ -2939,7 +2968,7 @@ up.Change.CloseLayer = class CloseLayer extends up.Change {
 
 
 /***/ }),
-/* 31 */
+/* 32 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -2969,7 +2998,7 @@ up.Change.FromURL = (_a = class FromURL extends up.Change {
                     return request;
                 (_e = (_d = this.options).handleAbort) === null || _e === void 0 ? void 0 : _e.call(_d, request);
                 request.runPreviews(this.options);
-                return yield u.always(request, responseOrError => this._onRequestSettled(responseOrError));
+                return yield u.always(request, (responseOrError) => this._onRequestSettled(responseOrError));
             });
         }
         _newPageReason() {
@@ -3024,7 +3053,7 @@ up.Change.FromURL = (_a = class FromURL extends up.Change {
 
 
 /***/ }),
-/* 32 */
+/* 33 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -3064,7 +3093,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);
@@ -3140,6 +3169,11 @@ 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, Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, 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;
@@ -3154,7 +3188,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;
             (_b = renderOptions.time) !== null && _b !== void 0 ? _b : (renderOptions.time = this._response.lastModified);
             (_c = renderOptions.etag) !== null && _c !== void 0 ? _c : (renderOptions.etag = this._response.etag);
         }
@@ -3168,7 +3202,7 @@ up.Change.FromResponse = (_a = class FromResponse extends up.Change {
 
 
 /***/ }),
-/* 33 */
+/* 34 */
 /***/ (() => {
 
 var _a;
@@ -3213,9 +3247,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);
@@ -3242,7 +3274,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
                 'fragment',
                 'document',
                 'html',
-                'cspNonces',
+                'cspInfo',
                 'origin',
                 'data',
             ]);
@@ -3274,7 +3306,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() {
@@ -3292,7 +3324,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 {
@@ -3326,7 +3358,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
 
 
 /***/ }),
-/* 34 */
+/* 35 */
 /***/ (() => {
 
 const u = up.util;
@@ -3422,7 +3454,7 @@ up.CompilerPass = class CompilerPass {
 
 
 /***/ }),
-/* 35 */
+/* 36 */
 /***/ (() => {
 
 const u = up.util;
@@ -3529,7 +3561,7 @@ up.CSSTransition = class CSSTransition {
 
 
 /***/ }),
-/* 36 */
+/* 37 */
 /***/ (() => {
 
 const u = up.util;
@@ -3552,7 +3584,7 @@ up.DestructorPass = class DestructorPass {
 
 
 /***/ }),
-/* 37 */
+/* 38 */
 /***/ (() => {
 
 const u = up.util;
@@ -3652,7 +3684,7 @@ up.EventEmitter = class EventEmitter extends up.Record {
 
 
 /***/ }),
-/* 38 */
+/* 39 */
 /***/ (() => {
 
 const u = up.util;
@@ -3705,7 +3737,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;
@@ -3759,7 +3792,7 @@ up.EventListener = class EventListener extends up.Record {
 
 
 /***/ }),
-/* 39 */
+/* 40 */
 /***/ (() => {
 
 const u = up.util;
@@ -3805,7 +3838,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;
@@ -3825,14 +3858,64 @@ up.EventListenerGroup = class EventListenerGroup extends up.Record {
         }
         const options = u.extractOptions(args);
         const selector = args[0];
-        const attributes = Object.assign(Object.assign({ elements, eventTypes, selector, callback }, options), defaults);
+        const attributes = Object.assign(Object.assign({ elements, eventTypes, selector, callback }, options), overrides);
         return new (this)(attributes);
     }
 };
 
 
 /***/ }),
-/* 40 */
+/* 41 */
+/***/ (() => {
+
+const u = up.util;
+up.SelectorTracker = class SelectorTracker {
+    constructor(selector, options, addCallback) {
+        var _a;
+        this._selector = selector;
+        this._addCallback = addCallback;
+        this._layer = options.layer || 'any';
+        this._filter = options.filter || u.identity;
+        this._live = (_a = options.live) !== null && _a !== void 0 ? _a : 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 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -3847,42 +3930,52 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const u = up.util;
 up.FieldWatcher = class FieldWatcher {
     constructor(root, options, callback) {
+        var _a;
         this._options = options;
         this._root = root;
-        this._scope = up.form.getScope(root);
         this._callback = callback;
         this._batch = options.batch;
+        this._logPrefix = (_a = options.logPrefix) !== null && _a !== void 0 ? _a : '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;
@@ -3908,7 +4001,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);
@@ -3954,20 +4047,116 @@ 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() {
+        var _a, _b;
+        let callback = () => this._onFieldChanged();
+        return ((_b = (_a = up.migrate).watchForSwitch) === null || _b === void 0 ? void 0 : _b.call(_a, 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 === null || scope === void 0 ? void 0 : 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() {
+        var _a;
+        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 ((_a = fields[0]) === null || _a === void 0 ? void 0 : _a.matches('[type=radio], [type=checkbox]')) {
+            let anyChecked = u.some(fields, 'checked');
+            tokens.push(anyChecked ? ':checked' : ':unchecked');
+        }
+        return tokens;
+    }
+};
+
+
+/***/ }),
+/* 44 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -3998,41 +4187,52 @@ 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);
+        var _a;
+        let newSolutions = this._getSolutions(options);
+        this._dirtySolutions.push(...newSolutions);
         this._scheduleNextRender();
-        return this._nextRenderPromise;
+        return (_a = newSolutions[0]) === null || _a === void 0 ? void 0 : _a.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;
     }
@@ -4085,9 +4285,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;
@@ -4108,14 +4305,15 @@ 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));
-                yield renderingPromise;
+                let renderPromise = up.render(renderOptions);
+                for (let solution of solutionsBatch) {
+                    solution.deferred.resolve(renderPromise);
+                }
+                yield renderPromise;
             }
             finally {
                 this._rendering = false;
@@ -4123,20 +4321,39 @@ up.FormValidator = class FormValidator {
             }
         });
     }
+    _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) {
         var _a;
         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;
         (_a = options.focus) !== null && _a !== void 0 ? _a : (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;
@@ -4164,15 +4381,11 @@ up.FormValidator = class FormValidator {
             value = ':unknown';
         headers[key] = value;
     }
-    static forElement(element) {
-        let form = up.form.get(element);
-        return form.upFormValidator || (form.upFormValidator = new this(form));
-    }
 };
 
 
 /***/ }),
-/* 42 */
+/* 45 */
 /***/ (() => {
 
 up.FocusCapsule = class FocusCapsule {
@@ -4211,7 +4424,7 @@ up.FocusCapsule = class FocusCapsule {
 
 
 /***/ }),
-/* 43 */
+/* 46 */
 /***/ (() => {
 
 const u = up.util;
@@ -4254,7 +4467,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') {
@@ -4276,7 +4489,7 @@ up.FragmentProcessor = class FragmentProcessor extends up.Record {
 
 
 /***/ }),
-/* 44 */
+/* 47 */
 /***/ (() => {
 
 const u = up.util;
@@ -4327,7 +4540,7 @@ up.FragmentFinder = class FragmentFinder {
 
 
 /***/ }),
-/* 45 */
+/* 48 */
 /***/ (() => {
 
 const u = up.util;
@@ -4337,6 +4550,7 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
     keys() {
         return super.keys().concat([
             'hash',
+            'focusVisible',
             'focusCapsule',
             'inputDevice',
         ]);
@@ -4394,7 +4608,7 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
     }
     _focusElement(element) {
         if (element) {
-            up.focus(element, Object.assign(Object.assign({ force: true }, PREVENT_SCROLL_OPTIONS), { inputDevice: this.inputDevice }));
+            up.focus(element, Object.assign(Object.assign({ force: true }, PREVENT_SCROLL_OPTIONS), { inputDevice: this.inputDevice, focusVisible: this.focusVisible }));
             return true;
         }
     }
@@ -4412,7 +4626,7 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
 
 
 /***/ }),
-/* 46 */
+/* 49 */
 /***/ (() => {
 
 const e = up.element;
@@ -4453,7 +4667,7 @@ up.FragmentPolling = class FragmentPolling {
         if (this._state === 'started') {
             this._clearReloadTimer();
             this._state = 'stopped';
-            (_a = this.unbindEvents) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_a = this._unbindEvents) === null || _a === void 0 ? void 0 : _a.call(this);
         }
     }
     forceStart(options) {
@@ -4466,8 +4680,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() {
@@ -4499,6 +4713,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;
@@ -4570,7 +4789,7 @@ up.FragmentPolling = class FragmentPolling {
 
 
 /***/ }),
-/* 47 */
+/* 50 */
 /***/ (() => {
 
 const u = up.util;
@@ -4587,8 +4806,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':
@@ -4623,9 +4844,8 @@ up.FragmentScrolling = class FragmentScrolling extends up.FragmentProcessor {
     _revealLayer() {
         return this._revealElement(this.layer.getBoxElement());
     }
-    _reset() {
-        up.viewport.resetScroll(Object.assign(Object.assign({}, this.attributes()), { around: this.fragment }));
-        return true;
+    _scrollTo(position) {
+        return up.viewport.scrollTo(position, Object.assign(Object.assign({}, this.attributes()), { around: this.fragment }));
     }
     _restore() {
         return up.viewport.restoreScroll(Object.assign(Object.assign({}, this.attributes()), { around: this.fragment }));
@@ -4634,7 +4854,7 @@ up.FragmentScrolling = class FragmentScrolling extends up.FragmentProcessor {
 
 
 /***/ }),
-/* 48 */
+/* 51 */
 /***/ (() => {
 
 const e = up.element;
@@ -4660,14 +4880,16 @@ 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() {
+        var _a;
+        (_a = this._unbindLocationChanged) === null || _a === void 0 ? void 0 : _a.call(this);
     }
-    teardownHandlers() { }
     mainTargets() {
         return up.layer.mainTargets(this.mode);
     }
@@ -4767,28 +4989,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) {
@@ -4797,32 +5019,37 @@ up.Layer = class Layer extends up.Record {
     updateHistory(options) {
         var _a, _b;
         if (u.isString(options.location)) {
-            this.location = options.location;
+            this._updateLocation(options.location, { push: true });
         }
         if (up.history.config.updateMetaTags && u.isList(options.metaTags)) {
             (_b = (_a = up.migrate) === null || _a === void 0 ? void 0 : _a.warnOfHungryMetaTags) === null || _b === void 0 ? void 0 : _b.call(_a, 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;
         }
@@ -4832,11 +5059,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);
         }
@@ -4846,11 +5073,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);
         }
@@ -4860,20 +5087,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) {
@@ -4902,7 +5127,7 @@ up.Layer = class Layer extends up.Record {
 
 
 /***/ }),
-/* 49 */
+/* 52 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -5012,14 +5237,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);
@@ -5028,17 +5253,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);
             });
             (_c = (_b = up.migrate).registerLayerCloser) === null || _c === void 0 ? void 0 : _c.call(_b, 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) {
@@ -5073,26 +5298,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 }));
             });
@@ -5113,8 +5350,8 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
         teardownHandlers() {
             var _b, _c;
             super.teardownHandlers();
-            (_b = this.unbindParentClicked) === null || _b === void 0 ? void 0 : _b.call(this);
-            (_c = this.unbindEscapePressed) === null || _c === void 0 ? void 0 : _c.call(this);
+            (_b = this._unbindParentClicked) === null || _b === void 0 ? void 0 : _b.call(this);
+            (_c = this._unbindEscapePressed) === null || _c === void 0 ? void 0 : _c.call(this);
             this.overlayFocus.teardown();
         }
         destroyElements(options) {
@@ -5201,11 +5438,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 {
@@ -5244,7 +5482,7 @@ up.Layer.OverlayWithTether = class OverlayWithTether extends up.Layer.Overlay {
 
 
 /***/ }),
-/* 51 */
+/* 54 */
 /***/ (() => {
 
 up.Layer.OverlayWithViewport = class OverlayWithViewport extends up.Layer.Overlay {
@@ -5273,7 +5511,7 @@ up.Layer.OverlayWithViewport = class OverlayWithViewport extends up.Layer.Overla
 
 
 /***/ }),
-/* 52 */
+/* 55 */
 /***/ (() => {
 
 var _a;
@@ -5319,7 +5557,7 @@ up.Layer.Root = (_a = class Root extends up.Layer {
 
 
 /***/ }),
-/* 53 */
+/* 56 */
 /***/ (() => {
 
 var _a;
@@ -5330,7 +5568,7 @@ up.Layer.Modal = (_a = class Modal extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 54 */
+/* 57 */
 /***/ (() => {
 
 var _a;
@@ -5341,7 +5579,7 @@ up.Layer.Popup = (_a = class Popup extends up.Layer.OverlayWithTether {
 
 
 /***/ }),
-/* 55 */
+/* 58 */
 /***/ (() => {
 
 var _a;
@@ -5352,7 +5590,7 @@ up.Layer.Drawer = (_a = class Drawer extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 56 */
+/* 59 */
 /***/ (() => {
 
 var _a;
@@ -5363,7 +5601,7 @@ up.Layer.Cover = (_a = class Cover extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 57 */
+/* 60 */
 /***/ (() => {
 
 var _a;
@@ -5379,7 +5617,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;
@@ -5394,7 +5632,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);
@@ -5476,7 +5714,7 @@ up.LayerLookup = (_a = class LayerLookup {
 
 
 /***/ }),
-/* 58 */
+/* 61 */
 /***/ (() => {
 
 const u = up.util;
@@ -5590,7 +5828,7 @@ up.LayerStack = class LayerStack {
 
 
 /***/ }),
-/* 59 */
+/* 62 */
 /***/ (() => {
 
 const u = up.util;
@@ -5621,11 +5859,19 @@ up.LinkCurrentURLs = class LinkCurrentURLs {
             this._upHREF === normalizedLocation ||
             ((_b = (_a = this._aliasPattern) === null || _a === void 0 ? void 0 : _a.test) === null || _b === void 0 ? void 0 : _b.call(_a, normalizedLocation, false)));
     }
+    isAnyCurrent(normalizedLocations) {
+        return normalizedLocations.some((normalizedLocation) => {
+            var _a, _b;
+            return (this._href === normalizedLocation ||
+                this._upHREF === normalizedLocation ||
+                ((_b = (_a = this._aliasPattern) === null || _a === void 0 ? void 0 : _a.test) === null || _b === void 0 ? void 0 : _b.call(_a, normalizedLocation, false)));
+        });
+    }
 };
 
 
 /***/ }),
-/* 60 */
+/* 63 */
 /***/ (() => {
 
 const u = up.util;
@@ -5668,13 +5914,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 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -5727,7 +5975,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);
@@ -5783,10 +6031,9 @@ up.MotionController = class MotionController {
 
 
 /***/ }),
-/* 62 */
+/* 65 */
 /***/ (() => {
 
-const u = up.util;
 const e = up.element;
 up.NonceableCallback = class NonceableCallback {
     constructor(script, nonce) {
@@ -5840,37 +6087,11 @@ up.NonceableCallback = class NonceableCallback {
             }
         }
     }
-    _allowedBy(allowedNonces) {
-        return this.nonce && u.contains(allowedNonces, this.nonce);
-    }
-    static adoptNonces(element, allowedNonces) {
-        if (!(allowedNonces === null || allowedNonces === void 0 ? void 0 : 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;
@@ -5892,7 +6113,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]');
         }
@@ -5943,7 +6164,7 @@ up.OverlayFocus = class OverlayFocus {
 
 
 /***/ }),
-/* 64 */
+/* 67 */
 /***/ (() => {
 
 const u = up.util;
@@ -5989,15 +6210,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 += "=";
@@ -6005,12 +6223,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()];
@@ -6040,9 +6261,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];
@@ -6080,7 +6307,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)) {
@@ -6095,16 +6322,11 @@ up.Params = class Params {
         return entry === null || entry === void 0 ? void 0 : 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;
@@ -6167,17 +6389,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;
@@ -6248,7 +6474,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');
@@ -6305,7 +6531,7 @@ up.Preview = class Preview {
 
 
 /***/ }),
-/* 66 */
+/* 69 */
 /***/ (() => {
 
 const e = up.element;
@@ -6355,7 +6581,7 @@ up.ProgressBar = class ProgressBar {
 
 
 /***/ }),
-/* 67 */
+/* 70 */
 /***/ (() => {
 
 const u = up.util;
@@ -6452,7 +6678,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 = '';
             }
@@ -6473,12 +6699,13 @@ up.RenderOptions = (function () {
         return overrides;
     }
     function deriveFailOptions(preprocessedOptions) {
+        let markFailure = { didFail: true };
         let overrides = failOverrides(preprocessedOptions);
         if (preprocessedOptions.failOptions) {
-            return Object.assign(Object.assign(Object.assign(Object.assign({}, preprocessedOptions.defaults), u.pick(preprocessedOptions, SHARED_KEYS)), overrides), { failPrefixForced: true });
+            return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, preprocessedOptions.defaults), u.pick(preprocessedOptions, SHARED_KEYS)), overrides), { didForceFailOptions: true }), markFailure);
         }
         else {
-            return Object.assign(Object.assign({}, preprocessedOptions), overrides);
+            return Object.assign(Object.assign(Object.assign({}, preprocessedOptions), overrides), markFailure);
         }
     }
     return {
@@ -6494,7 +6721,7 @@ up.RenderOptions = (function () {
 
 
 /***/ }),
-/* 68 */
+/* 71 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -6512,13 +6739,14 @@ up.RenderResult = class RenderResult extends up.Record {
             'fragments',
             'layer',
             'target',
-            'options',
+            'renderOptions',
             'finished',
         ];
     }
     defaults() {
         return {
             fragments: [],
+            finished: Promise.resolve(),
         };
     }
     get none() {
@@ -6527,33 +6755,25 @@ 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,
-            fragments: main.fragments.concat(extension.fragments),
-            finished: (mergeFinished && this.mergeFinished(main, extension))
-        });
+        }
+        return new this(Object.assign(Object.assign({}, main), { fragments: main.fragments.concat(extension.fragments), finished: (mergeFinished && this.mergeFinished(main, extension)) }));
     }
     static mergeFinished(main, extension) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.both(yield main.finished, yield extension.finished, false);
         });
     }
-    static buildNone() {
-        return new this({
-            target: ':none',
-            finished: Promise.resolve(),
-        });
-    }
 };
 
 
 /***/ }),
-/* 69 */
+/* 72 */
 /***/ (() => {
 
 var _a;
@@ -6580,6 +6800,8 @@ up.Request = (_a = class Request extends up.Record {
                 'failMode',
                 'failContext',
                 'origin',
+                'originLayer',
+                'originMode',
                 'builtAt',
                 'wrapMethod',
                 'contentType',
@@ -6592,31 +6814,32 @@ 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) {
-            var _b, _c;
+            var _b, _c, _d;
             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.context = this.layer.context || {});
-                this.failContext || (this.failContext = ((_b = this.failLayer) === null || _b === void 0 ? void 0 : _b.context) || {});
                 this.mode || (this.mode = this.layer.mode);
+                this.failLayer = up.layer.get(this.failLayer, layerLookupOptions);
+                this.failContext || (this.failContext = ((_b = this.failLayer) === null || _b === void 0 ? void 0 : _b.context) || {});
                 this.failMode || (this.failMode = (_c = this.failLayer) === null || _c === void 0 ? void 0 : _c.mode);
+                this.originLayer || (this.originLayer = up.layer.get(this.origin) || up.layer.current);
+                this.originMode || (this.originMode = (_d = this.originLayer) === null || _d === void 0 ? void 0 : _d.mode);
             }
             this.bindLayer = options.bindLayer || this.layer;
             this._fragments = options.fragments;
@@ -6666,8 +6889,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;
             });
@@ -6824,6 +7048,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),
@@ -6877,7 +7102,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;
@@ -6938,7 +7163,7 @@ up.Request = (_a = class Request extends up.Record {
 
 
 /***/ }),
-/* 70 */
+/* 73 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -7030,15 +7255,6 @@ up.Request.Cache = class Cache {
             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;
-    }
     track(existingRequest, newRequest, options = {}) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -7119,7 +7335,7 @@ up.Request.Cache = class Cache {
 
 
 /***/ }),
-/* 71 */
+/* 74 */
 /***/ (() => {
 
 const u = up.util;
@@ -7137,7 +7353,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());
@@ -7168,7 +7384,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 || (request = this._queuedRequests[0]);
         return u.remove(this._queuedRequests, request);
     }
@@ -7177,11 +7393,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());
     }
@@ -7230,7 +7443,7 @@ up.Request.Queue = class Queue {
 
 
 /***/ }),
-/* 72 */
+/* 75 */
 /***/ (() => {
 
 const u = up.util;
@@ -7241,7 +7454,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);
@@ -7269,7 +7482,7 @@ up.Request.FormRenderer = class FormRenderer {
 
 
 /***/ }),
-/* 73 */
+/* 76 */
 /***/ (() => {
 
 var _a;
@@ -7318,7 +7531,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;
@@ -7340,7 +7553,7 @@ up.Request.XHRRenderer = (_a = class XHRRenderer {
 
 
 /***/ }),
-/* 74 */
+/* 77 */
 /***/ (() => {
 
 const u = up.util;
@@ -7355,6 +7568,7 @@ up.Response = class Response extends up.Record {
             'xhr',
             'target',
             'title',
+            'openLayer',
             'acceptLayer',
             'dismissLayer',
             'eventPlans',
@@ -7369,7 +7583,7 @@ up.Response = class Response extends up.Record {
     defaults() {
         return {
             headers: {},
-            loadedAt: new Date()
+            loadedAt: new Date(),
         };
     }
     get ok() {
@@ -7390,8 +7604,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');
@@ -7416,19 +7631,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);
             }
@@ -7438,7 +7667,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) {
@@ -7467,9 +7696,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);
@@ -7507,7 +7733,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) {
@@ -7560,21 +7793,44 @@ 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) {
+            var _b;
+            let strategy = up.fragment.config.runScripts;
+            if (strategy === true && ((_b = this._cspInfo.declaration) === null || _b === void 0 ? void 0 : _b.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);
         }
     },
     (() => {
@@ -7586,7 +7842,7 @@ up.ResponseDoc = (_a = class ResponseDoc {
 
 
 /***/ }),
-/* 76 */
+/* 79 */
 /***/ (() => {
 
 const e = up.element;
@@ -7677,7 +7933,7 @@ up.RevealMotion = class RevealMotion {
 
 
 /***/ }),
-/* 77 */
+/* 80 */
 /***/ (() => {
 
 const u = up.util;
@@ -7700,7 +7956,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, Object.assign(Object.assign({}, options), { layer: expandTargetLayer }));
@@ -7735,7 +7991,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));
@@ -7747,7 +8003,7 @@ up.Selector = class Selector {
 
 
 /***/ }),
-/* 78 */
+/* 81 */
 /***/ (() => {
 
 const u = up.util;
@@ -7868,7 +8124,7 @@ up.Tether = class Tether {
 
 
 /***/ }),
-/* 79 */
+/* 82 */
 /***/ (() => {
 
 const u = up.util;
@@ -7942,7 +8198,7 @@ up.URLPattern = class URLPattern {
 
 
 /***/ }),
-/* 80 */
+/* 83 */
 /***/ (() => {
 
 up.framework = (function () {
@@ -7950,7 +8206,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;
@@ -7958,9 +8214,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);
@@ -7984,7 +8240,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';
     }
@@ -8031,7 +8287,7 @@ up.boot = up.framework.boot;
 
 
 /***/ }),
-/* 81 */
+/* 84 */
 /***/ (() => {
 
 up.event = (function () {
@@ -8083,9 +8339,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);
@@ -8106,7 +8361,7 @@ up.event = (function () {
         return newEvent;
     }
     function executeEmitAttr(event, element) {
-        if (!isUnmodified(event)) {
+        if (isModified(event)) {
             return;
         }
         const eventType = e.attr(element, 'up-emit');
@@ -8135,7 +8390,7 @@ up.event = (function () {
         assertEmitted,
         onEscape,
         halt,
-        isUnmodified,
+        isModified,
         isSyntheticClick,
         fork,
         keyModifiers,
@@ -8148,14 +8403,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) {
@@ -8195,6 +8450,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);
     }
@@ -8230,21 +8488,27 @@ 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) {
+        var _a;
+        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 = (_a = declaration.match(/^(script|default)-src:/)) === null || _a === void 0 ? void 0 : _a[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);
@@ -8256,6 +8520,7 @@ up.protocol = (function () {
         titleFromXHR,
         targetFromXHR,
         methodFromXHR,
+        openLayerFromXHR,
         acceptLayerFromXHR,
         contextFromXHR,
         dismissLayerFromXHR,
@@ -8269,13 +8534,13 @@ up.protocol = (function () {
         initialRequestMethod,
         headerize,
         wrapMethod,
-        cspNoncesFromHeader,
+        cspInfoFromHeader,
     };
 })();
 
 
 /***/ }),
-/* 83 */
+/* 86 */
 /***/ (() => {
 
 up.log = (function () {
@@ -8288,24 +8553,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() {
@@ -8356,7 +8623,7 @@ up.warn = up.log.warn;
 
 
 /***/ }),
-/* 84 */
+/* 87 */
 /***/ (() => {
 
 up.script = (function () {
@@ -8407,6 +8674,7 @@ up.script = (function () {
         '[up-expand]': -300,
         '[data-method]': -400,
         '[data-confirm]': -400,
+        '[up-keep]': 9999999999,
     };
     let registeredCompilers = [];
     let registeredMacros = [];
@@ -8534,16 +8802,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 === null || responseNonces === void 0 ? void 0 : 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');
@@ -8561,6 +8854,7 @@ up.script = (function () {
         findAssets,
         assertAssetsOK,
         disableSubtree: disableScriptsInSubtree,
+        adoptNoncesInSubtree,
         isScript,
     };
 })();
@@ -8573,7 +8867,7 @@ up.attribute = up.script.attrCompiler;
 
 
 /***/ }),
-/* 85 */
+/* 88 */
 /***/ (() => {
 
 up.history = (function () {
@@ -8599,60 +8893,78 @@ 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) {
+        var _a, _b;
+        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}`
+            });
+            (_b = (_a = up.migrate).prepareLocationChangedEvent) === null || _b === void 0 ? void 0 : _b.call(_a, locationChangedEvent);
+            if (reason) {
+                up.emit(locationChangedEvent);
+                reactToChange(locationChangedEvent);
+            }
         }
     }
-    trackCurrentLocation();
+    function splitLocation(location) {
+        return (location === null || location === void 0 ? void 0 : location.split(/(?=#)/)) || [];
+    }
+    function getBase(location) {
+        return splitLocation(location)[0];
+    }
     function isLocation(url, options) {
         return u.matchURLs(url, location.href, Object.assign({ 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) {
-        var _a, _b;
-        let event = up.event.build('up:location:changed', props);
-        (_b = (_a = up.migrate) === null || _a === void 0 ? void 0 : _a.renamedProperty) === null || _b === void 0 ? void 0 : _b.call(_a, 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 === null || state === void 0 ? void 0 : 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,
@@ -8670,28 +8982,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'));
     }
@@ -8713,6 +9020,62 @@ up.history = (function () {
     function updateLang(newLang) {
         e.setAttrPresence(e.root, 'lang', newLang, !!newLang);
     }
+    function patchHistoryAPI() {
+        const originalPushState = history.pushState;
+        history.pushState = function (...args) {
+            originalPushState.apply(this, args);
+            trackCurrentLocation({ reason: 'push', alreadyHandled: true });
+        };
+        const originalReplaceState = history.replaceState;
+        history.replaceState = function (...args) {
+            originalReplaceState.apply(this, args);
+            trackCurrentLocation({ reason: 'replace', alreadyHandled: true });
+        };
+    }
+    function adoptInitialHistoryEntry() {
+        if (up.protocol.initialRequestMethod() === 'GET') {
+            adopt();
+        }
+    }
+    up.on('up:framework:boot', function ({ 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) {
+        var _a;
+        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 = (_a = link.getAttribute('up-scroll-behavior')) !== null && _a !== void 0 ? _a : '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, {
@@ -8740,10 +9103,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 () {
@@ -8788,6 +9151,7 @@ up.fragment = (function () {
             saveScroll: true,
             saveFocus: true,
             focus: 'keep',
+            focusVisible: 'auto',
             abort: 'target',
             failOptions: true,
             feedback: true,
@@ -8802,12 +9166,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 }) {
@@ -8843,17 +9208,85 @@ up.fragment = (function () {
         const options = parseTargetAndOptions(args);
         return render(Object.assign(Object.assign({}, 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)) {
+        var _a;
+        return (_a = element.upKeepIdentity) !== null && _a !== void 0 ? _a : (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) {
         var _a;
         const log = (_a = options.log) !== null && _a !== void 0 ? _a : ['Destroyed fragment %o', fragment];
@@ -8931,7 +9364,7 @@ up.fragment = (function () {
     }
     function markFragmentAsDestroying(element) {
         element.classList.add('up-destroying');
-        element.setAttribute('aria-hidden', 'true');
+        element.setAttribute('inert', '');
     }
     function reload(...args) {
         var _a, _b;
@@ -8989,8 +9422,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.`;
@@ -9208,7 +9641,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) {
@@ -9306,10 +9739,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.');
         }
@@ -9333,6 +9771,8 @@ up.fragment = (function () {
         emitInserted: emitFragmentInserted,
         emitDestroyed: emitFragmentDestroyed,
         emitKeep: emitFragmentKeep,
+        keepPlan: findKeepPlan,
+        defaultNormalizeKeepHTML,
         successKey,
         failKey,
         expandTargets,
@@ -9358,6 +9798,7 @@ up.fragment = (function () {
         insertTemp,
         provideNodes,
         cloneTemplate,
+        trackSelector,
     };
 })();
 up.reload = up.fragment.reload;
@@ -9370,16 +9811,16 @@ u.delegate(up, ['context'], () => up.layer.current);
 
 
 /***/ }),
-/* 87 */
+/* 90 */
 /***/ (() => {
 
 
 
 /***/ }),
-/* 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;
@@ -9442,10 +9883,26 @@ up.viewport = (function () {
         doFocus(element, options);
         return element === document.activeElement;
     }
-    function revealHash(hash = location.hash, options) {
-        let match = firstHashTarget(hash, options);
+    function revealHash(...args) {
+        var _a;
+        return (_a = revealHashFn(...args)) === null || _a === void 0 ? void 0 : _a();
+    }
+    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() {
@@ -9517,7 +9974,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;
         }
@@ -9563,14 +10020,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 = {}) {
@@ -9612,7 +10071,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)
@@ -9640,22 +10100,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,
@@ -9668,7 +10116,7 @@ up.viewport = (function () {
         rootScrollbarWidth,
         saveScroll,
         restoreScroll,
-        resetScroll,
+        scrollTo,
         saveFocus,
         restoreFocus,
         absolutize,
@@ -9685,13 +10133,13 @@ up.reveal = up.viewport.reveal;
 
 
 /***/ }),
-/* 89 */
+/* 92 */
 /***/ (() => {
 
 
 
 /***/ }),
-/* 90 */
+/* 93 */
 /***/ (function() {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -9706,21 +10154,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 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;
@@ -9751,7 +10194,7 @@ up.motion = (function () {
     }
     function animateNow(element, lastFrame, options) {
         if (up.migrate.loaded)
-            lastFrame = up.migrate.fixStyleProps(lastFrame);
+            lastFrame = up.migrate.fixSetStyleProps(lastFrame);
         options = Object.assign(Object.assign({}, options), { finishEvent: motionController.finishEvent });
         const cssTransition = new up.CSSTransition(element, lastFrame, options);
         return cssTransition.start();
@@ -9761,9 +10204,6 @@ up.motion = (function () {
         (_a = options.easing) !== null && _a !== void 0 ? _a : (options.easing = config.easing);
         (_b = options.duration) !== null && _b !== void 0 ? _b : (options.duration = config.duration);
     }
-    function findNamedAnimation(name) {
-        return namedAnimations[name] || up.fail("Unknown animation %o", name);
-    }
     function finish(element) {
         return motionController.finish(element);
     }
@@ -9816,27 +10256,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) {
@@ -9849,21 +10283,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) {
@@ -9878,16 +10309,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');
@@ -9897,9 +10318,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);
         });
     }
@@ -9918,12 +10338,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);
@@ -9946,19 +10366,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,
@@ -9974,10 +10394,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(() => ({
@@ -9989,7 +10409,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,
@@ -10017,6 +10437,9 @@ up.network = (function () {
         return options;
     }
     function processRequest(request) {
+        var _a, _b, _c, _d;
+        cache.expire((_b = (_a = request.expireCache) !== null && _a !== void 0 ? _a : u.evalOption(config.expireCache, request)) !== null && _b !== void 0 ? _b : false);
+        cache.evict((_d = (_c = request.evictCache) !== null && _c !== void 0 ? _c : u.evalOption(config.evictCache, request)) !== null && _d !== void 0 ? _d : false);
         useCachedRequest(request) || queueRequest(request);
     }
     function useCachedRequest(newRequest) {
@@ -10042,29 +10465,28 @@ up.network = (function () {
             request.onLoading = () => cache.reindex(request);
         }
         u.always(request, function (responseOrError) {
-            var _a, _b, _c, _d;
-            let expireCache = (_b = (_a = responseOrError.expireCache) !== null && _a !== void 0 ? _a : request.expireCache) !== null && _b !== void 0 ? _b : u.evalOption(config.expireCache, request, responseOrError);
-            if (expireCache) {
-                cache.expire(expireCache, { except: request });
-            }
-            let evictCache = (_d = (_c = responseOrError.evictCache) !== null && _c !== void 0 ? _c : request.evictCache) !== null && _d !== void 0 ? _d : u.evalOption(config.evictCache, request, responseOrError);
-            if (evictCache) {
-                cache.evict(evictCache, { except: request });
-            }
-            let hasCacheEntry = cache.get(request);
+            var _a, _b;
+            cache.expire((_a = responseOrError.expireCache) !== null && _a !== void 0 ? _a : false, { except: request });
+            cache.evict((_b = responseOrError.evictCache) !== null && _b !== void 0 ? _b : 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);
+                }
             }
         });
     }
@@ -10079,16 +10501,6 @@ up.network = (function () {
         (_b = (_a = up.migrate).preprocessAbortArgs) === null || _b === void 0 ? void 0 : _b.call(_a, 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));
     }
@@ -10110,7 +10522,6 @@ up.network = (function () {
         isSafeMethod,
         config,
         abort: abortRequests,
-        registerAliasForRedirect,
         queue,
         loadPage,
     };
@@ -10120,13 +10531,13 @@ up.cache = up.network.cache;
 
 
 /***/ }),
-/* 92 */
+/* 95 */
 /***/ (() => {
 
 
 
 /***/ }),
-/* 93 */
+/* 96 */
 /***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
 
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -10138,7 +10549,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-__webpack_require__(94);
+__webpack_require__(97);
 const u = up.util;
 const e = up.element;
 up.layer = (function () {
@@ -10314,7 +10725,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)) {
@@ -10384,20 +10795,22 @@ up.layer = (function () {
 
 
 /***/ }),
-/* 94 */
+/* 97 */
 /***/ (() => {
 
 
 
 /***/ }),
-/* 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';
@@ -10427,7 +10840,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));
@@ -10449,6 +10864,7 @@ up.link = (function () {
         parser.string('contentType');
         parser.booleanOrNumber('lateDelay');
         parser.number('timeout');
+        parser.booleanOrString('fail');
         return options;
     }
     function followOptions(link, options, parserOptions) {
@@ -10458,7 +10874,6 @@ up.link = (function () {
         const parser = new up.OptionsParser(link, options, Object.assign({ fail: true }, parserOptions));
         parser.include(parseRequestOptions);
         options.origin || (options.origin = link);
-        parser.boolean('fail');
         parser.boolean('navigate', { default: true });
         parser.string('confirm', { attr: ['up-confirm', 'data-confirm'] });
         parser.string('target');
@@ -10492,9 +10907,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');
@@ -10519,7 +10937,7 @@ up.link = (function () {
             return Promise.reject(new up.Error(issue));
         }
         const guardEvent = up.event.build('up:link:preload', { log: ['Preloading link %o', link] });
-        return follow(link, Object.assign(Object.assign(Object.assign(Object.assign({ abort: false, abortable: false, background: true, cache: true }, up.RenderOptions.NO_INPUT_INTERFERENCE), up.RenderOptions.NO_PREVIEWS), options), { guardEvent, preload: true }));
+        return follow(link, Object.assign(Object.assign(Object.assign(Object.assign({ abort: false, abortable: false, background: true, cache: true }, options), up.RenderOptions.NO_INPUT_INTERFERENCE), up.RenderOptions.NO_PREVIEWS), { guardEvent, preload: true }));
     }
     function preloadIssue(link) {
         if (!isSafe(link)) {
@@ -10575,27 +10993,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);
     }
@@ -10684,13 +11112,13 @@ up.deferred = { load: up.link.loadDeferred };
 
 
 /***/ }),
-/* 96 */
+/* 99 */
 /***/ (() => {
 
 
 
 /***/ }),
-/* 97 */
+/* 100 */
 /***/ (() => {
 
 up.form = (function () {
@@ -10703,12 +11131,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());
@@ -10719,11 +11150,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());
     }
@@ -10757,16 +11194,18 @@ up.form = (function () {
         return options;
     }
     function watchOptions(field, options, parserOptions = {}) {
-        var _a;
+        var _a, _b, _c;
         options = u.options(options);
-        let parser = new up.OptionsParser(field, options, Object.assign(Object.assign({}, parserOptions), { closest: true, attrPrefix: 'up-watch-' }));
-        parser.include(up.status.statusOptions);
+        (_a = parserOptions.closest) !== null && _a !== void 0 ? _a : (parserOptions.closest = true);
+        (_b = parserOptions.attrPrefix) !== null && _b !== void 0 ? _b : (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;
         if (options.event === 'input') {
             options.event = u.evalOption(config.watchInputEvents, field);
-            (_a = options.delay) !== null && _a !== void 0 ? _a : (options.delay = config.watchInputDelay);
+            (_c = options.delay) !== null && _c !== void 0 ? _c : (options.delay = config.watchInputDelay);
         }
         else if (options.event === 'change') {
             options.event = u.evalOption(config.watchChangeEvents, field);
@@ -10774,15 +11213,22 @@ up.form = (function () {
         options.origin || (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, Object.assign(Object.assign({}, 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 disableContainerTemp(container) {
+        let controls = findFieldsAndButtons(container);
+        return u.sequence(u.map(controls, disableControlTemp));
     }
-    function disableControl(control) {
+    function disableControlTemp(control) {
         if (control.disabled)
             return;
         let focusFallback;
@@ -10797,7 +11243,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()];
         }
@@ -10822,6 +11268,11 @@ up.form = (function () {
             }
         };
     }
+    function setContainerDisabled(container, disabled) {
+        for (let control of findFieldsAndButtons(container)) {
+            control.disabled = disabled;
+        }
+    }
     function destinationOptions(form, options, parserOptions) {
         var _a;
         options = u.options(options);
@@ -10836,8 +11287,7 @@ up.form = (function () {
             options.method || (options.method = submitButton.getAttribute('formmethod'));
             options.url || (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'],
@@ -10854,8 +11304,7 @@ up.form = (function () {
         root = up.element.get(root);
         callback || (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');
@@ -10865,7 +11314,7 @@ up.form = (function () {
     }
     function autosubmit(target, options = {}) {
         const onChange = (_diff, renderOptions) => submit(target, renderOptions);
-        return watch(target, Object.assign(Object.assign({}, options), { batch: true }), onChange);
+        return watch(target, Object.assign(Object.assign({ logPrefix: 'up.autosubmit()' }, options), { batch: true }), onChange);
     }
     function getGroupSelectors() {
         var _a, _b;
@@ -10894,7 +11343,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) {
@@ -10907,88 +11357,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 || (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 || (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;
         }
@@ -10996,6 +11378,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);
     }
@@ -11010,49 +11405,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;
@@ -11062,13 +11447,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'],
@@ -11076,30 +11460,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 || (link.upCurrentURLs = new up.LinkCurrentURLs(link));
     }
-    function updateFragment(fragment, { layer } = {}) {
-        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;
@@ -11154,7 +11547,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);
@@ -11165,10 +11558,6 @@ up.status = (function () {
         activeElements || (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;
@@ -11187,33 +11576,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,
@@ -11223,7 +11594,7 @@ up.preview = up.status.preview;
 
 
 /***/ }),
-/* 99 */
+/* 102 */
 /***/ (() => {
 
 up.radio = (function () {
@@ -11306,7 +11677,7 @@ up.radio = (function () {
 
 
 /***/ }),
-/* 100 */
+/* 103 */
 /***/ (() => {
 
 (function () {
@@ -11357,8 +11728,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);
@@ -11445,15 +11815,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();
 
 })();