unpoly-rails 3.8.0.1 → 3.9.1

data/assets/unpoly/unpoly.js

@@ -5,7 +5,7 @@
 /***/ (() => {
 
 window.up = {
-    version: '3.8.0'
+    version: '3.9.1'
 };
 
 
@@ -51,11 +51,8 @@ up.util = (function () {
             }
         };
     }
-    const NORMALIZE_URL_DEFAULTS = {
-        host: 'cross-domain',
-    };
     function normalizeURL(url, options) {
-        options = newOptions(options, NORMALIZE_URL_DEFAULTS);
+        options = newOptions(options, { host: 'cross-domain' });
         const parts = parseURL(url);
         let normalized = '';
         if (options.host === 'cross-domain') {
@@ -77,8 +74,22 @@ up.util = (function () {
         }
         return normalized;
     }
-    function matchURLs(leftURL, rightURL) {
-        return normalizeURL(leftURL) === normalizeURL(rightURL);
+    function matchURLs(leftURL, rightURL, options) {
+        return matchableURL(leftURL, options) === matchableURL(rightURL, options);
+    }
+    function matchableURL(url, options) {
+        if (!url)
+            return;
+        return normalizeURL(url, { hash: false, trailingSlash: false, ...options });
+    }
+    function matchableURLPatternAtom(patternAtom) {
+        if (patternAtom.endsWith('/'))
+            return [patternAtom, patternAtom.slice(0, -1)];
+        if (patternAtom.includes('/?'))
+            return [patternAtom, patternAtom.replace('/?', '?')];
+        if (patternAtom.endsWith('/*'))
+            return [patternAtom, patternAtom.slice(0, -2), patternAtom.slice(0, -2) + '?*'];
+        return patternAtom;
     }
     const APP_PROTOCOL = location.protocol;
     const APP_HOSTNAME = location.hostname;
@@ -728,6 +739,8 @@ up.util = (function () {
     return {
         parseURL,
         normalizeURL,
+        matchableURL,
+        matchableURLPatternAtom,
         matchURLs,
         normalizeMethod,
         methodAllowsPayload,
@@ -1825,7 +1838,7 @@ up.BodyShifter = class BodyShifter {
         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));
+        this._cleaners.push(e.setTemporaryStyle(element, { ['--up-original-' + styleProp]: originalValue }), e.addTemporaryClass(element, SHIFT_CLASS));
     }
     _unshiftNow() {
         let cleaner;
@@ -1917,7 +1930,7 @@ up.Change.Addition = class Addition extends up.Change {
             source = (oldElement && up.fragment.source(oldElement));
         }
         if (source) {
-            e.setMissingAttr(newElement, 'up-source', u.normalizeURL(source, { hash: false }));
+            e.setMissingAttr(newElement, 'up-source', up.fragment.normalizeSource(source));
         }
     }
     setTime({ newElement, time }) {
@@ -1948,7 +1961,7 @@ var _a;
 const u = up.util;
 up.RenderJob = (_a = class RenderJob {
         constructor(options) {
-            this.options = up.RenderOptions.preprocess(options);
+            this.options = options;
         }
         execute() {
             this._rendered = this._executePromise();
@@ -1957,6 +1970,7 @@ up.RenderJob = (_a = class RenderJob {
         async _executePromise() {
             try {
                 this._guardRender();
+                this.options = up.RenderOptions.preprocess(this.options);
                 let result = await this._getChange().execute();
                 this._handleResult(result);
                 return result;
@@ -2396,9 +2410,6 @@ up.Change.UpdateLayer = (_a = class UpdateLayer extends up.Change.Addition {
                     step.scroll = false;
                     step.focus = false;
                 }
-                if ((step.placement === 'swap') || (step.placement === 'content')) {
-                    step.scrollBehavior = 'instant';
-                }
             });
         }
         _hasHistory() {
@@ -2718,11 +2729,6 @@ up.Change.CloseLayer = class CloseLayer extends up.Change.Removal {
 var _a;
 const u = up.util;
 up.Change.FromURL = (_a = class FromURL extends up.Change {
-        constructor(options) {
-            super(options);
-            this.options.layer = up.layer.getAll(this.options);
-            this.options.normalizeLayerOptions = false;
-        }
         execute() {
             let _newPageReason = this._newPageReason();
             if (_newPageReason) {
@@ -2941,12 +2947,13 @@ const u = up.util;
 up.Change.FromContent = (_a = class FromContent extends up.Change {
         constructor(options) {
             super(options);
-            this._origin = this.options.origin;
-            this._preview = this.options.preview;
+            this._origin = options.origin;
+            this._preview = options.preview;
+            this._layers = options.layers;
         }
         _getPlans() {
             let plans = [];
-            this._lookupLayers();
+            this._filterLayers();
             this._improveOptionsFromResponseDoc();
             this._expandIntoPlans(plans, this._layers, this.options.target);
             this._expandIntoPlans(plans, this._layers, this.options.fallback);
@@ -2955,9 +2962,8 @@ up.Change.FromContent = (_a = class FromContent extends up.Change {
         _isRenderableLayer(layer) {
             return (layer === 'new') || layer.isOpen();
         }
-        _lookupLayers() {
-            this._allLayers = up.layer.getAll(this.options);
-            this._layers = u.filter(this._allLayers, this._isRenderableLayer);
+        _filterLayers() {
+            this._layers = u.filter(this._layers, this._isRenderableLayer);
         }
         _expandIntoPlans(plans, layers, targets) {
             for (let layer of layers) {
@@ -4238,12 +4244,6 @@ up.FragmentPolling = class FragmentPolling {
             up.puts('[up-poll]', 'Will not poll hidden fragment');
             return;
         }
-        if (up.emit(this._fragment, 'up:fragment:poll', { log: ['Polling fragment', this._fragment] }).defaultPrevented) {
-            up.puts('[up-poll]', 'User prevented up:fragment:poll event');
-            this._satisfyInterval();
-            this._scheduleRemainingTime();
-            return;
-        }
         this._reloadNow();
     }
     _getFullDelay() {
@@ -4261,21 +4261,20 @@ up.FragmentPolling = class FragmentPolling {
     }
     _reloadNow() {
         this._clearReloadTimer();
-        let reloadOptions = {
-            url: this._options.url,
-            fail: false,
-            background: true,
-        };
         let oldAbortable = this._abortable;
         try {
             this._abortable = false;
             this._loading = true;
-            up.reload(this._fragment, reloadOptions).then(this._onReloadSuccess.bind(this), this._onReloadFailure.bind(this));
+            up.reload(this._fragment, this._reloadOptions()).then(this._onReloadSuccess.bind(this), this._onReloadFailure.bind(this));
         }
         finally {
             this._abortable = oldAbortable;
         }
     }
+    _reloadOptions() {
+        let guardEvent = up.event.build('up:fragment:poll', { log: ['Polling fragment', this._fragment] });
+        return { ...this._options, guardEvent };
+    }
     _onFragmentAborted({ newLayer }) {
         if (this._abortable && !newLayer) {
             this._stop();
@@ -4492,8 +4491,8 @@ up.Layer = class Layer extends up.Record {
     _containsEventTarget(event) {
         return this.contains(event.target);
     }
-    wasHitByMouseEvent(event) {
-        const hittableElement = document.elementFromPoint(event.clientX, event.clientY);
+    wasHitByMouseEvent({ clientX, clientY }) {
+        const hittableElement = document.elementFromPoint(clientX, clientY);
         return !hittableElement || this.contains(hittableElement);
     }
     _buildEventEmitter(args) {
@@ -4603,7 +4602,7 @@ up.Layer = class Layer extends up.Record {
     }
     set location(location) {
         const previousLocation = this.location;
-        location = up.history.normalizeURL(location);
+        location = u.normalizeURL(location);
         if (previousLocation !== location || this.opening) {
             this.savedLocation = location;
             if (this.showsLiveHistory()) {
@@ -4801,7 +4800,7 @@ up.Layer.Overlay = class Overlay extends up.Layer {
         up.log.putsEvent(event);
         if (halt)
             up.event.halt(event);
-        this.dismiss(':outside', { origin: event.target });
+        up.error.muteUncriticalSync(() => this.dismiss(':outside', { origin: event.target }));
     }
     onEscapePressed(event) {
         if (this.isFront()) {
@@ -4811,7 +4810,7 @@ up.Layer.Overlay = class Overlay extends up.Layer {
             }
             else if (this._supportsDismissMethod('key')) {
                 up.event.halt(event, { log: true });
-                this.dismiss(':key');
+                up.error.muteUncriticalSync(() => this.dismiss(':key'));
             }
         }
     }
@@ -4836,7 +4835,7 @@ up.Layer.Overlay = class Overlay extends up.Layer {
         }
         return this.on(eventTypes, event => {
             event.preventDefault();
-            closeFn.call(this, event, { response: event.response });
+            up.error.muteUncriticalSync(() => closeFn.call(this, event, { response: event.response }));
         });
     }
     tryAcceptForLocation(options) {
@@ -4849,7 +4848,7 @@ up.Layer.Overlay = class Overlay extends up.Layer {
         let location, resolution;
         if (urlPattern && (location = this.location) && (resolution = urlPattern.recognize(location))) {
             const closeValue = { ...resolution, location };
-            closeFn.call(this, closeValue, options);
+            up.error.muteUncriticalSync(() => closeFn.call(this, closeValue, options));
         }
     }
     teardownHandlers() {
@@ -5078,92 +5077,110 @@ up.Layer.Cover = (_a = class Cover extends up.Layer.OverlayWithViewport {
 /* 58 */
 /***/ (() => {
 
+var _a;
 const u = up.util;
 const e = up.element;
-up.LayerLookup = class LayerLookup {
-    constructor(stack, ...args) {
-        this._stack = stack;
-        const options = u.parseArgIntoOptions(args, 'layer');
-        if (options.normalizeLayerOptions !== false) {
-            up.layer.normalizeOptions(options);
-        }
-        this._values = u.parseTokens(options.layer);
-        this._origin = options.origin;
-        this._baseLayer = options.baseLayer || this._originLayer() || this._stack.current;
-        if (u.isString(this._baseLayer)) {
-            const recursiveOptions = { ...options, baseLayer: this._stack.current, normalizeLayerOptions: false };
-            this._baseLayer = new this.constructor(this._stack, this._baseLayer, recursiveOptions).first();
+up.LayerLookup = (_a = class LayerLookup {
+        constructor(stack, options) {
+            this._stack = stack;
+            if (options.normalizeLayerOptions !== false) {
+                up.layer.normalizeOptions(options);
+            }
+            this._options = options;
+            this._values = u.parseTokens(options.layer);
         }
-    }
-    _originLayer() {
-        if (this._origin) {
-            return this._forElement(this._origin);
+        all() {
+            let results = u.flatMap(this._values, value => this._resolveValue(value));
+            results = u.compact(results);
+            results = u.uniq(results);
+            return results;
         }
-    }
-    first() {
-        return this.all()[0];
-    }
-    all() {
-        let results = u.flatMap(this._values, value => this._resolveValue(value));
-        results = u.compact(results);
-        results = u.uniq(results);
-        return results;
-    }
-    _forElement(element) {
-        element = e.get(element);
-        return u.find(this._stack.reversed(), layer => layer.contains(element));
-    }
-    _forIndex(value) {
-        return this._stack.at(value);
-    }
-    _resolveValue(value) {
-        if (value instanceof up.Layer) {
-            return value;
+        static all(stack, ...args) {
+            const options = u.parseArgIntoOptions(args, 'layer');
+            const { layer } = options;
+            if (layer instanceof up.Layer) {
+                return [layer];
+            }
+            return new this(stack, options).all();
         }
-        if (u.isNumber(value)) {
-            return this._forIndex(value);
+        _forElement(element) {
+            element = e.get(element);
+            return u.find(this._stack.reversed(), layer => layer.contains(element));
         }
-        if (/^\d+$/.test(value)) {
-            return this._forIndex(Number(value));
+        _forIndex(value) {
+            return this._stack.at(value);
         }
-        if (u.isElementish(value)) {
-            return this._forElement(value);
+        _resolveValue(value) {
+            if (value instanceof up.Layer) {
+                return value;
+            }
+            if (u.isNumber(value)) {
+                return this._forIndex(value);
+            }
+            if (/^\d+$/.test(value)) {
+                return this._forIndex(Number(value));
+            }
+            if (u.isElementish(value)) {
+                return this._forElement(value);
+            }
+            switch (value) {
+                case 'any':
+                    return [this._getBaseLayer(), ...this._stack.reversed()];
+                case 'current':
+                    return this._getBaseLayer();
+                case 'closest':
+                    return this._stack.selfAndAncestorsOf(this._getBaseLayer());
+                case 'parent':
+                    return this._getBaseLayer().parent;
+                case 'ancestor':
+                case 'ancestors':
+                    return this._getBaseLayer().ancestors;
+                case 'child':
+                    return this._getBaseLayer().child;
+                case 'descendant':
+                case 'descendants':
+                    return this._getBaseLayer().descendants;
+                case 'subtree':
+                    return this._getBaseLayer().subtree;
+                case 'new':
+                    return 'new';
+                case 'root':
+                    return this._stack.root;
+                case 'overlay':
+                case 'overlays':
+                    return u.reverse(this._stack.overlays);
+                case 'front':
+                    return this._stack.front;
+                case 'origin':
+                    return this._getOriginLayer();
+                default:
+                    return up.fail("Unknown { layer } option: %o", value);
+            }
+        }
+        _getOriginLayer() {
+            let { origin } = this._options;
+            if (origin) {
+                return this._forElement(origin);
+            }
         }
-        switch (value) {
-            case 'any':
-                return [this._baseLayer, ...this._stack.reversed()];
-            case 'current':
-                return this._baseLayer;
-            case 'closest':
-                return this._stack.selfAndAncestorsOf(this._baseLayer);
-            case 'parent':
-                return this._baseLayer.parent;
-            case 'ancestor':
-            case 'ancestors':
-                return this._baseLayer.ancestors;
-            case 'child':
-                return this._baseLayer.child;
-            case 'descendant':
-            case 'descendants':
-                return this._baseLayer.descendants;
-            case 'subtree':
-                return this._baseLayer.subtree;
-            case 'new':
-                return 'new';
-            case 'root':
-                return this._stack.root;
-            case 'overlay':
-            case 'overlays':
-                return u.reverse(this._stack.overlays);
-            case 'front':
-                return this._stack.front;
-            case 'origin':
-                return this._originLayer();
-            default:
-                return up.fail("Unknown { layer } option: %o", value);
+        _getBaseLayer() {
+            let { baseLayer } = this._options;
+            if (u.isString(baseLayer)) {
+                const recursiveOptions = { ...this._options, baseLayer: this._stack.current, normalizeLayerOptions: false, layer: baseLayer };
+                return this.constructor.all(this._stack, recursiveOptions)[0];
+            }
+            else {
+                return baseLayer || this._getOriginLayer() || this._stack.current;
+            }
         }
-    }
-};
+    },
+    (() => {
+        u.memoizeMethod(_a.prototype, {
+            _getBaseLayer: true,
+            _getOriginLayer: true,
+        });
+    })(),
+    _a);
 
 
 /***/ }),
@@ -5231,7 +5248,7 @@ up.LayerStack = class LayerStack {
         return this.getAll(...args)[0];
     }
     getAll(...args) {
-        return new up.LayerLookup(this, ...args).all();
+        return up.LayerLookup.all(this, ...args);
     }
     sync() {
         for (let layer of this.layers) {
@@ -5284,22 +5301,22 @@ up.LayerStack = class LayerStack {
 /* 60 */
 /***/ (() => {
 
+const u = up.util;
 up.LinkFeedbackURLs = class LinkFeedbackURLs {
     constructor(link) {
-        const normalize = up.feedback.normalizeURL;
         this._isSafe = up.link.isSafe(link);
         if (this._isSafe) {
             const href = link.getAttribute('href');
             if (href && (href !== '#')) {
-                this.href = normalize(href);
+                this._href = u.matchableURL(href);
             }
             const upHREF = link.getAttribute('up-href');
             if (upHREF) {
-                this._upHREF = normalize(upHREF);
+                this._upHREF = u.matchableURL(upHREF);
             }
             const alias = link.getAttribute('up-alias');
             if (alias) {
-                this._aliasPattern = new up.URLPattern(alias, normalize);
+                this._aliasPattern = new up.URLPattern(alias);
             }
         }
     }
@@ -5307,7 +5324,7 @@ up.LinkFeedbackURLs = class LinkFeedbackURLs {
         if (!normalizedLocation) {
             return false;
         }
-        return !!(this.href === normalizedLocation ||
+        return !!(this._href === normalizedLocation ||
             this._upHREF === normalizedLocation ||
             this._aliasPattern?.test?.(normalizedLocation, false));
     }
@@ -5938,6 +5955,7 @@ up.RenderOptions = (function () {
         'source',
         'saveScroll',
         'navigate',
+        'baseLayer',
     ]);
     const CONTENT_KEYS = [
         'url',
@@ -5964,7 +5982,13 @@ up.RenderOptions = (function () {
     function preprocess(options) {
         up.migrate.preprocessRenderOptions?.(options);
         const defaults = u.merge(GLOBAL_DEFAULTS, navigateDefaults(options));
-        return u.merge(u.omit(defaults, LATE_KEYS), { defaults }, { inputDevice: up.event.inputDevice }, options, preloadOverrides(options));
+        return u.merge(u.omit(defaults, LATE_KEYS), { defaults }, { inputDevice: up.event.inputDevice }, options, lookupLayers(options), preloadOverrides(options));
+    }
+    function lookupLayers(options) {
+        return {
+            layers: up.layer.getAll(options),
+            normalizeLayerOptions: false,
+        };
     }
     function finalize(preprocessedOptions, lateDefaults) {
         return u.merge(preprocessedOptions.defaults, lateDefaults, preprocessedOptions);
@@ -5991,18 +6015,22 @@ up.RenderOptions = (function () {
         return overrides;
     }
     function deriveFailOptions(preprocessedOptions) {
+        let overrides = failOverrides(preprocessedOptions);
+        let layers = lookupLayers(overrides);
         if (preprocessedOptions.failOptions) {
             return {
                 ...preprocessedOptions.defaults,
                 ...u.pick(preprocessedOptions, SHARED_KEYS),
-                ...failOverrides(preprocessedOptions),
+                ...overrides,
+                ...layers,
                 ...{ failPrefixForced: true }
             };
         }
         else {
             return {
                 ...preprocessedOptions,
-                ...failOverrides(preprocessedOptions),
+                ...overrides,
+                ...layers,
             };
         }
     }
@@ -7036,7 +7064,7 @@ up.RevealMotion = class RevealMotion {
         this._element = element;
         this._viewport = e.get(options.viewport) || up.viewport.get(this._element);
         this._obstructionsLayer = up.layer.get(this._viewport);
-        this._behavior = options.behavior ?? 'instant';
+        this._behavior = options.scrollBehavior ?? options.behavior ?? 'instant';
         const viewportConfig = up.viewport.config;
         this._snap = options.snap ?? options.revealSnap ?? viewportConfig.revealSnap;
         this._padding = options.padding ?? options.revealPadding ?? viewportConfig.revealPadding;
@@ -7308,8 +7336,7 @@ up.Tether = class Tether {
 
 const u = up.util;
 up.URLPattern = class URLPattern {
-    constructor(fullPattern, normalizeURL = u.normalizeURL) {
-        this._normalizeURL = normalizeURL;
+    constructor(fullPattern) {
         this._groups = [];
         const positiveList = [];
         const negativeList = [];
@@ -7328,14 +7355,8 @@ up.URLPattern = class URLPattern {
         if (!list.length) {
             return;
         }
-        list = list.map((url) => {
-            if (url[0] === '*') {
-                url = '/' + url;
-            }
-            url = this._normalizeURL(url);
-            url = u.escapeRegExp(url);
-            return url;
-        });
+        list = u.flatMap(list, u.matchableURLPatternAtom);
+        list = list.map(u.escapeRegExp);
         let reCode = list.join('|');
         reCode = reCode.replace(/\\\*/g, '.*?');
         reCode = reCode.replace(/(:|\\\$)([a-z][\w-]*)/ig, (match, type, name) => {
@@ -7356,13 +7377,13 @@ up.URLPattern = class URLPattern {
     }
     test(url, doNormalize = true) {
         if (doNormalize) {
-            url = this._normalizeURL(url);
+            url = u.matchableURL(url);
         }
         return this._positiveRegexp.test(url) && !this._isExcluded(url);
     }
     recognize(url, doNormalize = true) {
         if (doNormalize) {
-            url = this._normalizeURL(url);
+            url = u.matchableURL(url);
         }
         let match = this._positiveRegexp.exec(url);
         if (match && !this._isExcluded(url)) {
@@ -7497,9 +7518,8 @@ up.event = (function () {
     }
     function build(...args) {
         const props = u.extractOptions(args);
-        const type = args[0] || props.type || up.fail('Expected event type to be passed as string argument or { type } property');
-        const event = document.createEvent('Event');
-        event.initEvent(type, true, true);
+        const type = args[0] || props.type || up.fail('Missing event type');
+        const event = new Event(type, { bubbles: true, cancelable: true });
         Object.assign(event, u.omit(props, ['type', 'target']));
         return event;
     }
@@ -7524,8 +7544,11 @@ up.event = (function () {
         return (u.isUndefined(event.button) || (event.button === 0)) &&
             !u.some(keyModifiers, modifier => event[modifier]);
     }
+    function isSyntheticClick(event) {
+        return u.isMissing(event.clientX);
+    }
     function fork(originalEvent, newType, copyKeys = []) {
-        const newEvent = up.event.build(newType, u.pick(originalEvent, copyKeys));
+        const newEvent = build(newType, u.pick(originalEvent, copyKeys));
         newEvent.originalEvent = originalEvent;
         ['stopPropagation', 'stopImmediatePropagation', 'preventDefault'].forEach(function (key) {
             const originalMethod = newEvent[key];
@@ -7549,7 +7572,7 @@ up.event = (function () {
         Object.assign(forkedEvent, eventProps);
         up.emit(element, forkedEvent);
     }
-    on('up:click', 'a[up-emit]', executeEmitAttr);
+    on('up:click', '[up-emit]', executeEmitAttr);
     let inputDevices = ['unknown'];
     function getInputDevice() {
         return u.last(inputDevices);
@@ -7570,6 +7593,7 @@ up.event = (function () {
         onEscape,
         halt,
         isUnmodified,
+        isSyntheticClick,
         fork,
         keyModifiers,
         get inputDevice() { return getInputDevice(); }
@@ -7818,7 +7842,7 @@ up.script = (function () {
     }));
     const SYSTEM_MACRO_PRIORITIES = {
         '[up-back]': -100,
-        '[up-content]': -200,
+        '[up-clickable]': -200,
         '[up-drawer]': -200,
         '[up-modal]': -200,
         '[up-cover]': -200,
@@ -8035,13 +8059,8 @@ up.history = (function () {
         nextPreviousLocation = undefined;
         trackCurrentLocation();
     }
-    const DEFAULT_NORMALIZE_OPTIONS = { hash: true };
-    function normalizeURL(url, options) {
-        options = u.merge(DEFAULT_NORMALIZE_OPTIONS, options);
-        return u.normalizeURL(url, options);
-    }
-    function currentLocation(normalizeOptions) {
-        return normalizeURL(location.href, normalizeOptions);
+    function currentLocation() {
+        return u.normalizeURL(location.href);
     }
     function trackCurrentLocation() {
         const url = currentLocation();
@@ -8051,19 +8070,17 @@ up.history = (function () {
         }
     }
     trackCurrentLocation();
-    const ADDITIONAL_NORMALIZE_OPTIONS_FOR_COMPARISON = { trailingSlash: false };
     function isLocation(url, options) {
-        options = u.merge(ADDITIONAL_NORMALIZE_OPTIONS_FOR_COMPARISON, options);
-        return normalizeURL(url, options) === currentLocation(options);
+        return u.matchURLs(url, location.href, { hash: true, ...options });
     }
     function replace(location, options = {}) {
-        location = normalizeURL(location);
+        location = u.normalizeURL(location);
         if (manipulate('replaceState', location) && (options.event !== false)) {
             emitLocationChanged({ location, reason: 'replace', log: `Replaced state for ${location}` });
         }
     }
     function push(location) {
-        location = normalizeURL(location);
+        location = u.normalizeURL(location);
         if (!isLocation(location) && manipulate('pushState', location)) {
             emitLocationChanged({ location, reason: 'push', log: `Advanced to location ${location}` });
         }
@@ -8090,7 +8107,7 @@ up.history = (function () {
             return;
         }
         let location = currentLocation();
-        up.render({
+        up.error.muteUncriticalRejection(up.render({
             guardEvent: up.event.build('up:location:restore', { location, log: `Restoring location ${location}` }),
             url: location,
             target: config.restoreTargets,
@@ -8105,7 +8122,7 @@ up.history = (function () {
             scroll: ['restore', 'auto'],
             saveFocus: false,
             focus: ['restore', 'auto'],
-        });
+        }));
     }
     function onPop(event) {
         trackCurrentLocation();
@@ -8150,7 +8167,7 @@ up.history = (function () {
     function updateLang(newLang) {
         e.toggleAttr(e.root, 'lang', newLang, !!newLang);
     }
-    up.macro('a[up-back], [up-href][up-back]', function (link) {
+    up.macro('[up-back]', function (link) {
         if (previousLocation) {
             e.setMissingAttrs(link, {
                 'up-href': previousLocation,
@@ -8167,7 +8184,6 @@ up.history = (function () {
         replace,
         get location() { return currentLocation(); },
         get previousLocation() { return previousLocation; },
-        normalizeURL,
         isLocation,
         findMetaTags,
         updateMetaTags,
@@ -8242,6 +8258,9 @@ up.fragment = (function () {
         element = getSmart(element, options);
         return e.closestAttr(element, 'up-source');
     }
+    function normalizeSource(source) {
+        return u.normalizeURL(source, { hash: false });
+    }
     function timeOf(element) {
         let value = e.closestAttr(element, 'up-time');
         if (value && value !== 'false') {
@@ -8676,7 +8695,7 @@ up.fragment = (function () {
     }
     up.on('up:framework:boot', function () {
         const { documentElement } = document;
-        documentElement.setAttribute('up-source', u.normalizeURL(location.href, { hash: false }));
+        documentElement.setAttribute('up-source', normalizeSource(location.href));
         up.hello(documentElement);
         if (!up.browser.canPushState()) {
             return up.warn('Cannot push history changes. Next fragment update will load in a new page.');
@@ -8695,6 +8714,7 @@ up.fragment = (function () {
         contains,
         closest,
         source: sourceOf,
+        normalizeSource,
         visit,
         markAsDestroying: markFragmentAsDestroying,
         emitInserted: emitFragmentInserted,
@@ -8911,7 +8931,7 @@ up.viewport = (function () {
         }
     }
     function newStateCache() {
-        return new up.FIFOCache({ capacity: 30, normalizeKey: up.history.normalizeURL });
+        return new up.FIFOCache({ capacity: 30, normalizeKey: u.matchableURL });
     }
     function parseOptions(args) {
         const options = u.copy(u.extractOptions(args));
@@ -9571,7 +9591,9 @@ up.layer = (function () {
             return [config[mode], config.overlay, config.any];
         }
     }
-    function normalizeOptions(options) {
+    function normalizeLayerOption(options) {
+        if (options.layer instanceof up.Layer)
+            return;
         up.migrate.handleLayerOptions?.(options);
         if (u.isGiven(options.layer)) {
             let match = String(options.layer).match(/^(new|shatter|swap)( (\w+))?/);
@@ -9590,25 +9612,29 @@ up.layer = (function () {
                 }
             }
         }
-        else {
-            if (options.mode) {
-                options.layer = 'new';
-            }
-            else if (u.isElementish(options.target)) {
-                options.layer = stack.get(options.target, { normalizeLayerOptions: false });
-            }
-            else if (options.origin) {
-                options.layer = 'origin';
-            }
-            else {
-                options.layer = 'current';
-            }
+        else if (options.mode) {
+            options.layer = 'new';
         }
-        if (!options.context) {
-            options.context = {};
+        else if (u.isElementish(options.target)) {
+            options.layer = stack.get(options.target, { normalizeLayerOptions: false });
+        }
+        else if (options.origin) {
+            options.layer = 'origin';
+        }
+        else {
+            options.layer = 'current';
         }
+    }
+    function setBaseLayerOption(options) {
+        if (options.baseLayer instanceof up.Layer)
+            return;
         options.baseLayer = stack.get('current', { ...options, normalizeLayerOptions: false });
     }
+    function normalizeOptions(options) {
+        normalizeLayerOption(options);
+        options.context ??= {};
+        setBaseLayerOption(options);
+    }
     function build(options, beforeNew) {
         const { mode } = options;
         const { Class } = config[mode];
@@ -9741,20 +9767,18 @@ up.link = (function () {
     const u = up.util;
     const e = up.element;
     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]'];
-    const ATTRIBUTES_SUGGESTING_FOLLOW = ['[up-follow]', '[up-target]', '[up-layer]', '[up-transition]', '[up-preload]', '[up-instant]', '[up-href]'];
-    function combineFollowableSelectors(elementSelectors, attributeSelectors) {
-        return u.flatMap(elementSelectors, elementSelector => attributeSelectors.map(attrSelector => elementSelector + attrSelector));
-    }
+    const ATTRS_WITH_LOCAL_HTML = '[up-content], [up-fragment], [up-document]';
+    const ATTRS_SUGGESTING_FOLLOW = `${ATTRS_WITH_LOCAL_HTML}, [up-target], [up-layer], [up-transition], [up-preload]`;
+    const DEFAULT_INTERACTIVE_ELEMENT = 'a[href], button';
     const config = new up.Config(() => ({
-        followSelectors: combineFollowableSelectors(LINKS_WITH_REMOTE_HTML, ATTRIBUTES_SUGGESTING_FOLLOW).concat(LINKS_WITH_LOCAL_HTML),
-        noFollowSelectors: ['[up-follow=false]', 'a[download]', 'a[target]', 'a[href^="#"]:not([up-content]):not([up-fragment]):not([up-document])', 'a[href^="javascript:"]', 'a[href^="mailto:"]', e.crossOriginSelector('href'), e.crossOriginSelector('up-href')],
+        followSelectors: ['[up-follow]', `a:is(${ATTRS_SUGGESTING_FOLLOW})`],
+        noFollowSelectors: ['[up-follow=false]', 'a[download]', 'a[target]', 'a[href^="javascript:"]', 'a[href^="mailto:"]', `a[href^="#"]:not(${ATTRS_WITH_LOCAL_HTML})`, e.crossOriginSelector('href'), e.crossOriginSelector('up-href')],
         instantSelectors: ['[up-instant]'],
         noInstantSelectors: ['[up-instant=false]', '[onclick]'],
-        preloadSelectors: combineFollowableSelectors(LINKS_WITH_REMOTE_HTML, ['[up-preload]']),
+        preloadSelectors: ['[up-preload]'],
         noPreloadSelectors: ['[up-preload=false]'],
-        clickableSelectors: LINKS_WITH_LOCAL_HTML.concat(['[up-emit]', '[up-accept]', '[up-dismiss]', '[up-clickable]']),
+        clickableSelectors: ['[up-clickable]', '[up-follow]', '[up-emit]', '[up-accept]', '[up-dismiss]', `a:is(${ATTRS_SUGGESTING_FOLLOW})`],
+        noClickableSelectors: ['[up-clickable=false]', DEFAULT_INTERACTIVE_ELEMENT],
         preloadDelay: 90,
     }));
     function isPreloadDisabled(link) {
@@ -9892,18 +9916,15 @@ up.link = (function () {
             link.setAttribute('up-follow', '');
         }
     }
-    function makeClickable(link) {
-        if (link.matches('a[href], button')) {
-            return;
-        }
-        let role = link.matches('a') ? 'link' : 'button';
-        e.setMissingAttrs(link, {
+    function makeClickable(element) {
+        let role = element.matches('a, [up-follow]') ? 'link' : 'button';
+        e.setMissingAttrs(element, {
             tabindex: '0',
             role,
             'up-clickable': ''
         });
-        link.addEventListener('keydown', function (event) {
-            if ((event.key === 'Enter') || (event.key === 'Space')) {
+        element.addEventListener('keydown', function (event) {
+            if ((event.key === 'Enter') || (element.role === 'button' && event.key === 'Space')) {
                 return forkEventAsUpClick(event);
             }
         });
@@ -9913,7 +9934,7 @@ up.link = (function () {
         if (event.defaultPrevented) {
             return false;
         }
-        const betterTargetSelector = `a, [up-href], ${up.form.fieldSelector()}`;
+        const betterTargetSelector = `a, [up-follow], ${up.form.fieldSelector()}`;
         const betterTarget = event.target.closest(betterTargetSelector);
         return !betterTarget || (betterTarget === link);
     }
@@ -9932,7 +9953,7 @@ up.link = (function () {
             if (isInstant(element) && lastMousedownTarget) {
                 up.event.halt(event);
             }
-            else if (layer.wasHitByMouseEvent(event) && !didUserDragAway(event)) {
+            else if (up.event.inputDevice === 'key' || up.event.isSyntheticClick(event) || (layer.wasHitByMouseEvent(event) && !didUserDragAway(event))) {
                 forkEventAsUpClick(event);
             }
             return lastMousedownTarget = null;
@@ -10024,6 +10045,7 @@ up.link = (function () {
     return {
         follow,
         followOptions,
+        requestOptions: parseRequestOptions,
         preload,
         makeFollowable,
         isSafe,
@@ -10031,7 +10053,6 @@ up.link = (function () {
         shouldFollowEvent,
         convertClicks,
         config,
-        combineFollowableSelectors,
         loadDeferred,
     };
 })();
@@ -10055,11 +10076,10 @@ __webpack_require__.r(__webpack_exports__);
 up.form = (function () {
     const u = up.util;
     const e = up.element;
-    const ATTRIBUTES_SUGGESTING_SUBMIT = ['[up-submit]', '[up-target]', '[up-layer]', '[up-transition]'];
     const config = new up.Config(() => ({
         groupSelectors: ['[up-form-group]', 'fieldset', 'label', 'form'],
         fieldSelectors: ['select', 'input:not([type=submit]):not([type=image])', 'button[type]:not([type=submit])', 'textarea'],
-        submitSelectors: up.link.combineFollowableSelectors(['form'], ATTRIBUTES_SUGGESTING_SUBMIT),
+        submitSelectors: ['form:is([up-submit], [up-target], [up-layer], [up-transition])'],
         noSubmitSelectors: ['[up-submit=false]', '[target]', e.crossOriginSelector('action')],
         submitButtonSelectors: ['input[type=submit]', 'input[type=image]', 'button[type=submit]', 'button:not([type])'],
         watchInputEvents: ['input', 'change'],
@@ -10086,15 +10106,8 @@ up.form = (function () {
     function findSubmitButtons(root) {
         return e.subtree(root, submitButtonSelector());
     }
-    function submittingButton(form) {
-        const selector = submitButtonSelector();
-        const focusedElement = document.activeElement;
-        if (focusedElement && focusedElement.form === form) {
-            if (focusedElement.matches(selector)) {
-                return focusedElement;
-            }
-        }
-        return e.get(form, selector);
+    function isSubmitButton(element) {
+        return element?.matches(submitButtonSelector());
     }
     function submitButtonSelector() {
         return config.selector('submitButtonSelectors');
@@ -10201,9 +10214,8 @@ up.form = (function () {
         parser.string('contentType', { attr: 'enctype' });
         parser.json('headers');
         const params = up.Params.fromForm(form);
-        const submitButton = submittingButton(form);
+        const submitButton = (options.submitButton ??= findSubmitButtons(form)[0]);
         if (submitButton) {
-            options.submitButton = submitButton;
             params.addField(submitButton);
             options.method ||= submitButton.getAttribute('formmethod');
             options.url ||= submitButton.getAttribute('formaction');
@@ -10221,12 +10233,6 @@ up.form = (function () {
         }
         return options;
     }
-    up.on('up:click', submitButtonSelector, function (event, button) {
-        const form = getForm(button);
-        if (form && isSubmittable(form)) {
-            button.focus();
-        }
-    });
     function watch(root, ...args) {
         root = up.element.get(root);
         const callback = u.extractCallback(args) || watchCallbackFromElement(root) || up.fail('No callback given for up.watch()');
@@ -10378,8 +10384,9 @@ up.form = (function () {
     up.on('submit', config.selectorFn('submitSelectors'), function (event, form) {
         if (event.defaultPrevented)
             return;
+        const submitButton = u.presence(event.submitter, isSubmitButton);
         up.event.halt(event, { log: true });
-        up.error.muteUncriticalRejection(submit(form));
+        up.error.muteUncriticalRejection(submit(form, { submitButton }));
     });
     up.compiler(validatingFieldSelector, function (fieldOrForm) {
         let validator = up.FormValidator.forElement(fieldOrForm);
@@ -10450,17 +10457,12 @@ up.feedback = (function () {
     const CLASS_ACTIVE = 'up-active';
     const CLASS_LOADING = 'up-loading';
     const SELECTOR_LINK = 'a, [up-href]';
-    function normalizeURL(url) {
-        if (url) {
-            return u.normalizeURL(url, { trailingSlash: false, hash: false });
-        }
-    }
     function linkURLs(link) {
         return link.upFeedbackURLs ||= new up.LinkFeedbackURLs(link);
     }
     function updateFragment(fragment, { layer } = {}) {
         layer ||= up.layer.get(fragment);
-        let layerLocation = getNormalizedLayerLocation(layer);
+        let layerLocation = getMatchableLayerLocation(layer);
         const navSelector = config.selector('navSelectors');
         const navLinkSelector = `${navSelector} :is(${SELECTOR_LINK}), ${navSelector}:is(${SELECTOR_LINK})`;
         const links = up.fragment.all(navLinkSelector, { layer });
@@ -10472,8 +10474,8 @@ up.feedback = (function () {
             e.toggleAttr(link, 'aria-current', 'page', isCurrent);
         }
     }
-    function getNormalizedLayerLocation(layer) {
-        return layer.feedbackLocation || normalizeURL(layer.location);
+    function getMatchableLayerLocation(layer) {
+        return layer.feedbackLocation || u.matchableURL(layer.location);
     }
     function findActivatableArea(element) {
         return e.ancestor(element, SELECTOR_LINK) || element;
@@ -10499,7 +10501,7 @@ up.feedback = (function () {
     }
     function updateLayerIfLocationChanged(layer) {
         const processedLocation = layer.feedbackLocation;
-        const layerLocation = getNormalizedLayerLocation(layer.location);
+        const layerLocation = getMatchableLayerLocation(layer.location);
         if (!processedLocation || (processedLocation !== layerLocation)) {
             layer.feedbackLocation = layerLocation;
             updateFragment(layer.element, { layer });
@@ -10524,7 +10526,6 @@ up.feedback = (function () {
     return {
         config,
         showAroundRequest,
-        normalizeURL,
     };
 })();
 
@@ -10589,9 +10590,11 @@ up.radio = (function () {
         up.FragmentPolling.forFragment(element).forceStop();
     }
     function pollOptions(fragment, options = {}) {
-        const parser = new up.OptionsParser(fragment, options);
+        const defaults = { background: true };
+        const parser = new up.OptionsParser(fragment, options, { defaults });
         parser.number('interval', { default: config.pollInterval });
         parser.string('ifLayer', { default: 'front' });
+        parser.include(up.link.requestOptions);
         return options;
     }
     up.attribute('up-poll', function (fragment) {