@react-motion-router/stack 2.0.0-beta.eb7bb7e → 2.0.0-beta.sha-dfc284b

package/build/index.js

@@ -0,0 +1,2385 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__ from "@react-motion-router/core";
+import * as __WEBPACK_EXTERNAL_MODULE_web_animations_extension_74b2916c__ from "web-animations-extension";
+/******/ var __webpack_modules__ = ({
+
+/***/ 837:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+var __webpack_unused_export__;
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var f=__webpack_require__(810),k=Symbol.for("react.element"),l=Symbol.for("react.fragment"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};
+function q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}__webpack_unused_export__=l;exports.jsx=q;__webpack_unused_export__=q;
+
+
+/***/ }),
+
+/***/ 322:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+
+
+if (true) {
+  module.exports = __webpack_require__(837);
+} else {}
+
+
+/***/ }),
+
+/***/ 319:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const GestureEvent_1 = __importDefault(__webpack_require__(292));
+class DoubleTapEvent extends GestureEvent_1.default {
+    constructor(touchEvent) {
+        super('doubletap', touchEvent);
+    }
+}
+exports["default"] = DoubleTapEvent;
+//# sourceMappingURL=DoubleTapEvent.js.map
+
+/***/ }),
+
+/***/ 292:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var GestureEventTypeEnum;
+(function (GestureEventTypeEnum) {
+    GestureEventTypeEnum[GestureEventTypeEnum["tap"] = 0] = "tap";
+    GestureEventTypeEnum[GestureEventTypeEnum["longpress"] = 1] = "longpress";
+    GestureEventTypeEnum[GestureEventTypeEnum["pinchstart"] = 2] = "pinchstart";
+    GestureEventTypeEnum[GestureEventTypeEnum["pinch"] = 3] = "pinch";
+    GestureEventTypeEnum[GestureEventTypeEnum["pinchend"] = 4] = "pinchend";
+    GestureEventTypeEnum[GestureEventTypeEnum["rotatestart"] = 5] = "rotatestart";
+    GestureEventTypeEnum[GestureEventTypeEnum["rotate"] = 6] = "rotate";
+    GestureEventTypeEnum[GestureEventTypeEnum["rotateend"] = 7] = "rotateend";
+    GestureEventTypeEnum[GestureEventTypeEnum["swipestart"] = 8] = "swipestart";
+    GestureEventTypeEnum[GestureEventTypeEnum["swipe"] = 9] = "swipe";
+    GestureEventTypeEnum[GestureEventTypeEnum["swipeend"] = 10] = "swipeend";
+    GestureEventTypeEnum[GestureEventTypeEnum["panstart"] = 11] = "panstart";
+    GestureEventTypeEnum[GestureEventTypeEnum["pan"] = 12] = "pan";
+    GestureEventTypeEnum[GestureEventTypeEnum["panend"] = 13] = "panend";
+    GestureEventTypeEnum[GestureEventTypeEnum["doubletap"] = 14] = "doubletap";
+})(GestureEventTypeEnum || (GestureEventTypeEnum = {}));
+class GestureEvent extends TouchEvent {
+    constructor(type, touchEvent) {
+        super(type, {
+            touches: Array.from(touchEvent.touches),
+            targetTouches: Array.from(touchEvent.targetTouches),
+            changedTouches: Array.from(touchEvent.changedTouches),
+            ctrlKey: touchEvent.ctrlKey,
+            shiftKey: touchEvent.shiftKey,
+            altKey: touchEvent.altKey,
+            metaKey: touchEvent.metaKey,
+            bubbles: true,
+            cancelable: true
+        });
+        if (type.includes("end") || touchEvent.type.includes("end")) {
+            this.gestureTarget = touchEvent.changedTouches[0].target;
+            this.x = touchEvent.changedTouches[0].clientX;
+            this.y = touchEvent.changedTouches[0].clientY;
+            return;
+        }
+        this.gestureTarget = touchEvent.touches[0].target;
+        this.x = touchEvent.touches[0].clientX;
+        this.y = touchEvent.touches[0].clientY;
+    }
+}
+exports["default"] = GestureEvent;
+//# sourceMappingURL=GestureEvent.js.map
+
+/***/ }),
+
+/***/ 747:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const GestureEvent_1 = __importDefault(__webpack_require__(292));
+class LongPressEvent extends GestureEvent_1.default {
+    constructor(touchEvent, duration) {
+        super('longpress', touchEvent);
+        this.duration = 0;
+        this.duration = duration;
+    }
+}
+exports["default"] = LongPressEvent;
+//# sourceMappingURL=LongPressEvent.js.map
+
+/***/ }),
+
+/***/ 985:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.PanEndEvent = exports.PanStartEvent = void 0;
+const GestureEvent_1 = __importDefault(__webpack_require__(292));
+var PanLifecycleStateEnum;
+(function (PanLifecycleStateEnum) {
+    PanLifecycleStateEnum[PanLifecycleStateEnum["start"] = 0] = "start";
+    PanLifecycleStateEnum[PanLifecycleStateEnum["end"] = 1] = "end";
+})(PanLifecycleStateEnum || (PanLifecycleStateEnum = {}));
+class PanEventBase extends GestureEvent_1.default {
+    constructor(touchEvent, panData, state) {
+        let eventType;
+        switch (state) {
+            case "start":
+                eventType = "panstart";
+                break;
+            case "end":
+                eventType = "panend";
+                break;
+            default:
+                eventType = "pan";
+        }
+        super(eventType, touchEvent);
+        this.velocity = panData.velocity;
+        this.translation = {
+            x: panData.translation.x,
+            y: panData.translation.y,
+            magnitude: panData.translation.magnitude,
+            clientX: panData.translation.clientX,
+            clientY: panData.translation.clientY,
+            clientMagnitude: panData.translation.clientMagnitude
+        };
+    }
+}
+class PanEvent extends PanEventBase {
+    constructor(touchEvent, panData) {
+        super(touchEvent, panData);
+    }
+}
+exports["default"] = PanEvent;
+class PanStartEvent extends PanEventBase {
+    constructor(touchEvent, panData) {
+        super(touchEvent, panData, "start");
+    }
+}
+exports.PanStartEvent = PanStartEvent;
+class PanEndEvent extends PanEventBase {
+    constructor(touchEvent, panData) {
+        super(touchEvent, panData, "end");
+    }
+}
+exports.PanEndEvent = PanEndEvent;
+//# sourceMappingURL=PanEvent.js.map
+
+/***/ }),
+
+/***/ 731:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.PinchEndEvent = exports.PinchStartEvent = void 0;
+const GestureEvent_1 = __importDefault(__webpack_require__(292));
+var PinchLifecycleStateEnum;
+(function (PinchLifecycleStateEnum) {
+    PinchLifecycleStateEnum[PinchLifecycleStateEnum["start"] = 0] = "start";
+    PinchLifecycleStateEnum[PinchLifecycleStateEnum["end"] = 1] = "end";
+})(PinchLifecycleStateEnum || (PinchLifecycleStateEnum = {}));
+class PinchEventBase extends GestureEvent_1.default {
+    constructor(touchEvent, pinchData, state) {
+        let eventType;
+        switch (state) {
+            case "start":
+                eventType = "pinchstart";
+                break;
+            case "end":
+                eventType = "pinchend";
+                break;
+            default:
+                eventType = "pinch";
+        }
+        super(eventType, touchEvent);
+        Object.defineProperty(this, 'scale', {
+            value: pinchData.scale,
+            writable: false
+        });
+    }
+}
+class PinchEvent extends PinchEventBase {
+    constructor(touchEvent, pinchData) {
+        super(touchEvent, pinchData);
+    }
+}
+exports["default"] = PinchEvent;
+class PinchStartEvent extends PinchEventBase {
+    constructor(touchEvent, pinchData) {
+        super(touchEvent, pinchData, "start");
+    }
+}
+exports.PinchStartEvent = PinchStartEvent;
+class PinchEndEvent extends PinchEventBase {
+    constructor(touchEvent, pinchData) {
+        super(touchEvent, pinchData, "end");
+    }
+}
+exports.PinchEndEvent = PinchEndEvent;
+//# sourceMappingURL=PinchEvent.js.map
+
+/***/ }),
+
+/***/ 473:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.RotateEndEvent = exports.RotateStartEvent = void 0;
+const GestureEvent_1 = __importDefault(__webpack_require__(292));
+var RotateLifecycleStateEnum;
+(function (RotateLifecycleStateEnum) {
+    RotateLifecycleStateEnum[RotateLifecycleStateEnum["start"] = 0] = "start";
+    RotateLifecycleStateEnum[RotateLifecycleStateEnum["end"] = 1] = "end";
+})(RotateLifecycleStateEnum || (RotateLifecycleStateEnum = {}));
+class RotateEventBase extends GestureEvent_1.default {
+    constructor(touchEvent, rotationData, state) {
+        let eventType;
+        switch (state) {
+            case "start":
+                eventType = "rotatestart";
+                break;
+            case "end":
+                eventType = "rotateend";
+                break;
+            default:
+                eventType = "rotate";
+        }
+        super(eventType, touchEvent);
+        this.anchor = {
+            x: rotationData.anchor.x,
+            y: rotationData.anchor.y,
+            clientX: rotationData.anchor.clientX,
+            clientY: rotationData.anchor.clientY
+        };
+        Object.defineProperty(this, 'rotation', {
+            value: rotationData.rotation,
+            writable: false
+        });
+        this.rotationDeg = rotationData.rotationDeg;
+    }
+}
+class RotateEvent extends RotateEventBase {
+    constructor(touchEvent, rotationData) {
+        super(touchEvent, rotationData);
+    }
+}
+exports["default"] = RotateEvent;
+class RotateStartEvent extends RotateEventBase {
+    constructor(touchEvent, rotationData) {
+        super(touchEvent, rotationData, "start");
+    }
+}
+exports.RotateStartEvent = RotateStartEvent;
+class RotateEndEvent extends RotateEventBase {
+    constructor(touchEvent, rotationData) {
+        super(touchEvent, rotationData, "end");
+    }
+}
+exports.RotateEndEvent = RotateEndEvent;
+//# sourceMappingURL=RotateEvent.js.map
+
+/***/ }),
+
+/***/ 376:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SwipeEndEvent = exports.SwipeStartEvent = void 0;
+const GestureEvent_1 = __importDefault(__webpack_require__(292));
+var SwipeLifecycleStateEnum;
+(function (SwipeLifecycleStateEnum) {
+    SwipeLifecycleStateEnum[SwipeLifecycleStateEnum["start"] = 0] = "start";
+    SwipeLifecycleStateEnum[SwipeLifecycleStateEnum["end"] = 1] = "end";
+})(SwipeLifecycleStateEnum || (SwipeLifecycleStateEnum = {}));
+class SwipeEventBase extends GestureEvent_1.default {
+    constructor(touchEvent, swipeData, state) {
+        let eventType;
+        switch (state) {
+            case "start":
+                eventType = "swipestart";
+                break;
+            case "end":
+                eventType = "swipeend";
+                break;
+            default:
+                eventType = "swipe";
+        }
+        super(eventType, touchEvent);
+        this.velocity = swipeData.velocity;
+        this.direction = swipeData.direction;
+    }
+}
+class SwipeEvent extends SwipeEventBase {
+    constructor(touchEvent, swipeData) {
+        super(touchEvent, swipeData);
+    }
+}
+exports["default"] = SwipeEvent;
+class SwipeStartEvent extends SwipeEventBase {
+    constructor(touchEvent, swipeData) {
+        super(touchEvent, swipeData, "start");
+    }
+}
+exports.SwipeStartEvent = SwipeStartEvent;
+class SwipeEndEvent extends SwipeEventBase {
+    constructor(touchEvent, swipeData) {
+        super(touchEvent, swipeData, "end");
+    }
+}
+exports.SwipeEndEvent = SwipeEndEvent;
+//# sourceMappingURL=SwipeEvent.js.map
+
+/***/ }),
+
+/***/ 59:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const GestureEvent_1 = __importDefault(__webpack_require__(292));
+class TapEvent extends GestureEvent_1.default {
+    constructor(touchEvent) {
+        super('tap', touchEvent);
+        this.duration = 0;
+    }
+}
+exports["default"] = TapEvent;
+//# sourceMappingURL=TapEvent.js.map
+
+/***/ }),
+
+/***/ 190:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.RotateEndEvent = exports.RotateEvent = exports.RotateStartEvent = exports.PinchEndEvent = exports.PinchEvent = exports.PinchStartEvent = exports.PanEndEvent = exports.PanEvent = exports.PanStartEvent = exports.SwipeEndEvent = exports.SwipeEvent = exports.SwipeStartEvent = exports.DoubleTapEvent = exports.LongPressEvent = exports.GestureEvent = exports.TapEvent = void 0;
+const GestureEvent_1 = __importDefault(__webpack_require__(292));
+exports.GestureEvent = GestureEvent_1.default;
+const LongPressEvent_1 = __importDefault(__webpack_require__(747));
+exports.LongPressEvent = LongPressEvent_1.default;
+const TapEvent_1 = __importDefault(__webpack_require__(59));
+exports.TapEvent = TapEvent_1.default;
+const DoubleTapEvent_1 = __importDefault(__webpack_require__(319));
+exports.DoubleTapEvent = DoubleTapEvent_1.default;
+const SwipeEvent_1 = __importStar(__webpack_require__(376));
+exports.SwipeEvent = SwipeEvent_1.default;
+Object.defineProperty(exports, "SwipeEndEvent", ({ enumerable: true, get: function () { return SwipeEvent_1.SwipeEndEvent; } }));
+Object.defineProperty(exports, "SwipeStartEvent", ({ enumerable: true, get: function () { return SwipeEvent_1.SwipeStartEvent; } }));
+const PanEvent_1 = __importStar(__webpack_require__(985));
+exports.PanEvent = PanEvent_1.default;
+Object.defineProperty(exports, "PanEndEvent", ({ enumerable: true, get: function () { return PanEvent_1.PanEndEvent; } }));
+Object.defineProperty(exports, "PanStartEvent", ({ enumerable: true, get: function () { return PanEvent_1.PanStartEvent; } }));
+const PinchEvent_1 = __importStar(__webpack_require__(731));
+exports.PinchEvent = PinchEvent_1.default;
+Object.defineProperty(exports, "PinchEndEvent", ({ enumerable: true, get: function () { return PinchEvent_1.PinchEndEvent; } }));
+Object.defineProperty(exports, "PinchStartEvent", ({ enumerable: true, get: function () { return PinchEvent_1.PinchStartEvent; } }));
+const RotateEvent_1 = __importStar(__webpack_require__(473));
+exports.RotateEvent = RotateEvent_1.default;
+Object.defineProperty(exports, "RotateEndEvent", ({ enumerable: true, get: function () { return RotateEvent_1.RotateEndEvent; } }));
+Object.defineProperty(exports, "RotateStartEvent", ({ enumerable: true, get: function () { return RotateEvent_1.RotateStartEvent; } }));
+const utils_1 = __webpack_require__(46);
+var CartesianDirectionEnum;
+(function (CartesianDirectionEnum) {
+    CartesianDirectionEnum[CartesianDirectionEnum["right"] = 0] = "right";
+    CartesianDirectionEnum[CartesianDirectionEnum["up"] = 1] = "up";
+    CartesianDirectionEnum[CartesianDirectionEnum["left"] = 2] = "left";
+    CartesianDirectionEnum[CartesianDirectionEnum["down"] = 3] = "down";
+})(CartesianDirectionEnum || (CartesianDirectionEnum = {}));
+class GestureProvider {
+    constructor() {
+        this.touchStart = new TouchEvent('touchstart') || {};
+        this.touchMove = new TouchEvent('touchmove') || {};
+        this.touchEnd = new TouchEvent('touchend') || {};
+        this.touchCancel = new TouchEvent('touchcancel') || {};
+        this.velocity = 0;
+        this.dxDy = new utils_1.Vec2(0, 0);
+        this.scale = 1;
+        this.rotation = 0;
+        this.rotationDeg = 0;
+        this.anchor = new utils_1.Vec2(0, 0);
+        this.octant = 0;
+        this.isPanning = false;
+        this.isPinching = false;
+        this.isSwiping = false;
+        this.isRotating = false;
+        this.touchStartTime = 0;
+        this.touchEndTime = 0;
+        this.lastTouchTime = 0;
+        this.taps = 0;
+        this.scaleBase = 0;
+        this.touchMoved = false;
+        this.touchDown = false;
+        this.shouldFire = false;
+        this.pointers = 0;
+        this.isLongPress = false;
+        this.longPressTimeout = 0;
+        this.touchStartListener = this.onTouchStart.bind(this);
+        this.touchMoveListener = this.onTouchMove.bind(this);
+        this.touchEndListener = this.onTouchEnd.bind(this);
+        this.touchCancelListener = this.onTouchCancel.bind(this);
+        this.currentTarget = window;
+        this.config = {
+            longPressDuration: 500,
+            tapDelay: 500,
+            minPointers: 1,
+            numberOfTaps: 0
+        };
+        if (!GestureProvider.listening) {
+            if (TouchEvent)
+                window.addEventListener('touchstart', this.touchStartListener, true);
+            GestureProvider.listening = true;
+        }
+    }
+    bind(target) {
+        this.unbind(this.currentTarget);
+        target.addEventListener('touchmove', this.touchMoveListener, true);
+        target.addEventListener('touchend', this.touchEndListener, true);
+        target.addEventListener('touchcancel', this.touchCancelListener, true);
+        this.currentTarget = target;
+    }
+    unbind(target) {
+        target.removeEventListener('touchmove', this.touchMoveListener);
+        target.removeEventListener('touchend', this.touchEndListener);
+        target.removeEventListener('touchcancel', this.touchCancelListener);
+    }
+    clean() {
+        this.touchMoved = false;
+        this.touchStartTime = 0;
+        this.touchDown = false;
+        this.scaleBase = 0;
+        if (this.longPressTimeout && !this.isLongPress) {
+            clearTimeout(this.longPressTimeout);
+            this.longPressTimeout = 0;
+        }
+        this.isLongPress = false;
+    }
+    onPointerLeave(touchEnd) {
+        if (!touchEnd.touches.length) {
+            if (this.isSwiping) {
+                const swipeEndEvent = new SwipeEvent_1.SwipeEndEvent(touchEnd, {
+                    velocity: this.velocity,
+                    direction: CartesianDirectionEnum[(0, utils_1.closest)(this.octant, [0, 1, 2, 3])]
+                });
+                this.dispatchEvent(swipeEndEvent);
+                this.isSwiping = false;
+            }
+            if (this.isPanning) {
+                const panEndEvent = new PanEvent_1.PanEndEvent(touchEnd, {
+                    translation: this.dxDy,
+                    velocity: this.velocity
+                });
+                this.dispatchEvent(panEndEvent);
+                this.isPanning = false;
+            }
+        }
+        if (touchEnd.touches.length === 1) {
+            this.scaleBase = 0;
+            if (this.isPinching) {
+                const pinchEndEvent = new PinchEvent_1.PinchEndEvent(touchEnd, {
+                    scale: this.scale
+                });
+                this.dispatchEvent(pinchEndEvent);
+                this.isPinching = false;
+            }
+            if (this.isRotating) {
+                const rotateEndEvent = new RotateEvent_1.RotateEndEvent(touchEnd, {
+                    rotation: this.rotation,
+                    rotationDeg: this.rotationDeg,
+                    anchor: this.anchor
+                });
+                this.dispatchEvent(rotateEndEvent);
+                this.isRotating = false;
+            }
+        }
+    }
+    dispatchEvent(gestureEvent) {
+        queueMicrotask(() => {
+            this.currentTarget.dispatchEvent(gestureEvent);
+        });
+    }
+    onTouchStart(touchStart) {
+        if (this.currentTarget !== touchStart.touches[0].target) {
+            this.clean();
+            this.unbind(this.currentTarget);
+            this.pointers = this.touchEnd.touches.length;
+            this.taps = 0;
+        }
+        this.touchStart = touchStart;
+        const minPointers = parseInt(touchStart.touches[0].target.dataset.minpointers || '0') || this.config.minPointers;
+        if (this.touchStart.touches.length < minPointers) {
+            this.shouldFire = false;
+            return;
+        }
+        this.shouldFire = true;
+        this.touchStartTime = touchStart.timeStamp;
+        this.touchDown = true;
+        if (!this.pointers)
+            this.bind(touchStart.touches[0].target);
+        this.pointers = this.touchStart.touches.length;
+        const longPressDuration = parseFloat(this.currentTarget.dataset.longpressduration || '0') || this.config.longPressDuration;
+        if (!this.longPressTimeout) {
+            this.longPressTimeout = setTimeout(() => {
+                if (!this.touchMoved && this.touchDown) {
+                    const touchDuration = Date.now() - this.touchStartTime;
+                    const longPressEvent = new LongPressEvent_1.default(this.touchStart, touchDuration);
+                    this.dispatchEvent(longPressEvent);
+                    this.isLongPress = true;
+                    this.longPressTimeout = 0;
+                }
+            }, longPressDuration);
+        }
+        if (this.touchStart.touches.length > 1) {
+            const originPointerPrimary = new utils_1.Vec2(this.touchStart.touches[0].clientX, this.touchStart.touches[0].clientY);
+            const originPointerSecondary = new utils_1.Vec2(this.touchStart.touches[1].clientX, this.touchStart.touches[1].clientY);
+            this.scaleBase = originPointerPrimary.substract(originPointerSecondary).magnitude;
+        }
+        else
+            this.scaleBase = 0;
+    }
+    onTouchMove(touchMove) {
+        if (!this.shouldFire)
+            return;
+        this.touchMoved = true;
+        this.touchMove = touchMove;
+        if (touchMove.touches.length > 1 && this.touchStart.touches.length > 1) {
+            if (touchMove.touches[1].clientX !== this.touchStart.touches[1].clientX
+                || touchMove.touches[1].clientY !== this.touchStart.touches[1].clientY) {
+                const currentPointerPrimary = new utils_1.Vec2(this.touchMove.touches[0].clientX, this.touchMove.touches[0].clientY);
+                const currentPointerSecondary = new utils_1.Vec2(this.touchMove.touches[1].clientX, this.touchMove.touches[1].clientY);
+                const originPointerPrimary = new utils_1.Vec2(this.touchStart.touches[0].clientX, this.touchStart.touches[0].clientY);
+                const distance = currentPointerPrimary.substract(currentPointerSecondary);
+                if (this.scaleBase && Math.abs(this.scaleBase - distance.magnitude) > 10) {
+                    const scaleFactor = distance.magnitude / this.scaleBase;
+                    this.scale = scaleFactor;
+                    if (this.isPinching) {
+                        const pinchEvent = new PinchEvent_1.default(touchMove, {
+                            scale: scaleFactor
+                        });
+                        this.dispatchEvent(pinchEvent);
+                    }
+                    else {
+                        const pinchStartEvent = new PinchEvent_1.PinchStartEvent(touchMove, {
+                            scale: scaleFactor
+                        });
+                        this.dispatchEvent(pinchStartEvent);
+                        this.isPinching = true;
+                    }
+                }
+                this.anchor = currentPointerPrimary;
+                let rotationAngle = Math.atan2((originPointerPrimary.clientY - currentPointerSecondary.clientY), (originPointerPrimary.clientX - currentPointerSecondary.clientX));
+                rotationAngle < 0 ? rotationAngle += 1.5708 : rotationAngle -= 1.5708;
+                this.rotation = rotationAngle;
+                this.rotationDeg = rotationAngle * 180 / Math.PI;
+                this.anchor = this.anchor;
+                if (this.isRotating) {
+                    const rotateEvent = new RotateEvent_1.default(touchMove, {
+                        anchor: this.anchor,
+                        rotation: this.rotation,
+                        rotationDeg: this.rotationDeg
+                    });
+                    this.dispatchEvent(rotateEvent);
+                }
+                else {
+                    const rotateStartEvent = new RotateEvent_1.RotateStartEvent(touchMove, {
+                        anchor: this.anchor,
+                        rotation: this.rotation,
+                        rotationDeg: this.rotationDeg
+                    });
+                    this.dispatchEvent(rotateStartEvent);
+                    this.isRotating = true;
+                }
+            }
+        }
+        const origin = new utils_1.Vec2(this.touchStart.touches[0].clientX, this.touchStart.touches[0].clientY);
+        const currentPosition = new utils_1.Vec2(this.touchMove.touches[0].clientX, this.touchMove.touches[0].clientY);
+        const dxDy = currentPosition.substract(origin);
+        const length = dxDy.magnitude;
+        const normalised = {
+            x: dxDy.x / length,
+            y: dxDy.y / length
+        };
+        const angle = Math.atan2(normalised.y, normalised.x);
+        this.octant = Math.round(4 * angle / (2 * Math.PI) + 4) % 4;
+        const dt = (touchMove.timeStamp - this.touchStart.timeStamp) / 1000;
+        const velocity = dxDy.magnitude / dt;
+        if (this.isSwiping) {
+            const swipeEvent = new SwipeEvent_1.default(touchMove, {
+                direction: CartesianDirectionEnum[(0, utils_1.closest)(this.octant, [0, 1, 2, 3])],
+                velocity: velocity
+            });
+            this.dispatchEvent(swipeEvent);
+        }
+        else {
+            const swipeStartEvent = new SwipeEvent_1.SwipeStartEvent(touchMove, {
+                direction: CartesianDirectionEnum[(0, utils_1.closest)(this.octant, [0, 1, 2, 3])],
+                velocity: velocity
+            });
+            this.dispatchEvent(swipeStartEvent);
+            this.isSwiping = true;
+        }
+        this.dxDy = dxDy;
+        this.velocity = velocity;
+        if (this.isPanning) {
+            const panEvent = new PanEvent_1.default(touchMove, {
+                translation: dxDy,
+                velocity: velocity
+            });
+            this.dispatchEvent(panEvent);
+        }
+        else {
+            const panStartEvent = new PanEvent_1.PanStartEvent(touchMove, {
+                translation: dxDy,
+                velocity: velocity
+            });
+            this.dispatchEvent(panStartEvent);
+            this.isPanning = true;
+        }
+    }
+    onTouchEnd(touchEnd) {
+        const numberOfTaps = parseInt(this.currentTarget.dataset.numberoftaps || '0') || this.config.numberOfTaps;
+        this.taps++;
+        this.shouldFire = Boolean(this.taps > numberOfTaps);
+        if (this.shouldFire) {
+            this.touchEnd = touchEnd;
+            this.touchEndTime = touchEnd.timeStamp;
+            const maxTapDelay = parseFloat(this.currentTarget.dataset.tapdelay || '0') || this.config.tapDelay;
+            if (!this.touchMoved && !this.isLongPress) {
+                if (this.taps === 1 || (this.touchEndTime - this.lastTouchTime) < maxTapDelay) {
+                    if (this.taps % 2 === numberOfTaps) {
+                        const doubleTapEvent = new DoubleTapEvent_1.default(touchEnd);
+                        this.dispatchEvent(doubleTapEvent);
+                        this.taps = 0;
+                    }
+                    const tapEvent = new TapEvent_1.default(touchEnd);
+                    this.dispatchEvent(tapEvent);
+                }
+                else {
+                    this.taps = 0;
+                }
+            }
+        }
+        this.pointers = this.touchEnd.touches.length;
+        this.lastTouchTime = this.touchEndTime;
+        this.onPointerLeave(touchEnd);
+        this.unbind(this.currentTarget);
+        this.clean();
+    }
+    onTouchCancel(touchCancel) {
+        if (!this.shouldFire)
+            return;
+        this.touchCancel = touchCancel;
+        this.unbind(this.currentTarget);
+        this.clean();
+    }
+}
+exports["default"] = GestureProvider;
+GestureProvider.listening = false;
+if (TouchEvent)
+    window.gestureProvider = new GestureProvider();
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 46:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.closest = exports.Vec2 = exports.assert = void 0;
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+exports.assert = assert;
+class Vec2 {
+    constructor(_x, _y) {
+        this._x = 0;
+        this._y = 0;
+        this._clientX = 0;
+        this._clientY = 0;
+        this._clientX = _x;
+        this._clientY = _y;
+        this._x = this.translateX(_x);
+        this._y = this.translateY(_y);
+    }
+    translateY(_y) {
+        return -(_y - window.innerHeight / 2);
+    }
+    translateX(_x) {
+        return _x - window.innerWidth / 2;
+    }
+    get x() {
+        return this._x;
+    }
+    get y() {
+        return this._y;
+    }
+    get clientX() {
+        return this._clientX;
+    }
+    get clientY() {
+        return this._clientY;
+    }
+    set x(_x) {
+        this._clientX = _x;
+        this._x = this.translateX(_x);
+    }
+    set y(_y) {
+        this._clientY = _y;
+        this._y = this.translateY(_y);
+    }
+    add(vector) {
+        this._x += vector.x;
+        this._y += vector.y;
+        this._clientX += vector.clientX;
+        this._clientY += vector.clientY;
+        return this;
+    }
+    substract(vector) {
+        this._x -= vector.x;
+        this._y -= vector.y;
+        this._clientX -= vector.clientX;
+        this._clientY -= vector.clientY;
+        return this;
+    }
+    dot(vector) {
+        const scalar = (this._x * vector.x) + (this._y * vector.y);
+        return scalar;
+    }
+    get magnitude() {
+        return Math.sqrt(Math.pow(this._x, 2) + Math.pow(this._y, 2));
+    }
+    get clientMagnitude() {
+        return Math.sqrt(Math.pow(this._clientX, 2) + Math.pow(this._clientY, 2));
+    }
+}
+exports.Vec2 = Vec2;
+function closest(needle, haystack) {
+    return haystack.reduce((a, b) => {
+        let a_diff = Math.abs(a - needle);
+        let b_diff = Math.abs(b - needle);
+        if (a_diff === b_diff) {
+            return a > b ? a : b;
+        }
+        else {
+            return b_diff < a_diff ? b : a;
+        }
+    });
+}
+exports.closest = closest;
+//# sourceMappingURL=utils.js.map
+
+/***/ }),
+
+/***/ 810:
+/***/ ((module) => {
+
+var x = y => { var x = {}; __webpack_require__.d(x, y); return x; }
+var y = x => () => x
+module.exports = __WEBPACK_EXTERNAL_MODULE_react__;
+
+/***/ })
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/ 
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ 	// Check if module is in cache
+/******/ 	var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 	if (cachedModule !== undefined) {
+/******/ 		return cachedModule.exports;
+/******/ 	}
+/******/ 	// Create a new module (and put it into the cache)
+/******/ 	var module = __webpack_module_cache__[moduleId] = {
+/******/ 		// no module.id needed
+/******/ 		// no module.loaded needed
+/******/ 		exports: {}
+/******/ 	};
+/******/ 
+/******/ 	// Execute the module function
+/******/ 	__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 
+/******/ 	// Return the exports of the module
+/******/ 	return module.exports;
+/******/ }
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__webpack_require__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "ee": () => (/* reexport */ Anchor),
+  "zF": () => (/* reexport */ FadeInKeyframes),
+  "JA": () => (/* reexport */ FadeOutKeyframes),
+  "rN": () => (/* reexport */ GestureRegion),
+  "W_": () => (/* reexport */ Navigation),
+  "F0": () => (/* reexport */ Router),
+  "lL": () => (/* reexport */ Screen),
+  "Tq": () => (/* reexport */ SlideInFromBottomKeyframes),
+  "um": () => (/* reexport */ SlideInFromLeftKeyframes),
+  "ID": () => (/* reexport */ SlideInFromRightKeyframes),
+  "u5": () => (/* reexport */ SlideInFromTopKeyframes),
+  "eH": () => (/* reexport */ SlideOutToBottomKeyframes),
+  "ak": () => (/* reexport */ SlideOutToLeftKeyframes),
+  "pQ": () => (/* reexport */ SlideOutToRightKeyframes),
+  "Bu": () => (/* reexport */ SlideOutToTopKeyframes),
+  "xH": () => (/* reexport */ ZoomInKeyframes),
+  "s$": () => (/* reexport */ ZoomOutKeyframes),
+  "eV": () => (/* reexport */ androidBottomSheetSlideInOptions),
+  "aR": () => (/* reexport */ androidBottomSheetSlideOutOptions),
+  "BI": () => (/* reexport */ androidConcealToBottomKeyframes),
+  "gd": () => (/* reexport */ androidFadeInFromBottom),
+  "d3": () => (/* reexport */ androidFadeInFromBottomKeyframes),
+  "yo": () => (/* reexport */ androidFadeInFromBottomOptions),
+  "_s": () => (/* reexport */ androidFadeInFromBottomSheet),
+  "ih": () => (/* reexport */ androidFadeInFromBottomSheetKeyframes),
+  "r_": () => (/* reexport */ androidFadeInFromRight),
+  "kb": () => (/* reexport */ androidFadeInFromRightKeyframes),
+  "GY": () => (/* reexport */ androidFadeOutToBottomOptions),
+  "ef": () => (/* reexport */ androidFadeOutToLeftKeyframes),
+  "n_": () => (/* reexport */ androidRevealFromBottom),
+  "RA": () => (/* reexport */ androidRevealFromBottomKeyframes),
+  "TA": () => (/* reexport */ androidRevealFromBottomOptions),
+  "zf": () => (/* reexport */ androidScaleFromCentre),
+  "mz": () => (/* reexport */ androidScaleFromCentreKeyframes),
+  "pb": () => (/* reexport */ androidScaleFromCentreOptions),
+  "G6": () => (/* reexport */ androidScaleToCentreKeyframes),
+  "ZM": () => (/* reexport */ iOSKeyframeOptions),
+  "kB": () => (/* reexport */ iOSSlideInFromBottom),
+  "Hh": () => (/* reexport */ iOSSlideInFromBottomKeyframes),
+  "kz": () => (/* reexport */ iOSSlideInFromLeft),
+  "nI": () => (/* reexport */ iOSSlideInFromLeftKeyframes),
+  "E7": () => (/* reexport */ iOSSlideInFromRight),
+  "Cq": () => (/* reexport */ iOSSlideInFromRightKeyframes),
+  "cj": () => (/* reexport */ iOSSlideOutToLeftKeyframes),
+  "Cj": () => (/* reexport */ iOSSlideOutToRightKeyframes),
+  "HJ": () => (/* reexport */ useNavigation),
+  "yj": () => (/* reexport */ useRoute),
+  "tv": () => (/* reexport */ useRouter)
+});
+
+// EXTERNAL MODULE: ../../node_modules/web-gesture-events/index.js
+var web_gesture_events = __webpack_require__(190);
+;// CONCATENATED MODULE: external "@react-motion-router/core"
+var x = y => { var x = {}; __webpack_require__.d(x, y); return x; }
+var y = x => () => x
+const core_namespaceObject = x({ ["NavigationBase"]: () => __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__.NavigationBase, ["RouterBase"]: () => __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__.RouterBase, ["ScreenBase"]: () => __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__.ScreenBase, ["includesRoute"]: () => __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__.includesRoute, ["isValidScreenChild"]: () => __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__.isValidScreenChild, ["matchRoute"]: () => __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__.matchRoute, ["resolveBaseURLFromPattern"]: () => __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__.resolveBaseURLFromPattern, ["useNavigationBase"]: () => __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__.useNavigationBase, ["useRouteBase"]: () => __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__.useRouteBase, ["useRouterBase"]: () => __WEBPACK_EXTERNAL_MODULE__react_motion_router_core_d1cff82c__.useRouterBase });
+;// CONCATENATED MODULE: ./src/common/events.ts
+class NavigateEvent extends Event {
+    routerId;
+    route;
+    props;
+    navigationType;
+    signal;
+    result;
+    transition;
+    constructor(routerId, route, props, type, signal, result, transition) {
+        super('navigate');
+        this.routerId = routerId;
+        this.route = route;
+        this.props = props;
+        this.navigationType = type ?? "push";
+        this.signal = signal;
+        this.result = result;
+        this.transition = transition;
+    }
+}
+class BackEvent extends Event {
+    routerId;
+    signal;
+    result;
+    transition;
+    constructor(routerId, signal, result, transition) {
+        super('back');
+        this.routerId = routerId;
+        this.signal = signal;
+        this.result = result;
+        this.transition = transition;
+    }
+}
+class ForwardEvent extends Event {
+    routerId;
+    signal;
+    result;
+    transition;
+    constructor(routerId, signal, result, transition) {
+        super('forward');
+        this.routerId = routerId;
+        this.signal = signal;
+        this.result = result;
+        this.transition = transition;
+    }
+}
+class GestureStartEvent extends Event {
+    source;
+    constructor(source) {
+        super('gesture-start');
+        this.source = source;
+    }
+}
+class GestureEndEvent extends Event {
+    source;
+    constructor(source) {
+        super('gesture-end');
+        this.source = source;
+    }
+}
+class GestureCancelEvent extends Event {
+    constructor() {
+        super('gesture-cancel');
+    }
+}
+
+;// CONCATENATED MODULE: ./src/HistoryEntry.ts
+class HistoryEntry {
+    routerId;
+    #nativeEntry;
+    index;
+    constructor(nativeEntry, routerId, index) {
+        this.#nativeEntry = nativeEntry;
+        this.routerId = routerId;
+        this.index = index;
+    }
+    set ondispose(handler) {
+        this.#nativeEntry.ondispose = handler;
+    }
+    get ondispose() {
+        return this.#nativeEntry.ondispose;
+    }
+    get id() {
+        return this.#nativeEntry.id;
+    }
+    get globalIndex() {
+        return this.#nativeEntry.index;
+    }
+    get url() {
+        if (!this.#nativeEntry.url)
+            return null;
+        return new URL(this.#nativeEntry.url);
+    }
+    get key() {
+        return this.#nativeEntry.key;
+    }
+    get sameDocument() {
+        return this.#nativeEntry.sameDocument;
+    }
+    addEventListener(type, listener, options) {
+        this.#nativeEntry.addEventListener(type, listener, options);
+        return () => this.#nativeEntry.removeEventListener(type, listener, options);
+    }
+    removeEventListener(type, listener, options) {
+        this.#nativeEntry.addEventListener(type, listener, options);
+    }
+    dispatchEvent(event) {
+        return this.#nativeEntry.dispatchEvent(event);
+    }
+    getState() {
+        return this.#nativeEntry.getState();
+    }
+}
+
+;// CONCATENATED MODULE: ./src/Navigation.ts
+
+
+
+class Navigation extends core_namespaceObject.NavigationBase {
+    router;
+    constructor(router) {
+        super(router);
+        this.router = router;
+    }
+    traverseTo(key) {
+        return window.navigation.traverseTo(key);
+    }
+    replace(route, props = {}, options = {}) {
+        return this.navigate(route, props, { ...options, type: "replace" });
+    }
+    push(route, props = {}, options = {}) {
+        return this.navigate(route, props, { ...options, type: "push" });
+    }
+    reload(props = {}) {
+        return window.navigation.reload({ state: props });
+    }
+    navigate(route, props = {}, options = {}) {
+        const { type: history = "push" } = options;
+        const url = new URL(route, this.baseURL);
+        const result = window.navigation.navigate(url.href, { history, state: props });
+        const transition = window.navigation.transition;
+        const controller = new AbortController();
+        controller.signal.addEventListener('abort', () => this.goBack(), { once: true });
+        options.signal?.addEventListener('abort', controller.abort, { once: true });
+        const event = this.createNavigateEvent(route, props, history, controller.signal, result, transition);
+        this.dispatchEvent?.(event);
+        return result;
+    }
+    goBack(options = {}) {
+        if (!this.canGoBack)
+            return;
+        const previous = this.previous;
+        const result = window.navigation.traverseTo(previous.key);
+        const transition = window.navigation.transition;
+        const controller = new AbortController();
+        controller.signal.addEventListener('abort', () => this.goForward(), { once: true });
+        options.signal?.addEventListener('abort', controller.abort, { once: true });
+        const event = this.createBackEvent(controller.signal, result, transition);
+        this.dispatchEvent?.(event);
+        return result;
+    }
+    goForward(options = {}) {
+        if (!this.canGoForward)
+            return;
+        const next = this.next;
+        const result = window.navigation.traverseTo(next.key);
+        const transition = window.navigation.transition;
+        const controller = new AbortController();
+        controller.signal.addEventListener('abort', () => this.goBack(), { once: true });
+        options.signal?.addEventListener('abort', controller.abort, { once: true });
+        const event = this.createForwardEvent(controller.signal, result, transition);
+        this.dispatchEvent?.(event);
+        return result;
+    }
+    createBackEvent(signal, result, transition) {
+        if (!this.routerId)
+            throw new Error("Router ID is not set");
+        return new BackEvent(this.routerId, signal, result, transition);
+    }
+    createForwardEvent(signal, result, transition) {
+        if (!this.routerId)
+            throw new Error("Router ID is not set");
+        return new ForwardEvent(this.routerId, signal, result, transition);
+    }
+    createNavigateEvent(route, props, type, signal, result, transition) {
+        if (!this.routerId)
+            throw new Error("Router ID is not set");
+        return new NavigateEvent(this.routerId, route, props, type, signal, result, transition);
+    }
+    get transition() {
+        return this.router.state.transition;
+    }
+    get globalEntries() {
+        return window.navigation.entries();
+    }
+    get entries() {
+        const nestedPathPatterns = this.router.pathPatterns.filter(({ pattern }) => pattern.endsWith("**"));
+        let inNestedScope = false;
+        return this.globalEntries
+            .filter(entry => {
+            if (!entry.url)
+                return false;
+            const url = new URL(entry.url);
+            if (!(0,core_namespaceObject.resolveBaseURLFromPattern)(this.baseURLPattern.pathname, url.pathname))
+                return false;
+            if ((0,core_namespaceObject.includesRoute)(nestedPathPatterns, url.pathname, this.baseURLPattern.pathname)) {
+                if (inNestedScope)
+                    return false;
+                return inNestedScope = true; // technically in nested scope but include the first entry (the entry intercepted by the parent router)
+            }
+            else {
+                inNestedScope = false;
+                return true; // not in nested scope, so include
+            }
+        })
+            .map((entry, index) => {
+            return new HistoryEntry(entry, this.routerId, index);
+        });
+    }
+    get index() {
+        const globalCurrentIndex = window.navigation.currentEntry?.index ?? -1;
+        const firstEntryGlobalIndex = this.entries.at(0)?.globalIndex ?? -1;
+        const lastEntryGlobalIndex = this.entries.at(-1)?.globalIndex ?? -1;
+        if (globalCurrentIndex <= firstEntryGlobalIndex)
+            return 0;
+        else if (globalCurrentIndex >= lastEntryGlobalIndex)
+            return this.entries.length - 1;
+        else {
+            const scopedEntries = this.globalEntries.slice(firstEntryGlobalIndex, globalCurrentIndex + 1);
+            return this.entries.findLastIndex(entry => {
+                return scopedEntries.findLastIndex(globalEntry => entry.key === globalEntry.key) > -1;
+            });
+        }
+    }
+    get previous() {
+        return this.entries[this.index - 1] ?? null;
+    }
+    get next() {
+        return this.entries[this.index + 1] ?? null;
+    }
+    get current() {
+        return this.entries[this.index];
+    }
+    get canGoBack() {
+        return Boolean(this.previous?.sameDocument);
+    }
+    get canGoForward() {
+        return Boolean(this.next?.sameDocument);
+    }
+}
+
+;// CONCATENATED MODULE: ./src/Screen.tsx
+
+class Screen extends core_namespaceObject.ScreenBase {
+    routeProp;
+    constructor(props, context) {
+        super(props, context);
+        const setParams = this.setParams.bind(this);
+        const setConfig = this.setConfig.bind(this);
+        const getProps = () => this.props;
+        const getState = () => this.state;
+        this.routeProp = {
+            setParams,
+            setConfig,
+            get path() {
+                return getProps().path;
+            },
+            get resolvedPathname() {
+                return getProps().resolvedPathname;
+            },
+            get focused() {
+                return getState().focused;
+            },
+            get config() {
+                return {
+                    ...getProps().config,
+                    ...context.screenState.get(this.path)?.config
+                };
+            },
+            get params() {
+                return {
+                    ...getProps().defaultParams,
+                    ...context.screenState.get(this.path)?.params
+                };
+            }
+        };
+    }
+    static getDerivedStateFromProps(props) {
+        if (props.config?.presentation === "dialog"
+            || props.config?.presentation === "modal")
+            return { elementType: "dialog" };
+        else
+            return { elementType: "div" };
+    }
+    get config() {
+        return {
+            ...this.props.config,
+            ...this.context.screenState.get(this.props.path)?.config
+        };
+    }
+    get params() {
+        return {
+            ...this.props.defaultParams,
+            ...this.context.screenState.get(this.props.path)?.params
+        };
+    }
+    setParams(params) {
+        super.setParams(params);
+        if (this.state.focused)
+            window.navigation.updateCurrentEntry({ state: { params } });
+    }
+    setConfig(config) {
+        super.setConfig(config);
+        if (this.state.focused)
+            window.navigation.updateCurrentEntry({ state: { config } });
+    }
+    get router() {
+        return this.context;
+    }
+    onClickOutside(e) {
+        if (!this.transitionProvider.current?.ref.current)
+            return;
+        const navigation = this.context?.navigation;
+        const rect = this.transitionProvider.current.ref.current.getBoundingClientRect();
+        const isInDialog = (rect.top <= e.clientY
+            && e.clientY <= rect.top + rect.height
+            && rect.left <= e.clientX
+            && e.clientX <= rect.left + rect.width);
+        if (!isInDialog)
+            navigation?.goBack();
+    }
+    onEnter(signal) {
+        if (this.transitionProvider.current?.ref.current instanceof HTMLDialogElement
+            && this.transitionProvider.current.ref.current.open === false) {
+            const navigation = this.context?.navigation;
+            if (this.props.config?.presentation === "modal") {
+                this.transitionProvider.current.ref.current.showModal();
+            }
+            else {
+                this.transitionProvider.current.ref.current.show();
+            }
+            this.transitionProvider.current.ref.current.style.maxHeight = 'unset';
+            this.transitionProvider.current.ref.current.style.maxWidth = 'unset';
+            this.transitionProvider.current.ref.current.style.width = 'max-content';
+            this.transitionProvider.current.ref.current.style.height = 'max-content';
+            if (this.ref.current) {
+                this.ref.current.style.width = 'max-content';
+                this.ref.current.style.height = 'max-content';
+            }
+            const onClickOutside = this.onClickOutside.bind(this);
+            // closed by form submit or ESC key
+            this.transitionProvider.current?.ref.current.addEventListener('close', function () {
+                if (this.returnValue !== "screen-exit") {
+                    this.style.display = "block";
+                    navigation?.goBack();
+                }
+                navigation?.removeEventListener('click', onClickOutside);
+            }, { once: true });
+            navigation?.addEventListener('click', onClickOutside);
+        }
+        return super.onEnter(signal);
+    }
+    ;
+    onExited(signal) {
+        if (this.transitionProvider.current?.ref.current instanceof HTMLDialogElement) {
+            this.transitionProvider.current.ref.current.close("screen-exit");
+        }
+        return super.onExited(signal);
+    }
+}
+
+;// CONCATENATED MODULE: ./src/common/types.ts
+function isRefObject(value) {
+    if (value !== null
+        && typeof value === 'object'
+        && value.hasOwnProperty('current'))
+        return true;
+    return false;
+}
+function isVerticalDirection(direction) {
+    return direction === 'up' || direction === 'down' || direction === 'vertical';
+}
+function isHorizontalDirection(direction) {
+    return direction === 'left' || direction === 'right' || direction === 'horizontal';
+}
+
+// EXTERNAL MODULE: external "react"
+var external_react_ = __webpack_require__(810);
+;// CONCATENATED MODULE: external "web-animations-extension"
+var external_web_animations_extension_x = y => { var x = {}; __webpack_require__.d(x, y); return x; }
+var external_web_animations_extension_y = x => () => x
+const external_web_animations_extension_namespaceObject = external_web_animations_extension_x({ ["GestureTimeline"]: () => __WEBPACK_EXTERNAL_MODULE_web_animations_extension_74b2916c__.GestureTimeline, ["easingToLinear"]: () => __WEBPACK_EXTERNAL_MODULE_web_animations_extension_74b2916c__.easingToLinear, ["springToLinear"]: () => __WEBPACK_EXTERNAL_MODULE_web_animations_extension_74b2916c__.springToLinear });
+;// CONCATENATED MODULE: ./src/common/utils.ts
+function searchParamsToObject(searchPart) {
+    const entries = new URLSearchParams(decodeURI(searchPart)).entries();
+    const result = {};
+    for (const [key, value] of entries) { // each 'entry' is a [key, value] tuple
+        let parsedValue = '';
+        try {
+            parsedValue = JSON.parse(value);
+        }
+        catch (e) {
+            console.warn("Non JSON serialisable value was passed as URL route param.");
+            parsedValue = value;
+        }
+        result[key] = parsedValue;
+    }
+    return Object.keys(result).length ? result : undefined;
+}
+function searchParamsFromObject(params) {
+    try {
+        return new URLSearchParams(params).toString();
+    }
+    catch (e) {
+        console.error(e);
+        console.warn("Non JSON serialisable value was passed as query param.");
+    }
+    return '';
+}
+function isRollback(info) {
+    if (info && typeof info === 'object' && 'rollback' in info)
+        return Boolean(info.rollback);
+    return false;
+}
+function deepEquals(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (obj1 === null || obj2 === null || typeof obj1 !== 'object' || typeof obj2 !== 'object') {
+        return false;
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (let key of keys1) {
+        if (!keys2.includes(key) || !deepEquals(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+;// CONCATENATED MODULE: ./src/common/constants.ts
+const DEFAULT_GESTURE_CONFIG = {
+    gestureHysteresis: 0.5,
+    gestureMinFlingVelocity: 400,
+    gestureAreaWidth: 100,
+    gestureDirection: 'right',
+    disableGesture: false
+};
+
+;// CONCATENATED MODULE: ./src/Router.tsx
+
+
+
+
+
+
+
+
+class Router extends core_namespaceObject.RouterBase {
+    navigation = new Navigation(this);
+    constructor(props, context) {
+        super(props, context);
+        this.state = {
+            screenStack: [],
+            gestureDirection: "horizontal",
+            gestureAreaWidth: 50,
+            gestureHysteresis: 0.5,
+            disableGesture: true,
+            gestureMinFlingVelocity: 500,
+            transition: null,
+            backNavigating: false,
+            documentTitle: document.title,
+            fromKey: null,
+            destinationKey: null
+        };
+    }
+    static defaultProps = {
+        config: {
+            screenConfig: {
+                ...DEFAULT_GESTURE_CONFIG
+            }
+        }
+    };
+    static getDerivedStateFromProps(_, state) {
+        const config = state.screenStack.find(screen => isRefObject(screen.ref) && screen.ref.current?.focused)?.props.config;
+        document.title = config?.title ?? document.title;
+        return {
+            gestureDirection: config?.gestureDirection ?? DEFAULT_GESTURE_CONFIG.gestureDirection,
+            gestureAreaWidth: config?.gestureAreaWidth ?? DEFAULT_GESTURE_CONFIG.gestureAreaWidth,
+            gestureMinFlingVelocity: config?.gestureMinFlingVelocity ?? DEFAULT_GESTURE_CONFIG.gestureMinFlingVelocity,
+            gestureHysteresis: config?.gestureHysteresis ?? DEFAULT_GESTURE_CONFIG.gestureHysteresis,
+            disableGesture: config?.disableGesture ?? DEFAULT_GESTURE_CONFIG.disableGesture,
+            documentTitle: config?.title
+        };
+    }
+    componentDidMount() {
+        super.componentDidMount();
+        this.ref.current?.addEventListener('swipestart', this.onSwipeStart);
+        this.ref.current?.addEventListener('swipeend', this.onSwipeEnd);
+    }
+    shouldComponentUpdate(nextProps, nextState) {
+        return (!deepEquals(this.props.config, nextProps.config)
+            || !deepEquals(this.state, nextState)
+            || this.props.id !== nextProps.id);
+    }
+    componentWillUnmount() {
+        this.ref.current?.removeEventListener('swipestart', this.onSwipeStart);
+        this.ref.current?.removeEventListener('swipeend', this.onSwipeEnd);
+    }
+    canGestureNavigate(e) {
+        if (!this.ref.current)
+            return false;
+        if (this.state.disableGesture)
+            return false;
+        const clientRect = this.ref.current.getBoundingClientRect();
+        const { direction } = e;
+        if ((direction === "down" || direction === "right") && !this.navigation.canGoBack)
+            return false;
+        if ((direction === "up" || direction === "left") && !this.navigation.canGoForward)
+            return false;
+        if (isHorizontalDirection(direction) !== isHorizontalDirection(this.state.gestureDirection))
+            return false;
+        if (direction === "right" && Math.abs(e.x - clientRect.left) >= this.state.gestureAreaWidth)
+            return false;
+        if (direction === "left" && Math.abs(e.x - clientRect.right) >= this.state.gestureAreaWidth)
+            return false;
+        if (direction === "down" && Math.abs(e.y - clientRect.top) >= this.state.gestureAreaWidth)
+            return false;
+        if (direction === "up" && Math.abs(e.y - clientRect.bottom) >= this.state.gestureAreaWidth)
+            return false;
+        return true;
+    }
+    onSwipeStart = (e) => {
+        if (!this.canGestureNavigate(e))
+            return;
+        if (!this.ref.current || !this.screenTransitionLayer.current)
+            return;
+        const { direction } = e;
+        let axis = isHorizontalDirection(direction) ? "x" : "y";
+        let rangeStart;
+        let rangeEnd;
+        switch (direction) {
+            case "right":
+                rangeStart = 0;
+                rangeEnd = this.ref.current.clientWidth;
+                break;
+            case "left":
+                rangeStart = this.ref.current.clientWidth;
+                rangeEnd = 0;
+                break;
+            case "down":
+                rangeStart = 0;
+                rangeEnd = this.ref.current.clientHeight;
+                break;
+            case "up":
+                rangeStart = this.ref.current.clientHeight;
+                rangeEnd = 0;
+                break;
+        }
+        this.screenTransitionLayer.current.animation.timeline = new external_web_animations_extension_namespaceObject.GestureTimeline({
+            source: this.ref.current,
+            type: "swipe",
+            axis,
+            rangeStart,
+            rangeEnd
+        });
+        if (direction === "down" || direction === "right")
+            this.navigation.goBack();
+        else
+            this.navigation.goForward();
+        this.dispatchEvent(new GestureStartEvent(e));
+    };
+    onSwipeEnd = (e) => {
+        if (!this.screenTransitionLayer.current)
+            return;
+        const progress = this.screenTransitionLayer.current.animation.effect?.getComputedTiming().progress ?? 0;
+        const playbackRate = this.screenTransitionLayer.current.animation.playbackRate;
+        this.screenTransitionLayer.current.animation.timeline = document.timeline;
+        const hysteresisReached = playbackRate > 0 ? progress > this.state.gestureHysteresis : progress < this.state.gestureHysteresis;
+        let rollback = false;
+        if (e.velocity < this.state.gestureMinFlingVelocity && !hysteresisReached) {
+            this.screenTransitionLayer.current.animation.reverse();
+            rollback = true;
+            this.dispatchEvent(new GestureCancelEvent());
+        }
+        else {
+            this.dispatchEvent(new GestureEndEvent(e));
+        }
+        const { fromKey } = this.state;
+        if (rollback && fromKey) {
+            this.state.transition?.finished.then(() => {
+                window.navigation.traverseTo(fromKey.toString(), { info: { rollback } });
+            });
+        }
+    };
+    get screens() {
+        const screenStack = this.state.screenStack;
+        return screenStack
+            .filter((screen, index) => {
+            const currentScreenRef = screen.ref ?? null;
+            const nextScreenRef = screenStack.at(index + 1)?.ref;
+            return (isRefObject(currentScreenRef) && currentScreenRef.current?.config.keepAlive)
+                || (isRefObject(nextScreenRef) && nextScreenRef.current?.config.presentation === "modal")
+                || (isRefObject(nextScreenRef) && nextScreenRef.current?.config.presentation === "dialog")
+                || screen.key === this.navigation.current?.key
+                || screen.key === this.state.fromKey
+                || screen.key === this.state.destinationKey;
+        });
+    }
+    screenChildFromPathname(pathname) {
+        return external_react_.Children.toArray(this.props.children)
+            .find(child => {
+            if (!(0,core_namespaceObject.isValidScreenChild)(child))
+                return;
+            return (0,core_namespaceObject.matchRoute)(child.props.path, pathname, this.baseURLPattern.pathname, child.props.caseSensitive);
+        });
+    }
+    getScreenRefByKey(key) {
+        const screen = this.state.screenStack.find(screen => screen.key === key)?.ref;
+        if (isRefObject(screen))
+            return screen;
+        return null;
+    }
+    canIntercept(e) {
+        const pathname = new URL(e.destination.url).pathname;
+        const baseURLPattern = this.baseURLPattern.pathname;
+        return this.mounted
+            && this.shouldIntercept(e)
+            && (0,core_namespaceObject.includesRoute)(this.pathPatterns, pathname, baseURLPattern);
+    }
+    shouldIntercept(e) {
+        if (this.props.config.shouldIntercept)
+            return this.props.config.shouldIntercept(e);
+        return e.canIntercept
+            && !e.formData
+            && !e.hashChange
+            && !e.downloadRequest;
+    }
+    intercept(e) {
+        if (this.props.config.onIntercept && e.navigationType !== "load")
+            if (this.props.config.onIntercept(e) || e.defaultPrevented)
+                return;
+        switch (e.navigationType) {
+            case "load":
+                this.handleLoad(e);
+                break;
+            case "reload":
+            case "replace":
+                this.handleReplace(e);
+                break;
+            default:
+                this.handleDefault(e);
+                break;
+        }
+    }
+    handleLoad(e) {
+        const handler = () => {
+            const fromKey = e.transition?.from?.key ?? null;
+            const destinationKey = e.destination.key;
+            const transition = e.transition;
+            const screenStack = new Array();
+            const entries = this.navigation.entries;
+            entries.forEach((entry) => {
+                if (!entry.url)
+                    return null;
+                const screen = this.screenChildFromPathname(entry.url.pathname);
+                if (!(0,core_namespaceObject.isValidScreenChild)(screen))
+                    return null;
+                const { params, config } = entry.getState() ?? {};
+                const queryParams = searchParamsToObject(entry.url.search);
+                screenStack.push((0,external_react_.cloneElement)(screen, {
+                    config: {
+                        title: document.title,
+                        ...this.props.config.screenConfig,
+                        ...screen.props.config,
+                        ...config
+                    },
+                    defaultParams: {
+                        ...screen.props.defaultParams,
+                        ...queryParams,
+                        ...params
+                    },
+                    resolvedPathname: entry.url.pathname,
+                    key: entry.key,
+                    ref: (0,external_react_.createRef)()
+                }));
+            });
+            return new Promise((resolve, reject) => (0,external_react_.startTransition)(() => {
+                this.setState({ screenStack, fromKey, transition, destinationKey }, async () => {
+                    const { initialPath } = this.props.config;
+                    const [firstEntry] = entries;
+                    if (initialPath
+                        && entries.length === 1
+                        && firstEntry.url
+                        && !(0,core_namespaceObject.matchRoute)(initialPath, firstEntry.url.pathname, this.baseURLPattern.pathname)) {
+                        const transitionFinished = window.navigation.transition?.finished ?? Promise.resolve();
+                        transitionFinished.then(() => {
+                            this.navigation.replace(initialPath).finished.then(() => {
+                                const state = e.destination.getState() ?? {};
+                                this.navigation.push(e.destination.url, state);
+                            });
+                        });
+                        return resolve();
+                    }
+                    const signal = e.signal;
+                    if (this.navigation.current?.key === undefined)
+                        reject(new Error("Current key is undefined"));
+                    const currentScreen = this.getScreenRefByKey(this.navigation.current.key);
+                    await this.dispatchLifecycleHandlers(currentScreen, null, signal).catch(reject);
+                    this.setState({ destinationKey: null, fromKey: null, transition: null }, resolve);
+                });
+            }));
+        };
+        e.intercept({ handler });
+    }
+    handleReplace(e) {
+        const screenStack = this.state.screenStack;
+        const destinationPathname = new URL(e.destination.url).pathname;
+        const destinationScreen = this.screenChildFromPathname(destinationPathname);
+        if (!(0,core_namespaceObject.isValidScreenChild)(destinationScreen))
+            return e.preventDefault();
+        const handler = () => {
+            const { params, config } = e.destination.getState() ?? {};
+            const destination = e.destination;
+            const isHotReplace = this.state.transition !== null;
+            const transition = this.state.transition ?? window.navigation.transition;
+            const fromKey = transition?.from?.key ?? null;
+            const destinationKey = window.navigation.currentEntry?.key ?? destination.key;
+            const resolvedPathname = new URL(e.destination.url).pathname;
+            const queryParams = searchParamsToObject(new URL(destination.url).search);
+            const currentIndex = screenStack.findIndex(screen => screen.key === this.navigation.current?.key);
+            const backNavigating = this.state.backNavigating;
+            screenStack.splice(currentIndex, 1, (0,external_react_.cloneElement)(destinationScreen, {
+                config: {
+                    title: document.title,
+                    ...this.props.config.screenConfig,
+                    ...destinationScreen.props.config,
+                    ...config
+                },
+                defaultParams: {
+                    ...destinationScreen.props.defaultParams,
+                    ...queryParams,
+                    ...params,
+                },
+                resolvedPathname,
+                key: destinationKey,
+                ref: (0,external_react_.createRef)()
+            }));
+            return new Promise((resolve, reject) => (0,external_react_.startTransition)(() => {
+                this.setState({ destinationKey, fromKey, transition, screenStack }, async () => {
+                    const signal = e.signal;
+                    const outgoingScreen = this.getScreenRefByKey(String(fromKey));
+                    const incomingScreen = this.getScreenRefByKey(String(destinationKey));
+                    const pendingLifecycleHandlers = this.dispatchLifecycleHandlers(incomingScreen, null, signal).catch(reject);
+                    if (isHotReplace) {
+                        const currentTime = this.screenTransitionLayer.current?.animation.currentTime ?? 0;
+                        this.screenTransitionLayer.current?.animation.cancel();
+                        await new Promise(requestAnimationFrame);
+                        const animation = this.screenTransition(incomingScreen, outgoingScreen, backNavigating);
+                        if (animation) {
+                            animation.currentTime = currentTime;
+                        }
+                        animation?.updatePlaybackRate(1);
+                        await animation?.finished.catch(reject);
+                    }
+                    await pendingLifecycleHandlers;
+                    this.setState({ destinationKey: null, fromKey: null, transition: null }, resolve);
+                });
+            }));
+        };
+        e.intercept({ handler });
+    }
+    handleDefault(e) {
+        const screenStack = this.state.screenStack;
+        const destinationPathname = new URL(e.destination.url).pathname;
+        const destinationScreen = this.screenChildFromPathname(destinationPathname);
+        if (!(0,core_namespaceObject.isValidScreenChild)(destinationScreen))
+            return e.preventDefault();
+        const handler = () => {
+            const { params, config } = e.destination.getState() ?? {};
+            const transition = window.navigation.transition;
+            const destination = e.destination;
+            const resolvedPathname = new URL(e.destination.url).pathname;
+            let fromIndex = screenStack.findIndex(screen => screen.key === transition?.from.key);
+            if (fromIndex === -1 && e.navigationType === "traverse") {
+                fromIndex = screenStack.findIndex(screen => {
+                    if (!transition?.from.url || !screen.props.resolvedPathname)
+                        return false;
+                    const pathnameMatched = transition.from.url.includes(screen.props.resolvedPathname);
+                    const patternMatched = (0,core_namespaceObject.matchRoute)(screen.props.path, new URL(transition.from.url).pathname, this.baseURLPattern.pathname, screen.props.caseSensitive);
+                    return pathnameMatched && patternMatched;
+                });
+            }
+            const destinationIndex = screenStack.findIndex(screen => screen.key === e.destination.key);
+            const fromKey = (screenStack[fromIndex]?.key || transition?.from.key) ?? null;
+            const destinationKey = (screenStack[destinationIndex]?.key || window.navigation.currentEntry?.key) ?? null;
+            const backNavigating = destinationIndex >= 0 && destinationIndex < fromIndex;
+            if (e.navigationType === "push") {
+                const queryParams = searchParamsToObject(new URL(destination.url).search);
+                screenStack.splice(fromIndex + 1, Infinity, // Remove all screens after current
+                (0,external_react_.cloneElement)(destinationScreen, {
+                    config: {
+                        title: document.title,
+                        ...this.props.config.screenConfig,
+                        ...destinationScreen.props.config,
+                        ...config
+                    },
+                    defaultParams: {
+                        ...destinationScreen.props.defaultParams,
+                        ...queryParams,
+                        ...params,
+                    },
+                    resolvedPathname,
+                    key: window.navigation.currentEntry?.key,
+                    ref: (0,external_react_.createRef)()
+                }));
+            }
+            return new Promise((resolve, reject) => (0,external_react_.startTransition)(() => {
+                this.setState({ destinationKey, fromKey, transition, screenStack, backNavigating }, async () => {
+                    const signal = e.signal;
+                    const outgoingScreen = this.getScreenRefByKey(String(fromKey));
+                    const incomingScreen = this.getScreenRefByKey(String(destinationKey));
+                    const pendingLifecycleHandlers = this.dispatchLifecycleHandlers(incomingScreen, outgoingScreen, signal).catch(reject);
+                    if (!isRollback(e.info)) {
+                        const animation = this.screenTransition(incomingScreen, outgoingScreen, backNavigating);
+                        animation?.updatePlaybackRate(1);
+                        animation?.finished.catch(reject);
+                    }
+                    await pendingLifecycleHandlers;
+                    this.setState({ destinationKey: null, fromKey: null, transition: null }, resolve);
+                });
+            }));
+        };
+        e.intercept({ handler });
+    }
+    async dispatchLifecycleHandlers(incomingScreen, outgoingScreen, signal) {
+        let animationStarted = false;
+        this.addEventListener('transition-start', () => animationStarted = true, { once: true });
+        await Promise.all([
+            outgoingScreen?.current?.onExit(signal).then(() => outgoingScreen.current?.blur()),
+            incomingScreen?.current?.onEnter(signal).then(() => incomingScreen.current?.focus()),
+            incomingScreen?.current?.load(signal)
+        ]);
+        if (animationStarted)
+            await new Promise((resolve) => this.addEventListener('transition-end', resolve, { once: true }));
+        await Promise.all([
+            outgoingScreen?.current?.onExited(signal),
+            incomingScreen?.current?.onEntered(signal)
+        ]);
+    }
+    screenTransition(incomingScreen, outgoingScreen, backNavigating) {
+        if (this.screenTransitionLayer.current && incomingScreen && outgoingScreen) {
+            this.screenTransitionLayer.current.direction = backNavigating ? 'reverse' : 'normal';
+            if (incomingScreen.current?.transitionProvider.current) {
+                incomingScreen.current.transitionProvider.current.exiting = false;
+            }
+            if (outgoingScreen.current?.transitionProvider.current) {
+                outgoingScreen.current.transitionProvider.current.exiting = true;
+            }
+            if (this.screenTransitionLayer.current.sharedElementTransitionLayer.current) {
+                this.screenTransitionLayer.current.sharedElementTransitionLayer.current.outgoingScreen = outgoingScreen;
+                this.screenTransitionLayer.current.sharedElementTransitionLayer.current.incomingScreen = incomingScreen;
+            }
+            const topScreenIndex = this.screens.findIndex(screen => screen.ref === (backNavigating ? outgoingScreen : incomingScreen));
+            this.screenTransitionLayer.current.screens = this.screens
+                .map((screen, index) => {
+                // normalise indices making incoming screen index 1 and preceding screens index 0...-n
+                index = (index - topScreenIndex) + 1;
+                if (isRefObject(screen.ref) && screen.ref.current?.transitionProvider.current) {
+                    screen.ref.current.transitionProvider.current.index = index;
+                    return screen.ref;
+                }
+                return null;
+            })
+                .filter(isRefObject);
+            return this.screenTransitionLayer.current.transition();
+        }
+    }
+}
+
+// EXTERNAL MODULE: ../../node_modules/react/jsx-runtime.js
+var jsx_runtime = __webpack_require__(322);
+;// CONCATENATED MODULE: ./src/common/hooks.ts
+
+
+function useNavigation() {
+    (0,external_react_.useDebugValue)("StackNavigation");
+    return (0,core_namespaceObject.useNavigationBase)();
+}
+function useRouter() {
+    (0,external_react_.useDebugValue)("StackRouter");
+    return (0,core_namespaceObject.useRouterBase)();
+}
+function useRoute() {
+    (0,external_react_.useDebugValue)("StackRoute");
+    return (0,core_namespaceObject.useRouteBase)();
+}
+
+;// CONCATENATED MODULE: ./src/Anchor.tsx
+
+
+
+
+function useNavigationOrDefault(navigation) {
+    const defaultNavigation = useNavigation();
+    return navigation ?? defaultNavigation;
+}
+function Anchor(props) {
+    const { preload, goBack, params = {}, type = "push", href: hrefProp, onClick: onClickProp, ...aProps } = props;
+    const navigation = useNavigationOrDefault(props.navigation);
+    const [href, setHref] = (0,external_react_.useState)(undefined);
+    const routerId = navigation?.routerId;
+    const isExternal = !href?.includes(window.location.origin);
+    const rel = isExternal ? "noopener noreferrer" : goBack ? "prev" : "next";
+    (0,external_react_.useEffect)(() => {
+        if (!preload || !href)
+            return;
+        navigation.preloadRoute(hrefProp);
+    }, [preload, hrefProp]);
+    (0,external_react_.useEffect)(() => {
+        if (goBack) {
+            setHref(navigation.previous?.url?.href);
+        }
+        else if (hrefProp) {
+            const search = searchParamsFromObject(params);
+            const uri = new URL(hrefProp, navigation.baseURL);
+            uri.search = search;
+            setHref(uri.href);
+        }
+    }, [hrefProp, params]);
+    const onClick = (e) => {
+        if (goBack) {
+            e.preventDefault();
+            navigation.goBack();
+        }
+        else if (type === "replace" && hrefProp) {
+            e.preventDefault();
+            navigation.replace(hrefProp);
+        }
+        onClickProp?.(e);
+    };
+    return ((0,jsx_runtime.jsx)("a", { href: href, "data-router-id": routerId, onClick: onClick, rel: rel, ...aProps, children: props.children }));
+}
+
+;// CONCATENATED MODULE: ./src/animation-configs/keyframe-presets.ts
+const SlideInFromRightKeyframes = [
+    {
+        transform: 'translateX(100vw)',
+    },
+    {
+        transform: 'translateX(0vw)'
+    }
+];
+const iOSSlideInFromRightKeyframes = [
+    {
+        transform: 'translateX(100vw)',
+    },
+    {
+        transform: 'translateX(0vw)'
+    }
+];
+const SlideOutToLeftKeyframes = [
+    {
+        transform: 'translateX(0vw)'
+    },
+    {
+        transform: 'translateX(-50vw)'
+    }
+];
+const iOSSlideOutToLeftKeyframes = [
+    {
+        transform: 'translateX(0vw)',
+    },
+    {
+        transform: 'translateX(calc(100vw * -0.3))'
+    }
+];
+const SlideInFromLeftKeyframes = [
+    {
+        transform: 'translateX(-100vw)'
+    },
+    {
+        transform: 'translateX(0vw)'
+    }
+];
+const iOSSlideInFromLeftKeyframes = [
+    {
+        transform: 'translateX(-100vw)'
+    },
+    {
+        transform: 'translateX(0vw)'
+    }
+];
+const SlideOutToRightKeyframes = [
+    {
+        transform: 'translateX(0vw)'
+    },
+    {
+        transform: 'translateX(50vw)'
+    }
+];
+const iOSSlideOutToRightKeyframes = [
+    {
+        transform: 'translateX(0vw)'
+    },
+    {
+        transform: 'translateX(calc(100vw * 0.3))'
+    }
+];
+const SlideInFromBottomKeyframes = [
+    {
+        transform: 'translateY(100vh)'
+    },
+    {
+        transform: 'translateY(0vh)'
+    }
+];
+const iOSSlideInFromBottomKeyframes = [
+    {
+        transform: 'translateY(100vh)'
+    },
+    {
+        transform: 'translateY(0vh)'
+    }
+];
+const SlideOutToTopKeyframes = [
+    {
+        transform: 'translateY(0vh)'
+    },
+    {
+        transform: 'translateY(-50vh)'
+    }
+];
+const SlideInFromTopKeyframes = [
+    {
+        transform: 'translateY(-100vh)'
+    },
+    {
+        transform: 'translateY(0vh)'
+    }
+];
+const SlideOutToBottomKeyframes = [
+    {
+        transform: 'translateY(0vh)'
+    },
+    {
+        transform: 'translateY(50vh)'
+    }
+];
+const ZoomInKeyframes = [
+    {
+        transform: 'scale(0.85)',
+        opacity: 0
+    },
+    {
+        transform: 'scale(1)',
+        opacity: 1
+    }
+];
+const ZoomOutKeyframes = [
+    {
+        transform: 'scale(1)',
+        opacity: 1
+    },
+    {
+        transform: 'scale(1.15)',
+        opacity: 0
+    }
+];
+const FadeInKeyframes = [
+    {
+        opacity: 0
+    },
+    {
+        opacity: 1
+    }
+];
+const FadeOutKeyframes = [
+    {
+        opacity: 1
+    },
+    {
+        opacity: 0
+    }
+];
+const androidFadeInFromBottomKeyframes = [
+    {
+        opacity: 0,
+        transform: 'translateY(calc(100vh * 0.08))'
+    },
+    {
+        opacity: 0.25,
+        offset: 0.5
+    },
+    {
+        opacity: 0.7,
+        offset: 0.9
+    },
+    {
+        opacity: 1,
+        transform: 'translateY(0vh)'
+    }
+];
+const androidFadeInFromRightKeyframes = [
+    {
+        opacity: 0,
+        transform: 'translateY(96vw)'
+    },
+    {
+        opacity: 1,
+        transform: 'translateY(0vw)'
+    }
+];
+const androidFadeOutToLeftKeyframes = [
+    {
+        opacity: 0,
+        transform: 'translateY(0vw)'
+    },
+    {
+        opacity: 1,
+        transform: 'translateY(-96vw)'
+    }
+];
+const androidRevealFromBottomKeyframes = [
+    {
+        transform: 'translateY(100vh)'
+    },
+    {
+        transform: 'translateY(0vh)'
+    }
+];
+const androidConcealToBottomKeyframes = [
+    {
+        transform: 'translateY(0vh)'
+    },
+    {
+        transform: 'translateY(-2vh)'
+    }
+];
+const androidScaleFromCentreKeyframes = [
+    {
+        transform: 'scale(0.85)',
+        opacity: 0
+    },
+    {
+        opacity: 0,
+        offset: 0.75
+    },
+    {
+        opacity: 1,
+        offset: 0.875
+    },
+    {
+        transform: 'scale(1)',
+        opacity: 1
+    }
+];
+const androidScaleToCentreKeyframes = [
+    {
+        transform: 'scale(1)',
+        opacity: 1
+    },
+    {
+        opacity: 1,
+        offset: 0.0825
+    },
+    {
+        opacity: 1,
+        offset: 0.2075
+    },
+    {
+        transform: 'scale(1.075)',
+        opacity: 0
+    }
+];
+const androidFadeInFromBottomSheetKeyframes = [
+    {
+        transform: 'translateY(calc(100vh * 0.8))',
+        opacity: 0
+    },
+    {
+        transform: 'translateY(0vh)',
+        opacity: 1
+    }
+];
+
+;// CONCATENATED MODULE: ./src/animation-configs/keyframe-options-presets.ts
+
+function easingOut(easing) {
+    return t => 1 - easing(1 - t);
+}
+function easingPoly(n) {
+    return (t) => Math.pow(t, n);
+}
+const iOSKeyframeOptions = {
+    ...(0,external_web_animations_extension_namespaceObject.springToLinear)({
+        mass: 3,
+        stiffness: 1000,
+        damping: 500,
+        velocity: 0,
+        steps: 200
+    })
+};
+const androidFadeInFromBottomOptions = {
+    duration: 350,
+    easing: (0,external_web_animations_extension_namespaceObject.easingToLinear)(easingOut(easingPoly(5)))
+};
+const androidFadeOutToBottomOptions = {
+    duration: 150,
+    easing: 'linear'
+};
+const androidRevealFromBottomOptions = {
+    duration: 425,
+    easing: 'cubic-bezier(0.35, 0.45, 0, 1)'
+};
+const androidScaleFromCentreOptions = {
+    duration: 400,
+    easing: 'cubic-bezier(0.35, 0.45, 0, 1)'
+};
+const androidBottomSheetSlideInOptions = {
+    duration: 250,
+    easing: (0,external_web_animations_extension_namespaceObject.easingToLinear)(t => Math.cos((t + 1) * Math.PI) / 2.0 + 0.5)
+};
+const androidBottomSheetSlideOutOptions = {
+    duration: 200,
+    easing: (0,external_web_animations_extension_namespaceObject.easingToLinear)(t => (t === 1.0 ? 1 : Math.pow(t, 2)))
+};
+
+;// CONCATENATED MODULE: ./src/animation-configs/animation-presets.ts
+
+
+function iOSSlideInFromRight({ ref, direction, playbackRate, index }) {
+    const keyframesPresets = [
+        iOSSlideOutToLeftKeyframes,
+        iOSSlideInFromRightKeyframes
+    ];
+    let keyframes = keyframesPresets[index];
+    const options = {
+        playbackRate,
+        fill: "forwards",
+        ...iOSKeyframeOptions
+    };
+    if (direction === "reverse")
+        keyframes = keyframes.toReversed();
+    return new KeyframeEffect(ref, keyframes, options);
+}
+function iOSSlideInFromLeft({ ref, direction, playbackRate, index }) {
+    const keyframesPresets = [
+        iOSSlideOutToRightKeyframes,
+        iOSSlideInFromLeftKeyframes
+    ];
+    let keyframes = keyframesPresets[index];
+    const options = {
+        playbackRate,
+        fill: "forwards",
+        ...iOSKeyframeOptions
+    };
+    if (direction === "reverse")
+        keyframes = keyframes.toReversed();
+    return new KeyframeEffect(ref, keyframes, options);
+}
+function iOSSlideInFromBottom({ ref, direction, playbackRate }) {
+    let keyframes = iOSSlideInFromBottomKeyframes;
+    const options = {
+        playbackRate,
+        fill: "forwards",
+        ...iOSKeyframeOptions
+    };
+    if (direction === "reverse")
+        keyframes = keyframes.toReversed();
+    return new KeyframeEffect(ref, keyframes, options);
+}
+function androidFadeInFromBottom({ ref, direction, playbackRate }) {
+    let keyframes = androidFadeInFromBottomKeyframes;
+    const options = {
+        playbackRate,
+        fill: "forwards",
+        ...androidFadeInFromBottomOptions
+    };
+    if (direction === "reverse")
+        keyframes = keyframes.toReversed();
+    return new KeyframeEffect(ref, keyframes, options);
+}
+function androidFadeInFromBottomSheet({ ref, direction, index, playbackRate }) {
+    let keyframes = androidFadeInFromBottomSheetKeyframes;
+    let timing;
+    if (index === 0)
+        timing = androidBottomSheetSlideOutOptions;
+    else
+        timing = androidBottomSheetSlideInOptions;
+    const options = {
+        playbackRate,
+        fill: "forwards",
+        ...timing
+    };
+    if (direction === "reverse")
+        keyframes = keyframes.toReversed();
+    return new KeyframeEffect(ref, keyframes, options);
+}
+function androidRevealFromBottom({ ref, direction, index, playbackRate }) {
+    let keyframesPresets = [
+        androidConcealToBottomKeyframes,
+        androidRevealFromBottomKeyframes
+    ];
+    const keyframes = keyframesPresets[index];
+    const options = {
+        direction,
+        playbackRate,
+        fill: "forwards",
+        ...androidRevealFromBottomOptions
+    };
+    return new KeyframeEffect(ref, keyframes, options);
+}
+function androidFadeInFromRight({ ref, direction, index, playbackRate }) {
+    let keyframesPresets = [
+        androidFadeOutToLeftKeyframes,
+        androidFadeInFromRightKeyframes
+    ];
+    let timing;
+    if (index === 0)
+        timing = androidFadeOutToBottomOptions;
+    else
+        timing = androidFadeInFromBottomOptions;
+    let keyframes = keyframesPresets[index];
+    const options = {
+        playbackRate,
+        fill: "forwards",
+        ...timing
+    };
+    if (direction === "reverse")
+        keyframes = keyframes.toReversed();
+    return new KeyframeEffect(ref, keyframes, options);
+}
+function androidScaleFromCentre({ ref, direction, index, playbackRate }) {
+    let keyframesPresets = [
+        androidScaleToCentreKeyframes,
+        androidScaleFromCentreKeyframes
+    ];
+    const keyframes = keyframesPresets[index];
+    const options = {
+        direction,
+        playbackRate,
+        fill: "forwards",
+        ...androidScaleFromCentreOptions
+    };
+    return new KeyframeEffect(ref, keyframes, options);
+}
+
+;// CONCATENATED MODULE: ./src/GestureRegion.tsx
+
+
+function GestureRegion({ disabled, children, ...props }) {
+    const ref = (0,external_react_.useRef)(null);
+    (0,external_react_.useEffect)(() => {
+        const onSwipeStart = (e) => {
+            e.stopPropagation();
+            e.preventDefault();
+        };
+        ref.current?.addEventListener('swipestart', onSwipeStart);
+        return () => {
+            ref.current?.removeEventListener('swipestart', onSwipeStart);
+        };
+    }, [ref]);
+    return ((0,jsx_runtime.jsx)("div", { ref: ref, className: "gesture-region", "data-disabled": disabled, style: { display: 'contents' }, ...props, children: children }));
+}
+
+;// CONCATENATED MODULE: ./src/index.ts
+/// <reference types="urlpattern-polyfill" />
+
+
+
+
+
+
+
+
+
+
+
+})();
+
+var __webpack_exports__Anchor = __webpack_exports__.ee;
+var __webpack_exports__FadeInKeyframes = __webpack_exports__.zF;
+var __webpack_exports__FadeOutKeyframes = __webpack_exports__.JA;
+var __webpack_exports__GestureRegion = __webpack_exports__.rN;
+var __webpack_exports__Navigation = __webpack_exports__.W_;
+var __webpack_exports__Router = __webpack_exports__.F0;
+var __webpack_exports__Screen = __webpack_exports__.lL;
+var __webpack_exports__SlideInFromBottomKeyframes = __webpack_exports__.Tq;
+var __webpack_exports__SlideInFromLeftKeyframes = __webpack_exports__.um;
+var __webpack_exports__SlideInFromRightKeyframes = __webpack_exports__.ID;
+var __webpack_exports__SlideInFromTopKeyframes = __webpack_exports__.u5;
+var __webpack_exports__SlideOutToBottomKeyframes = __webpack_exports__.eH;
+var __webpack_exports__SlideOutToLeftKeyframes = __webpack_exports__.ak;
+var __webpack_exports__SlideOutToRightKeyframes = __webpack_exports__.pQ;
+var __webpack_exports__SlideOutToTopKeyframes = __webpack_exports__.Bu;
+var __webpack_exports__ZoomInKeyframes = __webpack_exports__.xH;
+var __webpack_exports__ZoomOutKeyframes = __webpack_exports__.s$;
+var __webpack_exports__androidBottomSheetSlideInOptions = __webpack_exports__.eV;
+var __webpack_exports__androidBottomSheetSlideOutOptions = __webpack_exports__.aR;
+var __webpack_exports__androidConcealToBottomKeyframes = __webpack_exports__.BI;
+var __webpack_exports__androidFadeInFromBottom = __webpack_exports__.gd;
+var __webpack_exports__androidFadeInFromBottomKeyframes = __webpack_exports__.d3;
+var __webpack_exports__androidFadeInFromBottomOptions = __webpack_exports__.yo;
+var __webpack_exports__androidFadeInFromBottomSheet = __webpack_exports__._s;
+var __webpack_exports__androidFadeInFromBottomSheetKeyframes = __webpack_exports__.ih;
+var __webpack_exports__androidFadeInFromRight = __webpack_exports__.r_;
+var __webpack_exports__androidFadeInFromRightKeyframes = __webpack_exports__.kb;
+var __webpack_exports__androidFadeOutToBottomOptions = __webpack_exports__.GY;
+var __webpack_exports__androidFadeOutToLeftKeyframes = __webpack_exports__.ef;
+var __webpack_exports__androidRevealFromBottom = __webpack_exports__.n_;
+var __webpack_exports__androidRevealFromBottomKeyframes = __webpack_exports__.RA;
+var __webpack_exports__androidRevealFromBottomOptions = __webpack_exports__.TA;
+var __webpack_exports__androidScaleFromCentre = __webpack_exports__.zf;
+var __webpack_exports__androidScaleFromCentreKeyframes = __webpack_exports__.mz;
+var __webpack_exports__androidScaleFromCentreOptions = __webpack_exports__.pb;
+var __webpack_exports__androidScaleToCentreKeyframes = __webpack_exports__.G6;
+var __webpack_exports__iOSKeyframeOptions = __webpack_exports__.ZM;
+var __webpack_exports__iOSSlideInFromBottom = __webpack_exports__.kB;
+var __webpack_exports__iOSSlideInFromBottomKeyframes = __webpack_exports__.Hh;
+var __webpack_exports__iOSSlideInFromLeft = __webpack_exports__.kz;
+var __webpack_exports__iOSSlideInFromLeftKeyframes = __webpack_exports__.nI;
+var __webpack_exports__iOSSlideInFromRight = __webpack_exports__.E7;
+var __webpack_exports__iOSSlideInFromRightKeyframes = __webpack_exports__.Cq;
+var __webpack_exports__iOSSlideOutToLeftKeyframes = __webpack_exports__.cj;
+var __webpack_exports__iOSSlideOutToRightKeyframes = __webpack_exports__.Cj;
+var __webpack_exports__useNavigation = __webpack_exports__.HJ;
+var __webpack_exports__useRoute = __webpack_exports__.yj;
+var __webpack_exports__useRouter = __webpack_exports__.tv;
+export { __webpack_exports__Anchor as Anchor, __webpack_exports__FadeInKeyframes as FadeInKeyframes, __webpack_exports__FadeOutKeyframes as FadeOutKeyframes, __webpack_exports__GestureRegion as GestureRegion, __webpack_exports__Navigation as Navigation, __webpack_exports__Router as Router, __webpack_exports__Screen as Screen, __webpack_exports__SlideInFromBottomKeyframes as SlideInFromBottomKeyframes, __webpack_exports__SlideInFromLeftKeyframes as SlideInFromLeftKeyframes, __webpack_exports__SlideInFromRightKeyframes as SlideInFromRightKeyframes, __webpack_exports__SlideInFromTopKeyframes as SlideInFromTopKeyframes, __webpack_exports__SlideOutToBottomKeyframes as SlideOutToBottomKeyframes, __webpack_exports__SlideOutToLeftKeyframes as SlideOutToLeftKeyframes, __webpack_exports__SlideOutToRightKeyframes as SlideOutToRightKeyframes, __webpack_exports__SlideOutToTopKeyframes as SlideOutToTopKeyframes, __webpack_exports__ZoomInKeyframes as ZoomInKeyframes, __webpack_exports__ZoomOutKeyframes as ZoomOutKeyframes, __webpack_exports__androidBottomSheetSlideInOptions as androidBottomSheetSlideInOptions, __webpack_exports__androidBottomSheetSlideOutOptions as androidBottomSheetSlideOutOptions, __webpack_exports__androidConcealToBottomKeyframes as androidConcealToBottomKeyframes, __webpack_exports__androidFadeInFromBottom as androidFadeInFromBottom, __webpack_exports__androidFadeInFromBottomKeyframes as androidFadeInFromBottomKeyframes, __webpack_exports__androidFadeInFromBottomOptions as androidFadeInFromBottomOptions, __webpack_exports__androidFadeInFromBottomSheet as androidFadeInFromBottomSheet, __webpack_exports__androidFadeInFromBottomSheetKeyframes as androidFadeInFromBottomSheetKeyframes, __webpack_exports__androidFadeInFromRight as androidFadeInFromRight, __webpack_exports__androidFadeInFromRightKeyframes as androidFadeInFromRightKeyframes, __webpack_exports__androidFadeOutToBottomOptions as androidFadeOutToBottomOptions, __webpack_exports__androidFadeOutToLeftKeyframes as androidFadeOutToLeftKeyframes, __webpack_exports__androidRevealFromBottom as androidRevealFromBottom, __webpack_exports__androidRevealFromBottomKeyframes as androidRevealFromBottomKeyframes, __webpack_exports__androidRevealFromBottomOptions as androidRevealFromBottomOptions, __webpack_exports__androidScaleFromCentre as androidScaleFromCentre, __webpack_exports__androidScaleFromCentreKeyframes as androidScaleFromCentreKeyframes, __webpack_exports__androidScaleFromCentreOptions as androidScaleFromCentreOptions, __webpack_exports__androidScaleToCentreKeyframes as androidScaleToCentreKeyframes, __webpack_exports__iOSKeyframeOptions as iOSKeyframeOptions, __webpack_exports__iOSSlideInFromBottom as iOSSlideInFromBottom, __webpack_exports__iOSSlideInFromBottomKeyframes as iOSSlideInFromBottomKeyframes, __webpack_exports__iOSSlideInFromLeft as iOSSlideInFromLeft, __webpack_exports__iOSSlideInFromLeftKeyframes as iOSSlideInFromLeftKeyframes, __webpack_exports__iOSSlideInFromRight as iOSSlideInFromRight, __webpack_exports__iOSSlideInFromRightKeyframes as iOSSlideInFromRightKeyframes, __webpack_exports__iOSSlideOutToLeftKeyframes as iOSSlideOutToLeftKeyframes, __webpack_exports__iOSSlideOutToRightKeyframes as iOSSlideOutToRightKeyframes, __webpack_exports__useNavigation as useNavigation, __webpack_exports__useRoute as useRoute, __webpack_exports__useRouter as useRouter };
+
+//# sourceMappingURL=index.js.map