unpoly-rails 3.11.0.rc1 → 3.11.0.rc12

data/assets/unpoly/unpoly.es6.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;
     }
@@ -424,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];
             }
         }
@@ -527,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) {
@@ -795,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;
         };
@@ -838,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
@@ -869,6 +878,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,
@@ -977,6 +994,7 @@ up.util = (function () {
         maskPattern,
         expressionOutline,
         parseString,
+        assert,
     };
 })();
 
@@ -1544,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);
         }
@@ -1554,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);
         }
@@ -1630,18 +1648,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,
@@ -1710,8 +1716,6 @@ up.element = (function () {
         matchSelectorMap,
         elementLikeMatches,
         documentPosition,
-        preservingAppend,
-        preservingReplace,
     };
 })();
 
@@ -2192,8 +2196,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);
     }
 };
 
@@ -2214,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();
@@ -2225,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;
@@ -2240,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) {
@@ -2253,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();
@@ -2276,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);
             }
@@ -2288,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();
@@ -2462,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();
@@ -2471,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;
@@ -2489,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* () {
@@ -2511,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() {
@@ -2630,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();
@@ -2722,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);
@@ -2761,10 +2774,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);
@@ -2777,10 +2789,8 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                             up.fragment.markAsDestroying(step.oldElement);
                         }, 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 });
                         }, afterDetach() {
@@ -2807,53 +2817,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(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);
@@ -2868,7 +2852,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);
                 }
@@ -2878,12 +2862,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();
             }
@@ -3114,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);
@@ -3268,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);
@@ -3347,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 {
@@ -3976,6 +3953,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);
@@ -4068,9 +4048,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);
         }
     }
@@ -4111,7 +4091,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 === null || scope === void 0 ? void 0 : scope.contains(match));
         };
         let onSwitcheeAdded = (switchee) => this._switchSwitchee(switchee);
         return up.fragment.trackSelector(this._switcheeSelector, { filter }, onSwitcheeAdded);
@@ -4142,10 +4122,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) {
@@ -4159,45 +4140,17 @@ up.Switcher = class Switcher {
         return u.getSimpleTokens(str, { json: true });
     }
     _buildFieldTokens() {
-        var _a, _b;
+        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);
-        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 = ((_b = (_a = up.migrate).checkedRadioButtonForSwitch) === null || _b === void 0 ? void 0 : _b.call(_a, 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 ((_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');
         }
-        if (u.isPresent(meta)) {
-            values.push(meta);
-        }
-        return values;
+        return tokens;
     }
 };
 
@@ -4714,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) {
@@ -4727,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() {
@@ -4927,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);
     }
@@ -5034,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) {
@@ -5064,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;
         }
@@ -5099,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);
         }
@@ -5113,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);
         }
@@ -5127,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, 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) {
@@ -5286,7 +5244,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);
@@ -5295,7 +5253,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);
@@ -5392,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) {
@@ -5901,6 +5859,14 @@ 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)));
+        });
+    }
 };
 
 
@@ -6244,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 += "=";
@@ -6260,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()];
@@ -6295,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];
@@ -6350,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;
@@ -6422,11 +6389,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;
     }
 };
 
@@ -6728,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 {
@@ -6767,13 +6739,14 @@ up.RenderResult = class RenderResult extends up.Record {
             'fragments',
             'layer',
             'target',
-            'options',
+            'renderOptions',
             'finished',
         ];
     }
     defaults() {
         return {
             fragments: [],
+            finished: Promise.resolve(),
         };
     }
     get none() {
@@ -6782,28 +6755,20 @@ 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(),
-        });
-    }
 };
 
 
@@ -7290,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* () {
@@ -7397,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());
@@ -7437,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());
     }
@@ -7501,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);
@@ -7578,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;
@@ -7678,6 +7631,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;
+    }
 };
 
 
@@ -8239,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;
@@ -8247,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);
@@ -8273,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';
     }
@@ -8707,6 +8674,7 @@ up.script = (function () {
         '[up-expand]': -300,
         '[data-method]': -400,
         '[data-confirm]': -400,
+        '[up-keep]': 9999999999,
     };
     let registeredCompilers = [];
     let registeredMacros = [];
@@ -8980,6 +8948,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) {
@@ -9026,7 +8996,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) {
@@ -9067,14 +9037,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 });
@@ -9203,6 +9172,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 }) {
@@ -9238,6 +9208,77 @@ 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;
@@ -9246,13 +9287,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) {
         var _a;
         const log = (_a = options.log) !== null && _a !== void 0 ? _a : ['Destroyed fragment %o', fragment];
@@ -9712,8 +9746,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.');
         }
@@ -9737,6 +9771,8 @@ up.fragment = (function () {
         emitInserted: emitFragmentInserted,
         emitDestroyed: emitFragmentDestroyed,
         emitKeep: emitFragmentKeep,
+        keepPlan: findKeepPlan,
+        defaultNormalizeKeepHTML,
         successKey,
         failKey,
         expandTargets,
@@ -9851,7 +9887,7 @@ up.viewport = (function () {
         var _a;
         return (_a = revealHashFn(...args)) === null || _a === void 0 ? void 0 : _a();
     }
-    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 });
@@ -10158,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();
@@ -10283,8 +10319,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);
         });
     }
@@ -10433,20 +10468,25 @@ up.network = (function () {
             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 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);
+                }
             }
         });
     }
@@ -10461,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));
     }
@@ -10492,7 +10522,6 @@ up.network = (function () {
         isSafeMethod,
         config,
         abort: abortRequests,
-        registerAliasForRedirect,
         queue,
         loadPage,
     };
@@ -11107,6 +11136,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();
@@ -11189,6 +11219,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;
     }
@@ -11255,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'],
@@ -11350,10 +11381,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));
             });
         };
@@ -11430,29 +11461,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 || (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;
@@ -11536,30 +11576,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,
@@ -11706,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);