unpoly-rails 2.5.3 → 2.6.0

data/assets/unpoly/unpoly.js

@@ -8,7 +8,7 @@
 @module up
 */
 window.up = {
-    version: '2.5.3'
+    version: '2.6.0'
 };
 
 
@@ -2101,7 +2101,32 @@ up.error = (function () {
         const { message } = error;
         up.emit(window, 'error', { message, error, log: false });
     }
+    /*-
+    Throws a [JavaScript error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+    with the given message.
+  
+    The message may contain [substitution marks](https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions).
+  
+    ### Examples
+  
+        up.fail('Division by zero')
+        up.fail('Unexpected result %o', result)
+  
+    @function up.fail
+    @param {string} message
+      A message with details about the error.
+  
+      The message can contain [substitution marks](https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions)
+      like `%s` or `%o`.
+    @param {Array<string>} vars...
+      A list of variables to replace any substitution marks in the error message.
+    @internal
+    */
+    function fail(...args) {
+        throw up.error.failed(args);
+    }
     return {
+        fail,
         failed,
         aborted,
         invalidSelector,
@@ -2110,6 +2135,7 @@ up.error = (function () {
         emitGlobal
     };
 })();
+up.fail = up.error.fail;
 
 
 /***/ }),
@@ -2742,11 +2768,11 @@ up.element = (function () {
       The [text content](https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent) of the created element.
     @param {Object} [attrs.content]
       The [inner HTML](https://developer.mozilla.org/en-US/docs/Web/API/Element/innerHTML) of the created element.
-    @param {Object} [attrs.style]
+    @param {Object|string} [attrs.style]
       An object of CSS properties that will be set as the inline style
-      of the created element.
+      of the created element. The given object may use kebab-case or camelCase keys.
   
-      The given object may use kebab-case or camelCase keys.
+      You may also pass a string with semicolon-separated styles.
     @return {Element}
       The created element.
     @stable
@@ -2849,7 +2875,7 @@ up.element = (function () {
       An object of attributes to set on the created element.
     @param {Object} attrs.text
       The [text content](https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent) of the created element.
-    @param {Object} attrs.style
+    @param {Object|string} attrs.style
       An object of CSS properties that will be set as the inline style
       of the created element.
   
@@ -3352,11 +3378,16 @@ up.element = (function () {
     @stable
     */
     function setInlineStyle(element, props) {
-        const { style } = element;
-        for (let key in props) {
-            let value = props[key];
-            value = normalizeStyleValueForWrite(key, value);
-            style[key] = value;
+        if (u.isString(props)) {
+            element.setAttribute('style', props);
+        }
+        else {
+            const { style } = element;
+            for (let key in props) {
+                let value = props[key];
+                value = normalizeStyleValueForWrite(key, value);
+                style[key] = value;
+            }
         }
     }
     function normalizeStyleValueForWrite(key, value) {
@@ -4252,9 +4283,17 @@ up.Change.UpdateLayer = class UpdateLayer extends up.Change.Addition {
                         },
                         afterInsert: () => {
                             this.responseDoc.finalizeElement(step.newElement);
+                            step.keepPlans.forEach(this.reviveKeepable);
+                            // In the case of [up-keep] descendants, keepable elements are now transferred
+                            // to step.newElement, leaving a clone in their old DOM Position.
+                            // up.hello() is aware of step.keepPlans and will not compile kept elements a second time.
                             up.hello(step.newElement, step);
                         },
                         beforeDetach: () => {
+                            // In the case of [up-keep] descendants, keepable elements have been replaced
+                            // with a clone in step.oldElement. However, since that clone was never compiled,
+                            // it does not have destructors registered. Hence we will not clean the clone
+                            // unnecessarily.
                             up.syntax.clean(step.oldElement, { layer: this.layer });
                         },
                         afterDetach() {
@@ -4372,9 +4411,10 @@ up.Change.UpdateLayer = class UpdateLayer extends up.Change.Addition {
         const keepPlans = [];
         if (step.keep) {
             for (let keepable of step.oldElement.querySelectorAll('[up-keep]')) {
-                let plan = this.findKeepPlan({ ...step, oldElement: keepable, descendantsOnly: true });
-                if (plan) {
+                let keepPlan = this.findKeepPlan({ ...step, oldElement: keepable, descendantsOnly: true });
+                if (keepPlan) {
                     // plan.oldElement is now keepable
+                    this.hibernateKeepable(keepPlan);
                     // Replace keepable with its clone so it looks good in a transition between
                     // oldElement and newElement. Note that keepable will still point to the same element
                     // after the replacement, which is now detached.
@@ -4382,8 +4422,8 @@ up.Change.UpdateLayer = class UpdateLayer extends up.Change.Addition {
                     e.replace(keepable, keepableClone);
                     // Since we're going to swap the entire oldElement and newElement containers afterwards,
                     // replace the matching element with keepable so it will eventually return to the DOM.
-                    e.replace(plan.newElement, keepable);
-                    keepPlans.push(plan);
+                    e.replace(keepPlan.newElement, keepable);
+                    keepPlans.push(keepPlan);
                 }
             }
         }
@@ -4408,6 +4448,18 @@ up.Change.UpdateLayer = class UpdateLayer extends up.Change.Addition {
             }
         }
     }
+    hibernateKeepable(keepPlan) {
+        let viewports = up.viewport.subtree(keepPlan.oldElement);
+        keepPlan.revivers = viewports.map(function (viewport) {
+            let { scrollTop, scrollLeft } = viewport;
+            return () => u.assign(viewport, { scrollTop, scrollLeft });
+        });
+    }
+    reviveKeepable(keepPlan) {
+        for (let reviver of keepPlan.revivers) {
+            reviver();
+        }
+    }
     matchPreflight() {
         if (this.matchedPreflight) {
             return;
@@ -4565,7 +4617,7 @@ up.Change.CloseLayer = class CloseLayer extends up.Change.Removal {
         // The close event is emitted on the layer that is about to close.
         return this.layer.emit(this.buildEvent(`up:layer:${this.verb}`), {
             callback: this.layer.callback(`on${u.upperCaseFirst(this.verb)}`),
-            log: `Will ${this.verb} ${this.layer}`
+            log: [`Will ${this.verb} ${this.layer} with value %o`, this.value]
         });
     }
     emitClosedEvent(formerParent) {
@@ -4583,7 +4635,7 @@ up.Change.CloseLayer = class CloseLayer extends up.Change.Removal {
             baseLayer: formerParent,
             callback: this.layer.callback(`on${verbPastUpperCaseFirst}`),
             ensureBubbles: true,
-            log: `${verbPastUpperCaseFirst} ${this.layer}`
+            log: [`${verbPastUpperCaseFirst} ${this.layer} with value %o`, this.value]
         });
     }
     buildEvent(name) {
@@ -5882,6 +5934,110 @@ up.FragmentFocus = class FragmentFocus extends up.FragmentProcessor {
 /* 33 */
 /***/ (() => {
 
+const e = up.element;
+const u = up.util;
+up.FragmentPolling = class FragmentPolling {
+    constructor(fragment) {
+        this.options = {};
+        this.state = 'initialized';
+        this.setFragment(fragment);
+    }
+    static forFragment(fragment) {
+        return fragment.upPolling || (fragment.upPolling = new this(fragment));
+    }
+    onPollAttributeObserved() {
+        this.start();
+    }
+    onFragmentDestroyed() {
+        // The element may come back (when it is swapped) or or may not come back (when it is destroyed).
+        // If it does come back, `onPollAttributeObserved()` will restart the polling.
+        this.stop();
+    }
+    start() {
+        if (this.state !== 'started') {
+            this.state = 'started';
+            this.scheduleReload();
+        }
+    }
+    stop() {
+        if (this.state === 'started') {
+            clearTimeout(this.reloadTimer);
+            this.state = 'stopped';
+        }
+    }
+    forceStart(options) {
+        u.assign(this.options, options);
+        this.forceStarted = true;
+        this.start();
+    }
+    forceStop() {
+        this.stop();
+        this.forceStarted = false;
+    }
+    scheduleReload(delay = this.getInterval()) {
+        this.reloadTimer = setTimeout(() => this.reload(), delay);
+    }
+    reload() {
+        // The setTimeout(doReload) callback might already be scheduled
+        // before the polling stopped.
+        if (this.state !== 'started') {
+            return;
+        }
+        if (up.radio.shouldPoll(this.fragment)) {
+            let reloadOptions = {
+                url: this.options.url,
+                guardEvent: up.event.build('up:fragment:poll', { log: 'Polling fragment' })
+            };
+            u.always(up.reload(this.fragment, reloadOptions), (result) => this.onReloaded(result));
+        }
+        else {
+            up.puts('[up-poll]', 'Polling is disabled');
+            // Reconsider after 10 seconds at most
+            let reconsiderDisabledDelay = Math.min(10 * 1000, this.getInterval());
+            this.scheduleReload(reconsiderDisabledDelay);
+        }
+    }
+    onReloaded(result) {
+        // Transfer this instance to the new fragment.
+        // We can remove this in case we don't implement forced start/stop.
+        let newFragment = result?.fragments?.[0];
+        if (newFragment) {
+            // No need to scheduleReload() in this branch:
+            // (1) Either the new fragment also has an [up-poll] and we have already
+            //     started in #onPollAttributeObserved().
+            // (2) Or we are force-started and we will start in #onFragmentSwapped().
+            this.onFragmentSwapped(newFragment);
+        }
+        else {
+            this.scheduleReload();
+        }
+    }
+    onFragmentSwapped(newFragment) {
+        // Transfer this polling to the new instance
+        newFragment.upPolling = this;
+        delete this.fragment.upPolling;
+        this.setFragment(newFragment);
+        if (this.state === 'stopped' && this.forceStarted) {
+            // When polling was started programmatically through up.fragment.startPolling()
+            // we don't require the updated fragment to have an [up-poll] attribute to
+            // continue polling.
+            this.start();
+        }
+    }
+    setFragment(newFragment) {
+        this.fragment = newFragment;
+        up.destructor(newFragment, () => this.onFragmentDestroyed());
+    }
+    getInterval() {
+        return this.options.interval ?? e.numberAttr(this.fragment, 'up-interval') ?? up.radio.config.pollInterval;
+    }
+};
+
+
+/***/ }),
+/* 34 */
+/***/ (() => {
+
 const u = up.util;
 up.FragmentScrolling = class FragmentScrolling extends up.FragmentProcessor {
     keys() {
@@ -5957,7 +6113,7 @@ up.FragmentScrolling = class FragmentScrolling extends up.FragmentProcessor {
 
 
 /***/ }),
-/* 34 */
+/* 35 */
 /***/ (() => {
 
 const u = up.util;
@@ -5998,7 +6154,7 @@ up.HTMLWrapper = class HTMLWrapper {
 
 
 /***/ }),
-/* 35 */
+/* 36 */
 /***/ (() => {
 
 const e = up.element;
@@ -6687,7 +6843,7 @@ up.Layer = class Layer extends up.Record {
 
 
 /***/ }),
-/* 36 */
+/* 37 */
 /***/ (() => {
 
 const e = up.element;
@@ -6844,12 +7000,6 @@ up.Layer.Overlay = class Overlay extends up.Layer {
             this.createDismissElement(this.getBoxElement());
         }
         if (this.supportsDismissMethod('outside')) {
-            this.unbindParentClicked = this.parent.on('up:click', (event, element) => {
-                // When our origin is clicked again, halt the click event
-                // We achieve this by halting the click event.
-                const originClicked = this.origin && this.origin.contains(element);
-                this.onOutsideClicked(event, originClicked);
-            });
             // If this overlay has its own viewport, a click outside the frame will hit
             // the viewport and not the parent element.
             if (this.viewportElement) {
@@ -6860,6 +7010,18 @@ up.Layer.Overlay = class Overlay extends up.Layer {
                     }
                 });
             }
+            else {
+                // Only bind to the parent if there's not already a viewport.
+                // This prevents issues with other overlay libs appending elements to document.body,
+                // but overlaying this overlay with a huge z-index. Clicking such a foreign overlay
+                // would close this layer, as Unpoly considers it to be on the root layer (our parent).2
+                this.unbindParentClicked = this.parent.on('up:click', (event, element) => {
+                    // When our origin is clicked again, halt the click event
+                    // We achieve this by halting the click event.
+                    const originClicked = this.origin && this.origin.contains(element);
+                    this.onOutsideClicked(event, originClicked);
+                });
+            }
         }
         if (this.supportsDismissMethod('key')) {
             this.unbindEscapePressed = up.event.onEscape(event => this.onEscapePressed(event));
@@ -6882,7 +7044,7 @@ up.Layer.Overlay = class Overlay extends up.Layer {
         if (halt) {
             up.event.halt(event);
         }
-        this.dismiss(':outside');
+        this.dismiss(':outside', { origin: event.target });
     }
     onEscapePressed(event) {
         // All overlays listen to the Escape key being pressed, but only the front layer
@@ -6909,7 +7071,7 @@ up.Layer.Overlay = class Overlay extends up.Layer {
             // Since we're defining this handler on up.Overlay, we will not prevent
             // a link from being followed on the root layer.
             up.event.halt(event);
-            const origin = event.target.closest(selector);
+            const origin = e.closest(event.target, selector);
             const value = e.jsonAttr(origin, attribute);
             const closeOptions = { origin };
             const parser = new up.OptionsParser(closeOptions, origin);
@@ -7031,7 +7193,7 @@ up.Layer.Overlay = class Overlay extends up.Layer {
 
 
 /***/ }),
-/* 37 */
+/* 38 */
 /***/ (() => {
 
 up.Layer.OverlayWithTether = class OverlayWithTether extends up.Layer.Overlay {
@@ -7076,7 +7238,7 @@ up.Layer.OverlayWithTether = class OverlayWithTether extends up.Layer.Overlay {
 
 
 /***/ }),
-/* 38 */
+/* 39 */
 /***/ (() => {
 
 var _a;
@@ -7128,7 +7290,7 @@ up.Layer.OverlayWithViewport = (_a = class OverlayWithViewport extends up.Layer.
 
 
 /***/ }),
-/* 39 */
+/* 40 */
 /***/ (() => {
 
 var _a;
@@ -7200,7 +7362,7 @@ up.Layer.Root = (_a = class Root extends up.Layer {
 
 
 /***/ }),
-/* 40 */
+/* 41 */
 /***/ (() => {
 
 var _a;
@@ -7211,7 +7373,7 @@ up.Layer.Modal = (_a = class Modal extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 41 */
+/* 42 */
 /***/ (() => {
 
 var _a;
@@ -7222,7 +7384,7 @@ up.Layer.Popup = (_a = class Popup extends up.Layer.OverlayWithTether {
 
 
 /***/ }),
-/* 42 */
+/* 43 */
 /***/ (() => {
 
 var _a;
@@ -7233,7 +7395,7 @@ up.Layer.Drawer = (_a = class Drawer extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 43 */
+/* 44 */
 /***/ (() => {
 
 var _a;
@@ -7244,7 +7406,7 @@ up.Layer.Cover = (_a = class Cover extends up.Layer.OverlayWithViewport {
 
 
 /***/ }),
-/* 44 */
+/* 45 */
 /***/ (() => {
 
 const u = up.util;
@@ -7343,7 +7505,7 @@ up.LayerLookup = class LayerLookup {
 
 
 /***/ }),
-/* 45 */
+/* 46 */
 /***/ (() => {
 
 const u = up.util;
@@ -7476,7 +7638,7 @@ up.LayerStack = class LayerStack extends Array {
 
 
 /***/ }),
-/* 46 */
+/* 47 */
 /***/ (() => {
 
 up.LinkFeedbackURLs = class LinkFeedbackURLs {
@@ -7510,7 +7672,7 @@ up.LinkFeedbackURLs = class LinkFeedbackURLs {
 
 
 /***/ }),
-/* 47 */
+/* 48 */
 /***/ (() => {
 
 const u = up.util;
@@ -7585,7 +7747,7 @@ up.LinkPreloader = class LinkPreloader {
 
 
 /***/ }),
-/* 48 */
+/* 49 */
 /***/ (() => {
 
 const u = up.util;
@@ -7758,7 +7920,7 @@ up.MotionController = class MotionController {
 
 
 /***/ }),
-/* 49 */
+/* 50 */
 /***/ (() => {
 
 const u = up.util;
@@ -7871,7 +8033,7 @@ up.NonceableCallback = class NonceableCallback {
 
 
 /***/ }),
-/* 50 */
+/* 51 */
 /***/ (() => {
 
 const u = up.util;
@@ -7938,7 +8100,7 @@ up.OptionsParser = class OptionsParser {
 
 
 /***/ }),
-/* 51 */
+/* 52 */
 /***/ (() => {
 
 const e = up.element;
@@ -8029,7 +8191,7 @@ up.OverlayFocus = class OverlayFocus {
 
 
 /***/ }),
-/* 52 */
+/* 53 */
 /***/ (() => {
 
 const u = up.util;
@@ -8616,7 +8778,7 @@ up.Params = class Params {
 
 
 /***/ }),
-/* 53 */
+/* 54 */
 /***/ (() => {
 
 const e = up.element;
@@ -8673,7 +8835,7 @@ up.ProgressBar = class ProgressBar {
 
 
 /***/ }),
-/* 54 */
+/* 55 */
 /***/ (() => {
 
 const u = up.util;
@@ -8811,7 +8973,7 @@ up.RenderOptions = (function () {
 
 
 /***/ }),
-/* 55 */
+/* 56 */
 /***/ (() => {
 
 /*-
@@ -8852,7 +9014,7 @@ up.RenderResult = class RenderResult extends up.Record {
 
 
 /***/ }),
-/* 56 */
+/* 57 */
 /***/ (() => {
 
 const u = up.util;
@@ -9114,8 +9276,18 @@ up.Request = class Request extends up.Record {
         // Normalize a first time to get a normalized cache key.
         this.normalizeForCaching();
         if (!options.basic) {
-            this.layer = up.layer.get(this.layer); // If @layer and @origin is undefined, this will choose the current layer.
-            this.failLayer = up.layer.get(this.failLayer || this.layer);
+            const layerLookupOptions = { origin: this.origin };
+            // Calling up.layer.get() will give us:
+            //
+            // (1) Resolution of strings like 'current' to an up.Layer instance
+            // (2) Default of origin's layer
+            // (3) Default of up.layer.current
+            //
+            // up.layer.get('new') will return 'new' unchanged, but I'm not sure
+            // if any code actually calls up.request({ ..., layer: 'new' }).
+            // In up.Change.OpenLayer we connect requests to the base layer we're stacking upon.
+            this.layer = up.layer.get(this.layer, layerLookupOptions);
+            this.failLayer = up.layer.get(this.failLayer || this.layer, layerLookupOptions);
             this.context || (this.context = this.layer.context || {}); // @layer might be "new", so we default to {}
             this.failContext || (this.failContext = this.failLayer.context || {}); // @failLayer might be "new", so we default to {}
             this.mode || (this.mode = this.layer.mode);
@@ -9437,7 +9609,7 @@ up.Request.tester = function (condition) {
 
 
 /***/ }),
-/* 57 */
+/* 58 */
 /***/ (() => {
 
 let u = up.util;
@@ -9482,7 +9654,7 @@ up.Request.Cache = class Cache extends up.Cache {
 
 
 /***/ }),
-/* 58 */
+/* 59 */
 /***/ (() => {
 
 const u = up.util;
@@ -9620,7 +9792,7 @@ up.Request.Queue = class Queue {
 
 
 /***/ }),
-/* 59 */
+/* 60 */
 /***/ (() => {
 
 const u = up.util;
@@ -9672,7 +9844,7 @@ up.Request.FormRenderer = class FormRenderer {
 
 
 /***/ }),
-/* 60 */
+/* 61 */
 /***/ (() => {
 
 const CONTENT_TYPE_URL_ENCODED = 'application/x-www-form-urlencoded';
@@ -9779,7 +9951,7 @@ up.Request.XHRRenderer = class XHRRenderer {
 
 
 /***/ }),
-/* 61 */
+/* 62 */
 /***/ (() => {
 
 /*-
@@ -9960,7 +10132,7 @@ up.Response = class Response extends up.Record {
 
 
 /***/ }),
-/* 62 */
+/* 63 */
 /***/ (() => {
 
 const u = up.util;
@@ -10066,7 +10238,7 @@ up.ResponseDoc = class ResponseDoc {
 
 
 /***/ }),
-/* 63 */
+/* 64 */
 /***/ (() => {
 
 const e = up.element;
@@ -10182,7 +10354,7 @@ up.RevealMotion = class RevealMotion {
 
 
 /***/ }),
-/* 64 */
+/* 65 */
 /***/ (() => {
 
 const u = up.util;
@@ -10256,7 +10428,7 @@ up.ScrollMotion = class ScrollMotion {
 
 
 /***/ }),
-/* 65 */
+/* 66 */
 /***/ (() => {
 
 const e = up.element;
@@ -10307,7 +10479,7 @@ up.Selector = class Selector {
 
 
 /***/ }),
-/* 66 */
+/* 67 */
 /***/ (() => {
 
 const u = up.util;
@@ -10341,7 +10513,7 @@ up.store.Memory = class Memory {
 
 
 /***/ }),
-/* 67 */
+/* 68 */
 /***/ (() => {
 
 //#
@@ -10411,7 +10583,7 @@ up.store.Session = class Session extends up.store.Memory {
 
 
 /***/ }),
-/* 68 */
+/* 69 */
 /***/ (() => {
 
 const u = up.util;
@@ -10571,7 +10743,7 @@ up.Tether = class Tether {
 
 
 /***/ }),
-/* 69 */
+/* 70 */
 /***/ (() => {
 
 const u = up.util;
@@ -10658,7 +10830,7 @@ up.URLPattern = class URLPattern {
 
 
 /***/ }),
-/* 70 */
+/* 71 */
 /***/ (() => {
 
 /*-
@@ -10869,7 +11041,7 @@ up.boot = up.framework.boot;
 
 
 /***/ }),
-/* 71 */
+/* 72 */
 /***/ (() => {
 
 /*-
@@ -11435,7 +11607,7 @@ up.emit = up.event.emit;
 
 
 /***/ }),
-/* 72 */
+/* 73 */
 /***/ (() => {
 
 /*-
@@ -12232,7 +12404,7 @@ up.protocol = (function () {
 
 
 /***/ }),
-/* 73 */
+/* 74 */
 /***/ (() => {
 
 /*-
@@ -12382,33 +12554,6 @@ up.log = (function () {
         setEnabled(false);
     }
     /*-
-    Throws a [JavaScript error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
-    with the given message.
-  
-    The message will also be printed to the error log. Also a notification will be shown at the bottom of the screen.
-  
-    The message may contain [substitution marks](https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions).
-  
-    ### Examples
-  
-        up.fail('Division by zero')
-        up.fail('Unexpected result %o', result)
-  
-    @function up.fail
-    @param {string} message
-      A message with details about the error.
-  
-      The message can contain [substitution marks](https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions)
-      like `%s` or `%o`.
-    @param {Array<string>} vars...
-      A list of variables to replace any substitution marks in the error message.
-    @experimental
-    */
-    function fail(...args) {
-        printToError('error', ...args);
-        throw up.error.failed(args);
-    }
-    /*-
     Registers an empty rejection handler in case the given promise
     rejects with an AbortError or a failed up.Response.
   
@@ -12444,18 +12589,16 @@ up.log = (function () {
         config,
         enable,
         disable,
-        fail,
         muteUncriticalRejection,
         isEnabled() { return config.enabled; },
     };
 })();
 up.puts = up.log.puts;
 up.warn = up.log.warn;
-up.fail = up.log.fail;
 
 
 /***/ }),
-/* 74 */
+/* 75 */
 /***/ (() => {
 
 /*-
@@ -12765,7 +12908,6 @@ up.syntax = (function () {
             isDefault: up.framework.evaling,
             priority: 0,
             batch: false,
-            keep: false,
             jQuery: false
         });
         return u.assign(callback, options);
@@ -12960,7 +13102,7 @@ up.data = up.syntax.data;
 
 
 /***/ }),
-/* 75 */
+/* 76 */
 /***/ (() => {
 
 /*-
@@ -13226,9 +13368,6 @@ up.history = (function () {
         return historyLayer.emit(...args);
     }
     function register() {
-        // Supported by all browser except IE:
-        // https://developer.mozilla.org/en-US/docs/Web/API/History/scrollRestoration
-        window.history.scrollRestoration = 'manual';
         window.addEventListener('popstate', onPop);
         // Unpoly replaces the initial page state so it can later restore it when the user
         // goes back to that initial URL. However, if the initial request was a POST,
@@ -13303,10 +13442,10 @@ up.history = (function () {
 
 
 /***/ }),
-/* 76 */
+/* 77 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
-__webpack_require__(77);
+__webpack_require__(78);
 const u = up.util;
 const e = up.element;
 /*-
@@ -14154,7 +14293,7 @@ up.fragment = (function () {
         const keepPlans = options.keepPlans || [];
         const skip = keepPlans.map(function (plan) {
             emitFragmentKept(plan);
-            return plan.oldElement;
+            return plan.oldElement; // the kept element
         });
         up.syntax.compile(element, { skip, layer: options.layer });
         emitFragmentInserted(element, options);
@@ -15107,16 +15246,16 @@ u.delegate(up, 'context', () => up.layer.current);
 
 
 /***/ }),
-/* 77 */
+/* 78 */
 /***/ (() => {
 
 // extracted by mini-css-extract-plugin
 
 /***/ }),
-/* 78 */
+/* 79 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
-__webpack_require__(79);
+__webpack_require__(80);
 /*-
 Scrolling viewports
 ===================
@@ -15230,8 +15369,8 @@ up.viewport = (function () {
       The container element to scroll.
     @param {number} scrollPos
       The absolute number of pixels to set the scroll position to.
-    @param {string}[options.behavior='auto']
-      When set to `'auto'`, this will immediately scroll to the new position.
+    @param {string}[options.behavior='instant']
+      When set to `'instant'`, this will immediately scroll to the new position.
   
       When set to `'smooth'`, this will scroll smoothly to the new position.
     @param {number}[options.speed]
@@ -15303,8 +15442,8 @@ up.viewport = (function () {
   
       Defaults to `up.viewport.config.revealTop`.
   
-    @param {string}[options.behavior='auto']
-      When set to `'auto'`, this will immediately scroll to the new position.
+    @param {string}[options.behavior='instant']
+      When set to `'instant'`, this will immediately scroll to the new position.
   
       When set to `'smooth'`, this will scroll smoothly to the new position.
   
@@ -15409,7 +15548,7 @@ up.viewport = (function () {
     /*-
     [Reveals](/up.reveal) an element matching the given `#hash` anchor.
   
-    Other than the default behavior found in browsers, `up.revealHash` works with
+    Other than the default behavior found in browsers, `up.revealHash()` works with
     [multiple viewports](/up-viewport) and honors [fixed elements](/up-fixed-top) obstructing the user's
     view of the viewport.
   
@@ -15971,13 +16110,13 @@ up.reveal = up.viewport.reveal;
 
 
 /***/ }),
-/* 79 */
+/* 80 */
 /***/ (() => {
 
 // extracted by mini-css-extract-plugin
 
 /***/ }),
-/* 80 */
+/* 81 */
 /***/ (() => {
 
 /*-
@@ -16667,10 +16806,10 @@ up.animate = up.motion.animate;
 
 
 /***/ }),
-/* 81 */
+/* 82 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
-__webpack_require__(82);
+__webpack_require__(83);
 const u = up.util;
 /*-
 Network requests
@@ -17553,16 +17692,16 @@ up.cache = up.network.cache;
 
 
 /***/ }),
-/* 82 */
+/* 83 */
 /***/ (() => {
 
 // extracted by mini-css-extract-plugin
 
 /***/ }),
-/* 83 */
+/* 84 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
-__webpack_require__(84);
+__webpack_require__(85);
 const u = up.util;
 const e = up.element;
 /*-
@@ -17704,6 +17843,11 @@ up.layer = (function () {
       If set to `true`, the overlay will always render history.
       If set to `false`, the overlay will never render history.
   
+    @param {string} [config.overlay.class]
+      An HTML class for the overlay's container element.
+  
+      See [overlay classes](/customizing-overlays#overlay-classes).
+  
     @param {object} config.modal
       Defaults for [modal overlays](/layer-terminology).
   
@@ -18565,6 +18709,8 @@ up.layer = (function () {
     @event up:layer:accept
     @param {up.Layer} event.layer
       The layer that is about to close.
+    @param {Element} [event.value]
+      The overlay's [acceptance value](/closing-overlays#overlay-result-values).
     @param {Element} [event.origin]
       The element that is causing the layer to close.
     @param event.preventDefault()
@@ -18581,6 +18727,8 @@ up.layer = (function () {
     @event up:layer:accepted
     @param {up.Layer} event.layer
       The layer that was closed.
+    @param {Element} [event.value]
+      The overlay's [acceptance value](/closing-overlays#overlay-result-values).
     @param {Element} [event.origin]
       The element that has caused the layer to close.
     @stable
@@ -18604,6 +18752,8 @@ up.layer = (function () {
     @event up:layer:dismiss
     @param {up.Layer} event.layer
       The layer that is about to close.
+    @param {Element} [event.value]
+      The overlay's [dismissal value](/closing-overlays#overlay-result-values).
     @param {Element} [event.origin]
       The element that is causing the layer to close.
     @param event.preventDefault()
@@ -18620,6 +18770,8 @@ up.layer = (function () {
     @event up:layer:dismissed
     @param {up.Layer} event.layer
       The layer that was closed.
+    @param {Element} [event.value]
+      The overlay's [dismissal value](/closing-overlays#overlay-result-values).
     @param {Element} [event.origin]
       The element that has caused the layer to close.
     @stable
@@ -18825,16 +18977,16 @@ up.layer = (function () {
 
 
 /***/ }),
-/* 84 */
+/* 85 */
 /***/ (() => {
 
 // extracted by mini-css-extract-plugin
 
 /***/ }),
-/* 85 */
+/* 86 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
-__webpack_require__(86);
+__webpack_require__(87);
 /*-
 Linking to fragments
 ====================
@@ -19810,12 +19962,6 @@ up.link = (function () {
       A JSON object that will be merged into the [context](/context)
       of the current layer once the fragment is rendered.
   
-    @param [up-keep='true']
-      Whether [`[up-keep]`](/up-keep) elements will be preserved in the updated fragment.
-  
-    @param [up-hungry='true']
-      Whether [`[up-hungry]`](/up-hungry) elements outside the updated fragment will also be updated.
-  
     @param [up-scroll='auto']
       How to scroll after the new fragment was rendered.
   
@@ -19990,13 +20136,13 @@ up.follow = up.link.follow;
 
 
 /***/ }),
-/* 86 */
+/* 87 */
 /***/ (() => {
 
 // extracted by mini-css-extract-plugin
 
 /***/ }),
-/* 87 */
+/* 88 */
 /***/ (() => {
 
 /*-
@@ -20035,7 +20181,7 @@ up.form = (function () {
       up.form.config.submitSelectors.push('form')
       ```
   
-      Individual forms may opt out with an `[up-submit=follow]` attribute.
+      Individual forms may opt out with an `[up-submit=false]` attribute.
       You may configure additional exceptions in `config.noSubmitSelectors`.
   
     @param {Array<string>} [config.noSubmitSelectors]
@@ -21290,7 +21436,7 @@ up.validate = up.form.validate;
 
 
 /***/ }),
-/* 88 */
+/* 89 */
 /***/ (() => {
 
 /*-
@@ -21724,7 +21870,7 @@ up.feedback = (function () {
 
 
 /***/ }),
-/* 89 */
+/* 90 */
 /***/ (() => {
 
 /*-
@@ -21740,7 +21886,6 @@ This package contains functionality to passively receive updates from the server
 */
 up.radio = (function () {
     const u = up.util;
-    const e = up.element;
     /*-
     Configures defaults for passive updates.
   
@@ -21758,7 +21903,7 @@ up.radio = (function () {
     @param {boolean|string|Function(Element)} [config.pollEnabled=true]
       Whether Unpoly will follow instructions to poll fragments, like the `[up-poll]` attribute.
   
-      When set to `'auto'` Unpoly will poll if one of the following applies:
+      When set to `'auto'` Unpoly will skip polling updates while one of the following applies:
   
       - The browser tab is in the foreground
       - The fragment's layer is the [frontmost layer](/up.layer.front).
@@ -21770,6 +21915,9 @@ up.radio = (function () {
   
       You may also pass a function that accepts the polling fragment and returns `true`, `false` or `'auto'`.
   
+      When an update is skipped due to polling being disabled,
+      Unpoly will try to poll again after the configured interval.
+  
     @stable
     */
     const config = new up.Config(() => ({
@@ -21803,62 +21951,32 @@ up.radio = (function () {
     /*-
     Starts [polling](/up-poll) the given element.
   
+    The given element does not need an `[up-poll]` attribute.
+  
     @function up.radio.startPolling
-    @param {Element|jQuery|string} fragment
+    @param {Element} fragment
       The fragment to reload periodically.
     @param {number} options.interval
       The reload interval in milliseconds.
   
       Defaults to `up.radio.config.pollInterval`.
+    @param {string} options.url
+      Defaults to the element's closest `[up-source]` attribute.
     @stable
     */
     function startPolling(fragment, options = {}) {
-        const interval = (options.interval ?? e.numberAttr(fragment, 'up-interval')) ?? config.pollInterval;
-        let stopped = false;
-        let lastRequest = null;
-        options.onQueued = request => lastRequest = request;
-        function doReload() {
-            // The setTimeout(doReload) callback might already be scheduled
-            // before the polling stopped.
-            if (stopped) {
-                return;
-            }
-            if (shouldPoll(fragment)) {
-                u.always(up.reload(fragment, options), doSchedule);
-            }
-            else {
-                up.puts('[up-poll]', 'Polling is disabled');
-                // Reconsider after 10 seconds at most
-                doSchedule(Math.min(10 * 1000, interval));
-            }
-        }
-        function doSchedule(delay = interval) {
-            // The up.reload().then(doSchedule) callback might already be
-            // registered before the polling stopped.
-            if (stopped) {
-                return;
-            }
-            setTimeout(doReload, delay);
-        }
-        function destructor() {
-            stopped = true; // Don't execute already-scheduled callbacks
-            lastRequest?.abort(); // Abort any pending request
-        }
-        // up.radio.stopPolling() will emit up:poll:stop to signal cancelation.
-        up.on(fragment, 'up:poll:stop', destructor);
-        doSchedule();
-        return destructor;
+        up.FragmentPolling.forFragment(fragment).forceStart(options);
     }
     /*-
     Stops [polling](/up-poll) the given element.
   
     @function up.radio.stopPolling
-    @param {Element|jQuery|string} fragment
+    @param {Element} fragment
       The fragment to stop reloading.
     @stable
     */
     function stopPolling(element) {
-        up.emit(element, 'up:poll:stop');
+        up.FragmentPolling.forFragment(element).forceStop();
     }
     function shouldPoll(fragment) {
         const setting = u.evalOption(config.pollEnabled, fragment);
@@ -21909,7 +22027,17 @@ up.radio = (function () {
     </div>
     ```
   
-    ### Skipping updates when nothing changed
+    ### Skipping updates on the client
+  
+    Client-side code may skip an update by preventing an `up:fragment:poll` event
+    on the polling fragment.
+  
+    Unpoly will also choose to skip updates under certain conditions,
+    e.g. when the browser tab is in the background. See `up.radio.config.pollEnabled` for details.
+  
+    When an update is skipped, Unpoly will try to poll again after the configured interval.
+  
+    ### Skipping updates on the server
   
     When polling a fragment periodically we want to avoid rendering unchanged content.
     This saves <b>CPU time</b> and reduces the <b>bandwidth cost</b> for a
@@ -21918,26 +22046,57 @@ up.radio = (function () {
     To achieve this we timestamp your fragments with an `[up-time]` attribute to indicate
     when the underlying data was last changed. See `[up-time]` for a detailed example.
   
+    If the server has no more recent changes, it may skip the update by responding
+    with an HTTP status `304 Not Modified`.
+  
+    When an update is skipped, Unpoly will try to poll again after the configured interval.
+  
+    ### Stopping polling
+  
+    - The fragment from the server response no longer has an `[up-poll]` attribute.
+    - Client-side code has called `up.radio.stopPolling()` with the polling element.
+    - Polling was [disabled globally](/up.radio.config#config.pollEnabled).
+  
     @selector [up-poll]
     @param [up-interval]
       The reload interval in milliseconds.
   
       Defaults to `up.radio.config.pollInterval`.
+    @param [up-source]
+      The URL from which to reload the fragment.
+  
+      Defaults to the closest `[up-source]` attribute of an ancestor element.
     @stable
     */
-    up.compiler('[up-poll]', startPolling);
+    up.compiler('[up-poll]', (fragment) => {
+        up.FragmentPolling.forFragment(fragment).onPollAttributeObserved();
+    });
+    /*-
+    This event is emitted before a [polling](/up-poll) fragment is reloaded from the server.
+  
+    Listener may prevent the `up:fragment:poll` event to prevent the fragment from being reloaded.
+    Preventing the event will only skip a single update. It will *not* stop future polling.
+  
+    @event up:fragment:poll
+    @param {Element} event.target
+      The polling fragment.
+    @param event.preventDefault()
+      Event listeners may call this method to prevent the fragment from being reloaded.
+    @experimental
+    */
     up.on('up:framework:reset', reset);
     return {
         config,
         hungrySelector,
         startPolling,
-        stopPolling
+        stopPolling,
+        shouldPoll,
     };
 })();
 
 
 /***/ }),
-/* 90 */
+/* 91 */
 /***/ (() => {
 
 /*
@@ -22077,15 +22236,16 @@ __webpack_require__(73);
 __webpack_require__(74);
 __webpack_require__(75);
 __webpack_require__(76);
-__webpack_require__(78);
-__webpack_require__(80);
+__webpack_require__(77);
+__webpack_require__(79);
 __webpack_require__(81);
-__webpack_require__(83);
-__webpack_require__(85);
-__webpack_require__(87);
+__webpack_require__(82);
+__webpack_require__(84);
+__webpack_require__(86);
 __webpack_require__(88);
 __webpack_require__(89);
 __webpack_require__(90);
+__webpack_require__(91);
 up.framework.onEvaled();
 
 })();