unpoly-rails 3.7.3.2 → 3.8.0

data/assets/unpoly/unpoly.es6.js

@@ -5,7 +5,7 @@
 /***/ (() => {
 
 window.up = {
-    version: '3.7.3'
+    version: '3.8.0'
 };
 
 
@@ -230,11 +230,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;
@@ -338,9 +333,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);
     }
@@ -390,9 +382,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];
     }
@@ -400,6 +389,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);
@@ -583,6 +575,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) {
@@ -734,7 +734,6 @@ up.util = (function () {
         normalizeMethod,
         methodAllowsPayload,
         copy,
-        copyArrayLike,
         merge,
         mergeDefined,
         options: newOptions,
@@ -748,7 +747,6 @@ up.util = (function () {
         every,
         find: findInList,
         filter: filterList,
-        filterMap: filterMap,
         reject,
         intersect,
         compact,
@@ -780,6 +778,7 @@ up.util = (function () {
         isRegExp,
         timer: scheduleTimer,
         contains,
+        containsAll,
         objectContains,
         toArray,
         pick,
@@ -806,7 +805,6 @@ up.util = (function () {
         isBasicObjectProperty,
         isCrossOrigin,
         task: queueTask,
-        microtask: queueMicrotask,
         isEqual,
         parseTokens,
         wrapList,
@@ -817,10 +815,9 @@ up.util = (function () {
         delegate: defineDelegates,
         reverse,
         camelToKebabCase,
-        nullToUndefined,
+        replaceValue,
         sprintf,
         renameKeys,
-        negate,
         memoizeMethod,
         safeStringifyJSON,
         variant,
@@ -887,7 +884,9 @@ up.fail = up.error.fail;
 /* 5 */
 /***/ (() => {
 
-up.migrate = { config: {} };
+up.migrate = {
+    config: {},
+};
 
 
 /***/ }),
@@ -1184,7 +1183,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 {
@@ -1223,16 +1222,9 @@ up.element = (function () {
         paint(element);
         return undo;
     }
-    function hasCSSTransition(elementOrStyleHash) {
-        let styleHash;
-        if (u.isOptions(elementOrStyleHash)) {
-            styleHash = elementOrStyleHash;
-        }
-        else {
-            styleHash = computedStyle(elementOrStyleHash);
-        }
-        const prop = styleHash.transitionProperty;
-        const duration = styleHash.transitionDuration;
+    function hasCSSTransition(styleHash) {
+        const prop = styleHash['transition-property'];
+        const duration = styleHash['transition-duration'];
         const noTransition = ((prop === 'none') || ((prop === 'all') && (duration === 0)));
         return !noTransition;
     }
@@ -1241,8 +1233,8 @@ up.element = (function () {
         element.style.position = 'absolute';
         const offsetParentRect = element.offsetParent.getBoundingClientRect();
         setInlineStyle(element, {
-            left: elementRectAsFixed.left - computedStyleNumber(element, 'margin-left') - offsetParentRect.left,
-            top: elementRectAsFixed.top - computedStyleNumber(element, 'margin-top') - offsetParentRect.top,
+            left: (elementRectAsFixed.left - computedStyleNumber(element, 'margin-left') - offsetParentRect.left) + 'px',
+            top: (elementRectAsFixed.top - computedStyleNumber(element, 'margin-top') - offsetParentRect.top) + 'px',
             right: '',
             bottom: ''
         });
@@ -1274,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 {
@@ -1289,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))
@@ -1314,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);
             }
         }
@@ -1358,17 +1349,13 @@ 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);
     }
     function computedStyleNumber(element, prop) {
         const rawValue = computedStyle(element, prop);
-        if (u.isGiven(rawValue)) {
+        if (u.isPresent(rawValue)) {
             return parseFloat(rawValue);
         }
     }
@@ -1377,14 +1364,18 @@ up.element = (function () {
         return extractFromStyleObject(style, props);
     }
     function extractFromStyleObject(style, keyOrKeys) {
+        if (up.migrate.loaded)
+            keyOrKeys = up.migrate.fixStyleProps(keyOrKeys);
         if (u.isString(keyOrKeys)) {
-            return style[keyOrKeys];
+            return style.getPropertyValue(keyOrKeys);
         }
         else {
-            return u.pick(style, keyOrKeys);
+            return u.mapObject(keyOrKeys, (key) => [key, style.getPropertyValue(key)]);
         }
     }
-    function setInlineStyle(element, props) {
+    function setInlineStyle(element, props, unit = '') {
+        if (up.migrate.loaded)
+            props = up.migrate.fixStyleProps(props, unit);
         if (u.isString(props)) {
             element.setAttribute('style', props);
         }
@@ -1392,37 +1383,10 @@ up.element = (function () {
             const { style } = element;
             for (let key in props) {
                 let value = props[key];
-                value = normalizeStyleValueForWrite(key, value);
-                style[key] = value;
+                style.setProperty(key, value + unit);
             }
         }
     }
-    function normalizeStyleValueForWrite(key, value) {
-        if (u.isMissing(value)) {
-            value = '';
-        }
-        else if (CSS_LENGTH_PROPS.has(key.toLowerCase().replace(/-/, ''))) {
-            value = cssLength(value);
-        }
-        return value;
-    }
-    const CSS_LENGTH_PROPS = new Set([
-        'top', 'right', 'bottom', 'left',
-        'padding', 'paddingtop', 'paddingright', 'paddingbottom', 'paddingleft',
-        'margin', 'margintop', 'marginright', 'marginbottom', 'marginleft',
-        'borderwidth', 'bordertopwidth', 'borderrightwidth', 'borderbottomwidth', 'borderleftwidth',
-        'width', 'height',
-        'maxwidth', 'maxheight',
-        'minwidth', 'minheight',
-    ]);
-    function cssLength(obj) {
-        if (u.isNumber(obj) || (u.isString(obj) && /^\d+$/.test(obj))) {
-            return obj.toString() + "px";
-        }
-        else {
-            return obj;
-        }
-    }
     function isVisible(element) {
         return !!(element.offsetWidth || element.offsetHeight || element.getClientRects().length);
     }
@@ -1447,6 +1411,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,
@@ -1481,7 +1457,6 @@ up.element = (function () {
         setMissingAttr,
         unwrap,
         wrapChildren,
-        isWrapper,
         attr: stringAttr,
         booleanAttr,
         numberAttr,
@@ -1498,11 +1473,12 @@ up.element = (function () {
         upClasses,
         toggleAttr,
         addTemporaryClass,
-        setTemporaryAttr,
         cleanJQuery,
         parseSelector,
         isEmpty,
         crossOriginSelector,
+        isIntersectingWindow,
+        unionSelector,
     };
 })();
 
@@ -1612,6 +1588,7 @@ up.Record = class Record {
 /***/ (() => {
 
 const u = up.util;
+const e = up.element;
 up.Config = class Config {
     constructor(blueprintFn = (() => ({}))) {
         this._blueprintFn = blueprintFn;
@@ -1627,10 +1604,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);
@@ -1801,6 +1775,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());
     }
@@ -1812,64 +1792,49 @@ 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;
+        this._cleaners = [];
     }
     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();
+        this._cleaners.push(e.setTemporaryStyle(e.root, {
+            '--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);
+        this._cleaners.push(e.setTemporaryStyle(e.root, { ['--up-original-' + styleProp]: originalValue }), e.addTemporaryClass(element, SHIFT_CLASS));
     }
     _unshiftNow() {
-        let unshiftFn;
-        while (unshiftFn = this._unshiftFns.pop()) {
-            unshiftFn();
+        let cleaner;
+        while (cleaner = this._cleaners.pop()) {
+            cleaner();
         }
     }
 };
@@ -3078,6 +3043,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) {
@@ -3250,20 +3216,17 @@ up.CompilerPass = class CompilerPass {
 const u = up.util;
 const e = up.element;
 up.CSSTransition = class CSSTransition {
-    constructor(element, lastFrameKebab, options) {
+    constructor(element, lastFrame, options) {
         this._element = element;
-        this._lastFrameKebab = lastFrameKebab;
-        this._lastFrameKeysKebab = Object.keys(this._lastFrameKebab);
-        if (u.some(this._lastFrameKeysKebab, key => key.match(/A-Z/))) {
-            up.fail('Animation keys must be kebab-case');
-        }
+        this._lastFrame = lastFrame;
+        this._lastFrameKeys = Object.keys(this._lastFrame);
         this._finishEvent = options.finishEvent;
         this._duration = options.duration;
         this._easing = options.easing;
         this._finished = false;
     }
     start() {
-        if (this._lastFrameKeysKebab.length === 0) {
+        if (this._lastFrameKeys.length === 0) {
             this._finished = true;
             return Promise.resolve();
         }
@@ -3287,9 +3250,7 @@ up.CSSTransition = class CSSTransition {
     }
     _startFallbackTimer() {
         const timingTolerance = 100;
-        this._fallbackTimer = u.timer((this._duration + timingTolerance), () => {
-            this._finish();
-        });
+        this._fallbackTimer = u.timer((this._duration + timingTolerance), () => this._finish());
     }
     _stopFallbackTimer() {
         clearTimeout(this._fallbackTimer);
@@ -3305,11 +3266,10 @@ up.CSSTransition = class CSSTransition {
         if (elapsed <= (0.25 * this._duration)) {
             return;
         }
-        const completedPropertyKebab = event.propertyName;
-        if (!u.contains(this._lastFrameKeysKebab, completedPropertyKebab)) {
-            return;
+        const completedProperty = event.propertyName;
+        if (u.contains(this._lastFrameKeys, completedProperty)) {
+            this._finish();
         }
-        this._finish();
     }
     _finish() {
         var _a, _b;
@@ -3326,16 +3286,16 @@ up.CSSTransition = class CSSTransition {
     }
     _pauseOldTransition() {
         const oldTransition = e.style(this._element, [
-            'transitionProperty',
-            'transitionDuration',
-            'transitionDelay',
-            'transitionTimingFunction'
+            'transition-property',
+            'transition-duration',
+            'transition-delay',
+            'transition-timing-function'
         ]);
         if (e.hasCSSTransition(oldTransition)) {
-            if (oldTransition.transitionProperty !== 'all') {
-                const oldTransitionProperties = oldTransition.transitionProperty.split(/\s*,\s*/);
-                const oldTransitionFrameKebab = e.style(this._element, oldTransitionProperties);
-                this._setOldTransitionTargetFrame = e.setTemporaryStyle(this._element, oldTransitionFrameKebab);
+            if (oldTransition['transition-property'] !== 'all') {
+                const oldTransitionProperties = oldTransition['transition-property'].split(/\s*,\s*/);
+                const oldTransitionFrame = e.style(this._element, oldTransitionProperties);
+                this._setOldTransitionTargetFrame = e.setTemporaryStyle(this._element, oldTransitionFrame);
             }
             this._setOldTransition = e.concludeCSSTransition(this._element);
         }
@@ -3347,11 +3307,11 @@ up.CSSTransition = class CSSTransition {
     }
     _startMotion() {
         e.setStyle(this._element, {
-            transitionProperty: Object.keys(this._lastFrameKebab).join(', '),
-            transitionDuration: `${this._duration}ms`,
-            transitionTimingFunction: this._easing
+            'transition-property': this._lastFrameKeys.join(),
+            'transition-duration': `${this._duration}ms`,
+            'transition-timing-function': this._easing
         });
-        e.setStyle(this._element, this._lastFrameKebab);
+        e.setStyle(this._element, this._lastFrame);
     }
 };
 
@@ -3831,6 +3791,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 const u = up.util;
+const e = up.element;
 up.FormValidator = class FormValidator {
     constructor(form) {
         this._form = form;
@@ -3891,7 +3852,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) {
@@ -3920,7 +3881,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 });
         }
     }
@@ -3968,7 +3929,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;
@@ -4617,6 +4579,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() {
@@ -4632,6 +4595,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);
@@ -4648,6 +4614,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();
@@ -4680,6 +4649,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;
@@ -5408,7 +5391,10 @@ up.LinkFeedbackURLs = class LinkFeedbackURLs {
     }
     isCurrent(normalizedLocation) {
         var _a, _b;
-        return this._isSafe && !!(this.href === normalizedLocation ||
+        if (!normalizedLocation) {
+            return false;
+        }
+        return !!(this.href === normalizedLocation ||
             this._upHREF === normalizedLocation ||
             ((_b = (_a = this._aliasPattern) === null || _a === void 0 ? void 0 : _a.test) === null || _b === void 0 ? void 0 : _b.call(_a, normalizedLocation, false)));
     }
@@ -5421,62 +5407,41 @@ 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() {
-        var _a;
-        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 ((_a = this._currentRequest) === null || _a === void 0 ? void 0 : _a.background) {
-            this._currentRequest.abort();
+        else {
+            this._runCallback(event);
         }
-        this._currentLink = undefined;
-        this._currentRequest = undefined;
     }
-    _preloadAfterDelay(event, link) {
+    _unscheduleCallback() {
+        clearTimeout(this._timer);
+        up.network.abort((request) => (request.origin === this._link) && request.background);
+    }
+    _parseDelay() {
         var _a;
-        const delay = (_a = e.numberAttr(link, 'up-preload-delay')) !== null && _a !== void 0 ? _a : up.link.config.preloadDelay;
-        this._timer = u.timer(delay, () => this._preloadNow(event, link));
+        return (_a = e.numberAttr(this._link, 'up-preload-delay')) !== null && _a !== void 0 ? _a : 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());
     }
 };
 
@@ -6236,7 +6201,6 @@ up.Request = (_a = class Request extends up.Record {
                 'wrapMethod',
                 'contentType',
                 'payload',
-                'onQueued',
                 'onLoading',
                 'fail',
                 'abortable',
@@ -6271,7 +6235,7 @@ up.Request = (_a = class Request extends up.Record {
             }
             this.deferred = u.newDeferred();
             (_d = this.badResponseTime) !== null && _d !== void 0 ? _d : (this.badResponseTime = u.evalOption(up.network.config.badResponseTime, this));
-            this._addAutoHeaders();
+            this._setAutoHeaders();
         }
         get xhr() {
             var _b;
@@ -6281,7 +6245,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 };
@@ -6337,9 +6301,7 @@ up.Request = (_a = class Request extends up.Record {
             return u.evalAutoOption(this.cache, up.network.config.autoCache, this);
         }
         runQueuedCallbacks() {
-            var _b;
             u.always(this, () => this._evictExpensiveAttrs());
-            (_b = this.onQueued) === null || _b === void 0 ? void 0 : _b.call(this, this);
         }
         load() {
             var _b;
@@ -6484,9 +6446,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));
@@ -6498,17 +6457,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);
+        }
+        _setPropertyHeader(key) {
+            this._setAutoHeader(up.protocol.headerize(key), this[key]);
         }
-        _addAutoHeader(name, value) {
+        _setAutoHeader(name, value) {
             if (u.isMissing(value)) {
                 return;
             }
@@ -6517,6 +6479,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)) {
@@ -6560,78 +6532,85 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 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) {
-        var _a, _b;
-        return ((_a = this._varyInfo)[_b = request.description] || (_a[_b] = 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;
-    }
     put(request) {
         return __awaiter(this, void 0, void 0, function* () {
             request = this._wrap(request);
-            this._makeRoom();
-            let cacheKey = this._updateCacheKey(request);
-            this._map.set(cacheKey, request);
+            let route = this._getRoute(request);
+            let { response } = request;
+            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();
         });
     }
-    _updateCacheKey(request) {
-        let oldCacheKey = this._cacheKey(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);
-            }
-        }
-    }
     alias(existingCachedRequest, newRequest) {
         existingCachedRequest = this.get(existingCachedRequest);
         if (!existingCachedRequest)
@@ -6648,7 +6627,7 @@ up.Request.Cache = class Cache {
             newRequest.state = 'tracking';
             let value = yield 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);
@@ -6669,31 +6648,45 @@ 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) {
+        var _a;
+        u.remove(this._requests, request);
+        (_a = request.cacheRoute) === null || _a === void 0 ? void 0 : _a.delete(request);
+        delete request.cacheRoute;
+    }
+    _getRoute(request) {
+        var _a, _b;
+        return request.cacheRoute || ((_a = this._routes)[_b = request.description] || (_a[_b] = 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);
     }
@@ -6722,7 +6715,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) {
@@ -6763,7 +6756,7 @@ up.Request.Queue = class Queue {
             up.network.registerAliasForRedirect(request, responseOrError);
         }
         this._checkLate();
-        u.microtask(() => this._poke());
+        queueMicrotask(() => this._poke());
     }
     _poke() {
         let request;
@@ -6959,16 +6952,13 @@ up.Response = class Response extends up.Record {
     get none() {
         return !this.text;
     }
-    isCacheable() {
-        return this.ok && !this.none;
-    }
     header(name) {
         var _a;
         return this.headers[name] || ((_a = this.xhr) === null || _a === void 0 ? void 0 : _a.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');
@@ -7009,6 +6999,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) {
@@ -7029,43 +7020,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);
@@ -7074,9 +7065,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) {
@@ -7089,6 +7079,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) {
             var _b;
             return (_b = head.querySelector('title')) === null || _b === void 0 ? void 0 : _b.textContent;
@@ -7188,7 +7183,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');
@@ -7227,10 +7222,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);
@@ -7368,10 +7359,10 @@ up.Tether = class Tether {
     sync() {
         const elementBox = this._element.getBoundingClientRect();
         const elementMargin = {
-            top: e.styleNumber(this._element, 'marginTop'),
-            right: e.styleNumber(this._element, 'marginRight'),
-            bottom: e.styleNumber(this._element, 'marginBottom'),
-            left: e.styleNumber(this._element, 'marginLeft')
+            top: e.styleNumber(this._element, 'margin-top'),
+            right: e.styleNumber(this._element, 'margin-right'),
+            bottom: e.styleNumber(this._element, 'margin-bottom'),
+            left: e.styleNumber(this._element, 'margin-left')
         };
         const anchorBox = this._anchor.getBoundingClientRect();
         let left;
@@ -7439,7 +7430,7 @@ up.Tether = class Tether {
     _setOffset(left, top) {
         this.offsetLeft = left;
         this.offsetTop = top;
-        e.setStyle(this._element, { left, top });
+        e.setStyle(this._element, { left, top }, 'px');
     }
 };
 
@@ -7783,10 +7774,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'); },
@@ -7847,7 +7834,6 @@ up.protocol = (function () {
         headerize,
         wrapMethod,
         cspNoncesFromHeader,
-        influencingHeadersFromResponse,
     };
 })();
 
@@ -7983,44 +7969,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 || (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);
     }
-    const parseCompilerArgs = function (args) {
+    function registerProcessor(args, overrides = {}) {
+        let processor = buildProcessor(args, overrides);
+        if (processor.macro) {
+            if (up.framework.evaling) {
+                processor.priority || (processor.priority = detectSystemMacroPriority(processor.selector));
+            }
+            insertProcessor(registeredMacros, processor);
+        }
+        else {
+            insertProcessor(registeredCompilers, processor);
+        }
+    }
+    const parseProcessorArgs = function (args) {
         const defaults = u.extractOptions(args);
         const selector = args.shift();
         const callback = args.pop();
         const options = Object.assign(Object.assign({}, 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)) {
@@ -8114,6 +8117,7 @@ up.script = (function () {
         config,
         compiler: registerCompiler,
         macro: registerMacro,
+        attrCompiler: registerAttrCompiler,
         destructor: registerDestructor,
         hello,
         clean,
@@ -8128,6 +8132,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;
 
 
 /***/ }),
@@ -8218,10 +8223,8 @@ up.history = (function () {
             return;
         }
         let location = currentLocation();
-        if (up.emit('up:location:restore', { location, log: `Restoring location ${location}` }).defaultPrevented) {
-            return;
-        }
         up.render({
+            guardEvent: up.event.build('up:location:restore', { location, log: `Restoring location ${location}` }),
             url: location,
             target: config.restoreTargets,
             fail: false,
@@ -8229,7 +8232,8 @@ up.history = (function () {
             location,
             peel: true,
             layer: 'root',
-            cache: true,
+            cache: 'auto',
+            revalidate: 'auto',
             saveScroll: false,
             scroll: ['restore', 'auto'],
             saveFocus: false,
@@ -8270,6 +8274,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, {
@@ -8291,6 +8304,8 @@ up.history = (function () {
         isLocation,
         findMetaTags,
         updateMetaTags,
+        getLang,
+        updateLang,
     };
 })();
 
@@ -8773,6 +8788,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 }));
@@ -8813,6 +8847,7 @@ up.fragment = (function () {
         shouldRevalidate,
         abort,
         onAborted,
+        onFirstIntersect,
         splitTarget,
         parseTargetSteps,
         isAlive,
@@ -8942,33 +8977,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);
     }
@@ -9085,7 +9096,7 @@ up.viewport = (function () {
         const moveBounds = function (diffX, diffY) {
             boundsRect.left += diffX;
             boundsRect.top += diffY;
-            return e.setStyle(bounds, boundsRect);
+            return e.setStyle(bounds, boundsRect, 'px');
         };
         moveBounds(0, 0);
         const newElementRect = element.getBoundingClientRect();
@@ -9146,10 +9157,8 @@ up.viewport = (function () {
         get root() { return getRoot(); },
         rootWidth,
         rootHeight,
-        rootHasReducedWidthFromScrollbar,
-        rootOverflowElement,
         isRoot,
-        scrollbarWidth,
+        rootScrollbarWidth,
         saveScroll,
         restoreScroll,
         resetScroll,
@@ -9234,13 +9243,16 @@ up.motion = (function () {
         return Promise.resolve();
     }
     function animateNow(element, lastFrame, options) {
+        if (up.migrate.loaded)
+            lastFrame = up.migrate.fixStyleProps(lastFrame);
         options = Object.assign(Object.assign({}, options), { finishEvent: motionController.finishEvent });
         const cssTransition = new up.CSSTransition(element, lastFrame, options);
         return cssTransition.start();
     }
     function applyConfig(options) {
-        options.easing || (options.easing = config.easing);
-        options.duration || (options.duration = config.duration);
+        var _a, _b;
+        (_a = options.easing) !== null && _a !== void 0 ? _a : (options.easing = config.easing);
+        (_b = options.duration) !== null && _b !== void 0 ? _b : (options.duration = config.duration);
     }
     function findNamedAnimation(name) {
         return namedAnimations[name] || up.fail("Unknown animation %o", name);
@@ -9390,7 +9402,7 @@ up.motion = (function () {
         return { transform: `translate(${dx}px, ${dy}px)` };
     }
     function noTranslateCSS() {
-        return { transform: null };
+        return { transform: '' };
     }
     function untranslatedBox(element) {
         e.setStyle(element, noTranslateCSS());
@@ -9510,6 +9522,7 @@ up.network = (function () {
             if (!newRequest.background) {
                 queue.promoteToForeground(cachedRequest);
             }
+            cachedRequest.mergeIfUnsent(newRequest);
             cache.track(cachedRequest, newRequest, { onIncompatible: processRequest });
             return true;
         }
@@ -9522,10 +9535,10 @@ 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) {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c, _d;
             let expireCache = (_b = (_a = responseOrError.expireCache) !== null && _a !== void 0 ? _a : request.expireCache) !== null && _b !== void 0 ? _b : u.evalOption(config.expireCache, request, responseOrError);
             if (expireCache) {
                 cache.expire(expireCache, { except: request });
@@ -9534,12 +9547,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 (!((_e = responseOrError.isCacheable) === null || _e === void 0 ? void 0 : _e.call(responseOrError))) {
+            else if (isNetworkError || isEmptyResponse) {
                 cache.evict(request);
             }
+            else if (isSuccessResponse && hasCacheEntry) {
+                cache.put(request);
+            }
         });
     }
     function isBusy() {
@@ -9557,7 +9579,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);
         }
@@ -9864,7 +9887,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]'];
@@ -9898,10 +9920,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);
@@ -9923,6 +9944,7 @@ up.link = (function () {
         return options;
     }
     function followOptions(link, options, parserOptions) {
+        var _a;
         link = up.fragment.get(link);
         options = u.options(options);
         const parser = new up.OptionsParser(link, options, Object.assign({ fail: true }, parserOptions));
@@ -9976,10 +9998,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' });
-        }
+        (_a = options.guardEvent) !== null && _a !== void 0 ? _a : (options.guardEvent = up.event.build('up:link:follow', { log: ['Following link %o', link] }));
         return options;
     }
     function preload(link, options) {
@@ -10018,9 +10039,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) {
@@ -10080,6 +10102,38 @@ 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 = Object.assign({ 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 });
@@ -10087,21 +10141,20 @@ 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'] || (areaAttrs['up-href'] = childLink.getAttribute('href'));
-            e.setMissingAttrs(area, areaAttrs);
-            const areaClasses = e.upClasses(childLink);
-            area.classList.add(...areaClasses);
+            e.setMissingAttrs(area, Object.assign({ 'up-href': e.attr(childLink, 'href') }, e.upAttrs(childLink)));
+            area.classList.add(...e.upClasses(childLink));
             makeFollowable(area);
         }
     });
     up.compiler(config.selectorFn('preloadSelectors'), function (link) {
+        var _a;
         if (!isPreloadDisabled(link)) {
-            linkPreloader.watchLink(link);
+            let doPreload = () => up.error.muteUncriticalRejection(preload(link));
+            let condition = (_a = e.booleanOrStringAttr(link, 'up-preload', null)) !== null && _a !== void 0 ? _a : 'hover';
+            onLoadCondition(condition, link, doPreload);
         }
     });
     up.on('up:framework:reset', reset);
@@ -10110,18 +10163,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 };
 
 
 /***/ }),
@@ -10194,7 +10246,8 @@ up.form = (function () {
         options.guardEvent || (options.guardEvent = up.event.build('up:form:submit', {
             submitButton: options.submitButton,
             log: 'Submitting form',
-            params: options.params
+            params: options.params,
+            form,
         }));
         options.origin || (options.origin = up.viewport.focusedElementWithin(form) || options.submitButton || form);
         parser.include(up.link.followOptions);
@@ -10469,7 +10522,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);
@@ -10480,8 +10535,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,
@@ -10523,6 +10578,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;
@@ -10530,9 +10586,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 });
@@ -10541,40 +10594,23 @@ up.feedback = (function () {
     function linkURLs(link) {
         return link.upFeedbackURLs || (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 || (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;
     }
@@ -10602,7 +10638,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() {
@@ -10637,6 +10673,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) {
@@ -10682,7 +10719,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) {