unpoly-rails 3.11.0 → 3.12.0

data/assets/unpoly/unpoly.es6.js

@@ -5,7 +5,7 @@
 /***/ (() => {
 
 window.up = {
-    version: '3.11.0'
+    version: '3.12.0'
 };
 
 
@@ -395,6 +395,9 @@ up.util = (function () {
         return setTimeout(callback, millis);
     }
     function queueTask(task) {
+        setTimeout(task);
+    }
+    function queueFastTask(task) {
         const channel = new MessageChannel();
         channel.port1.onmessage = () => task();
         channel.port2.postMessage(0);
@@ -778,7 +781,7 @@ up.util = (function () {
     function scanFunctions(...values) {
         return values.flat().filter(isFunction);
     }
-    function cleaner() {
+    function cleaner(order = 'lifo') {
         let fns = [];
         let track = function (values, transform) {
             values = scanFunctions(...values).map(transform);
@@ -791,9 +794,9 @@ up.util = (function () {
             track(values, up.error.guardFn);
         };
         api.clean = function (...args) {
-            let { length } = fns;
-            for (let i = length - 1; i >= 0; i--)
-                fns[i](...args);
+            if (order === 'lifo')
+                fns.reverse();
+            fns.forEach((fn) => fn(...args));
             fns = [];
         };
         return api;
@@ -969,6 +972,7 @@ up.util = (function () {
         isBasicObjectProperty,
         isCrossOrigin,
         task: queueTask,
+        fastTask: queueFastTask,
         isEqual,
         getSimpleTokens,
         getComplexTokens,
@@ -1034,6 +1038,9 @@ up.error = (function () {
             reportError(error);
         }
     }
+    function guardPromise(promise) {
+        return promise.catch(reportError);
+    }
     function guardFn(fn) {
         return (...args) => guard(() => fn(...args));
     }
@@ -1043,6 +1050,7 @@ up.error = (function () {
         muteUncriticalRejection,
         muteUncriticalSync,
         guard,
+        guardPromise,
         guardFn,
     };
 })();
@@ -1359,6 +1367,10 @@ up.element = (function () {
         return `.${klass}`;
     }
     function createBrokenDocumentFromHTML(html) {
+        const firstTag = firstTagNameInHTML(html);
+        if (['TR', 'TD', 'TH', 'THEAD', 'TBODY'].includes(firstTag)) {
+            html = `<table>${html}</table>`;
+        }
         return new DOMParser().parseFromString(html, 'text/html');
     }
     function revivedClone(element) {
@@ -1648,6 +1660,15 @@ up.element = (function () {
             return [element.parentElement, 'beforeend'];
         }
     }
+    const FIRST_TAG_NAME_PATTERN = /^\s*(<!--[^-]*.*?-->\s*)*<([a-z-!]+)\b/i;
+    function firstTagNameInHTML(html) {
+        var _a;
+        return (_a = FIRST_TAG_NAME_PATTERN.exec(html)) === null || _a === void 0 ? void 0 : _a[2].toUpperCase();
+    }
+    function isFullDocumentHTML(html) {
+        let firstTag = firstTagNameInHTML(html);
+        return firstTag === 'HTML' || firstTag === '!DOCTYPE';
+    }
     return {
         subtree,
         subtreeFirst,
@@ -1716,6 +1737,8 @@ up.element = (function () {
         matchSelectorMap,
         elementLikeMatches,
         documentPosition,
+        firstTagNameInHTML,
+        isFullDocumentHTML,
     };
 })();
 
@@ -1916,12 +1939,13 @@ const u = up.util;
 const e = up.element;
 up.OptionsParser = class OptionsParser {
     constructor(element, options, parserOptions = {}) {
+        var _a;
         this._options = options;
         this._element = element;
         this._fail = parserOptions.fail;
         this._closest = parserOptions.closest;
         this._attrPrefix = parserOptions.attrPrefix || 'up-';
-        this._defaults = parserOptions.defaults || {};
+        this._defaults = (_a = parserOptions.defaults) !== null && _a !== void 0 ? _a : {};
     }
     string(key, keyOptions) {
         this.parse(e.attr, key, keyOptions);
@@ -1952,7 +1976,9 @@ up.OptionsParser = class OptionsParser {
         for (let attrName of attrNames) {
             value !== null && value !== void 0 ? value : (value = this._parseFromAttr(attrValueFn, this._element, attrName));
         }
-        value !== null && value !== void 0 ? value : (value = (_b = keyOptions.default) !== null && _b !== void 0 ? _b : this._defaults[key]);
+        if (this._defaults !== false) {
+            value !== null && value !== void 0 ? value : (value = (_b = keyOptions.default) !== null && _b !== void 0 ? _b : this._defaults[key]);
+        }
         if (u.isDefined(value)) {
             let normalizeFn = keyOptions.normalize;
             if (normalizeFn) {
@@ -2050,6 +2076,14 @@ up.Rect = class Rect extends up.Record {
     static fromElement(element) {
         return new (this)(element.getBoundingClientRect());
     }
+    static fromElementAsFixed(element) {
+        let fixedClone = element.cloneNode(true);
+        element.after(fixedClone);
+        fixedClone.style.position = 'fixed';
+        let rect = this.fromElement(fixedClone);
+        fixedClone.remove();
+        return rect;
+    }
 };
 
 
@@ -2124,6 +2158,11 @@ up.Change = class Change {
     deriveFailOptions() {
         return up.RenderOptions.deriveFailOptions(this.options);
     }
+    ensureLayerAlive(layer = this.layer) {
+        if (!layer.isAlive()) {
+            throw new up.Aborted("Layer is already " + layer.state);
+        }
+    }
 };
 
 
@@ -2144,18 +2183,18 @@ up.Change.Addition = class Addition extends up.Change {
     handleLayerChangeRequests() {
         if (this.layer.isOverlay()) {
             this._tryAcceptLayerFromServer();
-            this.abortWhenLayerClosed();
+            this.ensureLayerAlive();
             this.layer.tryAcceptForLocation(this._responseOptions());
-            this.abortWhenLayerClosed();
+            this.ensureLayerAlive();
             this._tryDismissLayerFromServer();
-            this.abortWhenLayerClosed();
+            this.ensureLayerAlive();
             this.layer.tryDismissForLocation(this._responseOptions());
-            this.abortWhenLayerClosed();
+            this.ensureLayerAlive();
         }
         this.layer.asCurrent(() => {
             for (let eventPlan of this._eventPlans) {
                 up.emit(Object.assign(Object.assign({}, eventPlan), this._responseOptions()));
-                this.abortWhenLayerClosed();
+                this.ensureLayerAlive();
             }
         });
     }
@@ -2169,11 +2208,6 @@ up.Change.Addition = class Addition extends up.Change {
             this.layer.dismiss(this._dismissLayer, this._responseOptions());
         }
     }
-    abortWhenLayerClosed(layer = this.layer) {
-        if (layer.isClosed()) {
-            throw new up.Aborted('Layer was closed');
-        }
-    }
     _setSource({ oldElement, newElement, source }) {
         if (source === 'keep') {
             source = (oldElement && up.fragment.source(oldElement));
@@ -2300,16 +2334,16 @@ up.RenderJob = (_a = class RenderJob {
                 }
             }
         }
-        _handleAbortOption(request) {
+        _handleAbortOption({ bindFragments, bindLayer, origin, layer, request }) {
             let { abort } = this.renderOptions;
-            if (!abort || !up.network.isBusy())
+            if (!abort)
                 return;
-            let { bindFragments, bindLayer, origin, layer } = this._getChange().getPreflightProps();
             let abortOptions = {
                 except: request,
                 logOnce: ['up.render()', 'Change with { abort } option will abort other requests'],
                 newLayer: (layer === 'new'),
                 origin,
+                jid: this.renderOptions.jid,
             };
             if (abort === 'target') {
                 up.fragment.abort(bindFragments, Object.assign({}, abortOptions));
@@ -2457,7 +2491,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         else {
             this._content = this.responseDoc.select(this.target);
         }
-        if (!this._content || this._baseLayer.isClosed()) {
+        if (!this._content || !this._baseLayer.isAlive()) {
             throw new up.CannotMatch();
         }
     }
@@ -2478,7 +2512,7 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         this.layer.setContent(this._content);
         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._helloPromise = 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],
@@ -2487,9 +2521,9 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
         });
         this._handleScroll();
         this._newOverlayResult.finished = this._finish();
-        this.layer.opening = false;
+        this.layer.state = 'opened';
         this._emitOpenedEvent();
-        this.abortWhenLayerClosed();
+        this.ensureLayerAlive();
     }
     _renderOtherLayers() {
         if (this._otherLayersResult)
@@ -2503,17 +2537,17 @@ up.Change.OpenLayer = class OpenLayer extends up.Change.Addition {
     _finish() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.layer.startOpenAnimation();
-            this.abortWhenLayerClosed();
+            this.ensureLayerAlive();
             this._handleFocus();
+            yield this._helloPromise;
             return this._newOverlayResult;
         });
     }
     _buildLayer() {
-        const buildOptions = Object.assign(Object.assign({}, this.options), { opening: true });
         const beforeNew = (optionsWithLayerDefaults) => {
             return this.options = up.RenderOptions.finalize(optionsWithLayerDefaults);
         };
-        return up.layer.build(buildOptions, beforeNew);
+        return up.layer.build(this.options, beforeNew);
     }
     _handleHistory() {
         var _a;
@@ -2630,7 +2664,10 @@ up.Change.UpdateLayer = (_a = class UpdateLayer extends up.Change.Addition {
                 this.layer.peel({ history: !this._hasHistory() });
             }
             if (this.options.abort !== false) {
-                up.fragment.abort(this._getFragments(), { reason: 'Fragment is being replaced' });
+                up.fragment.abort(this._getFragments(), {
+                    reason: 'Fragment is being replaced',
+                    jid: this.options.jid,
+                });
             }
             Object.assign(this.layer.context, this._context);
             if (this._hasHistory()) {
@@ -2739,6 +2776,7 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
         this._steps = u.copy(u.assert(options.steps));
         this._passRenderOptions = u.assert(options.passRenderOptions);
         this._noneOptions = options.noneOptions || {};
+        this._finishDelays = [];
     }
     execute(responseDoc) {
         this.responseDoc = responseDoc;
@@ -2755,16 +2793,21 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
         }
         else {
             this._steps.reverse();
-            const motionEndPromises = this._steps.map((step) => this._executeStep(step));
-            this.renderResult.finished = this._finish(motionEndPromises);
+            up.fragment.mutate(() => {
+                const motionEndPromises = this._steps.map((step) => this._executeStep(step));
+                this.renderResult.finished = this._finish(motionEndPromises);
+            });
         }
         return this.renderResult;
     }
-    _finish(motionEndPromises) {
+    _delayFinish(delay) {
+        this._finishDelays.push(delay);
+    }
+    _finish() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(motionEndPromises);
+            yield Promise.all(this._finishDelays);
             for (let step of this._steps) {
-                this.abortWhenLayerClosed(step.layer);
+                this.ensureLayerAlive(step.layer);
             }
             return this.renderResult;
         });
@@ -2780,7 +2823,8 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                 if (keepPlan) {
                     this._handleFocus(step.oldElement, step);
                     this._handleScroll(step.oldElement, step);
-                    return Promise.resolve();
+                    up.fragment.emitKept(keepPlan);
+                    break;
                 }
                 else {
                     this._preserveDescendantKeepables(step);
@@ -2794,23 +2838,27 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                         }, beforeDetach: () => {
                             up.script.clean(step.oldElement, { layer: step.layer });
                         }, afterDetach() {
+                            var _a;
                             e.cleanJQuery();
                             up.fragment.emitDestroyed(step.oldElement, { parent, log: false });
+                            (_a = step.afterDetach) === null || _a === void 0 ? void 0 : _a.call(step);
                         }, scrollNew: () => {
                             this._handleFocus(step.newElement, step);
                             this._handleScroll(step.newElement, step);
                         } });
-                    return up.morph(step.oldElement, step.newElement, step.transition, morphOptions);
+                    this._delayFinish(up.morph(step.oldElement, step.newElement, step.transition, morphOptions));
+                    break;
                 }
             }
             case 'content': {
                 let oldWrapper = e.wrapChildren(step.oldElement);
                 let newWrapper = e.wrapChildren(step.newElement);
-                let wrapperStep = Object.assign(Object.assign({}, step), { placement: 'swap', oldElement: oldWrapper, newElement: newWrapper, focus: false });
-                return this._executeStep(wrapperStep).then(() => {
-                    e.unwrap(newWrapper);
-                    this._handleFocus(step.oldElement, step);
-                });
+                let wrapperStep = Object.assign(Object.assign({}, step), { placement: 'swap', oldElement: oldWrapper, newElement: newWrapper, focus: false, afterDetach: () => {
+                        e.unwrap(newWrapper);
+                        this._handleFocus(step.oldElement, step);
+                    } });
+                this._executeStep(wrapperStep);
+                break;
             }
             case 'before':
             case 'after': {
@@ -2820,7 +2868,8 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
                 this._welcomeElement(wrapper, step);
                 this._handleFocus(wrapper, step);
                 this._handleScroll(wrapper, step);
-                return up.animate(wrapper, step.animation, step).then(() => e.unwrap(wrapper));
+                this._delayFinish(up.animate(wrapper, step.animation, step).then(() => e.unwrap(wrapper)));
+                break;
             }
             default: {
                 up.fail('Unknown placement: %o', step.placement);
@@ -2830,7 +2879,7 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
     _welcomeElement(element, step) {
         this.responseDoc.finalizeElement(element);
         this.setReloadAttrs(step);
-        up.hello(element, step);
+        this._delayFinish(up.hello(element, step));
         this._addToResult(element);
     }
     _preserveDescendantKeepables(step) {
@@ -2871,6 +2920,7 @@ up.Change.UpdateSteps = class UpdateSteps extends up.Change.Addition {
     _finalizeDescendantKeepables(step) {
         for (let keepPlan of step.descendantKeepPlans) {
             keepPlan.oldElement.classList.remove('up-keeping');
+            up.fragment.emitKept(keepPlan);
         }
     }
     _willChangeBody() {
@@ -2897,7 +2947,7 @@ up.Change.CloseLayer = class CloseLayer extends up.Change {
         var _a, _b;
         super(options);
         this._verb = options.verb;
-        this._layer = up.layer.get(options);
+        this.layer = up.layer.get(options);
         this._origin = options.origin;
         this._value = options.value;
         this._preventable = (_a = options.preventable) !== null && _a !== void 0 ? _a : true;
@@ -2905,50 +2955,51 @@ up.Change.CloseLayer = class CloseLayer extends up.Change {
         this._history = (_b = options.history) !== null && _b !== void 0 ? _b : true;
     }
     execute() {
-        if (!this._layer.isOpen())
-            return;
+        this.ensureLayerAlive();
         up.browser.assertConfirmed(this.options);
         if (this._emitCloseEvent().defaultPrevented && this._preventable) {
             throw new up.Aborted('Close event was prevented');
         }
         this._emitClosingEvent();
-        up.fragment.abort({ reason: 'Layer is closing', layer: this._layer });
-        const { parent } = this._layer;
-        this._layer.peel();
-        this._layer.stack.remove(this._layer);
+        up.fragment.abort({ reason: 'Layer is closing', layer: this.layer });
+        this.layer.state = 'closing';
+        const { parent } = this.layer;
+        this.layer.peel();
+        this._handleFocus(parent);
+        this.layer.teardownHandlers();
+        this.layer.destroyElements(this.options);
+        this.layer.stack.remove(this.layer);
         if (this._history) {
             parent.restoreHistory();
         }
-        this._handleFocus(parent);
-        this._layer.teardownHandlers();
-        this._layer.destroyElements(this.options);
+        this.layer.state = 'closed';
         this._emitClosedEvent(parent);
     }
     _emitCloseEvent() {
-        let event = this._layer.emit(this._buildEvent(`up:layer:${this._verb}`), {
-            callback: this._layer.callback(`on${u.upperCaseFirst(this._verb)}`),
-            log: [`Will ${this._verb} ${this._layer} with value %o`, this._value]
+        let event = this.layer.emit(this._buildEvent(`up:layer:${this._verb}`), {
+            callback: this.layer.callback(`on${u.upperCaseFirst(this._verb)}`),
+            log: [`Will ${this._verb} ${this.layer} with value %o`, this._value]
         });
         this._value = event.value;
         return event;
     }
     _emitClosingEvent() {
         let event = this._buildEvent(`up:layer:${this._verb}ing`);
-        this._layer.emit(event, { log: false });
+        this.layer.emit(event, { log: false });
     }
     _emitClosedEvent(formerParent) {
         const verbPast = `${this._verb}ed`;
         const verbPastUpperCaseFirst = u.upperCaseFirst(verbPast);
-        return this._layer.emit(this._buildEvent(`up:layer:${verbPast}`), {
+        return this.layer.emit(this._buildEvent(`up:layer:${verbPast}`), {
             baseLayer: formerParent,
-            callback: this._layer.callback(`on${verbPastUpperCaseFirst}`),
+            callback: this.layer.callback(`on${verbPastUpperCaseFirst}`),
             ensureBubbles: true,
-            log: [`${verbPastUpperCaseFirst} ${this._layer} with value %o`, this._value]
+            log: [`${verbPastUpperCaseFirst} ${this.layer} with value %o`, this._value]
         });
     }
     _buildEvent(name) {
         return up.event.build(name, {
-            layer: this._layer,
+            layer: this.layer,
             value: this._value,
             origin: this._origin,
             response: this._response,
@@ -2956,11 +3007,11 @@ up.Change.CloseLayer = class CloseLayer extends up.Change {
     }
     _handleFocus(formerParent) {
         var _a;
-        let hadFocus = this._layer.hasFocus();
-        this._layer.overlayFocus.teardown();
+        let hadFocus = this.layer.hasFocus();
+        this.layer.overlayFocus.teardown();
         (_a = formerParent.overlayFocus) === null || _a === void 0 ? void 0 : _a.moveToFront();
         if (hadFocus) {
-            let newFocusElement = this._layer.origin || formerParent.element;
+            let newFocusElement = this.layer.origin || formerParent.element;
             up.focus(newFocusElement, { preventScroll: true });
         }
     }
@@ -2984,7 +3035,7 @@ var _a;
 const u = up.util;
 up.Change.FromURL = (_a = class FromURL extends up.Change {
         execute() {
-            var _b, _c, _d, _e;
+            var _b, _c;
             return __awaiter(this, void 0, void 0, function* () {
                 let newPageReason = this._newPageReason();
                 if (newPageReason) {
@@ -2992,11 +3043,12 @@ up.Change.FromURL = (_a = class FromURL extends up.Change {
                     up.network.loadPage(this.options);
                     return u.unresolvablePromise();
                 }
-                let request = this.request = up.request(this._getRequestAttrs());
+                let requestAttrs = this._getRequestAttrs();
+                let request = this.request = up.request(requestAttrs);
                 (_c = (_b = this.options).onRequestKnown) === null || _c === void 0 ? void 0 : _c.call(_b, request);
                 if (this.options.preload)
                     return request;
-                (_e = (_d = this.options).handleAbort) === null || _e === void 0 ? void 0 : _e.call(_d, request);
+                this.options.handleAbort(Object.assign({ request }, requestAttrs));
                 request.runPreviews(this.options);
                 return yield u.always(request, (responseOrError) => this._onRequestSettled(responseOrError));
             });
@@ -3080,6 +3132,7 @@ up.Change.FromResponse = (_a = class FromResponse extends up.Change {
             }
             else {
                 this._request.assertEmitted('up:fragment:loaded', Object.assign(Object.assign({}, this._loadedEventProps()), { callback: this.options.onLoaded, log: ['Loaded fragment from %s', this._response.description], skip: () => this._skip() }));
+                this._assetRenderableResponse();
             }
             let fail = (_b = u.evalOption(this.options.fail, this._response)) !== null && _b !== void 0 ? _b : !this._response.ok;
             if (fail) {
@@ -3087,6 +3140,11 @@ up.Change.FromResponse = (_a = class FromResponse extends up.Change {
             }
             return this._updateContentFromResponse(this.options);
         }
+        _assetRenderableResponse() {
+            if (!up.fragment.config.renderableResponse(this._response)) {
+                throw new up.CannotParse(['Cannot render response with content-type "%s" (configure with up.fragment.config.renderableResponse)', this._response.contentType]);
+            }
+        }
         _skip() {
             up.puts('up.render()', 'Skipping ' + this._response.description);
             this.options.target = ':none';
@@ -3223,7 +3281,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
             return plans;
         }
         _isRenderableLayer(layer) {
-            return (layer === 'new') || layer.isOpen();
+            return (layer === 'new') || layer.isAlive();
         }
         _filterLayers() {
             this._layers = u.filter(this._layers, this._isRenderableLayer);
@@ -3253,7 +3311,6 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
             return !(error instanceof up.CannotMatch);
         }
         _onPlanApplicable(plan) {
-            var _b, _c;
             let primaryPlan = this._getPlans()[0];
             if (plan !== primaryPlan) {
                 up.puts('up.render()', 'Could not match primary target "%s". Updating a fallback target "%s".', primaryPlan.target, plan.target);
@@ -3262,7 +3319,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
             if (assets) {
                 up.script.assertAssetsOK(assets, plan.options);
             }
-            (_c = (_b = this.options).handleAbort) === null || _c === void 0 ? void 0 : _c.call(_b, null);
+            this.options.handleAbort(this.getPreflightProps());
         }
         _getResponseDoc() {
             var _b, _c;
@@ -3359,8 +3416,17 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
 
 /***/ }),
 /* 35 */
-/***/ (() => {
+/***/ (function() {
 
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 const u = up.util;
 up.CompilerPass = class CompilerPass {
     constructor(root, compilers, { layer, data, dataRoot, dataMap, meta }) {
@@ -3371,6 +3437,7 @@ up.CompilerPass = class CompilerPass {
         this._data = data;
         this._dataRoot = dataRoot || root;
         this._dataMap = dataMap;
+        this._compilePromises = [];
         meta || (meta = {});
         meta.layer = layer;
         this._meta = meta;
@@ -3382,6 +3449,7 @@ up.CompilerPass = class CompilerPass {
                 this._runCompiler(compiler);
             }
         });
+        return Promise.all(this._compilePromises);
     }
     setCompileData() {
         if (this._data) {
@@ -3412,7 +3480,7 @@ up.CompilerPass = class CompilerPass {
                 this._compileOneElement(compiler, match);
             }
         }
-        return (_b = (_a = up.migrate).postCompile) === null || _b === void 0 ? void 0 : _b.call(_a, matches, compiler);
+        (_b = (_a = up.migrate).postCompile) === null || _b === void 0 ? void 0 : _b.call(_a, matches, compiler);
     }
     _compileOneElement(compiler, element) {
         const compileArgs = [element];
@@ -3420,8 +3488,8 @@ up.CompilerPass = class CompilerPass {
             const data = up.script.data(element);
             compileArgs.push(data, this._meta);
         }
-        const result = this._applyCompilerFunction(compiler, element, compileArgs);
-        up.destructor(element, result);
+        let onDestructor = (destructor) => up.destructor(element, destructor);
+        this._applyCompilerFunction(compiler, element, compileArgs, onDestructor);
     }
     _compileBatch(compiler, elements) {
         const compileArgs = [elements];
@@ -3429,26 +3497,40 @@ up.CompilerPass = class CompilerPass {
             const dataList = u.map(elements, up.script.data);
             compileArgs.push(dataList, this._meta);
         }
-        const result = this._applyCompilerFunction(compiler, elements, compileArgs);
-        if (result) {
-            up.fail('Compilers with { batch: true } cannot return destructors');
-        }
+        let onDestructor = () => this._reportBatchCompilerWithDestructor(compiler);
+        this._applyCompilerFunction(compiler, elements, compileArgs, onDestructor);
     }
-    _applyCompilerFunction(compiler, elementOrElements, compileArgs) {
-        return up.error.guard(() => compiler.apply(elementOrElements, compileArgs));
+    _applyCompilerFunction(compiler, elementOrElements, compileArgs, onDestructor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let maybeDestructor = up.error.guard(() => compiler.apply(elementOrElements, compileArgs));
+            if (u.isPromise(maybeDestructor)) {
+                let guardedPromise = up.error.guardPromise(maybeDestructor);
+                this._compilePromises.push(guardedPromise);
+                maybeDestructor = yield guardedPromise;
+            }
+            if (maybeDestructor)
+                onDestructor(maybeDestructor);
+        });
+    }
+    _reportBatchCompilerWithDestructor(compiler) {
+        let error = new up.Error(['Batch compiler (%s) cannot return a destructor', compiler.selector]);
+        reportError(error);
     }
     _select(selector) {
         return up.fragment.subtree(this._root, u.evalOption(selector), { layer: this._layer });
     }
     _selectOnce(compiler) {
         let matches = this._select(compiler.selector);
-        return u.filter(matches, (element) => {
-            let appliedCompilers = (element.upAppliedCompilers || (element.upAppliedCompilers = new Set()));
-            if (!appliedCompilers.has(compiler)) {
-                appliedCompilers.add(compiler);
-                return true;
-            }
-        });
+        if (!compiler.rerun) {
+            matches = u.filter(matches, (element) => {
+                let appliedCompilers = (element.upAppliedCompilers || (element.upAppliedCompilers = new Set()));
+                if (!appliedCompilers.has(compiler)) {
+                    appliedCompilers.add(compiler);
+                    return true;
+                }
+            });
+        }
+        return matches;
     }
 };
 
@@ -3871,24 +3953,28 @@ up.EventListenerGroup = class EventListenerGroup extends up.Record {
 const u = up.util;
 up.SelectorTracker = class SelectorTracker {
     constructor(selector, options, addCallback) {
-        var _a;
         this._selector = selector;
         this._addCallback = addCallback;
         this._layer = options.layer || 'any';
         this._filter = options.filter || u.identity;
-        this._live = (_a = options.live) !== null && _a !== void 0 ? _a : true;
         this._knownMatches = new Map();
+        this._syncScheduled = false;
     }
     start() {
-        this._sync();
+        this._scheduleSync();
         return u.sequence(this._trackFragments(), () => this._removeAllMatches());
     }
     _trackFragments() {
-        if (this._live) {
-            return up.on('up:fragment:inserted up:fragment:destroyed', () => this._sync());
+        return up.on('up:fragment:inserted up:fragment:destroyed', () => this._scheduleSync());
+    }
+    _scheduleSync() {
+        if (!this._syncScheduled) {
+            this._syncScheduled = true;
+            up.fragment.afterMutate(() => this._sync());
         }
     }
     _sync() {
+        this._syncScheduled = false;
         let removeMap = new Map(this._knownMatches);
         this._knownMatches.clear();
         for (let newMatch of this._currentMatches) {
@@ -3943,7 +4029,7 @@ up.FieldWatcher = class FieldWatcher {
         this._processedValues = this._readFieldValues();
         this._currentTimer = null;
         this._callbackRunning = false;
-        return u.sequence(up.form.trackFields(this._root, (field) => this._watchField(field)), this._trackAbort(), this._trackReset(), () => this._abort());
+        return u.sequence(this._trackFields(), this._trackAbort(), this._trackReset(), () => this._abort());
     }
     _ensureWatchable() {
         const fail = (message) => up.fail(message, this._logPrefix, this._root);
@@ -3957,6 +4043,14 @@ up.FieldWatcher = class FieldWatcher {
             fail('%s can only watch fields with a name (%o)');
         }
     }
+    _trackFields() {
+        if (up.form.isField(this._root)) {
+            return this._watchField(this._root);
+        }
+        else {
+            return up.form.trackFields(this._root, (field) => this._watchField(field));
+        }
+    }
     _trackAbort() {
         let guard = ({ target }) => target.contains(this._region);
         return up.on('up:fragment:aborted', { guard }, () => this._abort());
@@ -4630,65 +4724,79 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
 /***/ (() => {
 
 const e = up.element;
+const u = up.util;
 up.FragmentPolling = class FragmentPolling {
+    static forFragment(fragment) {
+        return fragment.upPolling || (fragment.upPolling = new this(fragment));
+    }
     constructor(fragment) {
         this._options = up.radio.pollOptions(fragment);
         this._fragment = fragment;
         up.destructor(fragment, this._onFragmentDestroyed.bind(this));
-        up.fragment.onAborted(fragment, this._onFragmentAborted.bind(this));
-        this._state = 'initialized';
-        this._abortable = true;
+        this._state = 'stopped';
+        this._forceIntent = null;
+        this._reloadJID = u.uid();
         this._loading = false;
         this._satisfyInterval();
     }
-    static forFragment(fragment) {
-        return fragment.upPolling || (fragment.upPolling = new this(fragment));
-    }
     onPollAttributeObserved() {
         this._start();
     }
+    _onFragmentAborted({ newLayer, jid }) {
+        const isOurAbort = (jid === this._reloadJID);
+        if (isOurAbort || newLayer)
+            return;
+        this._stop();
+    }
+    _onFragmentKept() {
+        if (this._forceIntent !== 'stop') {
+            this._start();
+        }
+    }
     _onFragmentDestroyed() {
         this._stop();
     }
     _start(options) {
         Object.assign(this._options, options);
-        if (this._state !== 'started') {
+        if (this._state === 'stopped') {
             if (!up.fragment.isTargetable(this._fragment)) {
                 up.warn('[up-poll]', 'Cannot poll untargetable fragment %o', this._fragment);
                 return;
             }
             this._state = 'started';
-            this._ensureEventsBound();
+            this._bindEvents();
             this._scheduleRemainingTime();
         }
     }
     _stop() {
-        var _a;
         if (this._state === 'started') {
             this._clearReloadTimer();
             this._state = 'stopped';
-            (_a = this._unbindEvents) === null || _a === void 0 ? void 0 : _a.call(this);
         }
     }
     forceStart(options) {
         Object.assign(this._options, options);
-        this.forceStarted = true;
+        this._forceIntent = 'start';
         this._start();
     }
     forceStop() {
+        this._forceIntent = 'stop';
         this._stop();
-        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));
-        }
+    _bindEvents() {
+        if (this._eventsBound)
+            return;
+        this._eventsBound = true;
+        up.destructor(this._fragment, up.on('visibilitychange up:layer:opened up:layer:dismissed up:layer:accepted', this._onVisibilityChange.bind(this)));
+        up.fragment.onAborted(this._fragment, this._onFragmentAborted.bind(this));
+        up.fragment.onKept(this._fragment, this._onFragmentKept.bind(this));
     }
     _onVisibilityChange() {
         if (this._isFragmentVisible()) {
             this._scheduleRemainingTime();
         }
         else {
+            this._clearReloadTimer();
         }
     }
     _isFragmentVisible() {
@@ -4700,17 +4808,17 @@ up.FragmentPolling = class FragmentPolling {
         this._reloadTimer = null;
     }
     _scheduleRemainingTime() {
-        if (!this._reloadTimer && !this._loading) {
-            this._clearReloadTimer();
-            this._reloadTimer = setTimeout(this._onTimerReached.bind(this), this._getRemainingDelay());
-        }
+        if (this._reloadTimer || this._loading || this._state === 'stopped')
+            return;
+        this._clearReloadTimer();
+        this._reloadTimer = setTimeout(this._onTimerReached.bind(this), this._getRemainingDelay());
     }
     _onTimerReached() {
         this._reloadTimer = null;
         this._tryReload();
     }
     _tryReload() {
-        if (this._state !== 'started') {
+        if (this._state === 'stopped') {
             return;
         }
         if (!up.fragment.isAlive(this._fragment)) {
@@ -4741,24 +4849,10 @@ up.FragmentPolling = class FragmentPolling {
     }
     _reloadNow() {
         this._clearReloadTimer();
-        let oldAbortable = this._abortable;
-        try {
-            this._abortable = false;
-            this._loading = true;
-            up.reload(this._fragment, this._reloadOptions()).then(this._onReloadSuccess.bind(this), this._onReloadFailure.bind(this));
-        }
-        finally {
-            this._abortable = oldAbortable;
-        }
-    }
-    _reloadOptions() {
+        this._loading = true;
         let guardEvent = up.event.build('up:fragment:poll', { log: ['Polling fragment', this._fragment] });
-        return Object.assign(Object.assign({}, this._options), { guardEvent });
-    }
-    _onFragmentAborted({ newLayer }) {
-        if (this._abortable && !newLayer) {
-            this._stop();
-        }
+        let reloadOptions = Object.assign(Object.assign({}, this._options), { guardEvent, jid: this._reloadJID });
+        up.reload(this._fragment, reloadOptions).then(this._onReloadSuccess.bind(this), this._onReloadFailure.bind(this));
     }
     _onReloadSuccess({ fragment }) {
         this._loading = false;
@@ -4771,8 +4865,7 @@ up.FragmentPolling = class FragmentPolling {
         }
     }
     _onFragmentSwapped(newFragment) {
-        this._stop();
-        if (this.forceStarted && up.fragment.matches(this._fragment, newFragment)) {
+        if (this._forceIntent === 'start' && up.fragment.matches(this._fragment, newFragment)) {
             this.constructor.forFragment(newFragment).forceStart(this._options);
         }
     }
@@ -4919,11 +5012,8 @@ up.Layer = class Layer extends up.Record {
     isOverlay() {
         return this.stack.isOverlay(this);
     }
-    isOpen() {
-        return this.stack.isOpen(this);
-    }
-    isClosed() {
-        return this.stack.isClosed(this);
+    isAlive() {
+        throw new up.NotImplemented();
     }
     get parent() {
         return this.stack.parentOf(this);
@@ -5097,7 +5187,7 @@ up.Layer = class Layer extends up.Record {
         if (newLocation !== liveLocation && this.showsLiveHistory() && push) {
             up.history.push(newLocation);
         }
-        if (newLocation !== prevSavedLocation && !this.opening) {
+        if (newLocation !== prevSavedLocation && this.state !== 'opening') {
             this.emit('up:layer:location:changed', { location: newLocation, previousLocation: prevSavedLocation, log: false });
         }
     }
@@ -5156,11 +5246,11 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
                 'dismissEvent',
                 'acceptLocation',
                 'dismissLocation',
-                'opening'
             ];
         }
         constructor(options) {
             super(options);
+            this.state = 'opening';
             if (this.dismissable === true) {
                 this.dismissable = ['button', 'key', 'outside'];
             }
@@ -5352,7 +5442,6 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
             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);
-            this.overlayFocus.teardown();
         }
         destroyElements(options) {
             const animation = () => this.startCloseAnimation(options);
@@ -5396,9 +5485,12 @@ up.Layer.Overlay = (_a = class Overlay extends up.Layer {
                 boxAnimation,
                 backdropAnimation,
                 easing: options.easing || this.closeEasing,
-                duration: options.duration || this.closeDuration
+                duration: options.duration || this.closeDuration,
             });
         }
+        isAlive() {
+            return ['opening', 'opened'].includes(this.state);
+        }
         accept(value = null, options = {}) {
             return this._executeCloseChange('accept', value, options);
         }
@@ -5466,7 +5558,7 @@ up.Layer.OverlayWithTether = class OverlayWithTether extends up.Layer.Overlay {
         this._tether.stop();
     }
     sync() {
-        if (this.isOpen()) {
+        if (this.isAlive()) {
             if (this.isDetached() || this._tether.isDetached()) {
                 this.dismiss(':detached', {
                     animation: false,
@@ -5503,7 +5595,7 @@ up.Layer.OverlayWithViewport = class OverlayWithViewport extends up.Layer.Overla
         up.viewport.bodyShifter.lowerStack();
     }
     sync() {
-        if (this.isDetached() && this.isOpen()) {
+        if (this.isDetached() && this.isAlive()) {
             this.constructor.getParentElement().appendChild(this.element);
         }
     }
@@ -5539,6 +5631,9 @@ up.Layer.Root = (_a = class Root extends up.Layer {
         sync() {
             this.setupHandlers();
         }
+        isAlive() {
+            return true;
+        }
         accept() {
             this._cannotCloseRoot();
         }
@@ -5741,12 +5836,6 @@ up.LayerStack = class LayerStack {
         this._currentOverrides = [];
         this.root.reset();
     }
-    isOpen(layer) {
-        return u.contains(this.layers, layer);
-    }
-    isClosed(layer) {
-        return !this.isOpen(layer);
-    }
     parentOf(layer) {
         return this.layers[layer.index - 1];
     }
@@ -6613,6 +6702,7 @@ up.RenderOptions = (function () {
         'fallback',
         'abort',
         'abortable',
+        'handleAbort',
         'confirm',
         'feedback',
         'disable',
@@ -7557,6 +7647,7 @@ up.Request.XHRRenderer = (_a = class XHRRenderer {
 /***/ (() => {
 
 const u = up.util;
+const HTML_CONTENT_TYPE = /^(text\/html|application\/xhtml\+xml) *(;|$)/i;
 up.Response = class Response extends up.Record {
     keys() {
         return [
@@ -7604,6 +7695,9 @@ up.Response = class Response extends up.Record {
     get contentType() {
         return this.header('Content-Type');
     }
+    isHTML() {
+        return HTML_CONTENT_TYPE.test(this.contentType);
+    }
     get cspInfo() {
         let policy = this.header('Content-Security-Policy') || this.header('Content-Security-Policy-Report-Only');
         return up.protocol.cspInfoFromHeader(policy);
@@ -7655,7 +7749,6 @@ up.Response = class Response extends up.Record {
 var _a;
 const u = up.util;
 const e = up.element;
-const FULL_DOCUMENT_PATTERN = /^\s*(<!--[^-]*.*?-->\s*)*<(html|!DOCTYPE)\b/i;
 up.ResponseDoc = (_a = class ResponseDoc {
         constructor({ document, fragment, content, target, origin, data, cspInfo, match }) {
             if (document) {
@@ -7682,7 +7775,7 @@ up.ResponseDoc = (_a = class ResponseDoc {
                 this._isFullDocument = true;
             }
             else if (u.isString(value)) {
-                this._isFullDocument = FULL_DOCUMENT_PATTERN.test(value);
+                this._isFullDocument = e.isFullDocumentHTML(value);
                 let htmlParser = (html) => [e.createBrokenDocumentFromHTML(html)];
                 let nodes = up.fragment.provideNodes(value, { origin, data, htmlParser });
                 if (nodes[0] instanceof Document) {
@@ -7908,21 +8001,27 @@ up.RevealMotion = class RevealMotion {
             return up.Rect.fromElement(this._viewport);
         }
     }
-    _selectObstructions(selector) {
+    _computeObstructionRects(selector) {
         let elements = up.fragment.all(selector, { layer: this._obstructionsLayer });
-        return u.filter(elements, e.isVisible);
+        elements = u.filter(elements, e.isVisible);
+        return u.map(elements, (element) => {
+            if (e.style(element, 'position') === 'sticky') {
+                return up.Rect.fromElementAsFixed(element);
+            }
+            else {
+                return up.Rect.fromElement(element);
+            }
+        });
     }
     _substractObstructions(viewportRect) {
-        for (let obstruction of this._selectObstructions(this._topObstructionSelector)) {
-            let obstructionRect = up.Rect.fromElement(obstruction);
+        for (let obstructionRect of this._computeObstructionRects(this._topObstructionSelector)) {
             let diff = obstructionRect.bottom - viewportRect.top;
             if (diff > 0) {
                 viewportRect.top += diff;
                 viewportRect.height -= diff;
             }
         }
-        for (let obstruction of this._selectObstructions(this._bottomObstructionSelector)) {
-            let obstructionRect = up.Rect.fromElement(obstruction);
+        for (let obstructionRect of this._computeObstructionRects(this._bottomObstructionSelector)) {
             let diff = viewportRect.bottom - obstructionRect.top;
             if (diff > 0) {
                 viewportRect.height -= diff;
@@ -8222,12 +8321,12 @@ up.framework = (function () {
             console.error("Unpoly cannot boot: %s", issue);
         }
     }
-    function mustBootManually() {
-        let unpolyScript = document.currentScript;
-        if (unpolyScript === null || unpolyScript === void 0 ? void 0 : unpolyScript.async) {
+    function mustManualBoot() {
+        var _a;
+        if ((_a = document.currentScript) === null || _a === void 0 ? void 0 : _a.async) {
             return true;
         }
-        if ((unpolyScript === null || unpolyScript === void 0 ? void 0 : unpolyScript.getAttribute('up-boot')) === 'manual') {
+        if (document.querySelector('[up-boot=manual]:is(html, script)')) {
             return true;
         }
         if (document.readyState === 'complete') {
@@ -8236,7 +8335,7 @@ up.framework = (function () {
     }
     function onEvaled() {
         up.emit('up:framework:evaled', { log: false });
-        if (mustBootManually()) {
+        if (mustManualBoot()) {
             console.debug('Call up.boot() after you have configured Unpoly');
         }
         else {
@@ -8303,6 +8402,12 @@ up.event = (function () {
     function on(...args) {
         return buildListenerGroup(args).bind();
     }
+    function onAncestor(fragment, eventType, callback) {
+        let guard = (event) => event.target.contains(fragment);
+        let unsubscribe = up.on(eventType, { guard }, callback);
+        up.destructor(fragment, unsubscribe);
+        return unsubscribe;
+    }
     function off(...args) {
         return buildListenerGroup(args).unbind();
     }
@@ -8384,6 +8489,7 @@ up.event = (function () {
     on('up:framework:reset', reset);
     return {
         on,
+        onAncestor,
         off,
         build,
         emit,
@@ -8624,8 +8730,17 @@ up.warn = up.log.warn;
 
 /***/ }),
 /* 87 */
-/***/ (() => {
+/***/ (function() {
 
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 up.script = (function () {
     const u = up.util;
     const e = up.element;
@@ -8729,6 +8844,7 @@ up.script = (function () {
             isDefault: up.framework.evaling,
             priority: 0,
             batch: false,
+            rerun: false,
         });
         return Object.assign(callback, options, overrides);
     }
@@ -8755,14 +8871,21 @@ up.script = (function () {
         up.emit(fragment, 'up:fragment:compile', { log: false });
         let compilers = options.compilers || registeredMacros.concat(registeredCompilers);
         const pass = new up.CompilerPass(fragment, compilers, options);
-        pass.run();
+        return pass.run();
     }
-    function registerDestructor(element, destructor) {
-        let fns = u.scanFunctions(destructor);
+    function registerDestructor(element, value) {
+        let fns = u.scanFunctions(value);
         if (!fns.length)
             return;
-        let registry = (element.upDestructors || (element.upDestructors = buildDestructorRegistry(element)));
-        registry.guard(fns);
+        if (element.isConnected) {
+            let registry = (element.upDestructors || (element.upDestructors = buildDestructorRegistry(element)));
+            registry.guard(fns);
+        }
+        else {
+            up.puts('up.destructor()', 'Immediately calling destructor for detached element (%o)', element);
+            for (let fn of fns)
+                up.error.guard(fn, element);
+        }
     }
     function buildDestructorRegistry(element) {
         let registry = u.cleaner();
@@ -8770,11 +8893,16 @@ up.script = (function () {
         return registry;
     }
     function hello(element, options = {}) {
-        element = up.fragment.get(element, options);
-        up.puts('up.hello()', "Compiling fragment %o", element);
-        compile(element, options);
-        up.fragment.emitInserted(element);
-        return element;
+        return __awaiter(this, void 0, void 0, function* () {
+            element = up.fragment.get(element, options);
+            up.puts('up.hello()', "Compiling fragment %o", element);
+            yield up.fragment.mutate(() => __awaiter(this, void 0, void 0, function* () {
+                let compilePromise = compile(element, options);
+                up.fragment.emitInserted(element);
+                yield compilePromise;
+            }));
+            return element;
+        });
     }
     function clean(fragment, options = {}) {
         new up.DestructorPass(fragment, options).run();
@@ -8895,31 +9023,45 @@ up.history = (function () {
     let nextPreviousLocation;
     let nextTrackOptions;
     let adoptedBases = new up.FIFOCache({ capacity: 100, normalizeKey: getBase });
-    function isAdopted(location) {
-        return !!adoptedBases.get(location);
-    }
     function reset() {
         previousLocation = undefined;
         nextPreviousLocation = undefined;
         nextTrackOptions = undefined;
         adoptedBases.clear();
         trackCurrentLocation({ reason: null, alreadyHandled: true });
-        adopt();
+        adoptBase();
     }
     function currentLocation() {
         return u.normalizeURL(location.href);
     }
+    function withTrackOptions(trackOptions, fn) {
+        try {
+            nextTrackOptions = trackOptions;
+            fn();
+        }
+        finally {
+            nextTrackOptions = undefined;
+        }
+    }
     function trackCurrentLocation(trackOptions) {
         var _a, _b;
-        let { reason, alreadyHandled } = nextTrackOptions || trackOptions;
+        let { reason, alreadyHandled, pauseTracking } = nextTrackOptions || trackOptions;
+        if (pauseTracking)
+            return;
         let location = currentLocation();
+        if (isAdoptedState()) {
+            adoptBase(location);
+        }
+        else if (isAdoptedBase(location)) {
+            adoptState();
+        }
         if (nextPreviousLocation !== location) {
             previousLocation = nextPreviousLocation;
             nextPreviousLocation = location;
             if (reason === 'detect') {
                 reason = (getBase(location) === getBase(previousLocation)) ? 'hash' : 'pop';
             }
-            let willHandle = !alreadyHandled && isAdopted(location);
+            let willHandle = !alreadyHandled && isAdoptedBase(location);
             let locationChangedEvent = up.event.build('up:location:changed', {
                 reason,
                 location,
@@ -8953,17 +9095,34 @@ up.history = (function () {
         placeAdoptedHistoryEntry('pushState', location, trackOptions);
     }
     function placeAdoptedHistoryEntry(method, location, trackOptions) {
-        adopt(location);
+        adoptBase(location);
         if (config.enabled) {
-            nextTrackOptions = trackOptions;
-            history[method](null, '', location);
-            nextTrackOptions = undefined;
+            withTrackOptions(trackOptions, function () {
+                history[method](null, { up: true }, location);
+            });
         }
     }
-    function adopt(location = currentLocation()) {
+    function isAdoptedBase(location) {
+        return !!adoptedBases.get(location);
+    }
+    function adoptBase(location = currentLocation()) {
         location = u.normalizeURL(location);
         adoptedBases.set(location, true);
     }
+    function isAdoptedState() {
+        var _a;
+        return (_a = history.state) === null || _a === void 0 ? void 0 : _a.up;
+    }
+    function adoptState() {
+        let { state } = history;
+        if (isAdoptedState())
+            return;
+        if (u.isBlank(state) || u.isObject(state)) {
+            withTrackOptions({ pauseTracking: true }, function () {
+                history.replaceState(Object.assign(Object.assign({}, state), { up: true }), '');
+            });
+        }
+    }
     function restoreLocation(location) {
         up.error.muteUncriticalRejection(up.render({
             guardEvent: up.event.build('up:location:restore', { location, log: `Restoring location ${location}` }),
@@ -9034,7 +9193,8 @@ up.history = (function () {
     }
     function adoptInitialHistoryEntry() {
         if (up.protocol.initialRequestMethod() === 'GET') {
-            adopt();
+            adoptState();
+            adoptBase();
         }
     }
     up.on('up:framework:boot', function ({ mode }) {
@@ -9172,6 +9332,7 @@ up.fragment = (function () {
         autoScroll: ['hash', 'layer-if-main'],
         autoRevalidate: (response) => response.expired,
         skipResponse: defaultSkipResponse,
+        renderableResponse: (response) => response.isHTML(),
         normalizeKeepHTML: defaultNormalizeKeepHTML
     }));
     u.delegate(config, ['mainTargets'], () => up.layer.config.any);
@@ -9208,12 +9369,13 @@ 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;
+    function emitFragmentKeep({ oldElement, newElement: newFragment, newData, renderOptions }) {
         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 });
+        const callback = e.callbackAttr(oldElement, 'up-on-keep', { exposedKeys: ['newFragment', 'newData'] });
+        return up.emit(oldElement, 'up:fragment:keep', { log, callback, newFragment, newData, renderOptions });
+    }
+    function emitFragmentKept({ oldElement, newElement: newFragment, newData }) {
+        return up.emit(oldElement, 'up:fragment:kept', { log: true, newFragment, newData });
     }
     function findKeepPlan(options) {
         if (options.keep === false)
@@ -9307,12 +9469,7 @@ up.fragment = (function () {
         if (root) {
             return getFirstDescendant(root, selector, options);
         }
-        return new up.FragmentFinder({
-            selector,
-            origin: options.origin,
-            layer: options.layer,
-            match: options.match,
-        }).find();
+        return new up.FragmentFinder(Object.assign({ selector }, u.pick(options, ['layer', 'match', 'origin', 'destroying']))).find();
     }
     function getFirstDescendant(...args) {
         let [root, selectorString, options] = parseGetArgs(args);
@@ -9350,8 +9507,9 @@ up.fragment = (function () {
     function destroy(...args) {
         var _a, _b;
         const options = parseTargetAndOptions(args);
-        if (options.element = getSmart(options.target, options)) {
-            new up.Change.DestroyFragment(options).execute();
+        const element = getSmart(options.target, options);
+        if (element) {
+            new up.Change.DestroyFragment(Object.assign(Object.assign({}, options), { element })).execute();
         }
         return (_b = (_a = up.migrate).formerlyAsync) === null || _b === void 0 ? void 0 : _b.call(_a, 'up.destroy()');
     }
@@ -9536,7 +9694,7 @@ up.fragment = (function () {
                 targets.unshift(...replaced);
             }
             else if (LAYER_PSEUDO.test(target)) {
-                if (layer === 'new' || layer.opening)
+                if (layer === 'new' || layer.state === 'opening')
                     continue;
                 let firstSwappableTarget = toTarget(layer.getFirstSwappableElement(), options);
                 targets.unshift(target.replace(LAYER_PSEUDO, firstSwappableTarget));
@@ -9647,7 +9805,7 @@ up.fragment = (function () {
     function abort(...args) {
         let options = parseTargetAndOptions(args);
         let testFn;
-        let { reason, newLayer } = options;
+        let { reason, newLayer, jid } = options;
         let elements;
         if (options.target) {
             elements = getAll(options.target, options);
@@ -9663,14 +9821,14 @@ up.fragment = (function () {
         let testFnWithAbortable = (request) => request.abortable && testFn(request);
         up.network.abort(testFnWithAbortable, Object.assign(Object.assign({}, options), { reason }));
         for (let element of elements) {
-            up.emit(element, 'up:fragment:aborted', { reason, newLayer, log: false });
+            up.emit(element, 'up:fragment:aborted', { reason, newLayer, jid, log: reason });
         }
     }
     function onAborted(fragment, callback) {
-        let guard = (event) => event.target.contains(fragment);
-        let unsubscribe = up.on('up:fragment:aborted', { guard }, callback);
-        up.destructor(fragment, unsubscribe);
-        return unsubscribe;
+        return up.event.onAncestor(fragment, 'up:fragment:aborted', callback);
+    }
+    function onKept(fragment, callback) {
+        return up.event.onAncestor(fragment, 'up:fragment:kept', callback);
     }
     function onFirstIntersect(element, callback, { margin = 0 } = {}) {
         if (e.isIntersectingWindow(element, { margin })) {
@@ -9744,6 +9902,26 @@ up.fragment = (function () {
         let tracker = new up.SelectorTracker(...parsedArgs);
         return tracker.start();
     }
+    let mutateLevel = 0;
+    let afterMutateCleaner = u.cleaner('fifo');
+    function mutate(callback) {
+        try {
+            mutateLevel++;
+            return callback();
+        }
+        finally {
+            if (--mutateLevel === 0)
+                afterMutateCleaner.clean();
+        }
+    }
+    function afterMutate(callback) {
+        if (mutateLevel === 0) {
+            callback();
+        }
+        else {
+            afterMutateCleaner(callback);
+        }
+    }
     up.on('up:framework:boot', function () {
         const { documentElement } = document;
         up.hello(documentElement);
@@ -9771,6 +9949,7 @@ up.fragment = (function () {
         emitInserted: emitFragmentInserted,
         emitDestroyed: emitFragmentDestroyed,
         emitKeep: emitFragmentKeep,
+        emitKept: emitFragmentKept,
         keepPlan: findKeepPlan,
         defaultNormalizeKeepHTML,
         successKey,
@@ -9787,6 +9966,7 @@ up.fragment = (function () {
         shouldRevalidate,
         abort,
         onAborted,
+        onKept,
         onFirstIntersect,
         splitTarget,
         parseTargetSteps,
@@ -9799,6 +9979,8 @@ up.fragment = (function () {
         provideNodes,
         cloneTemplate,
         trackSelector,
+        mutate,
+        afterMutate,
     };
 })();
 up.reload = up.fragment.reload;
@@ -9895,7 +10077,7 @@ up.viewport = (function () {
             return () => {
                 let doReveal = () => reveal(match, { top: true, behavior });
                 if (strong)
-                    u.task(doReveal);
+                    u.fastTask(doReveal);
                 return doReveal();
             };
         }
@@ -11079,6 +11261,7 @@ up.link = (function () {
         let childLink = e.get(area, childLinkSelector);
         if (childLink) {
             e.setMissingAttrs(area, Object.assign({ 'up-href': e.attr(childLink, 'href') }, e.upAttrs(childLink)));
+            childLink.upExpandedPair = area.upExpandedPair = [area, childLink];
             e.addClasses(area, e.upClasses(childLink));
             makeFollowable(area);
         }
@@ -11177,6 +11360,7 @@ up.form = (function () {
         return up.render(submitOptions(form, options));
     });
     function submitOptions(form, options, parserOptions) {
+        form = up.fragment.get(form);
         form = getForm(form);
         options = u.options(options);
         let parser = new up.OptionsParser(form, options, parserOptions);
@@ -11191,6 +11375,7 @@ up.form = (function () {
         options.origin || (options.origin = up.viewport.focusedElementWithin(form) || options.submitButton || form);
         options.activeElements = u.uniq([options.origin, options.submitButton, form].filter(u.isElement));
         parser.include(up.link.followOptions);
+        Object.assign(options, submitButtonOverrides(options.submitButton));
         return options;
     }
     function watchOptions(field, options, parserOptions = {}) {
@@ -11280,14 +11465,22 @@ up.form = (function () {
         const parser = new up.OptionsParser(form, options, parserOptions);
         parser.string('contentType', { attr: 'enctype' });
         parser.json('headers');
-        const params = up.Params.fromForm(form);
+        const paramParts = [
+            up.Params.fromForm(form),
+            e.jsonAttr(form, 'up-params'),
+        ];
+        const headerParts = [
+            e.jsonAttr(form, 'up-headers'),
+        ];
         const submitButton = ((_a = options.submitButton) !== null && _a !== void 0 ? _a : (options.submitButton = findSubmitButtons(form)[0]));
         if (submitButton) {
-            params.addField(submitButton);
+            paramParts.push(up.Params.fromFields(submitButton), e.jsonAttr(submitButton, 'up-params'));
+            headerParts.push(e.jsonAttr(submitButton, 'up-headers'));
             options.method || (options.method = submitButton.getAttribute('formmethod'));
             options.url || (options.url = submitButton.getAttribute('formaction'));
         }
-        options.params = up.Params.merge(params, options.params);
+        options.params = up.Params.merge(...paramParts, options.params);
+        options.headers = u.merge(...headerParts, options.headers);
         parser.string('url', { attr: 'action', default: up.fragment.source(form) });
         parser.string('method', {
             attr: ['up-method', 'data-method', 'method'],
@@ -11299,6 +11492,12 @@ up.form = (function () {
         }
         return options;
     }
+    function submitButtonOverrides(submitButton) {
+        if (!submitButton)
+            return {};
+        let followOptions = up.link.followOptions(submitButton, {}, { defaults: false });
+        return u.omit(followOptions, ['method', 'url', 'guardEvent', 'origin', 'params', 'headers']);
+    }
     function watch(...args) {
         let [root, options, callback] = u.args(args, 'val', 'options', 'callback');
         root = up.element.get(root);
@@ -11357,9 +11556,22 @@ up.form = (function () {
         }
         return options;
     }
-    function getForm(elementOrSelector, options = {}) {
-        const element = up.fragment.get(elementOrSelector, options);
-        return element.form || element.closest('form');
+    function getForm(element) {
+        return getLiteralForm(element) || getClosestForm(element) || getAssociatedForm(element);
+    }
+    function getLiteralForm(element) {
+        if (element instanceof HTMLFormElement)
+            return element;
+    }
+    function getClosestForm(element) {
+        return element.closest('form');
+    }
+    function getAssociatedForm(element) {
+        let formID = element.getAttribute('form');
+        if (formID) {
+            let selector = 'form' + e.idSelector(formID);
+            return up.fragment.get(selector, { layer: element });
+        }
     }
     function getFormValidator(form) {
         return form.upFormValidator || (form.upFormValidator = setupFormValidator(form));
@@ -11370,15 +11582,16 @@ up.form = (function () {
         up.destructor(form, stop);
         return validator;
     }
-    function getRegion(origin, options) {
+    function getRegion(origin) {
+        return getOriginRegion(origin) || up.layer.current.element;
+    }
+    function getOriginRegion(origin) {
+        var _a;
         if (origin) {
-            return getForm(origin, options) || up.layer.get(origin).element;
-        }
-        else {
-            return up.layer.current.element;
+            return getForm(origin) || ((_a = up.layer.get(origin)) === null || _a === void 0 ? void 0 : _a.element);
         }
     }
-    function trackFields(...args) {
+    const trackFields = up.mockable(function (...args) {
         let [root, { guard }, callback] = u.args(args, 'val', 'options', 'callback');
         let filter = function (fields) {
             let region = getRegion(root);
@@ -11388,9 +11601,8 @@ up.form = (function () {
                     && (!guard || guard(field));
             });
         };
-        const live = true;
-        return up.fragment.trackSelector(fieldSelector(), { filter, live }, callback);
-    }
+        return up.fragment.trackSelector(fieldSelector(), { filter }, callback);
+    });
     function focusedField() {
         return u.presence(document.activeElement, isField);
     }
@@ -11399,14 +11611,18 @@ up.form = (function () {
         return config.matches(form, 'submitSelectors');
     }
     up.on('submit', config.selectorFn('submitSelectors'), function (event, form) {
+        const submitButton = u.presence(event.submitter, isSubmitButton);
+        if ((submitButton === null || submitButton === void 0 ? void 0 : submitButton.getAttribute('up-submit')) === 'false')
+            return;
         if (event.defaultPrevented)
             return;
-        const submitButton = u.presence(event.submitter, isSubmitButton);
         up.event.halt(event, { log: true });
         up.error.muteUncriticalRejection(submit(form, { submitButton }));
     });
-    up.compiler('form', function (form) {
-        getFormValidator(form);
+    up.compiler('[up-validate]', { rerun: true }, function (element) {
+        let form = getForm(element);
+        if (form)
+            getFormValidator(form);
     });
     up.compiler('[up-switch]', (switcher) => {
         return new up.Switcher(switcher).start();
@@ -11418,6 +11634,7 @@ up.form = (function () {
         submit,
         submitOptions,
         destinationOptions,
+        submitButtonOverrides,
         watchOptions,
         validateOptions,
         isSubmittable,
@@ -11494,8 +11711,8 @@ up.status = (function () {
     function getMatchableLayerLocation(layer) {
         return u.matchableURL(layer.location);
     }
-    function findActivatableArea(element) {
-        return e.ancestor(element, SELECTOR_LINK) || element;
+    function findActivatableAreas(element) {
+        return element.upExpandedPair || [element];
     }
     function runPreviews(request, renderOptions) {
         let { bindLayer } = request;
@@ -11556,7 +11773,7 @@ up.status = (function () {
     }
     function getActiveElements({ origin, activeElements }) {
         activeElements || (activeElements = u.wrapList(origin));
-        return activeElements.map(findActivatableArea);
+        return u.flatMap(activeElements, findActivatableAreas);
     }
     function getFeedbackClassesPreviewFn(feedbackOption, fragments) {
         if (!feedbackOption)