unpoly-rails 3.7.3.1 → 3.8.0.rc1

data/assets/unpoly/unpoly.js

@@ -5,7 +5,7 @@
 /***/ (() => {
 
 window.up = {
-    version: '3.7.3'
+    version: '3.8.0-rc1'
 };
 
 
@@ -229,11 +229,6 @@ up.util = (function () {
     function isArguments(value) {
         return Object.prototype.toString.call(value) === '[object Arguments]';
     }
-    function nullToUndefined(value) {
-        if (!isNull(value)) {
-            return value;
-        }
-    }
     function wrapList(value) {
         if (isList(value)) {
             return value;
@@ -337,9 +332,6 @@ up.util = (function () {
     function compact(array) {
         return filterList(array, isGiven);
     }
-    function filterMap(list, mapping) {
-        return filterList(map(list, mapping), isDefined);
-    }
     function compactObject(object) {
         return pickBy(object, isGiven);
     }
@@ -389,9 +381,6 @@ up.util = (function () {
     function queueTask(task) {
         return setTimeout(task);
     }
-    function queueMicrotask(task) {
-        return Promise.resolve().then(task);
-    }
     function last(value) {
         return value[value.length - 1];
     }
@@ -399,6 +388,9 @@ up.util = (function () {
         let indexOf = value.indexOf || Array.prototype.indexOf;
         return indexOf.call(value, subValue) >= 0;
     }
+    function containsAll(values, subValues) {
+        return every(subValues, (subValue) => contains(values, subValue));
+    }
     function objectContains(object, subObject) {
         const reducedValue = pick(object, Object.keys(subObject));
         return isEqual(subObject, reducedValue);
@@ -582,6 +574,14 @@ up.util = (function () {
     function reverse(list) {
         return copy(list).reverse();
     }
+    function replaceValue(value, matchValue, replacementValue) {
+        if (value === matchValue) {
+            return replacementValue;
+        }
+        else {
+            return value;
+        }
+    }
     function renameKeys(object, renameKeyFn) {
         const renamed = {};
         for (let key in object) {
@@ -732,7 +732,6 @@ up.util = (function () {
         normalizeMethod,
         methodAllowsPayload,
         copy,
-        copyArrayLike,
         merge,
         mergeDefined,
         options: newOptions,
@@ -746,7 +745,6 @@ up.util = (function () {
         every,
         find: findInList,
         filter: filterList,
-        filterMap: filterMap,
         reject,
         intersect,
         compact,
@@ -778,6 +776,7 @@ up.util = (function () {
         isRegExp,
         timer: scheduleTimer,
         contains,
+        containsAll,
         objectContains,
         toArray,
         pick,
@@ -804,7 +803,6 @@ up.util = (function () {
         isBasicObjectProperty,
         isCrossOrigin,
         task: queueTask,
-        microtask: queueMicrotask,
         isEqual,
         parseTokens,
         wrapList,
@@ -815,10 +813,9 @@ up.util = (function () {
         delegate: defineDelegates,
         reverse,
         camelToKebabCase,
-        nullToUndefined,
+        replaceValue,
         sprintf,
         renameKeys,
-        negate,
         memoizeMethod,
         safeStringifyJSON,
         variant,
@@ -1179,7 +1176,7 @@ up.element = (function () {
         }
     }
     function idSelector(id) {
-        if (id.match(/^[a-z0-9\-_]+$/i)) {
+        if (id.match(/^[a-z][a-z0-9\-_]*$/i)) {
             return `#${id}`;
         }
         else {
@@ -1269,9 +1266,6 @@ up.element = (function () {
         element.appendChild(wrapper);
         return wrapper;
     }
-    function isWrapper(element) {
-        return element.matches('up-wrapper');
-    }
     function preservingFocus(fn) {
         const oldFocusElement = document.activeElement;
         try {
@@ -1284,7 +1278,8 @@ up.element = (function () {
         }
     }
     function stringAttr(element, attribute) {
-        return u.nullToUndefined(element.getAttribute(attribute));
+        let value = element.getAttribute(attribute);
+        return u.replaceValue(value, null, undefined);
     }
     function booleanAttr(element, attribute, pass) {
         if (!element.hasAttribute(attribute))
@@ -1309,14 +1304,15 @@ up.element = (function () {
             }
         }
     }
-    function booleanOrStringAttr(element, attribute) {
-        return booleanAttr(element, attribute, true);
+    function booleanOrStringAttr(element, attribute, trueValue = true) {
+        let value = booleanAttr(element, attribute, true);
+        return value === true ? trueValue : value;
     }
     function numberAttr(element, attribute) {
         let value = element.getAttribute(attribute);
         if (value) {
             value = value.replace(/_/g, '');
-            if (value.match(/^[\d.]+$/)) {
+            if (value.match(/^-?[\d.]+$/)) {
                 return parseFloat(value);
             }
         }
@@ -1352,10 +1348,6 @@ up.element = (function () {
         element.classList.add(klass);
         return () => element.classList.remove(klass);
     }
-    function setTemporaryAttr(element, attr, value) {
-        element.setAttribute(attr, value);
-        return () => element.removeAttribute(element, attr);
-    }
     function computedStyle(element, props) {
         const style = window.getComputedStyle(element);
         return extractFromStyleObject(style, props);
@@ -1441,6 +1433,18 @@ up.element = (function () {
     function crossOriginSelector(attr) {
         return `[${attr}*="//"]:not([${attr}*="//${location.host}/"])`;
     }
+    function isIntersectingWindow(element, { margin = 0 } = {}) {
+        const rect = up.Rect.fromElement(element);
+        rect.grow(margin);
+        return (rect.bottom > 0) && (rect.top < window.innerHeight) &&
+            (rect.right > 0) && (rect.left < window.innerWidth);
+    }
+    function unionSelector(includes, excludes) {
+        let selector = `:is(${includes.join()})`;
+        if (u.isPresent(excludes))
+            selector += `:not(${excludes.join()})`;
+        return selector;
+    }
     return {
         subtree,
         contains,
@@ -1475,7 +1479,6 @@ up.element = (function () {
         setMissingAttr,
         unwrap,
         wrapChildren,
-        isWrapper,
         attr: stringAttr,
         booleanAttr,
         numberAttr,
@@ -1492,11 +1495,12 @@ up.element = (function () {
         upClasses,
         toggleAttr,
         addTemporaryClass,
-        setTemporaryAttr,
         cleanJQuery,
         parseSelector,
         isEmpty,
         crossOriginSelector,
+        isIntersectingWindow,
+        unionSelector,
     };
 })();
 
@@ -1609,6 +1613,7 @@ up.Record = class Record {
 /***/ (() => {
 
 const u = up.util;
+const e = up.element;
 up.Config = class Config {
     constructor(blueprintFn = (() => ({}))) {
         this._blueprintFn = blueprintFn;
@@ -1624,10 +1629,7 @@ up.Config = class Config {
     selector(prop) {
         let includes = this[prop];
         let excludes = this['no' + u.upperCaseFirst(prop)];
-        let selector = `:is(${includes.join()})`;
-        if (u.isPresent(excludes))
-            selector += `:not(${excludes.join()})`;
-        return selector;
+        return e.unionSelector(includes, excludes);
     }
     selectorFn(prop) {
         return () => this.selector(prop);
@@ -1797,6 +1799,12 @@ up.Rect = class Rect extends up.Record {
     get right() {
         return this.left + this.width;
     }
+    grow(padding) {
+        this.left -= padding;
+        this.top -= padding;
+        this.width += padding * 2;
+        this.height += padding * 2;
+    }
     static fromElement(element) {
         return new (this)(element.getBoundingClientRect());
     }
@@ -1808,64 +1816,46 @@ up.Rect = class Rect extends up.Record {
 /***/ (() => {
 
 const e = up.element;
+const SHIFT_CLASS = 'up-scrollbar-away';
 up.BodyShifter = class BodyShifter {
     constructor() {
-        this._unshiftFns = [];
         this._anchoredElements = new Set();
         this._stack = 0;
     }
     lowerStack() {
-        this._stack--;
-        if (this._stack === 0) {
+        if (--this._stack === 0)
             this._unshiftNow();
-        }
     }
     raiseStack() {
-        this._stack++;
-        if (this._stack === 1) {
+        if (++this._stack === 1)
             this._shiftNow();
-        }
     }
     onAnchoredElementInserted(element) {
         this._anchoredElements.add(element);
-        if (this._isShifted()) {
-            this._shiftAnchoredElement(element);
-        }
+        this._shiftElement(element, 'right');
         return () => this._anchoredElements.delete(element);
     }
     _isShifted() {
-        return this._scrollbarTookSpace && this._stack > 0;
+        return this._rootScrollbarWidth && this._stack > 0;
     }
     _shiftNow() {
-        this._scrollbarWidth = up.viewport.scrollbarWidth();
-        this._scrollbarTookSpace = up.viewport.rootHasReducedWidthFromScrollbar();
-        if (!this._scrollbarTookSpace)
-            return;
-        this._shiftBody();
+        this._rootScrollbarWidth = up.viewport.rootScrollbarWidth();
+        e.root.style.setProperty('--up-scrollbar-width', this._rootScrollbarWidth + 'px');
+        this._shiftElement(document.body, 'padding-right');
         for (let element of this._anchoredElements) {
-            this._shiftAnchoredElement(element);
+            this._shiftElement(element, 'right');
         }
     }
-    _shiftBody() {
-        const overflowElement = up.viewport.rootOverflowElement();
-        this._changeStyle(overflowElement, { overflowY: 'hidden' });
-        const { body } = document;
-        const bodyRightPadding = e.styleNumber(body, 'paddingRight');
-        const bodyRightShift = this._scrollbarWidth + bodyRightPadding;
-        this._changeStyle(body, { paddingRight: bodyRightShift });
-    }
-    _shiftAnchoredElement(element) {
-        const elementRight = e.styleNumber(element, 'right');
-        const elementRightShift = this._scrollbarWidth + elementRight;
-        this._changeStyle(element, { right: elementRightShift });
-    }
-    _changeStyle(element, styles) {
-        this._unshiftFns.push(e.setTemporaryStyle(element, styles));
+    _shiftElement(element, styleProp) {
+        if (!this._isShifted())
+            return;
+        let originalValue = e.style(element, styleProp);
+        element.style.setProperty('--up-original-' + styleProp, originalValue);
+        element.classList.add(SHIFT_CLASS);
     }
     _unshiftNow() {
-        let unshiftFn;
-        while (unshiftFn = this._unshiftFns.pop()) {
-            unshiftFn();
+        for (let element of [document.body, ...this._anchoredElements]) {
+            element.classList.remove(SHIFT_CLASS);
         }
     }
 };
@@ -3058,6 +3048,7 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
             }
             this.options.title = this.improveHistoryValue(this.options.title, responseDoc.title);
             this.options.metaTags = this.improveHistoryValue(this.options.metaTags, responseDoc.metaTags);
+            this.options.lang = this.improveHistoryValue(this.options.lang, responseDoc.lang);
         }
         _defaultPlacement() {
             if (!this.options.document && !this.options.fragment) {
@@ -3773,6 +3764,7 @@ up.FieldWatcher = class FieldWatcher {
 /***/ (() => {
 
 const u = up.util;
+const e = up.element;
 up.FormValidator = class FormValidator {
     constructor(form) {
         this._form = form;
@@ -3832,7 +3824,7 @@ up.FormValidator = class FormValidator {
         }
     }
     _getTargetSelectorSolutions({ target, origin }) {
-        if (u.isString(target) && target) {
+        if (u.isString(target)) {
             up.puts('up.validate()', 'Validating target "%s"', target);
             let simpleSelectors = up.fragment.splitTarget(target);
             return u.compact(simpleSelectors.map(function (simpleSelector) {
@@ -3861,7 +3853,7 @@ up.FormValidator = class FormValidator {
     _getValidateAttrSolutions(field) {
         let containerWithAttr = field.closest('[up-validate]');
         if (containerWithAttr) {
-            let target = containerWithAttr.getAttribute('up-validate');
+            let target = e.booleanOrStringAttr(containerWithAttr, 'up-validate');
             return this._getTargetSelectorSolutions({ target, origin: field });
         }
     }
@@ -3907,7 +3899,8 @@ up.FormValidator = class FormValidator {
         options.guardEvent = up.event.build('up:form:validate', {
             fields: dirtyFields,
             log: 'Validating form',
-            params: options.params
+            params: options.params,
+            form: this._form,
         });
         this._rendering = true;
         let renderingPromise = this._nextRenderPromise;
@@ -4548,6 +4541,7 @@ up.Layer = class Layer extends up.Record {
             this.savedTitle = document.title;
             this.savedMetaTags = up.history.findMetaTags();
             this.savedLocation = up.history.location;
+            this.savedLang = up.history.getLang();
         }
     }
     restoreHistory() {
@@ -4563,6 +4557,9 @@ up.Layer = class Layer extends up.Record {
         if (this.savedMetaTags) {
             up.history.updateMetaTags(this.savedMetaTags);
         }
+        if (u.isString(this.savedLang)) {
+            up.history.updateLang(this.savedLang);
+        }
     }
     asCurrent(fn) {
         return this.stack.asCurrent(this, fn);
@@ -4578,6 +4575,9 @@ up.Layer = class Layer extends up.Record {
         if (u.isString(options.title)) {
             this.title = options.title;
         }
+        if (u.isString(options.lang)) {
+            this.lang = options.lang;
+        }
     }
     showsLiveHistory() {
         return this.history && this.isFront();
@@ -4610,6 +4610,20 @@ up.Layer = class Layer extends up.Record {
             up.history.updateMetaTags(metaTags);
         }
     }
+    get lang() {
+        if (this.showsLiveHistory()) {
+            return up.history.getLang();
+        }
+        else {
+            return this.savedLang;
+        }
+    }
+    set lang(lang) {
+        this.savedLang = lang;
+        if (this.showsLiveHistory()) {
+            up.history.updateLang(lang);
+        }
+    }
     get location() {
         if (this.showsLiveHistory()) {
             return up.history.location;
@@ -5321,7 +5335,10 @@ up.LinkFeedbackURLs = class LinkFeedbackURLs {
         }
     }
     isCurrent(normalizedLocation) {
-        return this._isSafe && !!(this.href === normalizedLocation ||
+        if (!normalizedLocation) {
+            return false;
+        }
+        return !!(this.href === normalizedLocation ||
             this._upHREF === normalizedLocation ||
             this._aliasPattern?.test?.(normalizedLocation, false));
     }
@@ -5334,60 +5351,40 @@ up.LinkFeedbackURLs = class LinkFeedbackURLs {
 
 const u = up.util;
 const e = up.element;
-up.LinkPreloader = class LinkPreloader {
-    watchLink(link) {
-        if (!up.link.preloadIssue(link)) {
-            this._on(link, 'mouseenter', (event) => this._considerPreload(event, true));
-            this._on(link, 'mousedown touchstart', (event) => this._considerPreload(event));
-            this._on(link, 'mouseleave', (event) => this._stopPreload(event));
-        }
-    }
-    _on(link, eventTypes, callback) {
-        up.on(link, eventTypes, { passive: true }, callback);
-    }
-    _considerPreload(event, applyDelay) {
-        const link = event.target;
-        if (link !== this._currentLink) {
-            this.reset();
-            this._currentLink = link;
-            if (up.link.shouldFollowEvent(event, link)) {
-                if (applyDelay) {
-                    this._preloadAfterDelay(event, link);
-                }
-                else {
-                    this._preloadNow(event, link);
-                }
-            }
-        }
+up.LinkFollowIntent = class LinkFollowIntent {
+    constructor(link, callback) {
+        this._link = link;
+        this._callback = callback;
+        this._on('mouseenter mousedown touchstart', (event) => this._scheduleCallback(event));
+        this._on('mouseleave', () => this._unscheduleCallback());
+        up.fragment.onAborted(this._link, () => this._unscheduleCallback());
     }
-    _stopPreload(event) {
-        if (event.target === this._currentLink) {
-            return this.reset();
-        }
+    _on(eventType, callback) {
+        up.on(this._link, eventType, { passive: true }, callback);
     }
-    reset() {
-        if (!this._currentLink) {
+    _scheduleCallback(event) {
+        if (!up.link.shouldFollowEvent(event, this._link))
             return;
+        this._unscheduleCallback();
+        const applyDelay = (event.type === 'mouseenter');
+        if (applyDelay) {
+            let delay = this._parseDelay();
+            this._timer = u.timer(delay, () => this._runCallback(event));
         }
-        clearTimeout(this._timer);
-        if (this._currentRequest?.background) {
-            this._currentRequest.abort();
+        else {
+            this._runCallback(event);
         }
-        this._currentLink = undefined;
-        this._currentRequest = undefined;
     }
-    _preloadAfterDelay(event, link) {
-        const delay = e.numberAttr(link, 'up-preload-delay') ?? up.link.config.preloadDelay;
-        this._timer = u.timer(delay, () => this._preloadNow(event, link));
+    _unscheduleCallback() {
+        clearTimeout(this._timer);
+        up.network.abort((request) => (request.origin === this._link) && request.background);
+    }
+    _parseDelay() {
+        return e.numberAttr(this._link, 'up-preload-delay') ?? up.link.config.preloadDelay;
     }
-    _preloadNow(event, link) {
-        if (!link.isConnected) {
-            this.reset();
-            return;
-        }
-        const onQueued = request => { return this._currentRequest = request; };
+    _runCallback(event) {
         up.log.putsEvent(event);
-        up.error.muteUncriticalRejection(up.link.preload(link, { onQueued }));
+        up.error.muteUncriticalRejection(this._callback());
     }
 };
 
@@ -6130,7 +6127,6 @@ up.Request = (_a = class Request extends up.Record {
                 'wrapMethod',
                 'contentType',
                 'payload',
-                'onQueued',
                 'onLoading',
                 'fail',
                 'abortable',
@@ -6164,7 +6160,7 @@ up.Request = (_a = class Request extends up.Record {
             }
             this.deferred = u.newDeferred();
             this.badResponseTime ??= u.evalOption(up.network.config.badResponseTime, this);
-            this._addAutoHeaders();
+            this._setAutoHeaders();
         }
         get xhr() {
             return this._xhr ??= new XMLHttpRequest();
@@ -6173,7 +6169,7 @@ up.Request = (_a = class Request extends up.Record {
             if (this._fragments) {
                 return this._fragments;
             }
-            else if (this.target) {
+            else {
                 let steps = up.fragment.parseTargetSteps(this.target);
                 let selectors = u.map(steps, 'selector');
                 let lookupOpts = { origin: this.origin, layer: this.layer };
@@ -6228,7 +6224,6 @@ up.Request = (_a = class Request extends up.Record {
         }
         runQueuedCallbacks() {
             u.always(this, () => this._evictExpensiveAttrs());
-            this.onQueued?.(this);
         }
         load() {
             if (this.state !== 'new')
@@ -6372,9 +6367,6 @@ up.Request = (_a = class Request extends up.Record {
             return this.method + ' ' + this.url;
         }
         isPartOfSubtree(subtreeElements) {
-            if (!this.fragments || !subtreeElements) {
-                return false;
-            }
             subtreeElements = u.wrapList(subtreeElements);
             return u.some(this.fragments, function (fragment) {
                 return u.some(subtreeElements, (subtreeElement) => subtreeElement.contains(fragment));
@@ -6386,17 +6378,20 @@ up.Request = (_a = class Request extends up.Record {
         header(name) {
             return this.headers[name];
         }
-        _addAutoHeaders() {
+        _setAutoHeaders() {
             for (let key of ['target', 'failTarget', 'mode', 'failMode', 'context', 'failContext']) {
-                this._addAutoHeader(up.protocol.headerize(key), this[key]);
+                this._setPropertyHeader(key);
             }
             let csrfHeader, csrfToken;
             if ((csrfHeader = this.csrfHeader()) && (csrfToken = this.csrfToken())) {
-                this._addAutoHeader(csrfHeader, csrfToken);
+                this._setAutoHeader(csrfHeader, csrfToken);
             }
-            this._addAutoHeader(up.protocol.headerize('version'), up.version);
+            this._setAutoHeader(up.protocol.headerize('version'), up.version);
         }
-        _addAutoHeader(name, value) {
+        _setPropertyHeader(key) {
+            this._setAutoHeader(up.protocol.headerize(key), this[key]);
+        }
+        _setAutoHeader(name, value) {
             if (u.isMissing(value)) {
                 return;
             }
@@ -6405,6 +6400,16 @@ up.Request = (_a = class Request extends up.Record {
             }
             this.headers[name] = value;
         }
+        mergeIfUnsent(trackingRequest) {
+            if (this.state !== 'new')
+                return;
+            if (!this.target || !trackingRequest.target)
+                return;
+            let targetAtoms = up.fragment.splitTarget(this.target + ',' + trackingRequest.target);
+            this.target = u.uniq(targetAtoms).join(', ');
+            this._setPropertyHeader('target');
+            this._fragments = u.uniq([...this.fragments, ...trackingRequest.fragments]);
+        }
         static tester(condition, { except } = {}) {
             let testFn;
             if (u.isFunction(condition)) {
@@ -6439,74 +6444,82 @@ up.Request = (_a = class Request extends up.Record {
 /***/ (() => {
 
 const u = up.util;
+class Route {
+    constructor() {
+        this.varyHeaders = new Set();
+        this.requests = [];
+    }
+    matchBest(newRequest) {
+        let matches = this.requests.filter((cachedRequest) => this.satisfies(cachedRequest, newRequest));
+        return u.last(matches);
+    }
+    delete(request) {
+        u.remove(this.requests, request);
+    }
+    put(request) {
+        this.requests.push(request);
+    }
+    updateVary(response) {
+        for (let headerName of response.varyHeaderNames) {
+            this.varyHeaders.add(headerName);
+        }
+    }
+    satisfies(cachedRequest, newRequest) {
+        if (cachedRequest === newRequest)
+            return true;
+        return u.every(this.varyHeaders, (varyHeader) => {
+            let cachedValue = cachedRequest.header(varyHeader);
+            let newValue = newRequest.header(varyHeader);
+            if (varyHeader === 'X-Up-Target' || varyHeader === 'X-Up-Fail-Target') {
+                if (!cachedValue)
+                    return true;
+                if (!newValue)
+                    return false;
+                let cachedTokens = u.parseTokens(cachedValue, { separator: 'comma' });
+                let newTokens = u.parseTokens(newValue, { separator: 'comma' });
+                return u.containsAll(cachedTokens, newTokens);
+            }
+            else {
+                return cachedValue === newValue;
+            }
+        });
+    }
+}
 up.Request.Cache = class Cache {
     constructor() {
         this.reset();
     }
     reset() {
-        this._varyInfo = {};
-        this._map = new Map();
-    }
-    _cacheKey(request) {
-        let influencingHeaders = this._getPreviousInfluencingHeaders(request);
-        let varyPart = u.flatMap(influencingHeaders, (headerName) => [headerName, request.header(headerName)]);
-        return [request.description, ...varyPart].join(':');
-    }
-    _getPreviousInfluencingHeaders(request) {
-        return (this._varyInfo[request.description] ||= new Set());
+        this._routes = {};
+        this._requests = [];
     }
     get(request) {
         request = this._wrap(request);
-        let cacheKey = this._cacheKey(request);
-        let cachedRequest = this._map.get(cacheKey);
+        let route = this._getRoute(request);
+        let cachedRequest = route.matchBest(request);
         if (cachedRequest) {
             if (this._isUsable(cachedRequest)) {
                 return cachedRequest;
             }
             else {
-                this._map.delete(cacheKey);
+                this._delete(request, route);
             }
         }
     }
-    get _capacity() {
-        return up.network.config.cacheSize;
-    }
-    _isUsable(request) {
-        return request.age < up.network.config.cacheEvictAge;
-    }
     async put(request) {
         request = this._wrap(request);
-        this._makeRoom();
-        let cacheKey = this._updateCacheKey(request);
-        this._map.set(cacheKey, request);
-    }
-    _updateCacheKey(request) {
-        let oldCacheKey = this._cacheKey(request);
+        let route = this._getRoute(request);
         let { response } = request;
-        if (response) {
-            this._mergePreviousHeaderNames(request, response);
-            let newCacheKey = this._cacheKey(request);
-            this._renameMapKey(oldCacheKey, newCacheKey);
-            return newCacheKey;
-        }
-        else {
-            return oldCacheKey;
-        }
-    }
-    _renameMapKey(oldKey, newKey) {
-        if (oldKey !== newKey && this._map.has(oldKey)) {
-            this._map.set(newKey, this._map.get(oldKey));
-            this._map.delete(oldKey);
-        }
-    }
-    _mergePreviousHeaderNames(request, response) {
-        let headersInfluencingResponse = response.ownInfluncingHeaders;
-        if (headersInfluencingResponse.length) {
-            let previousInfluencingHeaders = this._getPreviousInfluencingHeaders(request);
-            for (let headerName of headersInfluencingResponse) {
-                previousInfluencingHeaders.add(headerName);
-            }
+        if (response)
+            route.updateVary(response);
+        let superseded = route.requests.filter((oldRequest) => route.satisfies(request, oldRequest));
+        for (let r of superseded) {
+            this._delete(r);
         }
+        request.cacheRoute = route;
+        route.put(request);
+        this._requests.push(request);
+        this._limitSize();
     }
     alias(existingCachedRequest, newRequest) {
         existingCachedRequest = this.get(existingCachedRequest);
@@ -6522,7 +6535,7 @@ up.Request.Cache = class Cache {
         newRequest.state = 'tracking';
         let value = await u.always(existingRequest);
         if (value instanceof up.Response) {
-            if (options.force || this._isCacheCompatible(existingRequest, newRequest)) {
+            if (options.force || existingRequest.cacheRoute.satisfies(existingRequest, newRequest)) {
                 newRequest.fromCache = true;
                 value = u.variant(value, { request: newRequest });
                 newRequest.respondWith(value);
@@ -6542,31 +6555,43 @@ up.Request.Cache = class Cache {
     willHaveSameResponse(existingRequest, newRequest) {
         return existingRequest === newRequest || existingRequest === newRequest.trackedRequest;
     }
-    _delete(request) {
-        request = this._wrap(request);
-        let cacheKey = this._cacheKey(request);
-        this._map.delete(cacheKey);
-    }
     evict(condition = true, testerOptions) {
         this._eachMatch(condition, testerOptions, (request) => this._delete(request));
     }
     expire(condition = true, testerOptions) {
         this._eachMatch(condition, testerOptions, (request) => request.expired = true);
     }
-    _makeRoom() {
-        while (this._map.size >= this._capacity) {
-            let oldestKey = this._map.keys().next().value;
-            this._map.delete(oldestKey);
+    reindex(request) {
+        this._delete(request);
+        this.put(request);
+    }
+    _delete(request) {
+        u.remove(this._requests, request);
+        request.cacheRoute?.delete(request);
+        delete request.cacheRoute;
+    }
+    _getRoute(request) {
+        return request.cacheRoute || (this._routes[request.description] ||= new Route());
+    }
+    _isUsable(request) {
+        return request.age < up.network.config.cacheEvictAge;
+    }
+    get _size() {
+        return this._requests.length;
+    }
+    get _capacity() {
+        return up.network.config.cacheSize;
+    }
+    _limitSize() {
+        for (let i = 0; i < (this._size - this._capacity); i++) {
+            this._delete(this._requests[0]);
         }
     }
     _eachMatch(condition = true, testerOptions, fn) {
         let tester = up.Request.tester(condition, testerOptions);
-        let results = u.filter(this._map.values(), tester);
+        let results = u.filter(this._requests, tester);
         u.each(results, fn);
     }
-    _isCacheCompatible(request1, request2) {
-        return this._cacheKey(request1) === this._cacheKey(request2);
-    }
     _wrap(requestOrOptions) {
         return u.wrapValue(up.Request, requestOrOptions);
     }
@@ -6595,7 +6620,7 @@ up.Request.Queue = class Queue {
         u.always(request, responseOrError => this._onRequestSettled(request, responseOrError));
         this._scheduleSlowTimer(request);
         this._queueRequest(request);
-        u.microtask(() => this._poke());
+        queueMicrotask(() => this._poke());
     }
     promoteToForeground(request) {
         if (request.background) {
@@ -6636,7 +6661,7 @@ up.Request.Queue = class Queue {
             up.network.registerAliasForRedirect(request, responseOrError);
         }
         this._checkLate();
-        u.microtask(() => this._poke());
+        queueMicrotask(() => this._poke());
     }
     _poke() {
         let request;
@@ -6830,15 +6855,12 @@ up.Response = class Response extends up.Record {
     get none() {
         return !this.text;
     }
-    isCacheable() {
-        return this.ok && !this.none;
-    }
     header(name) {
         return this.headers[name] || this.xhr?.getResponseHeader(name);
     }
-    get ownInfluncingHeaders() {
-        let influencingHeaders = up.protocol.influencingHeadersFromResponse(this);
-        return u.filter(influencingHeaders, (headerName) => this.request.header(headerName));
+    get varyHeaderNames() {
+        let varyHeaderValue = this.header('Vary');
+        return u.parseTokens(varyHeaderValue, { separator: 'comma' });
     }
     get contentType() {
         return this.header('Content-Type');
@@ -6879,6 +6901,7 @@ up.Response = class Response extends up.Record {
 var _a;
 const u = up.util;
 const e = up.element;
+const FULL_DOCUMENT_PATTERN = /^\s*<(html|!DOCTYPE)\b/i;
 up.ResponseDoc = (_a = class ResponseDoc {
         constructor({ document, fragment, content, target, origin, cspNonces, match }) {
             if (document) {
@@ -6899,43 +6922,43 @@ up.ResponseDoc = (_a = class ResponseDoc {
             }
             this._match = match;
         }
-        _parseDocument(document) {
-            document = this._parse(document, e.createBrokenDocumentFromHTML);
-            this._isDocumentBroken = true;
-            this._useParseResult(document);
-        }
-        _parseFragment(fragment) {
-            fragment = this._parse(fragment, e.createFromHTML);
-            this._useParseResult(fragment);
-        }
-        _parseContent(content, target) {
-            if (!target)
-                up.fail("must pass a { target } when passing { content }");
-            target = u.map(up.fragment.parseTargetSteps(target), 'selector').join();
-            const matchingElement = e.createFromSelector(target);
-            if (u.isString(content)) {
-                matchingElement.innerHTML = content;
+        _parseDocument(value) {
+            if (value instanceof Document) {
+                this._document = value;
+                this._isFullDocument = true;
+            }
+            else if (u.isString(value)) {
+                this._document = e.createBrokenDocumentFromHTML(value);
+                this._isFullDocument = FULL_DOCUMENT_PATTERN.test(value);
+                this._isDocumentBroken = true;
             }
             else {
-                matchingElement.appendChild(content);
+                this._document = this._buildFauxDocument(value);
+                this._isFullDocument = value.matches('html');
             }
-            this._useParseResult(matchingElement);
         }
-        _parse(value, parseFn) {
-            if (u.isString(value)) {
-                value = parseFn(value);
-            }
-            return value;
+        _parseFragment(value) {
+            let parsed = u.isString(value) ? e.createFromHTML(value) : value;
+            this._document = this._buildFauxDocument(parsed);
         }
-        _useParseResult(node) {
-            if (node instanceof Document) {
-                this._document = node;
+        _parseContent(value, target) {
+            if (!target)
+                up.fail("must pass a { target } when passing { content }");
+            let simplifiedTarget = u.map(up.fragment.parseTargetSteps(target), 'selector').join();
+            const matchingElement = e.createFromSelector(simplifiedTarget);
+            if (u.isString(value)) {
+                matchingElement.innerHTML = value;
             }
             else {
-                this._document = document.createElement('up-document');
-                this._document.append(node);
-                this._document.documentElement = node;
+                matchingElement.appendChild(value);
             }
+            this._document = this._buildFauxDocument(matchingElement);
+        }
+        _buildFauxDocument(node) {
+            let fauxDocument = document.createElement('up-document');
+            fauxDocument.append(node);
+            fauxDocument.documentElement = node;
+            return fauxDocument;
         }
         rootSelector() {
             return up.fragment.toTarget(this._document.documentElement);
@@ -6944,9 +6967,8 @@ up.ResponseDoc = (_a = class ResponseDoc {
             return this._fromHead(this._getTitleText);
         }
         _getHead() {
-            let { head } = this._document;
-            if (head && head.childNodes.length > 0) {
-                return head;
+            if (this._isFullDocument) {
+                return this._document.head;
             }
         }
         _fromHead(fn) {
@@ -6959,6 +6981,11 @@ up.ResponseDoc = (_a = class ResponseDoc {
         get assets() {
             return this._fromHead(up.script.findAssets);
         }
+        get lang() {
+            if (this._isFullDocument) {
+                return up.history.getLang(this._document);
+            }
+        }
         _getTitleText(head) {
             return head.querySelector('title')?.textContent;
         }
@@ -7056,7 +7083,7 @@ up.RevealMotion = class RevealMotion {
             const maxPixels = u.evalOption(this._max, this._element);
             elementRect.height = Math.min(elementRect.height, maxPixels);
         }
-        this._addPadding(elementRect);
+        elementRect.grow(this._padding);
         this._substractObstructions(viewportRect);
         if (viewportRect.height < 0) {
             up.fail('Viewport has no visible area');
@@ -7095,10 +7122,6 @@ up.RevealMotion = class RevealMotion {
             return up.Rect.fromElement(this._viewport);
         }
     }
-    _addPadding(elementRect) {
-        elementRect.top -= this._padding;
-        elementRect.height += 2 * this._padding;
-    }
     _selectObstructions(selector) {
         let elements = up.fragment.all(selector, { layer: this._obstructionsLayer });
         return u.filter(elements, e.isVisible);
@@ -7646,10 +7669,6 @@ up.protocol = (function () {
     function locationFromXHR(xhr) {
         return extractHeader(xhr, 'location') || xhr.responseURL;
     }
-    function influencingHeadersFromResponse(response) {
-        let varyHeaderValue = response.header('Vary');
-        return u.parseTokens(varyHeaderValue, { separator: 'comma' });
-    }
     const config = new up.Config(() => ({
         methodParam: '_method',
         csrfParam() { return e.metaContent('csrf-param'); },
@@ -7710,7 +7729,6 @@ up.protocol = (function () {
         headerize,
         wrapMethod,
         cspNoncesFromHeader,
-        influencingHeadersFromResponse,
     };
 })();
 
@@ -7846,44 +7864,61 @@ up.script = (function () {
     let registeredCompilers = [];
     let registeredMacros = [];
     function registerCompiler(...args) {
-        const compiler = buildCompiler(args);
-        return insertCompiler(registeredCompilers, compiler);
+        registerProcessor(args);
     }
     function registerMacro(...args) {
-        const macro = buildCompiler(args);
-        if (up.framework.evaling) {
-            macro.priority ||= detectSystemMacroPriority(macro.selector) ||
-                up.fail('Unregistered priority for system macro %o', macro.selector);
-        }
-        return insertCompiler(registeredMacros, macro);
+        registerProcessor(args, { macro: true });
+    }
+    function registerAttrCompiler(...args) {
+        let [attr, options, valueCallback] = parseProcessorArgs(args);
+        let selector = `[${attr}]`;
+        let callback = (element) => {
+            let value = e.booleanOrStringAttr(element, attr, options.defaultValue);
+            if (!value)
+                return;
+            return valueCallback(element, value);
+        };
+        registerProcessor([selector, options, callback]);
     }
     function detectSystemMacroPriority(macroSelector) {
         macroSelector = u.evalOption(macroSelector);
         for (let substr in SYSTEM_MACRO_PRIORITIES) {
-            const priority = SYSTEM_MACRO_PRIORITIES[substr];
             if (macroSelector.indexOf(substr) >= 0) {
-                return priority;
+                return SYSTEM_MACRO_PRIORITIES[substr];
+            }
+        }
+        up.fail('Unregistered priority for system macro %o', macroSelector);
+    }
+    function registerProcessor(args, overrides = {}) {
+        let processor = buildProcessor(args, overrides);
+        if (processor.macro) {
+            if (up.framework.evaling) {
+                processor.priority ||= detectSystemMacroPriority(processor.selector);
             }
+            insertProcessor(registeredMacros, processor);
+        }
+        else {
+            insertProcessor(registeredCompilers, processor);
         }
     }
-    const parseCompilerArgs = function (args) {
+    const parseProcessorArgs = function (args) {
         const defaults = u.extractOptions(args);
         const selector = args.shift();
         const callback = args.pop();
         const options = { ...defaults, ...u.extractOptions(args) };
         return [selector, options, callback];
     };
-    function buildCompiler(args) {
-        let [selector, options, callback] = parseCompilerArgs(args);
+    function buildProcessor(args, overrides) {
+        let [selector, options, callback] = parseProcessorArgs(args);
         options = u.options(options, {
             selector,
             isDefault: up.framework.evaling,
             priority: 0,
             batch: false,
         });
-        return Object.assign(callback, options);
+        return Object.assign(callback, options, overrides);
     }
-    function insertCompiler(queue, newCompiler) {
+    function insertProcessor(queue, newCompiler) {
         let existingCompiler;
         let index = 0;
         while ((existingCompiler = queue[index]) && (existingCompiler.priority >= newCompiler.priority)) {
@@ -7981,6 +8016,7 @@ up.script = (function () {
         config,
         compiler: registerCompiler,
         macro: registerMacro,
+        attrCompiler: registerAttrCompiler,
         destructor: registerDestructor,
         hello,
         clean,
@@ -7995,6 +8031,7 @@ up.destructor = up.script.destructor;
 up.macro = up.script.macro;
 up.data = up.script.data;
 up.hello = up.script.hello;
+up.attribute = up.script.attrCompiler;
 
 
 /***/ }),
@@ -8136,6 +8173,15 @@ up.history = (function () {
             document.head.append(newMetaTag);
         }
     }
+    function getLang(doc = document) {
+        let { documentElement } = doc;
+        if (documentElement.matches('html')) {
+            return doc.documentElement.lang;
+        }
+    }
+    function updateLang(newLang) {
+        e.toggleAttr(e.root, 'lang', newLang, !!newLang);
+    }
     up.macro('a[up-back], [up-href][up-back]', function (link) {
         if (previousLocation) {
             e.setMissingAttrs(link, {
@@ -8157,6 +8203,8 @@ up.history = (function () {
         isLocation,
         findMetaTags,
         updateMetaTags,
+        getLang,
+        updateLang,
     };
 })();
 
@@ -8639,6 +8687,25 @@ up.fragment = (function () {
         up.destructor(fragment, unsubscribe);
         return unsubscribe;
     }
+    function onFirstIntersect(origin, callback, { margin = 0 } = {}) {
+        if (e.isIntersectingWindow(origin, { margin })) {
+            callback();
+            return;
+        }
+        function processIntersectEntries(entries) {
+            for (let entry of entries) {
+                if (entry.isIntersecting) {
+                    disconnect();
+                    callback();
+                    return;
+                }
+            }
+        }
+        let observer = new IntersectionObserver(processIntersectEntries, { rootMargin: `${margin}px` });
+        let disconnect = () => observer.disconnect();
+        observer.observe(origin);
+        onAborted(origin, disconnect);
+    }
     up.on('up:framework:boot', function () {
         const { documentElement } = document;
         documentElement.setAttribute('up-source', u.normalizeURL(location.href, { hash: false }));
@@ -8679,6 +8746,7 @@ up.fragment = (function () {
         shouldRevalidate,
         abort,
         onAborted,
+        onFirstIntersect,
         splitTarget,
         parseTargetSteps,
         isAlive,
@@ -8810,33 +8878,9 @@ up.viewport = (function () {
     function isRoot(element) {
         return element === getRoot();
     }
-    function rootHasReducedWidthFromScrollbar() {
-        return window.innerWidth > document.documentElement.offsetWidth;
-    }
-    function rootOverflowElement() {
-        const { body } = document;
-        const html = document.documentElement;
-        const element = u.find([html, body], wasChosenAsOverflowingElement);
-        return element || getRoot();
-    }
-    function wasChosenAsOverflowingElement(element) {
-        const overflowY = e.style(element, 'overflow-y');
-        return overflowY === 'auto' || overflowY === 'scroll';
-    }
-    const scrollbarWidth = u.memoize(function () {
-        const outerStyle = {
-            position: 'absolute',
-            top: '0',
-            left: '0',
-            width: '100px',
-            height: '100px',
-            overflowY: 'scroll'
-        };
-        const outer = up.element.affix(document.body, '[up-viewport]', { style: outerStyle });
-        const width = outer.offsetWidth - outer.clientWidth;
-        outer.remove();
-        return width;
-    });
+    function rootScrollbarWidth() {
+        return window.innerWidth - rootWidth();
+    }
     function scrollTopKey(viewport) {
         return up.fragment.tryToTarget(viewport);
     }
@@ -9013,10 +9057,8 @@ up.viewport = (function () {
         get root() { return getRoot(); },
         rootWidth,
         rootHeight,
-        rootHasReducedWidthFromScrollbar,
-        rootOverflowElement,
         isRoot,
-        scrollbarWidth,
+        rootScrollbarWidth,
         saveScroll,
         restoreScroll,
         resetScroll,
@@ -9100,8 +9142,8 @@ up.motion = (function () {
         return cssTransition.start();
     }
     function applyConfig(options) {
-        options.easing ||= config.easing;
-        options.duration ||= config.duration;
+        options.easing ??= config.easing;
+        options.duration ??= config.duration;
     }
     function findNamedAnimation(name) {
         return namedAnimations[name] || up.fail("Unknown animation %o", name);
@@ -9368,6 +9410,7 @@ up.network = (function () {
             if (!newRequest.background) {
                 queue.promoteToForeground(cachedRequest);
             }
+            cachedRequest.mergeIfUnsent(newRequest);
             cache.track(cachedRequest, newRequest, { onIncompatible: processRequest });
             return true;
         }
@@ -9380,7 +9423,7 @@ up.network = (function () {
     function handleCaching(request) {
         if (request.willCache()) {
             cache.put(request);
-            request.onLoading = () => cache.put(request);
+            request.onLoading = () => cache.reindex(request);
         }
         u.always(request, function (responseOrError) {
             let expireCache = responseOrError.expireCache ?? request.expireCache ?? u.evalOption(config.expireCache, request, responseOrError);
@@ -9391,12 +9434,21 @@ up.network = (function () {
             if (evictCache) {
                 cache.evict(evictCache, { except: request });
             }
-            if (cache.get(request)) {
-                cache.put(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;
+            if (isErrorResponse) {
+                cache.evict(request.url);
             }
-            if (!responseOrError.isCacheable?.()) {
+            else if (isNetworkError || isEmptyResponse) {
                 cache.evict(request);
             }
+            else if (isSuccessResponse && hasCacheEntry) {
+                cache.put(request);
+            }
         });
     }
     function isBusy() {
@@ -9413,7 +9465,8 @@ up.network = (function () {
         if (request.cache && response.url && request.url !== response.url) {
             const newRequest = u.variant(request, {
                 method: response.method,
-                url: response.url
+                url: response.url,
+                cacheRoute: null,
             });
             cache.alias(request, newRequest);
         }
@@ -9717,7 +9770,6 @@ __webpack_require__(96);
 up.link = (function () {
     const u = up.util;
     const e = up.element;
-    const linkPreloader = new up.LinkPreloader();
     let lastMousedownTarget = null;
     const LINKS_WITH_LOCAL_HTML = ['a[up-content]', 'a[up-fragment]', 'a[up-document]'];
     const LINKS_WITH_REMOTE_HTML = ['a[href]', '[up-href]'];
@@ -9751,10 +9803,9 @@ up.link = (function () {
     }
     function reset() {
         lastMousedownTarget = null;
-        linkPreloader.reset();
     }
-    const follow = up.mockable(function (link, options) {
-        return up.render(followOptions(link, options));
+    const follow = up.mockable(function (link, options, parserOptions) {
+        return up.render(followOptions(link, options, parserOptions));
     });
     function parseRequestOptions(link, options, parserOptions) {
         options = u.options(options);
@@ -9829,10 +9880,9 @@ up.link = (function () {
         parser.booleanOrString('location');
         parser.booleanOrString('title');
         parser.boolean('metaTags');
+        parser.booleanOrString('lang');
         parser.include(up.motion.motionOptions);
-        if (!options.guardEvent) {
-            options.guardEvent = up.event.build('up:link:follow', { log: 'Following link' });
-        }
+        options.guardEvent ??= up.event.build('up:link:follow', { log: ['Following link %o', link] });
         return options;
     }
     function preload(link, options) {
@@ -9876,9 +9926,10 @@ up.link = (function () {
         if (link.matches('a[href], button')) {
             return;
         }
+        let role = link.matches('a') ? 'link' : 'button';
         e.setMissingAttrs(link, {
             tabindex: '0',
-            role: 'link',
+            role,
             'up-clickable': ''
         });
         link.addEventListener('keydown', function (event) {
@@ -9938,6 +9989,42 @@ up.link = (function () {
         const method = followMethod(link);
         return up.network.isSafeMethod(method);
     }
+    function onLoadCondition(condition, link, callback) {
+        switch (condition) {
+            case 'insert':
+                callback();
+                break;
+            case 'reveal': {
+                let margin = e.numberAttr(link, 'up-intersect-margin');
+                up.fragment.onFirstIntersect(link, callback, { margin });
+                break;
+            }
+            case 'hover':
+                new up.LinkFollowIntent(link, callback);
+                break;
+            case 'manual':
+                break;
+        }
+    }
+    function loadDeferred(link, options) {
+        let guardEvent = up.event.build('up:deferred:load', { log: ['Loading deferred %o', link] });
+        let forcedOptions = {
+            navigate: false,
+            guardEvent,
+            ...options,
+        };
+        let defaults = {
+            target: ':origin',
+            cache: 'auto',
+            revalidate: 'auto',
+            feedback: true,
+        };
+        return follow(link, forcedOptions, { defaults });
+    }
+    up.attribute('up-defer', { defaultValue: 'insert' }, function (link, condition) {
+        let doLoad = () => up.error.muteUncriticalRejection(loadDeferred(link));
+        onLoadCondition(condition, link, doLoad);
+    });
     up.on('up:click', config.selectorFn('followSelectors'), function (event, link) {
         if (shouldFollowEvent(event, link)) {
             up.event.halt(event, { log: true });
@@ -9945,21 +10032,22 @@ up.link = (function () {
             up.error.muteUncriticalRejection(follow(link));
         }
     });
-    up.macro('[up-expand]', function (area) {
-        const selector = area.getAttribute('up-expand') || 'a, [up-href]';
-        let childLink = e.get(area, selector);
+    up.attribute('up-expand', { defaultValue: 'a, [up-href]', macro: true }, function (area, childLinkSelector) {
+        let childLink = e.get(area, childLinkSelector);
         if (childLink) {
-            const areaAttrs = e.upAttrs(childLink);
-            areaAttrs['up-href'] ||= childLink.getAttribute('href');
-            e.setMissingAttrs(area, areaAttrs);
-            const areaClasses = e.upClasses(childLink);
-            area.classList.add(...areaClasses);
+            e.setMissingAttrs(area, {
+                'up-href': e.attr(childLink, 'href'),
+                ...e.upAttrs(childLink)
+            });
+            area.classList.add(...e.upClasses(childLink));
             makeFollowable(area);
         }
     });
     up.compiler(config.selectorFn('preloadSelectors'), function (link) {
         if (!isPreloadDisabled(link)) {
-            linkPreloader.watchLink(link);
+            let doPreload = () => up.error.muteUncriticalRejection(preload(link));
+            let condition = e.booleanOrStringAttr(link, 'up-preload', null) ?? 'hover';
+            onLoadCondition(condition, link, doPreload);
         }
     });
     up.on('up:framework:reset', reset);
@@ -9968,18 +10056,17 @@ up.link = (function () {
         followOptions,
         preload,
         makeFollowable,
-        makeClickable,
         isSafe,
         isFollowable,
         shouldFollowEvent,
-        followMethod,
         convertClicks,
         config,
         combineFollowableSelectors,
-        preloadIssue,
+        loadDeferred,
     };
 })();
 up.follow = up.link.follow;
+up.deferred = { load: up.link.loadDeferred };
 
 
 /***/ }),
@@ -10055,7 +10142,8 @@ up.form = (function () {
         options.guardEvent ||= up.event.build('up:form:submit', {
             submitButton: options.submitButton,
             log: 'Submitting form',
-            params: options.params
+            params: options.params,
+            form,
         });
         options.origin ||= up.viewport.focusedElementWithin(form) || options.submitButton || form;
         parser.include(up.link.followOptions);
@@ -10328,7 +10416,9 @@ up.form = (function () {
         validator.watchContainer(fieldOrForm);
     });
     function validatingFieldSelector() {
-        return config.fieldSelectors.map((selector) => `${selector}[up-validate], [up-validate] ${selector}`).join(', ');
+        let includes = config.fieldSelectors.map((selector) => `${selector}[up-validate], [up-validate] ${selector}`);
+        let excludes = ['[up-validate=false]'];
+        return e.unionSelector(includes, excludes);
     }
     up.compiler('[up-switch]', (switcher) => {
         switchTargets(switcher);
@@ -10339,8 +10429,8 @@ up.form = (function () {
     up.compiler('[up-show-for]:not(.up-switched), [up-hide-for]:not(.up-switched)', (element) => {
         switchTarget(element);
     });
-    up.compiler('[up-watch]', (formOrField) => watch(formOrField));
-    up.compiler('[up-autosubmit]', (formOrField) => autosubmit(formOrField));
+    up.attribute('up-watch', (formOrField) => watch(formOrField));
+    up.attribute('up-autosubmit', (formOrField) => autosubmit(formOrField));
     return {
         config,
         submit,
@@ -10382,6 +10472,7 @@ up.feedback = (function () {
     const config = new up.Config(() => ({
         currentClasses: ['up-current'],
         navSelectors: ['[up-nav]', 'nav'],
+        noNavSelectors: ['[up-nav=false]'],
     }));
     function reset() {
         up.layer.root.feedbackLocation = null;
@@ -10389,9 +10480,6 @@ up.feedback = (function () {
     const CLASS_ACTIVE = 'up-active';
     const CLASS_LOADING = 'up-loading';
     const SELECTOR_LINK = 'a, [up-href]';
-    function navSelector() {
-        return config.selector('navSelectors');
-    }
     function normalizeURL(url) {
         if (url) {
             return u.normalizeURL(url, { trailingSlash: false, hash: false });
@@ -10400,40 +10488,23 @@ up.feedback = (function () {
     function linkURLs(link) {
         return link.upFeedbackURLs ||= new up.LinkFeedbackURLs(link);
     }
-    function updateFragment(fragment) {
-        const layerOption = { layer: up.layer.get(fragment) };
-        if (up.fragment.closest(fragment, navSelector(), layerOption)) {
-            const links = up.fragment.subtree(fragment, SELECTOR_LINK, layerOption);
-            updateLinks(links, layerOption);
-        }
-        else {
-            updateLinksWithinNavs(fragment, layerOption);
+    function updateFragment(fragment, { layer } = {}) {
+        layer ||= up.layer.get(fragment);
+        let layerLocation = getNormalizedLayerLocation(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 = linkURLs(link).isCurrent(layerLocation);
+            for (let currentClass of config.currentClasses) {
+                link.classList.toggle(currentClass, isCurrent);
+            }
+            e.toggleAttr(link, 'aria-current', 'page', isCurrent);
         }
     }
-    function updateLinksWithinNavs(fragment, options) {
-        const navs = up.fragment.subtree(fragment, navSelector(), options);
-        const links = u.flatMap(navs, nav => e.subtree(nav, SELECTOR_LINK));
-        updateLinks(links, options);
-    }
     function getNormalizedLayerLocation(layer) {
         return layer.feedbackLocation || normalizeURL(layer.location);
     }
-    function updateLinks(links, options = {}) {
-        if (!links.length) {
-            return;
-        }
-        const layer = options.layer || up.layer.get(links[0]);
-        let layerLocation = getNormalizedLayerLocation(layer);
-        if (layerLocation) {
-            for (let link of links) {
-                const isCurrent = linkURLs(link).isCurrent(layerLocation);
-                for (let currentClass of config.currentClasses) {
-                    link.classList.toggle(currentClass, isCurrent);
-                }
-                e.toggleAttr(link, 'aria-current', 'page', isCurrent);
-            }
-        }
-    }
     function findActivatableArea(element) {
         return e.ancestor(element, SELECTOR_LINK) || element;
     }
@@ -10461,7 +10532,7 @@ up.feedback = (function () {
         const layerLocation = getNormalizedLayerLocation(layer.location);
         if (!processedLocation || (processedLocation !== layerLocation)) {
             layer.feedbackLocation = layerLocation;
-            updateLinksWithinNavs(layer.element, { layer });
+            updateFragment(layer.element, { layer });
         }
     }
     function onBrowserLocationChanged() {
@@ -10496,6 +10567,7 @@ up.radio = (function () {
     const e = up.element;
     const config = new up.Config(() => ({
         hungrySelectors: ['[up-hungry]'],
+        noHungrySelectors: ['[up-hungry=false]'],
         pollInterval: 30000,
     }));
     function hungrySteps(renderOptions) {
@@ -10552,7 +10624,7 @@ up.radio = (function () {
         parser.string('ifLayer', { default: 'front' });
         return options;
     }
-    up.compiler('[up-poll]:not([up-poll=false])', function (fragment) {
+    up.attribute('up-poll', function (fragment) {
         up.FragmentPolling.forFragment(fragment).onPollAttributeObserved();
     });
     up.macro('[up-flashes]', function (fragment) {