unpoly-rails 3.11.0.rc1 → 3.11.0.rc12

data/assets/unpoly/unpoly.js

@@ -5,7 +5,7 @@
 /***/ (() => {
 
 window.up = {
-    version: '3.11.0-rc1'
+    version: '3.11.0-rc12'
 };
 
 
@@ -146,6 +146,9 @@ up.util = (function () {
     function isNull(value) {
         return value === null;
     }
+    function isTruthy(value) {
+        return !!value;
+    }
     function isUndefined(value) {
         return value === undefined;
     }
@@ -423,7 +426,7 @@ up.util = (function () {
         const filtered = {};
         for (let key in object) {
             const value = object[key];
-            if (tester(value, key, object)) {
+            if (tester(value, key)) {
                 filtered[key] = object[key];
             }
         }
@@ -526,34 +529,36 @@ up.util = (function () {
         return Object.prototype.hasOwnProperty(k);
     }
     function isEqual(a, b) {
+        if (a === b) {
+            return true;
+        }
         if (a?.valueOf) {
             a = a.valueOf();
         }
         if (b?.valueOf) {
             b = b.valueOf();
         }
+        if (a === b) {
+            return true;
+        }
         if (typeof (a) !== typeof (b)) {
             return false;
         }
-        else if (isList(a) && isList(b)) {
+        if (isList(a) && isList(b)) {
             return isEqualList(a, b);
         }
-        else if (isObject(a) && a[isEqual.key]) {
+        if (isObject(a) && a[isEqual.key]) {
             return a[isEqual.key](b);
         }
-        else if (isOptions(a) && isOptions(b)) {
-            const aKeys = Object.keys(a);
-            const bKeys = Object.keys(b);
-            if (isEqualList(aKeys, bKeys)) {
-                return every(aKeys, (aKey) => isEqual(a[aKey], b[aKey]));
-            }
-            else {
-                return false;
-            }
-        }
-        else {
-            return a === b;
+        if (isOptions(a) && isOptions(b)) {
+            return isEqualOptions(a, b);
         }
+        return false;
+    }
+    function isEqualOptions(a, b) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        return isEqualList(aKeys, bKeys) && every(aKeys, (key) => isEqual(a[key], b[key]));
     }
     isEqual.key = 'up.util.isEqual';
     function isEqualList(a, b) {
@@ -792,36 +797,39 @@ up.util = (function () {
     }
     function maskPattern(str, patterns, { keepDelimiters = false } = {}) {
         let maskCount = 0;
-        let maskPattern = /§(\d+)/g;
-        let matches = [];
-        let replaceLayers = 0;
-        let replace = (replacePattern) => {
+        let maskPattern = /§\d+/g;
+        let maskings = {};
+        let replaceLayers = [];
+        let replace = (replacePattern, allowRestoreTransform) => {
             let didReplace = false;
             str = str.replaceAll(replacePattern, function (match) {
                 didReplace = true;
-                let glyph = '§' + (maskCount++);
-                let mask;
+                let mask = '§' + (maskCount++);
+                let remain;
                 let masked;
                 if (keepDelimiters) {
                     let startDelimiter = match[0];
                     let endDelimiter = match.slice(-1);
                     masked = match.slice(1, -1);
-                    mask = startDelimiter + glyph + endDelimiter;
+                    remain = startDelimiter + mask + endDelimiter;
                 }
                 else {
                     masked = match;
-                    mask = glyph;
+                    remain = mask;
                 }
-                matches.push(masked);
-                return mask;
+                maskings[mask] = masked;
+                return remain;
             });
             if (didReplace)
-                replaceLayers++;
+                replaceLayers.unshift({ allowRestoreTransform });
         };
-        [maskPattern, ...patterns].forEach(replace);
+        replace(maskPattern, false);
+        for (let pattern of patterns)
+            replace(pattern, true);
         let restore = (s, transform = identity) => {
-            for (let i = 0; i < replaceLayers; i++) {
-                s = s.replace(maskPattern, (match, placeholderIndex) => transform(matches[placeholderIndex]));
+            for (let { allowRestoreTransform } of replaceLayers) {
+                let iterationTransform = allowRestoreTransform ? transform : identity;
+                s = s.replace(maskPattern, (match) => iterationTransform(assert(maskings[match], isString)));
             }
             return s;
         };
@@ -835,6 +843,7 @@ up.util = (function () {
     function ensureDoubleQuotes(str) {
         if (str[0] === '"')
             return str;
+        assert(str[0] === "'");
         str = str.slice(1, -1);
         let transformed = str.replace(/(\\\\)|(\\')|(\\")|(")/g, function (_match, escapedBackslash, escapedSingleQuote, _doubleQuote) {
             return escapedBackslash
@@ -866,6 +875,14 @@ 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,
@@ -974,6 +991,7 @@ up.util = (function () {
         maskPattern,
         expressionOutline,
         parseString,
+        assert,
     };
 })();
 
@@ -1537,7 +1555,7 @@ up.element = (function () {
     }
     function extractFromStyleObject(style, keyOrKeys) {
         if (up.migrate.loaded)
-            keyOrKeys = up.migrate.fixStyleProps(keyOrKeys);
+            keyOrKeys = up.migrate.fixGetStyleProps(keyOrKeys);
         if (u.isString(keyOrKeys)) {
             return style.getPropertyValue(keyOrKeys);
         }
@@ -1547,7 +1565,7 @@ up.element = (function () {
     }
     function setInlineStyle(element, props, unit = '') {
         if (up.migrate.loaded)
-            props = up.migrate.fixStyleProps(props, unit);
+            props = up.migrate.fixSetStyleProps(props, unit);
         if (u.isString(props)) {
             element.setAttribute('style', props);
         }
@@ -1623,18 +1641,6 @@ up.element = (function () {
             return [element.parentElement, 'beforeend'];
         }
     }
-    function moveBefore(parent, movedElement, referenceElement) {
-        let fn = parent.moveBefore || parent.insertBefore;
-        fn.call(parent, movedElement, referenceElement);
-    }
-    function preservingAppend(parent, newNode) {
-        moveBefore(parent, newNode, null);
-    }
-    function preservingReplace(oldElement, newElement) {
-        let parent = oldElement.parentElement;
-        moveBefore(parent, newElement, oldElement);
-        oldElement.remove();
-    }
     return {
         subtree,
         subtreeFirst,
@@ -1703,8 +1709,6 @@ up.element = (function () {
         matchSelectorMap,
         elementLikeMatches,
         documentPosition,
-        preservingAppend,
-        preservingReplace,
     };
 })();
 
@@ -2187,8 +2191,8 @@ 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);
     }
 };
 
@@ -2200,8 +2204,8 @@ up.Change.Addition = class Addition extends up.Change {
 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();
@@ -2210,9 +2214,9 @@ up.RenderJob = (_a = class RenderJob {
         async _executePromise() {
             try {
                 this._emitGuardEvent();
-                this.options = up.RenderOptions.preprocess(this.options);
-                up.browser.assertConfirmed(this.options);
-                up.RenderOptions.assertContentGiven(this.options);
+                this.renderOptions = up.RenderOptions.preprocess(this.renderOptions);
+                up.browser.assertConfirmed(this.renderOptions);
+                up.RenderOptions.assertContentGiven(this.renderOptions);
                 let result = await this._getChange().execute();
                 this._handleResult(result);
                 return result;
@@ -2224,7 +2228,7 @@ up.RenderJob = (_a = class RenderJob {
         }
         _handleResult(result) {
             if (result instanceof up.RenderResult) {
-                let { onRendered, onFinished } = result.options;
+                let { onRendered, onFinished } = result.renderOptions;
                 if (!result.none)
                     up.error.guard(() => onRendered?.(result));
                 let guardedOnFinished = function (result) {
@@ -2237,7 +2241,7 @@ up.RenderJob = (_a = class RenderJob {
         _handleError(error) {
             let prefix = error instanceof up.Aborted ? 'Rendering was aborted' : 'Error while rendering';
             up.puts('up.render()', `${prefix}: ${error.name}: ${error.message}`);
-            up.error.guard(() => this.options.onError?.(error));
+            up.error.guard(() => this.renderOptions.onError?.(error));
         }
         get finished() {
             return this._awaitFinished();
@@ -2258,7 +2262,7 @@ up.RenderJob = (_a = class RenderJob {
         }
         _getChange() {
             let handleAbort = u.memoize((request) => this._handleAbortOption(request));
-            let renderOptions = { ...this.options, handleAbort };
+            let renderOptions = { ...this.renderOptions, handleAbort };
             if (renderOptions.url) {
                 return new up.Change.FromURL(renderOptions);
             }
@@ -2270,16 +2274,16 @@ up.RenderJob = (_a = class RenderJob {
             }
         }
         _emitGuardEvent() {
-            let guardEvent = u.pluckKey(this.options, 'guardEvent');
+            let guardEvent = u.pluckKey(this.renderOptions, 'guardEvent');
             if (guardEvent) {
-                guardEvent.renderOptions = this.options;
-                if (up.emit(guardEvent, { target: this.options.origin }).defaultPrevented) {
+                guardEvent.renderOptions = this.renderOptions;
+                if (up.emit(guardEvent, { target: this.renderOptions.origin }).defaultPrevented) {
                     throw new up.Aborted(`Rendering was prevented by ${guardEvent.type} listener`);
                 }
             }
         }
         _handleAbortOption(request) {
-            let { abort } = this.options;
+            let { abort } = this.renderOptions;
             if (!abort || !up.network.isBusy())
                 return;
             let { bindFragments, bindLayer, origin, layer } = this._getChange().getPreflightProps();
@@ -2422,6 +2426,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         this._assertOpenEventEmitted();
         this.layer = this._buildLayer();
         this._baseLayer.peel({ history: !this.layer.history });
+        this._baseLayer.saveHistory();
         up.layer.stack.push(this.layer);
         this.layer.createElements();
         this.layer.setupHandlers();
@@ -2431,14 +2436,15 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         this.handleLayerChangeRequests();
         this.responseDoc.commitElement(this._content);
         this.layer.setContent(this._content);
-        this.setReloadAttrs({ newElement: this._content, source: this.options.source });
         this.responseDoc.finalizeElement(this._content);
+        this.setReloadAttrs({ newElement: this._content, source: this.options.source });
+        up.hello(this.layer.element, { ...this.options, layer: this.layer, dataRoot: this._content });
         this._newOverlayResult = new up.RenderResult({
             layer: this.layer,
             fragments: [this._content],
             target: this.target,
+            renderOptions: this.options,
         });
-        up.hello(this.layer.element, { ...this.options, layer: this.layer, dataRoot: this._content });
         this._handleScroll();
         this._newOverlayResult.finished = this._finish();
         this.layer.opening = false;
@@ -2449,7 +2455,10 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         if (this._otherLayersResult)
             return;
         let otherLayerSteps = this._getHungrySteps().other;
-        this._otherLayersResult = this.executeSteps(otherLayerSteps, this.responseDoc);
+        this._otherLayersResult = this.executeSteps({
+            steps: otherLayerSteps,
+            responseDoc: this.responseDoc,
+        });
     }
     async _finish() {
         await this.layer.startOpenAnimation();
@@ -2468,9 +2477,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         if (this.layer.history === 'auto') {
             this.layer.history = up.fragment.hasAutoHistory([this._content], this.layer);
         }
-        let { parent } = this.layer;
-        this.layer.history &&= parent.history;
-        parent.saveHistory();
+        this.layer.history &&= this._baseLayer.history;
         this.layer.updateHistory(this.options);
     }
     _handleFocus() {
@@ -2595,13 +2602,20 @@ up.Change.UpdateLayer = (_a = class UpdateLayer extends up.Change.Addition {
                 this.layer.updateHistory(this.options);
             }
             this.handleLayerChangeRequests();
-            this._currentLayerResult = this.executeSteps(this._steps, this.responseDoc, this.options);
+            this._currentLayerResult = this.executeSteps({
+                steps: this._steps,
+                responseDoc: this.responseDoc,
+                noneOptions: this.options,
+            });
         }
         _renderOtherLayers() {
             if (this._otherLayersResult)
                 return;
             let otherLayerSteps = this._getHungrySteps().other;
-            this._otherLayersResult = this.executeSteps(otherLayerSteps, this.responseDoc);
+            this._otherLayersResult = this.executeSteps({
+                steps: otherLayerSteps,
+                responseDoc: this.responseDoc,
+            });
         }
         _matchPreflight() {
             this._matchOldElements();
@@ -2682,30 +2696,30 @@ const e = up.element;
 up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
     constructor(options) {
         super(options);
+        this._steps = u.copy(u.assert(options.steps));
+        this._passRenderOptions = u.assert(options.passRenderOptions);
         this._noneOptions = options.noneOptions || {};
-        this._steps = u.copy(options.steps);
     }
     execute(responseDoc) {
         this.responseDoc = responseDoc;
         this._steps = responseDoc.selectSteps(this._steps);
         this._steps = responseDoc.commitSteps(this._steps);
-        if (!this._steps.length) {
-            return this._executeNone();
-        }
         this.renderResult = new up.RenderResult({
-            layer: this._steps[0]?.layer,
+            layer: this._passRenderOptions.layer,
             target: up.fragment.targetForSteps(this._steps),
+            renderOptions: this._passRenderOptions,
         });
-        this._steps.reverse();
-        const motionEndPromises = this._steps.map((step) => this._executeStep(step));
-        this.renderResult.finished = this._finish(motionEndPromises);
+        if (!this._steps.length) {
+            this._handleFocus(null, this._noneOptions);
+            this._handleScroll(null, this._noneOptions);
+        }
+        else {
+            this._steps.reverse();
+            const motionEndPromises = this._steps.map((step) => this._executeStep(step));
+            this.renderResult.finished = this._finish(motionEndPromises);
+        }
         return this.renderResult;
     }
-    _executeNone() {
-        this._handleFocus(null, this._noneOptions);
-        this._handleScroll(null, this._noneOptions);
-        return up.RenderResult.buildNone();
-    }
     async _finish(motionEndPromises) {
         await Promise.all(motionEndPromises);
         for (let step of this._steps) {
@@ -2718,10 +2732,9 @@ 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);
@@ -2737,10 +2750,8 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                         },
                         afterInsert: () => {
                             this._restoreDescendantKeepables(step);
-                            this.responseDoc.finalizeElement(step.newElement);
+                            this._welcomeElement(step.newElement, step);
                             this._finalizeDescendantKeepables(step);
-                            up.hello(step.newElement, step);
-                            this._addToResult(step.newElement);
                         },
                         beforeDetach: () => {
                             up.script.clean(step.oldElement, { layer: step.layer });
@@ -2777,53 +2788,27 @@ 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);
     }
     _preserveDescendantKeepables(step) {
         const descendantKeepPlans = [];
         if (step.keep) {
             for (let keepable of step.oldElement.querySelectorAll('[up-keep]')) {
-                let keepPlan = this._findKeepPlan({ ...step, oldElement: keepable, descendantsOnly: true });
+                let keepPlan = up.fragment.keepPlan({ ...step, oldElement: keepable, descendantsOnly: true });
                 if (keepPlan) {
                     const keepableClone = keepable.cloneNode(true);
                     keepable.insertAdjacentElement('beforebegin', keepableClone);
@@ -2838,7 +2823,7 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                         keepPlan.newElement.replaceWith(keepable);
                     }
                     else {
-                        e.preservingAppend(document.body, keepable);
+                        document.body.append(keepable);
                     }
                     descendantKeepPlans.push(keepPlan);
                 }
@@ -2848,12 +2833,7 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
     }
     _restoreDescendantKeepables(step) {
         for (let keepPlan of step.descendantKeepPlans) {
-            if (this._willChangeBody()) {
-                keepPlan.newElement.replaceWith(keepPlan.oldElement);
-            }
-            else {
-                e.preservingReplace(keepPlan.newElement, keepPlan.oldElement);
-            }
+            keepPlan.newElement.replaceWith(keepPlan.oldElement);
             for (let reviver of keepPlan.revivers) {
                 reviver();
             }
@@ -3077,7 +3057,7 @@ up.Change.FromResponse = (_a = class FromResponse extends up.Change {
             this.options.failTarget = ':none';
         }
         _updateContentFromResponse(finalRenderOptions) {
-            if (finalRenderOptions.failPrefixForced) {
+            if (finalRenderOptions.didForceFailOptions) {
                 up.puts('up.render()', 'Rendering failed response using fail-prefixed options (https://unpoly.com/failed-responses)');
             }
             this._augmentOptionsFromResponse(finalRenderOptions);
@@ -3244,9 +3224,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
             return this._seekPlan(this._executePlan.bind(this)) || this._cannotMatchPostflightTarget();
         }
         _executePlan(matchedPlan) {
-            let result = matchedPlan.execute(this._getResponseDoc(), this._onPlanApplicable.bind(this, matchedPlan));
-            result.options = this.options;
-            return result;
+            return matchedPlan.execute(this._getResponseDoc(), this._onPlanApplicable.bind(this, matchedPlan));
         }
         _isApplicablePlanError(error) {
             return !(error instanceof up.CannotMatch);
@@ -3320,7 +3298,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
             else if (this._layers.length === 0) {
                 this._cannotMatchLayer();
             }
-            else if (this.options.failPrefixForced) {
+            else if (this.options.didForceFailOptions) {
                 throw new up.CannotMatch('No target selector given for failed responses (https://unpoly.com/failed-responses)');
             }
             else {
@@ -3931,6 +3909,9 @@ up.FieldWatcher = class FieldWatcher {
         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);
@@ -4021,9 +4002,9 @@ up.FieldWatcher = class FieldWatcher {
         return up.Params.fromContainer(this._root).toObject();
     }
     _check(event, fieldOptions = {}) {
-        up.log.putsEvent(event);
         const values = this._readFieldValues();
         if (this._isNewValues(values)) {
+            up.log.putsEvent(event);
             this._scheduleValues(values, fieldOptions);
         }
     }
@@ -4063,7 +4044,7 @@ up.Switcher = class Switcher {
     _trackNewSwitchees() {
         let filter = (matches) => {
             let scope = this._scope;
-            return u.filter(matches, (match) => scope.contains(match));
+            return u.filter(matches, (match) => scope?.contains(match));
         };
         let onSwitcheeAdded = (switchee) => this._switchSwitchee(switchee);
         return up.fragment.trackSelector(this._switcheeSelector, { filter }, onSwitcheeAdded);
@@ -4094,10 +4075,11 @@ up.Switcher = class Switcher {
             }
         }
         let log = ['Switching %o', switchee];
-        up.emit(switchee, 'up:form:switch', { field: this._root, tokens: fieldTokens, log });
+        up.emit(switchee, 'up:form:switch', { field: this._root, fieldTokens, log });
     }
     _findSwitchees() {
-        return up.fragment.subtree(this._scope, this._switcheeSelector);
+        let scope = this._scope;
+        return scope ? up.fragment.subtree(scope, this._switcheeSelector) : [];
     }
     get _scope() {
         if (this._regionSelector) {
@@ -4111,44 +4093,16 @@ up.Switcher = class Switcher {
         return u.getSimpleTokens(str, { json: true });
     }
     _buildFieldTokens() {
+        let values = up.Params.fromContainer(this._root).values();
+        let tokens = [...values];
+        let anyPresent = u.some(values, u.isPresent);
+        tokens.push(anyPresent ? ':present' : ':blank');
         let fields = up.form.fields(this._root);
-        let field = fields[0];
-        let value;
-        let meta;
-        if (field.matches('input[type=checkbox]')) {
-            if (field.checked) {
-                value = field.value;
-                meta = ':checked';
-            }
-            else {
-                meta = ':unchecked';
-            }
-        }
-        else if (field.matches('input[type=radio]')) {
-            let checkedButton = up.migrate.checkedRadioButtonForSwitch?.(field) || u.find(fields, 'checked');
-            if (checkedButton) {
-                meta = ':checked';
-                value = checkedButton.value;
-            }
-            else {
-                meta = ':unchecked';
-            }
-        }
-        else {
-            value = field.value;
-        }
-        const values = [];
-        if (u.isPresent(value)) {
-            values.push(value);
-            values.push(':present');
-        }
-        else {
-            values.push(':blank');
+        if (fields[0]?.matches('[type=radio], [type=checkbox]')) {
+            let anyChecked = u.some(fields, 'checked');
+            tokens.push(anyChecked ? ':checked' : ':unchecked');
         }
-        if (u.isPresent(meta)) {
-            values.push(meta);
-        }
-        return values;
+        return tokens;
     }
 };
 
@@ -4640,7 +4594,7 @@ up.FragmentPolling = class FragmentPolling {
         if (this._state === 'started') {
             this._clearReloadTimer();
             this._state = 'stopped';
-            this.unbindEvents?.();
+            this._unbindEvents?.();
         }
     }
     forceStart(options) {
@@ -4653,8 +4607,8 @@ up.FragmentPolling = class FragmentPolling {
         this.forceStarted = false;
     }
     _ensureEventsBound() {
-        if (!this.unbindEvents) {
-            this.unbindEvents = up.on('visibilitychange up:layer:opened up:layer:dismissed up:layer:accepted', this._onVisibilityChange.bind(this));
+        if (!this._unbindEvents) {
+            this._unbindEvents = up.on('visibilitychange up:layer:opened up:layer:dismissed up:layer:accepted', this._onVisibilityChange.bind(this));
         }
     }
     _onVisibilityChange() {
@@ -4851,14 +4805,15 @@ up.Layer = class Layer extends up.Record {
     }
     constructor(options = {}) {
         super(options);
-        if (!this.mode) {
-            throw "missing { mode } option";
-        }
+        u.assert(this.mode);
     }
     setupHandlers() {
         up.link.convertClicks(this);
+        this._unbindLocationChanged = up.on('up:location:changed', (event) => this._onBrowserLocationChanged(event));
+    }
+    teardownHandlers() {
+        this._unbindLocationChanged?.();
     }
-    teardownHandlers() { }
     mainTargets() {
         return up.layer.mainTargets(this.mode);
     }
@@ -4957,28 +4912,28 @@ up.Layer = class Layer extends up.Record {
         return !this.element.isConnected;
     }
     saveHistory() {
-        if (this.history) {
-            this.savedTitle = document.title;
-            this.savedMetaTags = up.history.findMetaTags();
-            this.savedLocation = up.history.location;
-            this.savedLang = up.history.getLang();
-        }
+        u.assert(this.isFront());
+        if (!this.showsLiveHistory())
+            return;
+        this._savedTitle = this.title;
+        this._savedMetaTags = this.metaTags;
+        this._savedLocation = this.location;
+        this._savedLang = this.lang;
     }
     restoreHistory() {
-        if (!this.showsLiveHistory()) {
+        if (!this.showsLiveHistory())
             return;
+        if (this._savedLocation) {
+            up.history.push(this._savedLocation);
         }
-        if (this.savedLocation) {
-            up.history.push(this.savedLocation);
-        }
-        if (this.savedTitle) {
-            document.title = this.savedTitle;
+        if (this._savedTitle) {
+            document.title = this._savedTitle;
         }
-        if (this.savedMetaTags) {
-            up.history.updateMetaTags(this.savedMetaTags);
+        if (this._savedMetaTags) {
+            up.history.updateMetaTags(this._savedMetaTags);
         }
-        if (u.isString(this.savedLang)) {
-            up.history.updateLang(this.savedLang);
+        if (u.isString(this._savedLang)) {
+            up.history.updateLang(this._savedLang);
         }
     }
     asCurrent(fn) {
@@ -4986,32 +4941,37 @@ up.Layer = class Layer extends up.Record {
     }
     updateHistory(options) {
         if (u.isString(options.location)) {
-            this.location = options.location;
+            this._updateLocation(options.location, { push: true });
         }
         if (up.history.config.updateMetaTags && u.isList(options.metaTags)) {
             up.migrate?.warnOfHungryMetaTags?.(options.metaTags);
-            this.metaTags = options.metaTags;
+            this._updateMetaTags(options.metaTags);
         }
         if (u.isString(options.title)) {
-            this.title = options.title;
+            this._updateTitle(options.title);
         }
         if (u.isString(options.lang)) {
-            this.lang = options.lang;
+            this._updateLang(options.lang);
         }
     }
     showsLiveHistory() {
         return this.history && this.isFront();
     }
+    _onBrowserLocationChanged({ location }) {
+        if (this.showsLiveHistory()) {
+            this._updateLocation(location, { push: false });
+        }
+    }
     get title() {
         if (this.showsLiveHistory()) {
             return document.title;
         }
         else {
-            return this.savedTitle;
+            return this._savedTitle;
         }
     }
-    set title(title) {
-        this.savedTitle = title;
+    _updateTitle(title) {
+        this._savedTitle = title;
         if (this.showsLiveHistory()) {
             document.title = title;
         }
@@ -5021,11 +4981,11 @@ up.Layer = class Layer extends up.Record {
             return up.history.findMetaTags();
         }
         else {
-            return this.savedMetaTags;
+            return this._savedMetaTags;
         }
     }
-    set metaTags(metaTags) {
-        this.savedMetaTags = metaTags;
+    _updateMetaTags(metaTags) {
+        this._savedMetaTags = metaTags;
         if (this.showsLiveHistory()) {
             up.history.updateMetaTags(metaTags);
         }
@@ -5035,11 +4995,11 @@ up.Layer = class Layer extends up.Record {
             return up.history.getLang();
         }
         else {
-            return this.savedLang;
+            return this._savedLang;
         }
     }
-    set lang(lang) {
-        this.savedLang = lang;
+    _updateLang(lang) {
+        this._savedLang = lang;
         if (this.showsLiveHistory()) {
             up.history.updateLang(lang);
         }
@@ -5049,20 +5009,18 @@ up.Layer = class Layer extends up.Record {
             return up.history.location;
         }
         else {
-            return this.savedLocation;
+            return this._savedLocation;
         }
     }
-    set location(location) {
-        const previousLocation = this.location;
-        location = u.normalizeURL(location);
-        if (previousLocation !== location || this.opening) {
-            this.savedLocation = location;
-            if (this.showsLiveHistory()) {
-                up.history.push(location);
-            }
-            if (!this.opening) {
-                this.emit('up:layer:location:changed', { location, log: false });
-            }
+    _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) {
@@ -5198,7 +5156,7 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
                     });
                 }
                 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);
@@ -5207,7 +5165,7 @@ 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.registerAttrCloser('up-accept', (value, closeOptions) => {
                 this.accept(value, closeOptions);
@@ -5303,8 +5261,8 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
         }
         teardownHandlers() {
             super.teardownHandlers();
-            this.unbindParentClicked?.();
-            this.unbindEscapePressed?.();
+            this._unbindParentClicked?.();
+            this._unbindEscapePressed?.();
             this.overlayFocus.teardown();
         }
         destroyElements(options) {
@@ -5806,6 +5764,11 @@ up.LinkCurrentURLs = class LinkCurrentURLs {
             this._upHREF === normalizedLocation ||
             this._aliasPattern?.test?.(normalizedLocation, false));
     }
+    isAnyCurrent(normalizedLocations) {
+        return normalizedLocations.some((normalizedLocation) => (this._href === normalizedLocation ||
+            this._upHREF === normalizedLocation ||
+            this._aliasPattern?.test?.(normalizedLocation, false)));
+    }
 };
 
 
@@ -6134,15 +6097,12 @@ up.Params = class Params {
         return formData;
     }
     toQuery() {
-        let parts = u.map(this.entries, this._arrayEntryToQuery.bind(this));
-        parts = u.compact(parts);
+        let simpleEntries = this.withoutBinaryEntries().entries;
+        let parts = simpleEntries.map(this._arrayEntryToQuery);
         return parts.join('&');
     }
     _arrayEntryToQuery(entry) {
         const { value } = entry;
-        if (this._isBinaryValue(value)) {
-            return;
-        }
         let query = encodeURIComponent(entry.name);
         if (u.isGiven(value)) {
             query += "=";
@@ -6150,12 +6110,15 @@ up.Params = class Params {
         }
         return query;
     }
-    _isBinaryValue(value) {
+    _isBinaryEntry({ value }) {
         return value instanceof Blob;
     }
-    hasBinaryValues() {
-        const values = u.map(this.entries, 'value');
-        return u.some(values, this._isBinaryValue);
+    hasBinaryEntries() {
+        return u.some(this.entries, this._isBinaryEntry);
+    }
+    withoutBinaryEntries() {
+        let simpleEntries = u.reject(this.entries, this._isBinaryEntry);
+        return new this.constructor(simpleEntries);
     }
     toURL(base) {
         let parts = [base, this.toQuery()];
@@ -6185,9 +6148,15 @@ up.Params = class Params {
             this._addAllFromObject(raw);
         }
         else {
-            up.fail("Unsupport params type: %o", raw);
+            up.fail("Unsupported params type: %o", raw);
         }
     }
+    keys() {
+        return u.map(this.entries, 'name');
+    }
+    values() {
+        return u.map(this.entries, 'value');
+    }
     _addAllFromObject(object) {
         for (let key in object) {
             const value = object[key];
@@ -6240,16 +6209,11 @@ up.Params = class Params {
         return entry?.value;
     }
     getAll(name) {
-        if (this._isArrayKey(name)) {
-            return this.getAll(name);
-        }
-        else {
-            const entries = u.map(this.entries, this._matchEntryFn(name));
-            return u.map(entries, 'value');
-        }
+        const entries = u.filter(this.entries, this._matchEntryFn(name));
+        return u.map(entries, 'value');
     }
     _isArrayKey(key) {
-        return key.endsWith('[]');
+        return u.evalOption(up.form.config.arrayParam, key);
     }
     [u.isBlank.key]() {
         return this.entries.length === 0;
@@ -6312,11 +6276,15 @@ 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;
     }
 };
 
@@ -6623,19 +6591,22 @@ up.RenderOptions = (function () {
         return overrides;
     }
     function deriveFailOptions(preprocessedOptions) {
+        let markFailure = { didFail: true };
         let overrides = failOverrides(preprocessedOptions);
         if (preprocessedOptions.failOptions) {
             return {
                 ...preprocessedOptions.defaults,
                 ...u.pick(preprocessedOptions, SHARED_KEYS),
                 ...overrides,
-                ...{ failPrefixForced: true }
+                didForceFailOptions: true,
+                ...markFailure,
             };
         }
         else {
             return {
                 ...preprocessedOptions,
                 ...overrides,
+                ...markFailure,
             };
         }
     }
@@ -6661,13 +6632,14 @@ up.RenderResult = class RenderResult extends up.Record {
             'fragments',
             'layer',
             'target',
-            'options',
+            'renderOptions',
             'finished',
         ];
     }
     defaults() {
         return {
             fragments: [],
+            finished: Promise.resolve(),
         };
     }
     get none() {
@@ -6676,13 +6648,15 @@ up.RenderResult = class RenderResult extends up.Record {
     get fragment() {
         return this.fragments[0];
     }
+    get ok() {
+        return !this.renderOptions.didFail;
+    }
     static both(main, extension, mergeFinished = true) {
-        if (!extension)
+        if (!extension) {
             return main;
+        }
         return new this({
-            target: main.target,
-            layer: main.layer,
-            options: main.options,
+            ...main,
             fragments: main.fragments.concat(extension.fragments),
             finished: (mergeFinished && this.mergeFinished(main, extension))
         });
@@ -6690,12 +6664,6 @@ up.RenderResult = class RenderResult extends up.Record {
     static async mergeFinished(main, extension) {
         return this.both(await main.finished, await extension.finished, false);
     }
-    static buildNone() {
-        return new this({
-            target: ':none',
-            finished: Promise.resolve(),
-        });
-    }
 };
 
 
@@ -7164,15 +7132,6 @@ up.Request.Cache = class Cache {
         this._requests.push(request);
         this._limitSize();
     }
-    alias(existingCachedRequest, newRequest) {
-        existingCachedRequest = this.get(existingCachedRequest);
-        if (!existingCachedRequest)
-            return;
-        newRequest = this._wrap(newRequest);
-        this.track(existingCachedRequest, newRequest, { force: true });
-        this.put(newRequest);
-        return newRequest;
-    }
     async track(existingRequest, newRequest, options = {}) {
         newRequest.trackedRequest = existingRequest;
         newRequest.state = 'tracking';
@@ -7266,7 +7225,7 @@ up.Request.Queue = class Queue {
     }
     asap(request) {
         request.runQueuedCallbacks();
-        u.always(request, (responseOrError) => this._onRequestSettled(request, responseOrError));
+        u.always(request, () => this._onRequestSettled(request));
         this._scheduleSlowTimer(request);
         this._queueRequest(request);
         queueMicrotask(() => this._poke());
@@ -7306,11 +7265,8 @@ up.Request.Queue = class Queue {
             this._currentRequests.push(request);
         }
     }
-    _onRequestSettled(request, responseOrError) {
+    _onRequestSettled(request) {
         u.remove(this._currentRequests, request) || u.remove(this._queuedRequests, request);
-        if ((responseOrError instanceof up.Response) && responseOrError.ok) {
-            up.network.registerAliasForRedirect(request, responseOrError);
-        }
         queueMicrotask(() => this._poke());
         u.task(() => this._checkForRecover());
     }
@@ -7370,7 +7326,7 @@ up.Request.FormRenderer = class FormRenderer {
         this._request = request;
     }
     buildAndSubmit() {
-        this.params = u.copy(this._request.params);
+        this.params = this._request.params.withoutBinaryEntries();
         let action = this._request.url;
         let { method } = this._request;
         const paramsFromQuery = up.Params.fromURL(action);
@@ -7447,7 +7403,7 @@ up.Request.XHRRenderer = (_a = class XHRRenderer {
             this._contentType = this._request.contentType;
             if (!this._payload && this._request.allowsPayload()) {
                 if (!this._contentType) {
-                    this._contentType = this._params.hasBinaryValues() ? CONTENT_TYPE_FORM_DATA : CONTENT_TYPE_URL_ENCODED;
+                    this._contentType = this._params.hasBinaryEntries() ? CONTENT_TYPE_FORM_DATA : CONTENT_TYPE_URL_ENCODED;
                 }
                 if (this._contentType === CONTENT_TYPE_FORM_DATA) {
                     this._contentType = null;
@@ -7545,6 +7501,20 @@ 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;
+    }
 };
 
 
@@ -8100,7 +8070,7 @@ up.framework = (function () {
     function emitReset() {
         up.emit('up:framework:reset', { log: false });
     }
-    function boot() {
+    function boot({ mode = 'manual' } = {}) {
         if (readyState !== 'configuring') {
             console.error('Unpoly has already booted');
             return;
@@ -8108,9 +8078,9 @@ up.framework = (function () {
         let issue = supportIssue();
         if (!issue) {
             readyState = 'booting';
-            up.emit('up:framework:boot', { log: false });
+            up.emit('up:framework:boot', { mode, log: false });
             readyState = 'booted';
-            up.emit('up:framework:booted', { log: false });
+            up.emit('up:framework:booted', { mode, log: false });
         }
         else {
             console.error("Unpoly cannot boot: %s", issue);
@@ -8134,7 +8104,7 @@ up.framework = (function () {
             console.debug('Call up.boot() after you have configured Unpoly');
         }
         else {
-            document.addEventListener('DOMContentLoaded', boot);
+            document.addEventListener('DOMContentLoaded', () => boot({ mode: 'auto' }));
         }
         readyState = 'configuring';
     }
@@ -8565,6 +8535,7 @@ up.script = (function () {
         '[up-expand]': -300,
         '[data-method]': -400,
         '[data-confirm]': -400,
+        '[up-keep]': 9999999999,
     };
     let registeredCompilers = [];
     let registeredMacros = [];
@@ -8841,6 +8812,8 @@ up.history = (function () {
         placeAdoptedHistoryEntry('replaceState', location, trackOptions);
     }
     function push(location, trackOptions) {
+        if (isLocation(location))
+            return;
         placeAdoptedHistoryEntry('pushState', location, trackOptions);
     }
     function placeAdoptedHistoryEntry(method, location, trackOptions) {
@@ -8887,7 +8860,7 @@ up.history = (function () {
             restoreLocation(event.location);
         }
         else if (event.reason === 'hash') {
-            up.viewport.revealHash(event.hash, { strong: true });
+            up.viewport.revealHash(location.hash, { strong: true });
         }
     }
     function findMetaTags(head = document.head) {
@@ -8928,14 +8901,13 @@ up.history = (function () {
             adopt();
         }
     }
-    up.on('up:framework:boot', function () {
+    up.on('up:framework:boot', function ({ mode }) {
         trackCurrentLocation({ reason: null, alreadyHandled: true });
         patchHistoryAPI();
         adoptInitialHistoryEntry();
-    });
-    up.on('DOMContentLoaded', function () {
-        up.viewport.revealHash({ strong: true });
-        u.task(up.viewport.revealHash);
+        if (mode === 'auto') {
+            up.viewport.revealHash(location.hash, { strong: true });
+        }
     });
     up.on(window, 'hashchange, popstate', () => {
         trackCurrentLocation({ reason: 'detect', alreadyHandled: false });
@@ -9063,6 +9035,7 @@ up.fragment = (function () {
         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 }) {
@@ -9098,6 +9071,76 @@ up.fragment = (function () {
         const options = parseTargetAndOptions(args);
         return render({ ...options, navigate: true });
     });
+    function emitFragmentKeep(keepPlan) {
+        let { oldElement, newElement: newFragment, newData, renderOptions } = keepPlan;
+        const log = ['Keeping fragment %o', oldElement];
+        const callback = e.callbackAttr(keepPlan.oldElement, 'up-on-keep', { exposedKeys: ['newFragment', 'newData'] });
+        const event = up.event.build('up:fragment:keep', { newFragment, newData, renderOptions });
+        return up.emit(oldElement, event, { log, callback });
+    }
+    function findKeepPlan(options) {
+        if (options.keep === false)
+            return;
+        const { oldElement, newElement } = options;
+        let oldElementMode = keepMode(oldElement);
+        if (!oldElementMode) {
+            return;
+        }
+        let partner;
+        let partnerSelector = up.fragment.toTarget(oldElement);
+        const lookupOpts = { layer: options.layer };
+        if (options.descendantsOnly) {
+            partner = up.fragment.get(newElement, partnerSelector, lookupOpts);
+        }
+        else {
+            partner = e.subtreeFirst(newElement, partnerSelector, lookupOpts);
+        }
+        if (!partner)
+            return;
+        let partnerMode = keepMode(partner);
+        if (partnerMode === false)
+            return;
+        let oldIdentity = keepIdentity(oldElement, oldElementMode);
+        let partnerIdentity = keepIdentity(partner, oldElementMode);
+        if (!u.isEqual(oldIdentity, partnerIdentity))
+            return;
+        const plan = {
+            oldElement,
+            newElement: partner,
+            newData: up.script.data(partner),
+            renderOptions: options,
+        };
+        if (emitFragmentKeep(plan).defaultPrevented)
+            return;
+        return plan;
+    }
+    function keepIdentity(element, mode = keepMode(element)) {
+        return element.upKeepIdentity ??= u.copy(buildKeepIdentity(element, mode));
+    }
+    function defaultNormalizeKeepHTML(html) {
+        let tagPattern = /<[^<]+>/g;
+        let attrs = ['up-etag', 'up-source', 'up-time', 'nonce', ...up.script.config.nonceableAttributes];
+        let attrPattern = new RegExp(`\\s+(${attrs.join('|')})="[^"]*"`, 'g');
+        let cleanTag = (match) => match.replace(attrPattern, '');
+        html = html.replace(tagPattern, cleanTag);
+        html = html.replace(/^[ \t]+/mg, '');
+        return html;
+    }
+    function buildKeepIdentity(element, mode) {
+        if (mode === 'same-html') {
+            return config.normalizeKeepHTML(element.outerHTML);
+        }
+        else if (mode === 'same-data') {
+            return up.data(element);
+        }
+        else {
+            return true;
+        }
+    }
+    up.macro('[up-keep]', (element) => keepIdentity(element));
+    function keepMode(element) {
+        return e.booleanOrStringAttr(element, 'up-keep');
+    }
     function emitFragmentInserted(element) {
         if (element.upInserted)
             return;
@@ -9106,13 +9149,6 @@ up.fragment = (function () {
             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(keepPlan.oldElement, 'up-on-keep', { exposedKeys: ['newFragment', 'newData'] });
-        const event = up.event.build('up:fragment:keep', { newFragment, newData, renderOptions });
-        return up.emit(oldElement, event, { log, callback });
-    }
     function emitFragmentDestroyed(fragment, options) {
         const log = options.log ?? ['Destroyed fragment %o', fragment];
         const parent = options.parent || document;
@@ -9570,8 +9606,8 @@ up.fragment = (function () {
     }
     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.');
         }
@@ -9595,6 +9631,8 @@ up.fragment = (function () {
         emitInserted: emitFragmentInserted,
         emitDestroyed: emitFragmentDestroyed,
         emitKeep: emitFragmentKeep,
+        keepPlan: findKeepPlan,
+        defaultNormalizeKeepHTML,
         successKey,
         failKey,
         expandTargets,
@@ -9710,7 +9748,7 @@ up.viewport = (function () {
     function revealHash(...args) {
         return revealHashFn(...args)?.();
     }
-    function revealHashFn(hash = location.hash, { strong, layer, origin, behavior = 'instant' } = {}) {
+    function revealHashFn(hash, { strong, layer, origin, behavior = 'instant' } = {}) {
         if (!hash)
             return;
         let match = firstHashTarget(hash, { layer, origin });
@@ -10010,7 +10048,7 @@ up.motion = (function () {
     }
     function animateNow(element, lastFrame, options) {
         if (up.migrate.loaded)
-            lastFrame = up.migrate.fixStyleProps(lastFrame);
+            lastFrame = up.migrate.fixSetStyleProps(lastFrame);
         options = { ...options, finishEvent: motionController.finishEvent };
         const cssTransition = new up.CSSTransition(element, lastFrame, options);
         return cssTransition.start();
@@ -10132,8 +10170,7 @@ up.motion = (function () {
     }
     function registerOpacityAnimation(name, from, to) {
         namedAnimations.put(name, function (element, options) {
-            element.style.opacity = 0;
-            e.setStyle(element, { opacity: from });
+            element.style.opacity = from;
             return animateNow(element, { opacity: to }, options);
         });
     }
@@ -10279,20 +10316,25 @@ up.network = (function () {
         u.always(request, function (responseOrError) {
             cache.expire(responseOrError.expireCache ?? false, { except: request });
             cache.evict(responseOrError.evictCache ?? false, { except: request });
-            let hasCacheEntry = cache.get(request);
             let isResponse = responseOrError instanceof up.Response;
             let isNetworkError = !isResponse;
             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);
+                }
             }
         });
     }
@@ -10306,16 +10348,6 @@ up.network = (function () {
         up.migrate.preprocessAbortArgs?.(args);
         queue.abort(...args);
     }
-    function registerAliasForRedirect(request, response) {
-        if (request.cache && response.url && request.url !== response.url) {
-            const newRequest = u.variant(request, {
-                method: response.method,
-                url: response.url,
-                cacheRoute: null,
-            });
-            cache.alias(request, newRequest);
-        }
-    }
     function isSafeMethod(method) {
         return u.contains(['GET', 'OPTIONS', 'HEAD'], u.normalizeMethod(method));
     }
@@ -10337,7 +10369,6 @@ up.network = (function () {
         isSafeMethod,
         config,
         abort: abortRequests,
-        registerAliasForRedirect,
         queue,
         loadPage,
     };
@@ -10967,6 +10998,7 @@ up.form = (function () {
         watchInputDelay: 0,
         watchChangeEvents: ['change'],
         watchableEvents: ['input', 'change'],
+        arrayParam: (name) => name.endsWith('[]'),
     }));
     function fieldSelector(suffix = '') {
         return config.fieldSelectors.map((field) => field + suffix).join();
@@ -11048,6 +11080,8 @@ up.form = (function () {
         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;
     }
@@ -11113,8 +11147,7 @@ up.form = (function () {
             options.method ||= submitButton.getAttribute('formmethod');
             options.url ||= submitButton.getAttribute('formaction');
         }
-        params.addAll(options.params);
-        options.params = params;
+        options.params = up.Params.merge(params, options.params);
         parser.string('url', { attr: 'action', default: up.fragment.source(form) });
         parser.string('method', {
             attr: ['up-method', 'data-method', 'method'],
@@ -11207,10 +11240,10 @@ up.form = (function () {
     function trackFields(...args) {
         let [root, { guard }, callback] = u.args(args, 'val', 'options', 'callback');
         let filter = function (fields) {
-            let scope = getRegion(root);
+            let region = getRegion(root);
             return u.filter(fields, function (field) {
-                return (root === scope || root.contains(field))
-                    && (getForm(field) === scope)
+                return (root === region || root.contains(field))
+                    && (getRegion(field) === region)
                     && (!guard || guard(field));
             });
         };
@@ -11287,29 +11320,38 @@ up.status = (function () {
         noNavSelectors: ['[up-nav=false]'],
     }));
     let namedPreviewFns = new up.Registry('preview');
-    function reset() {
-        up.layer.root.feedbackLocation = null;
-    }
     const SELECTOR_LINK = 'a, [up-href]';
     function linkCurrentURLs(link) {
         return link.upCurrentURLs ||= new up.LinkCurrentURLs(link);
     }
-    function updateFragment(fragment, { layer } = {}) {
-        layer ||= up.layer.get(fragment);
-        let layerLocation = getMatchableLayerLocation(layer);
-        const navSelector = config.selector('navSelectors');
-        const navLinkSelector = `${navSelector} :is(${SELECTOR_LINK}), ${navSelector}:is(${SELECTOR_LINK})`;
-        const links = up.fragment.all(navLinkSelector, { layer });
-        for (let link of links) {
-            const isCurrent = linkCurrentURLs(link).isCurrent(layerLocation);
-            for (let currentClass of config.currentClasses) {
-                link.classList.toggle(currentClass, isCurrent);
+    function getNavLocations(nav) {
+        let layerRef = e.attr(nav, 'up-layer') || 'origin';
+        let layers = up.layer.getAll(layerRef, { origin: nav });
+        return u.compact(layers.map(getMatchableLayerLocation));
+    }
+    function updateNav(nav, links, { newLinks, anyLocationChanged }) {
+        let currentLocations = (!anyLocationChanged && nav.upNavLocations) || getNavLocations(nav);
+        if (newLinks || !u.isEqual(nav.upNavLocations, currentLocations)) {
+            for (let link of links) {
+                const isCurrent = linkCurrentURLs(link).isAnyCurrent(currentLocations);
+                for (let currentClass of config.currentClasses) {
+                    link.classList.toggle(currentClass, isCurrent);
+                }
+                e.setAttrPresence(link, 'aria-current', 'page', isCurrent);
             }
-            e.setAttrPresence(link, 'aria-current', 'page', isCurrent);
+            nav.upNavLocations = currentLocations;
+        }
+    }
+    function updateNavsAround(root, opts) {
+        const navSelector = config.selector('navSelectors');
+        const fullNavs = e.around(root, navSelector);
+        for (let fullNav of fullNavs) {
+            let links = e.subtree(fullNav, SELECTOR_LINK);
+            updateNav(fullNav, links, opts);
         }
     }
     function getMatchableLayerLocation(layer) {
-        return layer.feedbackLocation || u.matchableURL(layer.location);
+        return u.matchableURL(layer.location);
     }
     function findActivatableArea(element) {
         return e.ancestor(element, SELECTOR_LINK) || element;
@@ -11393,30 +11435,12 @@ 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: namedPreviewFns.put,
@@ -11586,7 +11610,7 @@ up.radio = (function () {
 /******/ 	
 /************************************************************************/
 var __webpack_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
 (() => {
 __webpack_require__(1);
 __webpack_require__(2);