{"version":3,"file":"695-33400cde19.js","mappings":"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","sources":["webpack://source-maps/ClientApp/node_modules/.pnpm/@reduxjs+toolkit@1.9.7_reac_3dc30913779b57d5bdad922118cc8c26/node_modules/@reduxjs/toolkit/dist/query/react/rtk-query-react.esm.js","webpack://source-maps/ClientApp/node_modules/.pnpm/@reduxjs+toolkit@1.9.7_reac_3dc30913779b57d5bdad922118cc8c26/node_modules/@reduxjs/toolkit/dist/query/rtk-query.esm.js","webpack://source-maps/ClientApp/node_modules/.pnpm/@reduxjs+toolkit@1.9.7_reac_3dc30913779b57d5bdad922118cc8c26/node_modules/@reduxjs/toolkit/dist/redux-toolkit.esm.js","webpack://source-maps/ClientApp/node_modules/.pnpm/@remix-run+router@1.22.0/node_modules/@remix-run/router/dist/router.js","webpack://source-maps/ClientApp/node_modules/.pnpm/regenerator-runtime@0.13.11/node_modules/regenerator-runtime/runtime.js","webpack://source-maps/ClientApp/node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/es/defaultMemoize.js","webpack://source-maps/ClientApp/node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/es/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/BehaviorSubject.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/InnerSubscriber.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Notification.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Observable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Observer.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/OuterSubscriber.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Scheduler.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Subject.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/SubjectSubscription.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Subscriber.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Subscription.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/dom/ajax.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/empty.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/from.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/interval.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/of.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/throw.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/catch.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/combineLatest.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/concatMap.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/count.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/delay.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/do.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/filter.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/map.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/mergeMap.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/retryWhen.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/share.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/take.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/ArrayLikeObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/ArrayObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/ConnectableObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/EmptyObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/ErrorObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/FromObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/IntervalObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/IteratorObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/PromiseObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/ScalarObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/dom/AjaxObservable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/dom/ajax.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/empty.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/from.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/interval.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/of.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/throw.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/catch.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/combineLatest.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/concatMap.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/count.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/delay.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/do.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/filter.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/map.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/mergeMap.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/retryWhen.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/share.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/take.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/catchError.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/combineLatest.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/concatMap.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/count.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/delay.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/filter.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/map.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/mergeMap.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/multicast.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/observeOn.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/refCount.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/retryWhen.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/share.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/take.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/tap.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/scheduler/Action.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/scheduler/AsyncAction.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/scheduler/AsyncScheduler.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/scheduler/async.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/symbol/iterator.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/symbol/observable.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/symbol/rxSubscriber.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/ArgumentOutOfRangeError.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/ObjectUnsubscribedError.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/UnsubscriptionError.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/errorObject.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isArray.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isArrayLike.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isDate.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isFunction.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isNumeric.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isObject.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isPromise.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isScheduler.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/noop.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/pipe.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/root.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/subscribeToResult.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/toSubscriber.js","webpack://source-maps/ClientApp/node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/tryCatch.js","webpack://source-maps/ClientApp/node_modules/.pnpm/safe-regex-test@1.1.0/node_modules/safe-regex-test/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/scheduler@0.23.2/node_modules/scheduler/cjs/scheduler.production.min.js","webpack://source-maps/ClientApp/node_modules/.pnpm/scheduler@0.23.2/node_modules/scheduler/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/style-to-js@1.1.3/node_modules/style-to-js/cjs/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/style-to-js@1.1.3/node_modules/style-to-js/cjs/utilities.js","webpack://source-maps/ClientApp/node_modules/.pnpm/style-to-object@0.4.1/node_modules/style-to-object/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/stylis@4.2.0/node_modules/stylis/src/Enum.js","webpack://source-maps/ClientApp/node_modules/.pnpm/stylis@4.2.0/node_modules/stylis/src/Middleware.js","webpack://source-maps/ClientApp/node_modules/.pnpm/stylis@4.2.0/node_modules/stylis/src/Parser.js","webpack://source-maps/ClientApp/node_modules/.pnpm/stylis@4.2.0/node_modules/stylis/src/Serializer.js","webpack://source-maps/ClientApp/node_modules/.pnpm/stylis@4.2.0/node_modules/stylis/src/Tokenizer.js","webpack://source-maps/ClientApp/node_modules/.pnpm/stylis@4.2.0/node_modules/stylis/src/Utility.js","webpack://source-maps/ClientApp/node_modules/.pnpm/ssr-window@4.0.2/node_modules/ssr-window/ssr-window.esm.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/utils.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/get-support.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/get-device.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/get-browser.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/events-emitter.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/process-lazy-preloader.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/update/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/update/updateSize.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/update/updateSlides.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/update/updateAutoHeight.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/update/updateSlidesOffset.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/update/updateSlidesProgress.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/update/updateProgress.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/update/updateSlidesClasses.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/update/updateActiveIndex.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/update/updateClickedSlide.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/translate/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/translate/getTranslate.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/translate/setTranslate.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/translate/minTranslate.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/translate/maxTranslate.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/translate/translateTo.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/transition/transitionEmit.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/slide/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/slide/slideTo.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/slide/slideToLoop.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/slide/slideNext.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/slide/slidePrev.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/slide/slideReset.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/slide/slideToClosest.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/slide/slideToClickedSlide.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/loop/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/loop/loopCreate.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/loop/loopFix.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/loop/loopDestroy.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/events/onTouchStart.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/events/onTouchMove.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/events/onTouchEnd.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/events/onResize.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/events/onClick.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/events/onScroll.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/events/onLoad.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/events/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/breakpoints/setBreakpoint.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/check-overflow/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/defaults.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/moduleExtendParams.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/core.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/transition/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/transition/setTransition.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/transition/transitionStart.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/transition/transitionEnd.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/grab-cursor/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/grab-cursor/setGrabCursor.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/grab-cursor/unsetGrabCursor.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/breakpoints/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/breakpoints/getBreakpoint.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/classes/index.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/classes/addClasses.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/classes/removeClasses.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/modules/resize/resize.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/core/modules/observer/observer.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/virtual/virtual.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/keyboard/keyboard.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/mousewheel/mousewheel.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/create-element-if-not-defined.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/navigation/navigation.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/classes-to-selector.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/pagination/pagination.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/scrollbar/scrollbar.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/parallax/parallax.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/zoom/zoom.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/controller/controller.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/a11y/a11y.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/history/history.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/hash-navigation/hash-navigation.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/autoplay/autoplay.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/thumbs/thumbs.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/free-mode/free-mode.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/grid/grid.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/manipulation/methods/appendSlide.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/manipulation/methods/prependSlide.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/manipulation/methods/addSlide.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/manipulation/methods/removeSlide.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/manipulation/methods/removeAllSlides.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/manipulation/manipulation.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/effect-init.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/effect-target.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/effect-virtual-transition-end.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/effect-fade/effect-fade.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/effect-cube/effect-cube.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/shared/create-shadow.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/effect-flip/effect-flip.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/effect-coverflow/effect-coverflow.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/effect-creative/effect-creative.js","webpack://source-maps/ClientApp/node_modules/.pnpm/swiper@9.4.1/node_modules/swiper/modules/effect-cards/effect-cards.js"],"sourcesContent":["var __spreadArray = (this && this.__spreadArray) || function (to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n};\r\nvar __defProp = Object.defineProperty;\r\nvar __defProps = Object.defineProperties;\r\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\r\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\r\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\r\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\r\nvar __defNormalProp = function (obj, key, value) { return key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value: value }) : obj[key] = value; };\r\nvar __spreadValues = function (a, b) {\r\n    for (var prop in b || (b = {}))\r\n        if (__hasOwnProp.call(b, prop))\r\n            __defNormalProp(a, prop, b[prop]);\r\n    if (__getOwnPropSymbols)\r\n        for (var _i = 0, _c = __getOwnPropSymbols(b); _i < _c.length; _i++) {\r\n            var prop = _c[_i];\r\n            if (__propIsEnum.call(b, prop))\r\n                __defNormalProp(a, prop, b[prop]);\r\n        }\r\n    return a;\r\n};\r\nvar __spreadProps = function (a, b) { return __defProps(a, __getOwnPropDescs(b)); };\r\n// src/query/react/index.ts\r\nimport { coreModule, buildCreateApi } from \"@reduxjs/toolkit/query\";\r\n// src/query/react/buildHooks.ts\r\nimport { createSelector } from \"@reduxjs/toolkit\";\r\nimport { useCallback, useDebugValue, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo2, useRef as useRef3, useState } from \"react\";\r\nimport { QueryStatus, skipToken } from \"@reduxjs/toolkit/query\";\r\nimport { shallowEqual as shallowEqual2 } from \"react-redux\";\r\n// src/query/react/useSerializedStableValue.ts\r\nimport { useEffect, useRef, useMemo } from \"react\";\r\nfunction useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointName) {\r\n    var incoming = useMemo(function () { return ({\r\n        queryArgs: queryArgs,\r\n        serialized: typeof queryArgs == \"object\" ? serialize({ queryArgs: queryArgs, endpointDefinition: endpointDefinition, endpointName: endpointName }) : queryArgs\r\n    }); }, [queryArgs, serialize, endpointDefinition, endpointName]);\r\n    var cache2 = useRef(incoming);\r\n    useEffect(function () {\r\n        if (cache2.current.serialized !== incoming.serialized) {\r\n            cache2.current = incoming;\r\n        }\r\n    }, [incoming]);\r\n    return cache2.current.serialized === incoming.serialized ? cache2.current.queryArgs : queryArgs;\r\n}\r\n// src/query/react/constants.ts\r\nvar UNINITIALIZED_VALUE = Symbol();\r\n// src/query/react/useShallowStableValue.ts\r\nimport { useEffect as useEffect2, useRef as useRef2 } from \"react\";\r\nimport { shallowEqual } from \"react-redux\";\r\nfunction useShallowStableValue(value) {\r\n    var cache2 = useRef2(value);\r\n    useEffect2(function () {\r\n        if (!shallowEqual(cache2.current, value)) {\r\n            cache2.current = value;\r\n        }\r\n    }, [value]);\r\n    return shallowEqual(cache2.current, value) ? cache2.current : value;\r\n}\r\n// src/query/defaultSerializeQueryArgs.ts\r\nimport { isPlainObject } from \"@reduxjs/toolkit\";\r\nvar cache = WeakMap ? new WeakMap() : void 0;\r\nvar defaultSerializeQueryArgs = function (_c) {\r\n    var endpointName = _c.endpointName, queryArgs = _c.queryArgs;\r\n    var serialized = \"\";\r\n    var cached = cache == null ? void 0 : cache.get(queryArgs);\r\n    if (typeof cached === \"string\") {\r\n        serialized = cached;\r\n    }\r\n    else {\r\n        var stringified = JSON.stringify(queryArgs, function (key, value) { return isPlainObject(value) ? Object.keys(value).sort().reduce(function (acc, key2) {\r\n            acc[key2] = value[key2];\r\n            return acc;\r\n        }, {}) : value; });\r\n        if (isPlainObject(queryArgs)) {\r\n            cache == null ? void 0 : cache.set(queryArgs, stringified);\r\n        }\r\n        serialized = stringified;\r\n    }\r\n    return endpointName + \"(\" + serialized + \")\";\r\n};\r\n// src/query/react/buildHooks.ts\r\nvar useIsomorphicLayoutEffect = typeof window !== \"undefined\" && !!window.document && !!window.document.createElement ? useLayoutEffect : useEffect3;\r\nvar defaultMutationStateSelector = function (x) { return x; };\r\nvar noPendingQueryStateSelector = function (selected) {\r\n    if (selected.isUninitialized) {\r\n        return __spreadProps(__spreadValues({}, selected), {\r\n            isUninitialized: false,\r\n            isFetching: true,\r\n            isLoading: selected.data !== void 0 ? false : true,\r\n            status: QueryStatus.pending\r\n        });\r\n    }\r\n    return selected;\r\n};\r\nfunction buildHooks(_c) {\r\n    var api = _c.api, _d = _c.moduleOptions, batch = _d.batch, useDispatch = _d.useDispatch, useSelector = _d.useSelector, useStore = _d.useStore, unstable__sideEffectsInRender = _d.unstable__sideEffectsInRender, serializeQueryArgs = _c.serializeQueryArgs, context = _c.context;\r\n    var usePossiblyImmediateEffect = unstable__sideEffectsInRender ? function (cb) { return cb(); } : useEffect3;\r\n    return { buildQueryHooks: buildQueryHooks, buildMutationHook: buildMutationHook, usePrefetch: usePrefetch };\r\n    function queryStatePreSelector(currentState, lastResult, queryArgs) {\r\n        if ((lastResult == null ? void 0 : lastResult.endpointName) && currentState.isUninitialized) {\r\n            var endpointName = lastResult.endpointName;\r\n            var endpointDefinition = context.endpointDefinitions[endpointName];\r\n            if (serializeQueryArgs({\r\n                queryArgs: lastResult.originalArgs,\r\n                endpointDefinition: endpointDefinition,\r\n                endpointName: endpointName\r\n            }) === serializeQueryArgs({\r\n                queryArgs: queryArgs,\r\n                endpointDefinition: endpointDefinition,\r\n                endpointName: endpointName\r\n            }))\r\n                lastResult = void 0;\r\n        }\r\n        var data = currentState.isSuccess ? currentState.data : lastResult == null ? void 0 : lastResult.data;\r\n        if (data === void 0)\r\n            data = currentState.data;\r\n        var hasData = data !== void 0;\r\n        var isFetching = currentState.isLoading;\r\n        var isLoading = !hasData && isFetching;\r\n        var isSuccess = currentState.isSuccess || isFetching && hasData;\r\n        return __spreadProps(__spreadValues({}, currentState), {\r\n            data: data,\r\n            currentData: currentState.data,\r\n            isFetching: isFetching,\r\n            isLoading: isLoading,\r\n            isSuccess: isSuccess\r\n        });\r\n    }\r\n    function usePrefetch(endpointName, defaultOptions) {\r\n        var dispatch = useDispatch();\r\n        var stableDefaultOptions = useShallowStableValue(defaultOptions);\r\n        return useCallback(function (arg, options) { return dispatch(api.util.prefetch(endpointName, arg, __spreadValues(__spreadValues({}, stableDefaultOptions), options))); }, [endpointName, dispatch, stableDefaultOptions]);\r\n    }\r\n    function buildQueryHooks(name) {\r\n        var useQuerySubscription = function (arg, _c) {\r\n            var _d = _c === void 0 ? {} : _c, refetchOnReconnect = _d.refetchOnReconnect, refetchOnFocus = _d.refetchOnFocus, refetchOnMountOrArgChange = _d.refetchOnMountOrArgChange, _e = _d.skip, skip = _e === void 0 ? false : _e, _f = _d.pollingInterval, pollingInterval = _f === void 0 ? 0 : _f;\r\n            var initiate = api.endpoints[name].initiate;\r\n            var dispatch = useDispatch();\r\n            var stableArg = useStableQueryArgs(skip ? skipToken : arg, defaultSerializeQueryArgs, context.endpointDefinitions[name], name);\r\n            var stableSubscriptionOptions = useShallowStableValue({\r\n                refetchOnReconnect: refetchOnReconnect,\r\n                refetchOnFocus: refetchOnFocus,\r\n                pollingInterval: pollingInterval\r\n            });\r\n            var lastRenderHadSubscription = useRef3(false);\r\n            var promiseRef = useRef3();\r\n            var _g = promiseRef.current || {}, queryCacheKey = _g.queryCacheKey, requestId = _g.requestId;\r\n            var currentRenderHasSubscription = false;\r\n            if (queryCacheKey && requestId) {\r\n                var returnedValue = dispatch(api.internalActions.internal_probeSubscription({\r\n                    queryCacheKey: queryCacheKey,\r\n                    requestId: requestId\r\n                }));\r\n                if (process.env.NODE_ENV !== \"production\") {\r\n                    if (typeof returnedValue !== \"boolean\") {\r\n                        throw new Error(\"Warning: Middleware for RTK-Query API at reducerPath \\\"\" + api.reducerPath + \"\\\" has not been added to the store.\\n    You must add the middleware for RTK-Query to function correctly!\");\r\n                    }\r\n                }\r\n                currentRenderHasSubscription = !!returnedValue;\r\n            }\r\n            var subscriptionRemoved = !currentRenderHasSubscription && lastRenderHadSubscription.current;\r\n            usePossiblyImmediateEffect(function () {\r\n                lastRenderHadSubscription.current = currentRenderHasSubscription;\r\n            });\r\n            usePossiblyImmediateEffect(function () {\r\n                if (subscriptionRemoved) {\r\n                    promiseRef.current = void 0;\r\n                }\r\n            }, [subscriptionRemoved]);\r\n            usePossiblyImmediateEffect(function () {\r\n                var _a;\r\n                var lastPromise = promiseRef.current;\r\n                if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"removeMeOnCompilation\") {\r\n                    console.log(subscriptionRemoved);\r\n                }\r\n                if (stableArg === skipToken) {\r\n                    lastPromise == null ? void 0 : lastPromise.unsubscribe();\r\n                    promiseRef.current = void 0;\r\n                    return;\r\n                }\r\n                var lastSubscriptionOptions = (_a = promiseRef.current) == null ? void 0 : _a.subscriptionOptions;\r\n                if (!lastPromise || lastPromise.arg !== stableArg) {\r\n                    lastPromise == null ? void 0 : lastPromise.unsubscribe();\r\n                    var promise = dispatch(initiate(stableArg, {\r\n                        subscriptionOptions: stableSubscriptionOptions,\r\n                        forceRefetch: refetchOnMountOrArgChange\r\n                    }));\r\n                    promiseRef.current = promise;\r\n                }\r\n                else if (stableSubscriptionOptions !== lastSubscriptionOptions) {\r\n                    lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);\r\n                }\r\n            }, [\r\n                dispatch,\r\n                initiate,\r\n                refetchOnMountOrArgChange,\r\n                stableArg,\r\n                stableSubscriptionOptions,\r\n                subscriptionRemoved\r\n            ]);\r\n            useEffect3(function () {\r\n                return function () {\r\n                    var _a;\r\n                    (_a = promiseRef.current) == null ? void 0 : _a.unsubscribe();\r\n                    promiseRef.current = void 0;\r\n                };\r\n            }, []);\r\n            return useMemo2(function () { return ({\r\n                refetch: function () {\r\n                    var _a;\r\n                    if (!promiseRef.current)\r\n                        throw new Error(\"Cannot refetch a query that has not been started yet.\");\r\n                    return (_a = promiseRef.current) == null ? void 0 : _a.refetch();\r\n                }\r\n            }); }, []);\r\n        };\r\n        var useLazyQuerySubscription = function (_c) {\r\n            var _d = _c === void 0 ? {} : _c, refetchOnReconnect = _d.refetchOnReconnect, refetchOnFocus = _d.refetchOnFocus, _e = _d.pollingInterval, pollingInterval = _e === void 0 ? 0 : _e;\r\n            var initiate = api.endpoints[name].initiate;\r\n            var dispatch = useDispatch();\r\n            var _f = useState(UNINITIALIZED_VALUE), arg = _f[0], setArg = _f[1];\r\n            var promiseRef = useRef3();\r\n            var stableSubscriptionOptions = useShallowStableValue({\r\n                refetchOnReconnect: refetchOnReconnect,\r\n                refetchOnFocus: refetchOnFocus,\r\n                pollingInterval: pollingInterval\r\n            });\r\n            usePossiblyImmediateEffect(function () {\r\n                var _a, _b;\r\n                var lastSubscriptionOptions = (_a = promiseRef.current) == null ? void 0 : _a.subscriptionOptions;\r\n                if (stableSubscriptionOptions !== lastSubscriptionOptions) {\r\n                    (_b = promiseRef.current) == null ? void 0 : _b.updateSubscriptionOptions(stableSubscriptionOptions);\r\n                }\r\n            }, [stableSubscriptionOptions]);\r\n            var subscriptionOptionsRef = useRef3(stableSubscriptionOptions);\r\n            usePossiblyImmediateEffect(function () {\r\n                subscriptionOptionsRef.current = stableSubscriptionOptions;\r\n            }, [stableSubscriptionOptions]);\r\n            var trigger = useCallback(function (arg2, preferCacheValue) {\r\n                if (preferCacheValue === void 0) { preferCacheValue = false; }\r\n                var promise;\r\n                batch(function () {\r\n                    var _a;\r\n                    (_a = promiseRef.current) == null ? void 0 : _a.unsubscribe();\r\n                    promiseRef.current = promise = dispatch(initiate(arg2, {\r\n                        subscriptionOptions: subscriptionOptionsRef.current,\r\n                        forceRefetch: !preferCacheValue\r\n                    }));\r\n                    setArg(arg2);\r\n                });\r\n                return promise;\r\n            }, [dispatch, initiate]);\r\n            useEffect3(function () {\r\n                return function () {\r\n                    var _a;\r\n                    (_a = promiseRef == null ? void 0 : promiseRef.current) == null ? void 0 : _a.unsubscribe();\r\n                };\r\n            }, []);\r\n            useEffect3(function () {\r\n                if (arg !== UNINITIALIZED_VALUE && !promiseRef.current) {\r\n                    trigger(arg, true);\r\n                }\r\n            }, [arg, trigger]);\r\n            return useMemo2(function () { return [trigger, arg]; }, [trigger, arg]);\r\n        };\r\n        var useQueryState = function (arg, _c) {\r\n            var _d = _c === void 0 ? {} : _c, _e = _d.skip, skip = _e === void 0 ? false : _e, selectFromResult = _d.selectFromResult;\r\n            var select = api.endpoints[name].select;\r\n            var stableArg = useStableQueryArgs(skip ? skipToken : arg, serializeQueryArgs, context.endpointDefinitions[name], name);\r\n            var lastValue = useRef3();\r\n            var selectDefaultResult = useMemo2(function () { return createSelector([\r\n                select(stableArg),\r\n                function (_, lastResult) { return lastResult; },\r\n                function (_) { return stableArg; }\r\n            ], queryStatePreSelector); }, [select, stableArg]);\r\n            var querySelector = useMemo2(function () { return selectFromResult ? createSelector([selectDefaultResult], selectFromResult) : selectDefaultResult; }, [selectDefaultResult, selectFromResult]);\r\n            var currentState = useSelector(function (state) { return querySelector(state, lastValue.current); }, shallowEqual2);\r\n            var store = useStore();\r\n            var newLastValue = selectDefaultResult(store.getState(), lastValue.current);\r\n            useIsomorphicLayoutEffect(function () {\r\n                lastValue.current = newLastValue;\r\n            }, [newLastValue]);\r\n            return currentState;\r\n        };\r\n        return {\r\n            useQueryState: useQueryState,\r\n            useQuerySubscription: useQuerySubscription,\r\n            useLazyQuerySubscription: useLazyQuerySubscription,\r\n            useLazyQuery: function (options) {\r\n                var _c = useLazyQuerySubscription(options), trigger = _c[0], arg = _c[1];\r\n                var queryStateResults = useQueryState(arg, __spreadProps(__spreadValues({}, options), {\r\n                    skip: arg === UNINITIALIZED_VALUE\r\n                }));\r\n                var info = useMemo2(function () { return ({ lastArg: arg }); }, [arg]);\r\n                return useMemo2(function () { return [trigger, queryStateResults, info]; }, [trigger, queryStateResults, info]);\r\n            },\r\n            useQuery: function (arg, options) {\r\n                var querySubscriptionResults = useQuerySubscription(arg, options);\r\n                var queryStateResults = useQueryState(arg, __spreadValues({\r\n                    selectFromResult: arg === skipToken || (options == null ? void 0 : options.skip) ? void 0 : noPendingQueryStateSelector\r\n                }, options));\r\n                var data = queryStateResults.data, status = queryStateResults.status, isLoading = queryStateResults.isLoading, isSuccess = queryStateResults.isSuccess, isError = queryStateResults.isError, error = queryStateResults.error;\r\n                useDebugValue({ data: data, status: status, isLoading: isLoading, isSuccess: isSuccess, isError: isError, error: error });\r\n                return useMemo2(function () { return __spreadValues(__spreadValues({}, queryStateResults), querySubscriptionResults); }, [queryStateResults, querySubscriptionResults]);\r\n            }\r\n        };\r\n    }\r\n    function buildMutationHook(name) {\r\n        return function (_c) {\r\n            var _d = _c === void 0 ? {} : _c, _e = _d.selectFromResult, selectFromResult = _e === void 0 ? defaultMutationStateSelector : _e, fixedCacheKey = _d.fixedCacheKey;\r\n            var _f = api.endpoints[name], select = _f.select, initiate = _f.initiate;\r\n            var dispatch = useDispatch();\r\n            var _g = useState(), promise = _g[0], setPromise = _g[1];\r\n            useEffect3(function () { return function () {\r\n                if (!(promise == null ? void 0 : promise.arg.fixedCacheKey)) {\r\n                    promise == null ? void 0 : promise.reset();\r\n                }\r\n            }; }, [promise]);\r\n            var triggerMutation = useCallback(function (arg) {\r\n                var promise2 = dispatch(initiate(arg, { fixedCacheKey: fixedCacheKey }));\r\n                setPromise(promise2);\r\n                return promise2;\r\n            }, [dispatch, initiate, fixedCacheKey]);\r\n            var requestId = (promise || {}).requestId;\r\n            var mutationSelector = useMemo2(function () { return createSelector([select({ fixedCacheKey: fixedCacheKey, requestId: promise == null ? void 0 : promise.requestId })], selectFromResult); }, [select, promise, selectFromResult, fixedCacheKey]);\r\n            var currentState = useSelector(mutationSelector, shallowEqual2);\r\n            var originalArgs = fixedCacheKey == null ? promise == null ? void 0 : promise.arg.originalArgs : void 0;\r\n            var reset = useCallback(function () {\r\n                batch(function () {\r\n                    if (promise) {\r\n                        setPromise(void 0);\r\n                    }\r\n                    if (fixedCacheKey) {\r\n                        dispatch(api.internalActions.removeMutationResult({\r\n                            requestId: requestId,\r\n                            fixedCacheKey: fixedCacheKey\r\n                        }));\r\n                    }\r\n                });\r\n            }, [dispatch, fixedCacheKey, promise, requestId]);\r\n            var endpointName = currentState.endpointName, data = currentState.data, status = currentState.status, isLoading = currentState.isLoading, isSuccess = currentState.isSuccess, isError = currentState.isError, error = currentState.error;\r\n            useDebugValue({\r\n                endpointName: endpointName,\r\n                data: data,\r\n                status: status,\r\n                isLoading: isLoading,\r\n                isSuccess: isSuccess,\r\n                isError: isError,\r\n                error: error\r\n            });\r\n            var finalState = useMemo2(function () { return __spreadProps(__spreadValues({}, currentState), { originalArgs: originalArgs, reset: reset }); }, [currentState, originalArgs, reset]);\r\n            return useMemo2(function () { return [triggerMutation, finalState]; }, [triggerMutation, finalState]);\r\n        };\r\n    }\r\n}\r\n// src/query/endpointDefinitions.ts\r\nvar DefinitionType;\r\n(function (DefinitionType2) {\r\n    DefinitionType2[\"query\"] = \"query\";\r\n    DefinitionType2[\"mutation\"] = \"mutation\";\r\n})(DefinitionType || (DefinitionType = {}));\r\nfunction isQueryDefinition(e) {\r\n    return e.type === DefinitionType.query;\r\n}\r\nfunction isMutationDefinition(e) {\r\n    return e.type === DefinitionType.mutation;\r\n}\r\n// src/query/utils/capitalize.ts\r\nfunction capitalize(str) {\r\n    return str.replace(str[0], str[0].toUpperCase());\r\n}\r\n// src/query/tsHelpers.ts\r\nfunction safeAssign(target) {\r\n    var args = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        args[_i - 1] = arguments[_i];\r\n    }\r\n    Object.assign.apply(Object, __spreadArray([target], args));\r\n}\r\n// src/query/react/module.ts\r\nimport { useDispatch as rrUseDispatch, useSelector as rrUseSelector, useStore as rrUseStore, batch as rrBatch } from \"react-redux\";\r\nvar reactHooksModuleName = /* @__PURE__ */ Symbol();\r\nvar reactHooksModule = function (_c) {\r\n    var _d = _c === void 0 ? {} : _c, _e = _d.batch, batch = _e === void 0 ? rrBatch : _e, _f = _d.useDispatch, useDispatch = _f === void 0 ? rrUseDispatch : _f, _g = _d.useSelector, useSelector = _g === void 0 ? rrUseSelector : _g, _h = _d.useStore, useStore = _h === void 0 ? rrUseStore : _h, _j = _d.unstable__sideEffectsInRender, unstable__sideEffectsInRender = _j === void 0 ? false : _j;\r\n    return ({\r\n        name: reactHooksModuleName,\r\n        init: function (api, _c, context) {\r\n            var serializeQueryArgs = _c.serializeQueryArgs;\r\n            var anyApi = api;\r\n            var _d = buildHooks({\r\n                api: api,\r\n                moduleOptions: {\r\n                    batch: batch,\r\n                    useDispatch: useDispatch,\r\n                    useSelector: useSelector,\r\n                    useStore: useStore,\r\n                    unstable__sideEffectsInRender: unstable__sideEffectsInRender\r\n                },\r\n                serializeQueryArgs: serializeQueryArgs,\r\n                context: context\r\n            }), buildQueryHooks = _d.buildQueryHooks, buildMutationHook = _d.buildMutationHook, usePrefetch = _d.usePrefetch;\r\n            safeAssign(anyApi, { usePrefetch: usePrefetch });\r\n            safeAssign(context, { batch: batch });\r\n            return {\r\n                injectEndpoint: function (endpointName, definition) {\r\n                    if (isQueryDefinition(definition)) {\r\n                        var _c = buildQueryHooks(endpointName), useQuery = _c.useQuery, useLazyQuery = _c.useLazyQuery, useLazyQuerySubscription = _c.useLazyQuerySubscription, useQueryState = _c.useQueryState, useQuerySubscription = _c.useQuerySubscription;\r\n                        safeAssign(anyApi.endpoints[endpointName], {\r\n                            useQuery: useQuery,\r\n                            useLazyQuery: useLazyQuery,\r\n                            useLazyQuerySubscription: useLazyQuerySubscription,\r\n                            useQueryState: useQueryState,\r\n                            useQuerySubscription: useQuerySubscription\r\n                        });\r\n                        api[\"use\" + capitalize(endpointName) + \"Query\"] = useQuery;\r\n                        api[\"useLazy\" + capitalize(endpointName) + \"Query\"] = useLazyQuery;\r\n                    }\r\n                    else if (isMutationDefinition(definition)) {\r\n                        var useMutation = buildMutationHook(endpointName);\r\n                        safeAssign(anyApi.endpoints[endpointName], {\r\n                            useMutation: useMutation\r\n                        });\r\n                        api[\"use\" + capitalize(endpointName) + \"Mutation\"] = useMutation;\r\n                    }\r\n                }\r\n            };\r\n        }\r\n    });\r\n};\r\n// src/query/react/index.ts\r\nexport * from \"@reduxjs/toolkit/query\";\r\n// src/query/react/ApiProvider.tsx\r\nimport { configureStore } from \"@reduxjs/toolkit\";\r\nimport { useEffect as useEffect4 } from \"react\";\r\nimport React from \"react\";\r\nimport { Provider } from \"react-redux\";\r\nimport { setupListeners } from \"@reduxjs/toolkit/query\";\r\nfunction ApiProvider(props) {\r\n    var store = React.useState(function () {\r\n        var _c;\r\n        return configureStore({\r\n            reducer: (_c = {},\r\n                _c[props.api.reducerPath] = props.api.reducer,\r\n                _c),\r\n            middleware: function (gDM) { return gDM().concat(props.api.middleware); }\r\n        });\r\n    })[0];\r\n    useEffect4(function () { return props.setupListeners === false ? void 0 : setupListeners(store.dispatch, props.setupListeners); }, [props.setupListeners, store.dispatch]);\r\n    return /* @__PURE__ */ React.createElement(Provider, {\r\n        store: store,\r\n        context: props.context\r\n    }, props.children);\r\n}\r\n// src/query/react/index.ts\r\nvar createApi = /* @__PURE__ */ buildCreateApi(coreModule(), reactHooksModule());\r\nexport { ApiProvider, createApi, reactHooksModule, reactHooksModuleName };\r\n//# sourceMappingURL=rtk-query-react.esm.js.map","var __generator = (this && this.__generator) || function (thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n};\r\nvar __spreadArray = (this && this.__spreadArray) || function (to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n};\r\nvar __defProp = Object.defineProperty;\r\nvar __defProps = Object.defineProperties;\r\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\r\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\r\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\r\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\r\nvar __defNormalProp = function (obj, key, value) { return key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value: value }) : obj[key] = value; };\r\nvar __spreadValues = function (a, b) {\r\n    for (var prop in b || (b = {}))\r\n        if (__hasOwnProp.call(b, prop))\r\n            __defNormalProp(a, prop, b[prop]);\r\n    if (__getOwnPropSymbols)\r\n        for (var _j = 0, _k = __getOwnPropSymbols(b); _j < _k.length; _j++) {\r\n            var prop = _k[_j];\r\n            if (__propIsEnum.call(b, prop))\r\n                __defNormalProp(a, prop, b[prop]);\r\n        }\r\n    return a;\r\n};\r\nvar __spreadProps = function (a, b) { return __defProps(a, __getOwnPropDescs(b)); };\r\nvar __objRest = function (source, exclude) {\r\n    var target = {};\r\n    for (var prop in source)\r\n        if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\r\n            target[prop] = source[prop];\r\n    if (source != null && __getOwnPropSymbols)\r\n        for (var _j = 0, _k = __getOwnPropSymbols(source); _j < _k.length; _j++) {\r\n            var prop = _k[_j];\r\n            if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\r\n                target[prop] = source[prop];\r\n        }\r\n    return target;\r\n};\r\nvar __async = function (__this, __arguments, generator) {\r\n    return new Promise(function (resolve, reject) {\r\n        var fulfilled = function (value) {\r\n            try {\r\n                step(generator.next(value));\r\n            }\r\n            catch (e) {\r\n                reject(e);\r\n            }\r\n        };\r\n        var rejected = function (value) {\r\n            try {\r\n                step(generator.throw(value));\r\n            }\r\n            catch (e) {\r\n                reject(e);\r\n            }\r\n        };\r\n        var step = function (x) { return x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); };\r\n        step((generator = generator.apply(__this, __arguments)).next());\r\n    });\r\n};\r\n// src/query/core/apiState.ts\r\nvar QueryStatus;\r\n(function (QueryStatus2) {\r\n    QueryStatus2[\"uninitialized\"] = \"uninitialized\";\r\n    QueryStatus2[\"pending\"] = \"pending\";\r\n    QueryStatus2[\"fulfilled\"] = \"fulfilled\";\r\n    QueryStatus2[\"rejected\"] = \"rejected\";\r\n})(QueryStatus || (QueryStatus = {}));\r\nfunction getRequestStatusFlags(status) {\r\n    return {\r\n        status: status,\r\n        isUninitialized: status === QueryStatus.uninitialized,\r\n        isLoading: status === QueryStatus.pending,\r\n        isSuccess: status === QueryStatus.fulfilled,\r\n        isError: status === QueryStatus.rejected\r\n    };\r\n}\r\n// src/query/utils/isAbsoluteUrl.ts\r\nfunction isAbsoluteUrl(url) {\r\n    return new RegExp(\"(^|:)//\").test(url);\r\n}\r\n// src/query/utils/joinUrls.ts\r\nvar withoutTrailingSlash = function (url) { return url.replace(/\\/$/, \"\"); };\r\nvar withoutLeadingSlash = function (url) { return url.replace(/^\\//, \"\"); };\r\nfunction joinUrls(base, url) {\r\n    if (!base) {\r\n        return url;\r\n    }\r\n    if (!url) {\r\n        return base;\r\n    }\r\n    if (isAbsoluteUrl(url)) {\r\n        return url;\r\n    }\r\n    var delimiter = base.endsWith(\"/\") || !url.startsWith(\"?\") ? \"/\" : \"\";\r\n    base = withoutTrailingSlash(base);\r\n    url = withoutLeadingSlash(url);\r\n    return \"\" + base + delimiter + url;\r\n}\r\n// src/query/utils/flatten.ts\r\nvar flatten = function (arr) { return [].concat.apply([], arr); };\r\n// src/query/utils/isOnline.ts\r\nfunction isOnline() {\r\n    return typeof navigator === \"undefined\" ? true : navigator.onLine === void 0 ? true : navigator.onLine;\r\n}\r\n// src/query/utils/isDocumentVisible.ts\r\nfunction isDocumentVisible() {\r\n    if (typeof document === \"undefined\") {\r\n        return true;\r\n    }\r\n    return document.visibilityState !== \"hidden\";\r\n}\r\n// src/query/utils/copyWithStructuralSharing.ts\r\nimport { isPlainObject as _iPO } from \"@reduxjs/toolkit\";\r\nvar isPlainObject = _iPO;\r\nfunction copyWithStructuralSharing(oldObj, newObj) {\r\n    if (oldObj === newObj || !(isPlainObject(oldObj) && isPlainObject(newObj) || Array.isArray(oldObj) && Array.isArray(newObj))) {\r\n        return newObj;\r\n    }\r\n    var newKeys = Object.keys(newObj);\r\n    var oldKeys = Object.keys(oldObj);\r\n    var isSameObject = newKeys.length === oldKeys.length;\r\n    var mergeObj = Array.isArray(newObj) ? [] : {};\r\n    for (var _j = 0, newKeys_1 = newKeys; _j < newKeys_1.length; _j++) {\r\n        var key = newKeys_1[_j];\r\n        mergeObj[key] = copyWithStructuralSharing(oldObj[key], newObj[key]);\r\n        if (isSameObject)\r\n            isSameObject = oldObj[key] === mergeObj[key];\r\n    }\r\n    return isSameObject ? oldObj : mergeObj;\r\n}\r\n// src/query/fetchBaseQuery.ts\r\nimport { isPlainObject as isPlainObject2 } from \"@reduxjs/toolkit\";\r\nvar defaultFetchFn = function () {\r\n    var args = [];\r\n    for (var _j = 0; _j < arguments.length; _j++) {\r\n        args[_j] = arguments[_j];\r\n    }\r\n    return fetch.apply(void 0, args);\r\n};\r\nvar defaultValidateStatus = function (response) { return response.status >= 200 && response.status <= 299; };\r\nvar defaultIsJsonContentType = function (headers) { return /ion\\/(vnd\\.api\\+)?json/.test(headers.get(\"content-type\") || \"\"); };\r\nfunction stripUndefined(obj) {\r\n    if (!isPlainObject2(obj)) {\r\n        return obj;\r\n    }\r\n    var copy = __spreadValues({}, obj);\r\n    for (var _j = 0, _k = Object.entries(copy); _j < _k.length; _j++) {\r\n        var _l = _k[_j], k = _l[0], v = _l[1];\r\n        if (v === void 0)\r\n            delete copy[k];\r\n    }\r\n    return copy;\r\n}\r\nfunction fetchBaseQuery(_a) {\r\n    var _this = this;\r\n    if (_a === void 0) { _a = {}; }\r\n    var _b = _a, baseUrl = _b.baseUrl, _j = _b.prepareHeaders, prepareHeaders = _j === void 0 ? function (x) { return x; } : _j, _k = _b.fetchFn, fetchFn = _k === void 0 ? defaultFetchFn : _k, paramsSerializer = _b.paramsSerializer, _l = _b.isJsonContentType, isJsonContentType = _l === void 0 ? defaultIsJsonContentType : _l, _m = _b.jsonContentType, jsonContentType = _m === void 0 ? \"application/json\" : _m, jsonReplacer = _b.jsonReplacer, defaultTimeout = _b.timeout, globalResponseHandler = _b.responseHandler, globalValidateStatus = _b.validateStatus, baseFetchOptions = __objRest(_b, [\r\n        \"baseUrl\",\r\n        \"prepareHeaders\",\r\n        \"fetchFn\",\r\n        \"paramsSerializer\",\r\n        \"isJsonContentType\",\r\n        \"jsonContentType\",\r\n        \"jsonReplacer\",\r\n        \"timeout\",\r\n        \"responseHandler\",\r\n        \"validateStatus\"\r\n    ]);\r\n    if (typeof fetch === \"undefined\" && fetchFn === defaultFetchFn) {\r\n        console.warn(\"Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments.\");\r\n    }\r\n    return function (arg, api) { return __async(_this, null, function () {\r\n        var signal, getState, extra, endpoint, forced, type, meta, _a2, url, _j, headers, _k, params, _l, responseHandler, _m, validateStatus, _o, timeout, rest, config, _p, isJsonifiable, divider, query, request, requestClone, response, timedOut, timeoutId, e_1, responseClone, resultData, responseText, handleResponseError_1, e_2;\r\n        return __generator(this, function (_q) {\r\n            switch (_q.label) {\r\n                case 0:\r\n                    signal = api.signal, getState = api.getState, extra = api.extra, endpoint = api.endpoint, forced = api.forced, type = api.type;\r\n                    _a2 = typeof arg == \"string\" ? { url: arg } : arg, url = _a2.url, _j = _a2.headers, headers = _j === void 0 ? new Headers(baseFetchOptions.headers) : _j, _k = _a2.params, params = _k === void 0 ? void 0 : _k, _l = _a2.responseHandler, responseHandler = _l === void 0 ? globalResponseHandler != null ? globalResponseHandler : \"json\" : _l, _m = _a2.validateStatus, validateStatus = _m === void 0 ? globalValidateStatus != null ? globalValidateStatus : defaultValidateStatus : _m, _o = _a2.timeout, timeout = _o === void 0 ? defaultTimeout : _o, rest = __objRest(_a2, [\r\n                        \"url\",\r\n                        \"headers\",\r\n                        \"params\",\r\n                        \"responseHandler\",\r\n                        \"validateStatus\",\r\n                        \"timeout\"\r\n                    ]);\r\n                    config = __spreadValues(__spreadProps(__spreadValues({}, baseFetchOptions), {\r\n                        signal: signal\r\n                    }), rest);\r\n                    headers = new Headers(stripUndefined(headers));\r\n                    _p = config;\r\n                    return [4 /*yield*/, prepareHeaders(headers, {\r\n                            getState: getState,\r\n                            extra: extra,\r\n                            endpoint: endpoint,\r\n                            forced: forced,\r\n                            type: type\r\n                        })];\r\n                case 1:\r\n                    _p.headers = (_q.sent()) || headers;\r\n                    isJsonifiable = function (body) { return typeof body === \"object\" && (isPlainObject2(body) || Array.isArray(body) || typeof body.toJSON === \"function\"); };\r\n                    if (!config.headers.has(\"content-type\") && isJsonifiable(config.body)) {\r\n                        config.headers.set(\"content-type\", jsonContentType);\r\n                    }\r\n                    if (isJsonifiable(config.body) && isJsonContentType(config.headers)) {\r\n                        config.body = JSON.stringify(config.body, jsonReplacer);\r\n                    }\r\n                    if (params) {\r\n                        divider = ~url.indexOf(\"?\") ? \"&\" : \"?\";\r\n                        query = paramsSerializer ? paramsSerializer(params) : new URLSearchParams(stripUndefined(params));\r\n                        url += divider + query;\r\n                    }\r\n                    url = joinUrls(baseUrl, url);\r\n                    request = new Request(url, config);\r\n                    requestClone = new Request(url, config);\r\n                    meta = { request: requestClone };\r\n                    timedOut = false, timeoutId = timeout && setTimeout(function () {\r\n                        timedOut = true;\r\n                        api.abort();\r\n                    }, timeout);\r\n                    _q.label = 2;\r\n                case 2:\r\n                    _q.trys.push([2, 4, 5, 6]);\r\n                    return [4 /*yield*/, fetchFn(request)];\r\n                case 3:\r\n                    response = _q.sent();\r\n                    return [3 /*break*/, 6];\r\n                case 4:\r\n                    e_1 = _q.sent();\r\n                    return [2 /*return*/, {\r\n                            error: {\r\n                                status: timedOut ? \"TIMEOUT_ERROR\" : \"FETCH_ERROR\",\r\n                                error: String(e_1)\r\n                            },\r\n                            meta: meta\r\n                        }];\r\n                case 5:\r\n                    if (timeoutId)\r\n                        clearTimeout(timeoutId);\r\n                    return [7 /*endfinally*/];\r\n                case 6:\r\n                    responseClone = response.clone();\r\n                    meta.response = responseClone;\r\n                    responseText = \"\";\r\n                    _q.label = 7;\r\n                case 7:\r\n                    _q.trys.push([7, 9, , 10]);\r\n                    return [4 /*yield*/, Promise.all([\r\n                            handleResponse(response, responseHandler).then(function (r) { return resultData = r; }, function (e) { return handleResponseError_1 = e; }),\r\n                            responseClone.text().then(function (r) { return responseText = r; }, function () {\r\n                            })\r\n                        ])];\r\n                case 8:\r\n                    _q.sent();\r\n                    if (handleResponseError_1)\r\n                        throw handleResponseError_1;\r\n                    return [3 /*break*/, 10];\r\n                case 9:\r\n                    e_2 = _q.sent();\r\n                    return [2 /*return*/, {\r\n                            error: {\r\n                                status: \"PARSING_ERROR\",\r\n                                originalStatus: response.status,\r\n                                data: responseText,\r\n                                error: String(e_2)\r\n                            },\r\n                            meta: meta\r\n                        }];\r\n                case 10: return [2 /*return*/, validateStatus(response, resultData) ? {\r\n                        data: resultData,\r\n                        meta: meta\r\n                    } : {\r\n                        error: {\r\n                            status: response.status,\r\n                            data: resultData\r\n                        },\r\n                        meta: meta\r\n                    }];\r\n            }\r\n        });\r\n    }); };\r\n    function handleResponse(response, responseHandler) {\r\n        return __async(this, null, function () {\r\n            var text;\r\n            return __generator(this, function (_j) {\r\n                switch (_j.label) {\r\n                    case 0:\r\n                        if (typeof responseHandler === \"function\") {\r\n                            return [2 /*return*/, responseHandler(response)];\r\n                        }\r\n                        if (responseHandler === \"content-type\") {\r\n                            responseHandler = isJsonContentType(response.headers) ? \"json\" : \"text\";\r\n                        }\r\n                        if (!(responseHandler === \"json\")) return [3 /*break*/, 2];\r\n                        return [4 /*yield*/, response.text()];\r\n                    case 1:\r\n                        text = _j.sent();\r\n                        return [2 /*return*/, text.length ? JSON.parse(text) : null];\r\n                    case 2: return [2 /*return*/, response.text()];\r\n                }\r\n            });\r\n        });\r\n    }\r\n}\r\n// src/query/HandledError.ts\r\nvar HandledError = /** @class */ (function () {\r\n    function HandledError(value, meta) {\r\n        if (meta === void 0) { meta = void 0; }\r\n        this.value = value;\r\n        this.meta = meta;\r\n    }\r\n    return HandledError;\r\n}());\r\n// src/query/retry.ts\r\nfunction defaultBackoff(attempt, maxRetries) {\r\n    if (attempt === void 0) { attempt = 0; }\r\n    if (maxRetries === void 0) { maxRetries = 5; }\r\n    return __async(this, null, function () {\r\n        var attempts, timeout;\r\n        return __generator(this, function (_j) {\r\n            switch (_j.label) {\r\n                case 0:\r\n                    attempts = Math.min(attempt, maxRetries);\r\n                    timeout = ~~((Math.random() + 0.4) * (300 << attempts));\r\n                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(function (res) { return resolve(res); }, timeout); })];\r\n                case 1:\r\n                    _j.sent();\r\n                    return [2 /*return*/];\r\n            }\r\n        });\r\n    });\r\n}\r\nfunction fail(e) {\r\n    throw Object.assign(new HandledError({ error: e }), {\r\n        throwImmediately: true\r\n    });\r\n}\r\nvar EMPTY_OPTIONS = {};\r\nvar retryWithBackoff = function (baseQuery, defaultOptions) { return function (args, api, extraOptions) { return __async(void 0, null, function () {\r\n    var possibleMaxRetries, maxRetries, defaultRetryCondition, options, retry2, result, e_3;\r\n    return __generator(this, function (_j) {\r\n        switch (_j.label) {\r\n            case 0:\r\n                possibleMaxRetries = [\r\n                    5,\r\n                    (defaultOptions || EMPTY_OPTIONS).maxRetries,\r\n                    (extraOptions || EMPTY_OPTIONS).maxRetries\r\n                ].filter(function (x) { return x !== void 0; });\r\n                maxRetries = possibleMaxRetries.slice(-1)[0];\r\n                defaultRetryCondition = function (_, __, _j) {\r\n                    var attempt = _j.attempt;\r\n                    return attempt <= maxRetries;\r\n                };\r\n                options = __spreadValues(__spreadValues({\r\n                    maxRetries: maxRetries,\r\n                    backoff: defaultBackoff,\r\n                    retryCondition: defaultRetryCondition\r\n                }, defaultOptions), extraOptions);\r\n                retry2 = 0;\r\n                _j.label = 1;\r\n            case 1:\r\n                if (!true) return [3 /*break*/, 7];\r\n                _j.label = 2;\r\n            case 2:\r\n                _j.trys.push([2, 4, , 6]);\r\n                return [4 /*yield*/, baseQuery(args, api, extraOptions)];\r\n            case 3:\r\n                result = _j.sent();\r\n                if (result.error) {\r\n                    throw new HandledError(result);\r\n                }\r\n                return [2 /*return*/, result];\r\n            case 4:\r\n                e_3 = _j.sent();\r\n                retry2++;\r\n                if (e_3.throwImmediately) {\r\n                    if (e_3 instanceof HandledError) {\r\n                        return [2 /*return*/, e_3.value];\r\n                    }\r\n                    throw e_3;\r\n                }\r\n                if (e_3 instanceof HandledError && !options.retryCondition(e_3.value.error, args, {\r\n                    attempt: retry2,\r\n                    baseQueryApi: api,\r\n                    extraOptions: extraOptions\r\n                })) {\r\n                    return [2 /*return*/, e_3.value];\r\n                }\r\n                return [4 /*yield*/, options.backoff(retry2, options.maxRetries)];\r\n            case 5:\r\n                _j.sent();\r\n                return [3 /*break*/, 6];\r\n            case 6: return [3 /*break*/, 1];\r\n            case 7: return [2 /*return*/];\r\n        }\r\n    });\r\n}); }; };\r\nvar retry = /* @__PURE__ */ Object.assign(retryWithBackoff, { fail: fail });\r\n// src/query/core/setupListeners.ts\r\nimport { createAction } from \"@reduxjs/toolkit\";\r\nvar onFocus = /* @__PURE__ */ createAction(\"__rtkq/focused\");\r\nvar onFocusLost = /* @__PURE__ */ createAction(\"__rtkq/unfocused\");\r\nvar onOnline = /* @__PURE__ */ createAction(\"__rtkq/online\");\r\nvar onOffline = /* @__PURE__ */ createAction(\"__rtkq/offline\");\r\nvar initialized = false;\r\nfunction setupListeners(dispatch, customHandler) {\r\n    function defaultHandler() {\r\n        var handleFocus = function () { return dispatch(onFocus()); };\r\n        var handleFocusLost = function () { return dispatch(onFocusLost()); };\r\n        var handleOnline = function () { return dispatch(onOnline()); };\r\n        var handleOffline = function () { return dispatch(onOffline()); };\r\n        var handleVisibilityChange = function () {\r\n            if (window.document.visibilityState === \"visible\") {\r\n                handleFocus();\r\n            }\r\n            else {\r\n                handleFocusLost();\r\n            }\r\n        };\r\n        if (!initialized) {\r\n            if (typeof window !== \"undefined\" && window.addEventListener) {\r\n                window.addEventListener(\"visibilitychange\", handleVisibilityChange, false);\r\n                window.addEventListener(\"focus\", handleFocus, false);\r\n                window.addEventListener(\"online\", handleOnline, false);\r\n                window.addEventListener(\"offline\", handleOffline, false);\r\n                initialized = true;\r\n            }\r\n        }\r\n        var unsubscribe = function () {\r\n            window.removeEventListener(\"focus\", handleFocus);\r\n            window.removeEventListener(\"visibilitychange\", handleVisibilityChange);\r\n            window.removeEventListener(\"online\", handleOnline);\r\n            window.removeEventListener(\"offline\", handleOffline);\r\n            initialized = false;\r\n        };\r\n        return unsubscribe;\r\n    }\r\n    return customHandler ? customHandler(dispatch, { onFocus: onFocus, onFocusLost: onFocusLost, onOffline: onOffline, onOnline: onOnline }) : defaultHandler();\r\n}\r\n// src/query/core/buildSelectors.ts\r\nimport { createNextState as createNextState2, createSelector } from \"@reduxjs/toolkit\";\r\n// src/query/endpointDefinitions.ts\r\nvar DefinitionType;\r\n(function (DefinitionType2) {\r\n    DefinitionType2[\"query\"] = \"query\";\r\n    DefinitionType2[\"mutation\"] = \"mutation\";\r\n})(DefinitionType || (DefinitionType = {}));\r\nfunction isQueryDefinition(e) {\r\n    return e.type === DefinitionType.query;\r\n}\r\nfunction isMutationDefinition(e) {\r\n    return e.type === DefinitionType.mutation;\r\n}\r\nfunction calculateProvidedBy(description, result, error, queryArg, meta, assertTagTypes) {\r\n    if (isFunction(description)) {\r\n        return description(result, error, queryArg, meta).map(expandTagDescription).map(assertTagTypes);\r\n    }\r\n    if (Array.isArray(description)) {\r\n        return description.map(expandTagDescription).map(assertTagTypes);\r\n    }\r\n    return [];\r\n}\r\nfunction isFunction(t) {\r\n    return typeof t === \"function\";\r\n}\r\nfunction expandTagDescription(description) {\r\n    return typeof description === \"string\" ? { type: description } : description;\r\n}\r\n// src/query/core/buildSlice.ts\r\nimport { combineReducers, createAction as createAction2, createSlice, isAnyOf, isFulfilled as isFulfilled2, isRejectedWithValue as isRejectedWithValue2, createNextState, prepareAutoBatched } from \"@reduxjs/toolkit\";\r\n// src/query/utils/isNotNullish.ts\r\nfunction isNotNullish(v) {\r\n    return v != null;\r\n}\r\n// src/query/core/buildInitiate.ts\r\nvar forceQueryFnSymbol = Symbol(\"forceQueryFn\");\r\nvar isUpsertQuery = function (arg) { return typeof arg[forceQueryFnSymbol] === \"function\"; };\r\nfunction buildInitiate(_j) {\r\n    var serializeQueryArgs = _j.serializeQueryArgs, queryThunk = _j.queryThunk, mutationThunk = _j.mutationThunk, api = _j.api, context = _j.context;\r\n    var runningQueries = new Map();\r\n    var runningMutations = new Map();\r\n    var _k = api.internalActions, unsubscribeQueryResult = _k.unsubscribeQueryResult, removeMutationResult = _k.removeMutationResult, updateSubscriptionOptions = _k.updateSubscriptionOptions;\r\n    return {\r\n        buildInitiateQuery: buildInitiateQuery,\r\n        buildInitiateMutation: buildInitiateMutation,\r\n        getRunningQueryThunk: getRunningQueryThunk,\r\n        getRunningMutationThunk: getRunningMutationThunk,\r\n        getRunningQueriesThunk: getRunningQueriesThunk,\r\n        getRunningMutationsThunk: getRunningMutationsThunk,\r\n        getRunningOperationPromises: getRunningOperationPromises,\r\n        removalWarning: removalWarning\r\n    };\r\n    function removalWarning() {\r\n        throw new Error(\"This method had to be removed due to a conceptual bug in RTK.\\n       Please see https://github.com/reduxjs/redux-toolkit/pull/2481 for details.\\n       See https://redux-toolkit.js.org/rtk-query/usage/server-side-rendering for new guidance on SSR.\");\r\n    }\r\n    function getRunningOperationPromises() {\r\n        if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\r\n            removalWarning();\r\n        }\r\n        else {\r\n            var extract = function (v) { return Array.from(v.values()).flatMap(function (queriesForStore) { return queriesForStore ? Object.values(queriesForStore) : []; }); };\r\n            return __spreadArray(__spreadArray([], extract(runningQueries)), extract(runningMutations)).filter(isNotNullish);\r\n        }\r\n    }\r\n    function getRunningQueryThunk(endpointName, queryArgs) {\r\n        return function (dispatch) {\r\n            var _a;\r\n            var endpointDefinition = context.endpointDefinitions[endpointName];\r\n            var queryCacheKey = serializeQueryArgs({\r\n                queryArgs: queryArgs,\r\n                endpointDefinition: endpointDefinition,\r\n                endpointName: endpointName\r\n            });\r\n            return (_a = runningQueries.get(dispatch)) == null ? void 0 : _a[queryCacheKey];\r\n        };\r\n    }\r\n    function getRunningMutationThunk(_endpointName, fixedCacheKeyOrRequestId) {\r\n        return function (dispatch) {\r\n            var _a;\r\n            return (_a = runningMutations.get(dispatch)) == null ? void 0 : _a[fixedCacheKeyOrRequestId];\r\n        };\r\n    }\r\n    function getRunningQueriesThunk() {\r\n        return function (dispatch) { return Object.values(runningQueries.get(dispatch) || {}).filter(isNotNullish); };\r\n    }\r\n    function getRunningMutationsThunk() {\r\n        return function (dispatch) { return Object.values(runningMutations.get(dispatch) || {}).filter(isNotNullish); };\r\n    }\r\n    function middlewareWarning(dispatch) {\r\n        if (process.env.NODE_ENV !== \"production\") {\r\n            if (middlewareWarning.triggered)\r\n                return;\r\n            var registered = dispatch(api.internalActions.internal_probeSubscription({\r\n                queryCacheKey: \"DOES_NOT_EXIST\",\r\n                requestId: \"DUMMY_REQUEST_ID\"\r\n            }));\r\n            middlewareWarning.triggered = true;\r\n            if (typeof registered !== \"boolean\") {\r\n                throw new Error(\"Warning: Middleware for RTK-Query API at reducerPath \\\"\" + api.reducerPath + \"\\\" has not been added to the store.\\nYou must add the middleware for RTK-Query to function correctly!\");\r\n            }\r\n        }\r\n    }\r\n    function buildInitiateQuery(endpointName, endpointDefinition) {\r\n        var queryAction = function (arg, _j) {\r\n            var _k = _j === void 0 ? {} : _j, _l = _k.subscribe, subscribe = _l === void 0 ? true : _l, forceRefetch = _k.forceRefetch, subscriptionOptions = _k.subscriptionOptions, _m = forceQueryFnSymbol, forceQueryFn = _k[_m];\r\n            return function (dispatch, getState) {\r\n                var _j;\r\n                var _a;\r\n                var queryCacheKey = serializeQueryArgs({\r\n                    queryArgs: arg,\r\n                    endpointDefinition: endpointDefinition,\r\n                    endpointName: endpointName\r\n                });\r\n                var thunk = queryThunk((_j = {\r\n                        type: \"query\",\r\n                        subscribe: subscribe,\r\n                        forceRefetch: forceRefetch,\r\n                        subscriptionOptions: subscriptionOptions,\r\n                        endpointName: endpointName,\r\n                        originalArgs: arg,\r\n                        queryCacheKey: queryCacheKey\r\n                    },\r\n                    _j[forceQueryFnSymbol] = forceQueryFn,\r\n                    _j));\r\n                var selector = api.endpoints[endpointName].select(arg);\r\n                var thunkResult = dispatch(thunk);\r\n                var stateAfter = selector(getState());\r\n                middlewareWarning(dispatch);\r\n                var requestId = thunkResult.requestId, abort = thunkResult.abort;\r\n                var skippedSynchronously = stateAfter.requestId !== requestId;\r\n                var runningQuery = (_a = runningQueries.get(dispatch)) == null ? void 0 : _a[queryCacheKey];\r\n                var selectFromState = function () { return selector(getState()); };\r\n                var statePromise = Object.assign(forceQueryFn ? thunkResult.then(selectFromState) : skippedSynchronously && !runningQuery ? Promise.resolve(stateAfter) : Promise.all([runningQuery, thunkResult]).then(selectFromState), {\r\n                    arg: arg,\r\n                    requestId: requestId,\r\n                    subscriptionOptions: subscriptionOptions,\r\n                    queryCacheKey: queryCacheKey,\r\n                    abort: abort,\r\n                    unwrap: function () {\r\n                        return __async(this, null, function () {\r\n                            var result;\r\n                            return __generator(this, function (_j) {\r\n                                switch (_j.label) {\r\n                                    case 0: return [4 /*yield*/, statePromise];\r\n                                    case 1:\r\n                                        result = _j.sent();\r\n                                        if (result.isError) {\r\n                                            throw result.error;\r\n                                        }\r\n                                        return [2 /*return*/, result.data];\r\n                                }\r\n                            });\r\n                        });\r\n                    },\r\n                    refetch: function () { return dispatch(queryAction(arg, { subscribe: false, forceRefetch: true })); },\r\n                    unsubscribe: function () {\r\n                        if (subscribe)\r\n                            dispatch(unsubscribeQueryResult({\r\n                                queryCacheKey: queryCacheKey,\r\n                                requestId: requestId\r\n                            }));\r\n                    },\r\n                    updateSubscriptionOptions: function (options) {\r\n                        statePromise.subscriptionOptions = options;\r\n                        dispatch(updateSubscriptionOptions({\r\n                            endpointName: endpointName,\r\n                            requestId: requestId,\r\n                            queryCacheKey: queryCacheKey,\r\n                            options: options\r\n                        }));\r\n                    }\r\n                });\r\n                if (!runningQuery && !skippedSynchronously && !forceQueryFn) {\r\n                    var running_1 = runningQueries.get(dispatch) || {};\r\n                    running_1[queryCacheKey] = statePromise;\r\n                    runningQueries.set(dispatch, running_1);\r\n                    statePromise.then(function () {\r\n                        delete running_1[queryCacheKey];\r\n                        if (!Object.keys(running_1).length) {\r\n                            runningQueries.delete(dispatch);\r\n                        }\r\n                    });\r\n                }\r\n                return statePromise;\r\n            };\r\n        };\r\n        return queryAction;\r\n    }\r\n    function buildInitiateMutation(endpointName) {\r\n        return function (arg, _j) {\r\n            var _k = _j === void 0 ? {} : _j, _l = _k.track, track = _l === void 0 ? true : _l, fixedCacheKey = _k.fixedCacheKey;\r\n            return function (dispatch, getState) {\r\n                var thunk = mutationThunk({\r\n                    type: \"mutation\",\r\n                    endpointName: endpointName,\r\n                    originalArgs: arg,\r\n                    track: track,\r\n                    fixedCacheKey: fixedCacheKey\r\n                });\r\n                var thunkResult = dispatch(thunk);\r\n                middlewareWarning(dispatch);\r\n                var requestId = thunkResult.requestId, abort = thunkResult.abort, unwrap = thunkResult.unwrap;\r\n                var returnValuePromise = thunkResult.unwrap().then(function (data) { return ({ data: data }); }).catch(function (error) { return ({ error: error }); });\r\n                var reset = function () {\r\n                    dispatch(removeMutationResult({ requestId: requestId, fixedCacheKey: fixedCacheKey }));\r\n                };\r\n                var ret = Object.assign(returnValuePromise, {\r\n                    arg: thunkResult.arg,\r\n                    requestId: requestId,\r\n                    abort: abort,\r\n                    unwrap: unwrap,\r\n                    unsubscribe: reset,\r\n                    reset: reset\r\n                });\r\n                var running = runningMutations.get(dispatch) || {};\r\n                runningMutations.set(dispatch, running);\r\n                running[requestId] = ret;\r\n                ret.then(function () {\r\n                    delete running[requestId];\r\n                    if (!Object.keys(running).length) {\r\n                        runningMutations.delete(dispatch);\r\n                    }\r\n                });\r\n                if (fixedCacheKey) {\r\n                    running[fixedCacheKey] = ret;\r\n                    ret.then(function () {\r\n                        if (running[fixedCacheKey] === ret) {\r\n                            delete running[fixedCacheKey];\r\n                            if (!Object.keys(running).length) {\r\n                                runningMutations.delete(dispatch);\r\n                            }\r\n                        }\r\n                    });\r\n                }\r\n                return ret;\r\n            };\r\n        };\r\n    }\r\n}\r\n// src/query/core/buildThunks.ts\r\nimport { isAllOf, isFulfilled, isPending, isRejected, isRejectedWithValue } from \"@reduxjs/toolkit\";\r\nimport { isDraftable, produceWithPatches } from \"immer\";\r\nimport { createAsyncThunk, SHOULD_AUTOBATCH } from \"@reduxjs/toolkit\";\r\nfunction defaultTransformResponse(baseQueryReturnValue) {\r\n    return baseQueryReturnValue;\r\n}\r\nfunction buildThunks(_j) {\r\n    var _this = this;\r\n    var reducerPath = _j.reducerPath, baseQuery = _j.baseQuery, endpointDefinitions = _j.context.endpointDefinitions, serializeQueryArgs = _j.serializeQueryArgs, api = _j.api, assertTagType = _j.assertTagType;\r\n    var patchQueryData = function (endpointName, args, patches, updateProvided) { return function (dispatch, getState) {\r\n        var endpointDefinition = endpointDefinitions[endpointName];\r\n        var queryCacheKey = serializeQueryArgs({\r\n            queryArgs: args,\r\n            endpointDefinition: endpointDefinition,\r\n            endpointName: endpointName\r\n        });\r\n        dispatch(api.internalActions.queryResultPatched({ queryCacheKey: queryCacheKey, patches: patches }));\r\n        if (!updateProvided) {\r\n            return;\r\n        }\r\n        var newValue = api.endpoints[endpointName].select(args)(getState());\r\n        var providedTags = calculateProvidedBy(endpointDefinition.providesTags, newValue.data, void 0, args, {}, assertTagType);\r\n        dispatch(api.internalActions.updateProvidedBy({ queryCacheKey: queryCacheKey, providedTags: providedTags }));\r\n    }; };\r\n    var updateQueryData = function (endpointName, args, updateRecipe, updateProvided) {\r\n        if (updateProvided === void 0) { updateProvided = true; }\r\n        return function (dispatch, getState) {\r\n            var _j, _k;\r\n            var endpointDefinition = api.endpoints[endpointName];\r\n            var currentState = endpointDefinition.select(args)(getState());\r\n            var ret = {\r\n                patches: [],\r\n                inversePatches: [],\r\n                undo: function () { return dispatch(api.util.patchQueryData(endpointName, args, ret.inversePatches, updateProvided)); }\r\n            };\r\n            if (currentState.status === QueryStatus.uninitialized) {\r\n                return ret;\r\n            }\r\n            var newValue;\r\n            if (\"data\" in currentState) {\r\n                if (isDraftable(currentState.data)) {\r\n                    var _l = produceWithPatches(currentState.data, updateRecipe), value = _l[0], patches = _l[1], inversePatches = _l[2];\r\n                    (_j = ret.patches).push.apply(_j, patches);\r\n                    (_k = ret.inversePatches).push.apply(_k, inversePatches);\r\n                    newValue = value;\r\n                }\r\n                else {\r\n                    newValue = updateRecipe(currentState.data);\r\n                    ret.patches.push({ op: \"replace\", path: [], value: newValue });\r\n                    ret.inversePatches.push({\r\n                        op: \"replace\",\r\n                        path: [],\r\n                        value: currentState.data\r\n                    });\r\n                }\r\n            }\r\n            dispatch(api.util.patchQueryData(endpointName, args, ret.patches, updateProvided));\r\n            return ret;\r\n        };\r\n    };\r\n    var upsertQueryData = function (endpointName, args, value) { return function (dispatch) {\r\n        var _j;\r\n        return dispatch(api.endpoints[endpointName].initiate(args, (_j = {\r\n                subscribe: false,\r\n                forceRefetch: true\r\n            },\r\n            _j[forceQueryFnSymbol] = function () { return ({\r\n                data: value\r\n            }); },\r\n            _j)));\r\n    }; };\r\n    var executeEndpoint = function (_0, _1) { return __async(_this, [_0, _1], function (arg, _j) {\r\n        var endpointDefinition, transformResponse, result, baseQueryApi_1, forceQueryFn, what, err, _k, _l, key, _m, error_1, catchedError, transformErrorResponse, _o, e_4;\r\n        var _p, _q;\r\n        var signal = _j.signal, abort = _j.abort, rejectWithValue = _j.rejectWithValue, fulfillWithValue = _j.fulfillWithValue, dispatch = _j.dispatch, getState = _j.getState, extra = _j.extra;\r\n        return __generator(this, function (_r) {\r\n            switch (_r.label) {\r\n                case 0:\r\n                    endpointDefinition = endpointDefinitions[arg.endpointName];\r\n                    _r.label = 1;\r\n                case 1:\r\n                    _r.trys.push([1, 8, , 13]);\r\n                    transformResponse = defaultTransformResponse;\r\n                    result = void 0;\r\n                    baseQueryApi_1 = {\r\n                        signal: signal,\r\n                        abort: abort,\r\n                        dispatch: dispatch,\r\n                        getState: getState,\r\n                        extra: extra,\r\n                        endpoint: arg.endpointName,\r\n                        type: arg.type,\r\n                        forced: arg.type === \"query\" ? isForcedQuery(arg, getState()) : void 0\r\n                    };\r\n                    forceQueryFn = arg.type === \"query\" ? arg[forceQueryFnSymbol] : void 0;\r\n                    if (!forceQueryFn) return [3 /*break*/, 2];\r\n                    result = forceQueryFn();\r\n                    return [3 /*break*/, 6];\r\n                case 2:\r\n                    if (!endpointDefinition.query) return [3 /*break*/, 4];\r\n                    return [4 /*yield*/, baseQuery(endpointDefinition.query(arg.originalArgs), baseQueryApi_1, endpointDefinition.extraOptions)];\r\n                case 3:\r\n                    result = _r.sent();\r\n                    if (endpointDefinition.transformResponse) {\r\n                        transformResponse = endpointDefinition.transformResponse;\r\n                    }\r\n                    return [3 /*break*/, 6];\r\n                case 4: return [4 /*yield*/, endpointDefinition.queryFn(arg.originalArgs, baseQueryApi_1, endpointDefinition.extraOptions, function (arg2) { return baseQuery(arg2, baseQueryApi_1, endpointDefinition.extraOptions); })];\r\n                case 5:\r\n                    result = _r.sent();\r\n                    _r.label = 6;\r\n                case 6:\r\n                    if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\r\n                        what = endpointDefinition.query ? \"`baseQuery`\" : \"`queryFn`\";\r\n                        err = void 0;\r\n                        if (!result) {\r\n                            err = what + \" did not return anything.\";\r\n                        }\r\n                        else if (typeof result !== \"object\") {\r\n                            err = what + \" did not return an object.\";\r\n                        }\r\n                        else if (result.error && result.data) {\r\n                            err = what + \" returned an object containing both `error` and `result`.\";\r\n                        }\r\n                        else if (result.error === void 0 && result.data === void 0) {\r\n                            err = what + \" returned an object containing neither a valid `error` and `result`. At least one of them should not be `undefined`\";\r\n                        }\r\n                        else {\r\n                            for (_k = 0, _l = Object.keys(result); _k < _l.length; _k++) {\r\n                                key = _l[_k];\r\n                                if (key !== \"error\" && key !== \"data\" && key !== \"meta\") {\r\n                                    err = \"The object returned by \" + what + \" has the unknown property \" + key + \".\";\r\n                                    break;\r\n                                }\r\n                            }\r\n                        }\r\n                        if (err) {\r\n                            console.error(\"Error encountered handling the endpoint \" + arg.endpointName + \".\\n              \" + err + \"\\n              It needs to return an object with either the shape `{ data: <value> }` or `{ error: <value> }` that may contain an optional `meta` property.\\n              Object returned was:\", result);\r\n                        }\r\n                    }\r\n                    if (result.error)\r\n                        throw new HandledError(result.error, result.meta);\r\n                    _m = fulfillWithValue;\r\n                    return [4 /*yield*/, transformResponse(result.data, result.meta, arg.originalArgs)];\r\n                case 7: return [2 /*return*/, _m.apply(void 0, [_r.sent(), (_p = {\r\n                                fulfilledTimeStamp: Date.now(),\r\n                                baseQueryMeta: result.meta\r\n                            },\r\n                            _p[SHOULD_AUTOBATCH] = true,\r\n                            _p)])];\r\n                case 8:\r\n                    error_1 = _r.sent();\r\n                    catchedError = error_1;\r\n                    if (!(catchedError instanceof HandledError)) return [3 /*break*/, 12];\r\n                    transformErrorResponse = defaultTransformResponse;\r\n                    if (endpointDefinition.query && endpointDefinition.transformErrorResponse) {\r\n                        transformErrorResponse = endpointDefinition.transformErrorResponse;\r\n                    }\r\n                    _r.label = 9;\r\n                case 9:\r\n                    _r.trys.push([9, 11, , 12]);\r\n                    _o = rejectWithValue;\r\n                    return [4 /*yield*/, transformErrorResponse(catchedError.value, catchedError.meta, arg.originalArgs)];\r\n                case 10: return [2 /*return*/, _o.apply(void 0, [_r.sent(), (_q = { baseQueryMeta: catchedError.meta }, _q[SHOULD_AUTOBATCH] = true, _q)])];\r\n                case 11:\r\n                    e_4 = _r.sent();\r\n                    catchedError = e_4;\r\n                    return [3 /*break*/, 12];\r\n                case 12:\r\n                    if (typeof process !== \"undefined\" && process.env.NODE_ENV !== \"production\") {\r\n                        console.error(\"An unhandled error occurred processing a request for the endpoint \\\"\" + arg.endpointName + \"\\\".\\nIn the case of an unhandled error, no tags will be \\\"provided\\\" or \\\"invalidated\\\".\", catchedError);\r\n                    }\r\n                    else {\r\n                        console.error(catchedError);\r\n                    }\r\n                    throw catchedError;\r\n                case 13: return [2 /*return*/];\r\n            }\r\n        });\r\n    }); };\r\n    function isForcedQuery(arg, state) {\r\n        var _a, _b, _c, _d;\r\n        var requestState = (_b = (_a = state[reducerPath]) == null ? void 0 : _a.queries) == null ? void 0 : _b[arg.queryCacheKey];\r\n        var baseFetchOnMountOrArgChange = (_c = state[reducerPath]) == null ? void 0 : _c.config.refetchOnMountOrArgChange;\r\n        var fulfilledVal = requestState == null ? void 0 : requestState.fulfilledTimeStamp;\r\n        var refetchVal = (_d = arg.forceRefetch) != null ? _d : arg.subscribe && baseFetchOnMountOrArgChange;\r\n        if (refetchVal) {\r\n            return refetchVal === true || (Number(new Date()) - Number(fulfilledVal)) / 1e3 >= refetchVal;\r\n        }\r\n        return false;\r\n    }\r\n    var queryThunk = createAsyncThunk(reducerPath + \"/executeQuery\", executeEndpoint, {\r\n        getPendingMeta: function () {\r\n            var _j;\r\n            return _j = { startedTimeStamp: Date.now() }, _j[SHOULD_AUTOBATCH] = true, _j;\r\n        },\r\n        condition: function (queryThunkArgs, _j) {\r\n            var getState = _j.getState;\r\n            var _a, _b, _c;\r\n            var state = getState();\r\n            var requestState = (_b = (_a = state[reducerPath]) == null ? void 0 : _a.queries) == null ? void 0 : _b[queryThunkArgs.queryCacheKey];\r\n            var fulfilledVal = requestState == null ? void 0 : requestState.fulfilledTimeStamp;\r\n            var currentArg = queryThunkArgs.originalArgs;\r\n            var previousArg = requestState == null ? void 0 : requestState.originalArgs;\r\n            var endpointDefinition = endpointDefinitions[queryThunkArgs.endpointName];\r\n            if (isUpsertQuery(queryThunkArgs)) {\r\n                return true;\r\n            }\r\n            if ((requestState == null ? void 0 : requestState.status) === \"pending\") {\r\n                return false;\r\n            }\r\n            if (isForcedQuery(queryThunkArgs, state)) {\r\n                return true;\r\n            }\r\n            if (isQueryDefinition(endpointDefinition) && ((_c = endpointDefinition == null ? void 0 : endpointDefinition.forceRefetch) == null ? void 0 : _c.call(endpointDefinition, {\r\n                currentArg: currentArg,\r\n                previousArg: previousArg,\r\n                endpointState: requestState,\r\n                state: state\r\n            }))) {\r\n                return true;\r\n            }\r\n            if (fulfilledVal) {\r\n                return false;\r\n            }\r\n            return true;\r\n        },\r\n        dispatchConditionRejection: true\r\n    });\r\n    var mutationThunk = createAsyncThunk(reducerPath + \"/executeMutation\", executeEndpoint, {\r\n        getPendingMeta: function () {\r\n            var _j;\r\n            return _j = { startedTimeStamp: Date.now() }, _j[SHOULD_AUTOBATCH] = true, _j;\r\n        }\r\n    });\r\n    var hasTheForce = function (options) { return \"force\" in options; };\r\n    var hasMaxAge = function (options) { return \"ifOlderThan\" in options; };\r\n    var prefetch = function (endpointName, arg, options) { return function (dispatch, getState) {\r\n        var force = hasTheForce(options) && options.force;\r\n        var maxAge = hasMaxAge(options) && options.ifOlderThan;\r\n        var queryAction = function (force2) {\r\n            if (force2 === void 0) { force2 = true; }\r\n            return api.endpoints[endpointName].initiate(arg, { forceRefetch: force2 });\r\n        };\r\n        var latestStateValue = api.endpoints[endpointName].select(arg)(getState());\r\n        if (force) {\r\n            dispatch(queryAction());\r\n        }\r\n        else if (maxAge) {\r\n            var lastFulfilledTs = latestStateValue == null ? void 0 : latestStateValue.fulfilledTimeStamp;\r\n            if (!lastFulfilledTs) {\r\n                dispatch(queryAction());\r\n                return;\r\n            }\r\n            var shouldRetrigger = (Number(new Date()) - Number(new Date(lastFulfilledTs))) / 1e3 >= maxAge;\r\n            if (shouldRetrigger) {\r\n                dispatch(queryAction());\r\n            }\r\n        }\r\n        else {\r\n            dispatch(queryAction(false));\r\n        }\r\n    }; };\r\n    function matchesEndpoint(endpointName) {\r\n        return function (action) {\r\n            var _a, _b;\r\n            return ((_b = (_a = action == null ? void 0 : action.meta) == null ? void 0 : _a.arg) == null ? void 0 : _b.endpointName) === endpointName;\r\n        };\r\n    }\r\n    function buildMatchThunkActions(thunk, endpointName) {\r\n        return {\r\n            matchPending: isAllOf(isPending(thunk), matchesEndpoint(endpointName)),\r\n            matchFulfilled: isAllOf(isFulfilled(thunk), matchesEndpoint(endpointName)),\r\n            matchRejected: isAllOf(isRejected(thunk), matchesEndpoint(endpointName))\r\n        };\r\n    }\r\n    return {\r\n        queryThunk: queryThunk,\r\n        mutationThunk: mutationThunk,\r\n        prefetch: prefetch,\r\n        updateQueryData: updateQueryData,\r\n        upsertQueryData: upsertQueryData,\r\n        patchQueryData: patchQueryData,\r\n        buildMatchThunkActions: buildMatchThunkActions\r\n    };\r\n}\r\nfunction calculateProvidedByThunk(action, type, endpointDefinitions, assertTagType) {\r\n    return calculateProvidedBy(endpointDefinitions[action.meta.arg.endpointName][type], isFulfilled(action) ? action.payload : void 0, isRejectedWithValue(action) ? action.payload : void 0, action.meta.arg.originalArgs, \"baseQueryMeta\" in action.meta ? action.meta.baseQueryMeta : void 0, assertTagType);\r\n}\r\n// src/query/core/buildSlice.ts\r\nimport { isDraft } from \"immer\";\r\nimport { applyPatches, original } from \"immer\";\r\nfunction updateQuerySubstateIfExists(state, queryCacheKey, update) {\r\n    var substate = state[queryCacheKey];\r\n    if (substate) {\r\n        update(substate);\r\n    }\r\n}\r\nfunction getMutationCacheKey(id) {\r\n    var _a;\r\n    return (_a = \"arg\" in id ? id.arg.fixedCacheKey : id.fixedCacheKey) != null ? _a : id.requestId;\r\n}\r\nfunction updateMutationSubstateIfExists(state, id, update) {\r\n    var substate = state[getMutationCacheKey(id)];\r\n    if (substate) {\r\n        update(substate);\r\n    }\r\n}\r\nvar initialState = {};\r\nfunction buildSlice(_j) {\r\n    var reducerPath = _j.reducerPath, queryThunk = _j.queryThunk, mutationThunk = _j.mutationThunk, _k = _j.context, definitions = _k.endpointDefinitions, apiUid = _k.apiUid, extractRehydrationInfo = _k.extractRehydrationInfo, hasRehydrationInfo = _k.hasRehydrationInfo, assertTagType = _j.assertTagType, config = _j.config;\r\n    var resetApiState = createAction2(reducerPath + \"/resetApiState\");\r\n    var querySlice = createSlice({\r\n        name: reducerPath + \"/queries\",\r\n        initialState: initialState,\r\n        reducers: {\r\n            removeQueryResult: {\r\n                reducer: function (draft, _j) {\r\n                    var queryCacheKey = _j.payload.queryCacheKey;\r\n                    delete draft[queryCacheKey];\r\n                },\r\n                prepare: prepareAutoBatched()\r\n            },\r\n            queryResultPatched: {\r\n                reducer: function (draft, _j) {\r\n                    var _k = _j.payload, queryCacheKey = _k.queryCacheKey, patches = _k.patches;\r\n                    updateQuerySubstateIfExists(draft, queryCacheKey, function (substate) {\r\n                        substate.data = applyPatches(substate.data, patches.concat());\r\n                    });\r\n                },\r\n                prepare: prepareAutoBatched()\r\n            }\r\n        },\r\n        extraReducers: function (builder) {\r\n            builder.addCase(queryThunk.pending, function (draft, _j) {\r\n                var meta = _j.meta, arg = _j.meta.arg;\r\n                var _a, _b;\r\n                var upserting = isUpsertQuery(arg);\r\n                if (arg.subscribe || upserting) {\r\n                    (_b = draft[_a = arg.queryCacheKey]) != null ? _b : draft[_a] = {\r\n                        status: QueryStatus.uninitialized,\r\n                        endpointName: arg.endpointName\r\n                    };\r\n                }\r\n                updateQuerySubstateIfExists(draft, arg.queryCacheKey, function (substate) {\r\n                    substate.status = QueryStatus.pending;\r\n                    substate.requestId = upserting && substate.requestId ? substate.requestId : meta.requestId;\r\n                    if (arg.originalArgs !== void 0) {\r\n                        substate.originalArgs = arg.originalArgs;\r\n                    }\r\n                    substate.startedTimeStamp = meta.startedTimeStamp;\r\n                });\r\n            }).addCase(queryThunk.fulfilled, function (draft, _j) {\r\n                var meta = _j.meta, payload = _j.payload;\r\n                updateQuerySubstateIfExists(draft, meta.arg.queryCacheKey, function (substate) {\r\n                    var _a;\r\n                    if (substate.requestId !== meta.requestId && !isUpsertQuery(meta.arg))\r\n                        return;\r\n                    var merge = definitions[meta.arg.endpointName].merge;\r\n                    substate.status = QueryStatus.fulfilled;\r\n                    if (merge) {\r\n                        if (substate.data !== void 0) {\r\n                            var fulfilledTimeStamp_1 = meta.fulfilledTimeStamp, arg_1 = meta.arg, baseQueryMeta_1 = meta.baseQueryMeta, requestId_1 = meta.requestId;\r\n                            var newData = createNextState(substate.data, function (draftSubstateData) {\r\n                                return merge(draftSubstateData, payload, {\r\n                                    arg: arg_1.originalArgs,\r\n                                    baseQueryMeta: baseQueryMeta_1,\r\n                                    fulfilledTimeStamp: fulfilledTimeStamp_1,\r\n                                    requestId: requestId_1\r\n                                });\r\n                            });\r\n                            substate.data = newData;\r\n                        }\r\n                        else {\r\n                            substate.data = payload;\r\n                        }\r\n                    }\r\n                    else {\r\n                        substate.data = ((_a = definitions[meta.arg.endpointName].structuralSharing) != null ? _a : true) ? copyWithStructuralSharing(isDraft(substate.data) ? original(substate.data) : substate.data, payload) : payload;\r\n                    }\r\n                    delete substate.error;\r\n                    substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;\r\n                });\r\n            }).addCase(queryThunk.rejected, function (draft, _j) {\r\n                var _k = _j.meta, condition = _k.condition, arg = _k.arg, requestId = _k.requestId, error = _j.error, payload = _j.payload;\r\n                updateQuerySubstateIfExists(draft, arg.queryCacheKey, function (substate) {\r\n                    if (condition) {\r\n                    }\r\n                    else {\r\n                        if (substate.requestId !== requestId)\r\n                            return;\r\n                        substate.status = QueryStatus.rejected;\r\n                        substate.error = payload != null ? payload : error;\r\n                    }\r\n                });\r\n            }).addMatcher(hasRehydrationInfo, function (draft, action) {\r\n                var queries = extractRehydrationInfo(action).queries;\r\n                for (var _j = 0, _k = Object.entries(queries); _j < _k.length; _j++) {\r\n                    var _l = _k[_j], key = _l[0], entry = _l[1];\r\n                    if ((entry == null ? void 0 : entry.status) === QueryStatus.fulfilled || (entry == null ? void 0 : entry.status) === QueryStatus.rejected) {\r\n                        draft[key] = entry;\r\n                    }\r\n                }\r\n            });\r\n        }\r\n    });\r\n    var mutationSlice = createSlice({\r\n        name: reducerPath + \"/mutations\",\r\n        initialState: initialState,\r\n        reducers: {\r\n            removeMutationResult: {\r\n                reducer: function (draft, _j) {\r\n                    var payload = _j.payload;\r\n                    var cacheKey = getMutationCacheKey(payload);\r\n                    if (cacheKey in draft) {\r\n                        delete draft[cacheKey];\r\n                    }\r\n                },\r\n                prepare: prepareAutoBatched()\r\n            }\r\n        },\r\n        extraReducers: function (builder) {\r\n            builder.addCase(mutationThunk.pending, function (draft, _j) {\r\n                var meta = _j.meta, _k = _j.meta, requestId = _k.requestId, arg = _k.arg, startedTimeStamp = _k.startedTimeStamp;\r\n                if (!arg.track)\r\n                    return;\r\n                draft[getMutationCacheKey(meta)] = {\r\n                    requestId: requestId,\r\n                    status: QueryStatus.pending,\r\n                    endpointName: arg.endpointName,\r\n                    startedTimeStamp: startedTimeStamp\r\n                };\r\n            }).addCase(mutationThunk.fulfilled, function (draft, _j) {\r\n                var payload = _j.payload, meta = _j.meta;\r\n                if (!meta.arg.track)\r\n                    return;\r\n                updateMutationSubstateIfExists(draft, meta, function (substate) {\r\n                    if (substate.requestId !== meta.requestId)\r\n                        return;\r\n                    substate.status = QueryStatus.fulfilled;\r\n                    substate.data = payload;\r\n                    substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;\r\n                });\r\n            }).addCase(mutationThunk.rejected, function (draft, _j) {\r\n                var payload = _j.payload, error = _j.error, meta = _j.meta;\r\n                if (!meta.arg.track)\r\n                    return;\r\n                updateMutationSubstateIfExists(draft, meta, function (substate) {\r\n                    if (substate.requestId !== meta.requestId)\r\n                        return;\r\n                    substate.status = QueryStatus.rejected;\r\n                    substate.error = payload != null ? payload : error;\r\n                });\r\n            }).addMatcher(hasRehydrationInfo, function (draft, action) {\r\n                var mutations = extractRehydrationInfo(action).mutations;\r\n                for (var _j = 0, _k = Object.entries(mutations); _j < _k.length; _j++) {\r\n                    var _l = _k[_j], key = _l[0], entry = _l[1];\r\n                    if (((entry == null ? void 0 : entry.status) === QueryStatus.fulfilled || (entry == null ? void 0 : entry.status) === QueryStatus.rejected) && key !== (entry == null ? void 0 : entry.requestId)) {\r\n                        draft[key] = entry;\r\n                    }\r\n                }\r\n            });\r\n        }\r\n    });\r\n    var invalidationSlice = createSlice({\r\n        name: reducerPath + \"/invalidation\",\r\n        initialState: initialState,\r\n        reducers: {\r\n            updateProvidedBy: {\r\n                reducer: function (draft, action) {\r\n                    var _a, _b, _c, _d;\r\n                    var _j = action.payload, queryCacheKey = _j.queryCacheKey, providedTags = _j.providedTags;\r\n                    for (var _k = 0, _l = Object.values(draft); _k < _l.length; _k++) {\r\n                        var tagTypeSubscriptions = _l[_k];\r\n                        for (var _m = 0, _o = Object.values(tagTypeSubscriptions); _m < _o.length; _m++) {\r\n                            var idSubscriptions = _o[_m];\r\n                            var foundAt = idSubscriptions.indexOf(queryCacheKey);\r\n                            if (foundAt !== -1) {\r\n                                idSubscriptions.splice(foundAt, 1);\r\n                            }\r\n                        }\r\n                    }\r\n                    for (var _p = 0, providedTags_1 = providedTags; _p < providedTags_1.length; _p++) {\r\n                        var _q = providedTags_1[_p], type = _q.type, id = _q.id;\r\n                        var subscribedQueries = (_d = (_b = (_a = draft[type]) != null ? _a : draft[type] = {})[_c = id || \"__internal_without_id\"]) != null ? _d : _b[_c] = [];\r\n                        var alreadySubscribed = subscribedQueries.includes(queryCacheKey);\r\n                        if (!alreadySubscribed) {\r\n                            subscribedQueries.push(queryCacheKey);\r\n                        }\r\n                    }\r\n                },\r\n                prepare: prepareAutoBatched()\r\n            }\r\n        },\r\n        extraReducers: function (builder) {\r\n            builder.addCase(querySlice.actions.removeQueryResult, function (draft, _j) {\r\n                var queryCacheKey = _j.payload.queryCacheKey;\r\n                for (var _k = 0, _l = Object.values(draft); _k < _l.length; _k++) {\r\n                    var tagTypeSubscriptions = _l[_k];\r\n                    for (var _m = 0, _o = Object.values(tagTypeSubscriptions); _m < _o.length; _m++) {\r\n                        var idSubscriptions = _o[_m];\r\n                        var foundAt = idSubscriptions.indexOf(queryCacheKey);\r\n                        if (foundAt !== -1) {\r\n                            idSubscriptions.splice(foundAt, 1);\r\n                        }\r\n                    }\r\n                }\r\n            }).addMatcher(hasRehydrationInfo, function (draft, action) {\r\n                var _a, _b, _c, _d;\r\n                var provided = extractRehydrationInfo(action).provided;\r\n                for (var _j = 0, _k = Object.entries(provided); _j < _k.length; _j++) {\r\n                    var _l = _k[_j], type = _l[0], incomingTags = _l[1];\r\n                    for (var _m = 0, _o = Object.entries(incomingTags); _m < _o.length; _m++) {\r\n                        var _p = _o[_m], id = _p[0], cacheKeys = _p[1];\r\n                        var subscribedQueries = (_d = (_b = (_a = draft[type]) != null ? _a : draft[type] = {})[_c = id || \"__internal_without_id\"]) != null ? _d : _b[_c] = [];\r\n                        for (var _q = 0, cacheKeys_1 = cacheKeys; _q < cacheKeys_1.length; _q++) {\r\n                            var queryCacheKey = cacheKeys_1[_q];\r\n                            var alreadySubscribed = subscribedQueries.includes(queryCacheKey);\r\n                            if (!alreadySubscribed) {\r\n                                subscribedQueries.push(queryCacheKey);\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }).addMatcher(isAnyOf(isFulfilled2(queryThunk), isRejectedWithValue2(queryThunk)), function (draft, action) {\r\n                var providedTags = calculateProvidedByThunk(action, \"providesTags\", definitions, assertTagType);\r\n                var queryCacheKey = action.meta.arg.queryCacheKey;\r\n                invalidationSlice.caseReducers.updateProvidedBy(draft, invalidationSlice.actions.updateProvidedBy({\r\n                    queryCacheKey: queryCacheKey,\r\n                    providedTags: providedTags\r\n                }));\r\n            });\r\n        }\r\n    });\r\n    var subscriptionSlice = createSlice({\r\n        name: reducerPath + \"/subscriptions\",\r\n        initialState: initialState,\r\n        reducers: {\r\n            updateSubscriptionOptions: function (d, a) {\r\n            },\r\n            unsubscribeQueryResult: function (d, a) {\r\n            },\r\n            internal_probeSubscription: function (d, a) {\r\n            }\r\n        }\r\n    });\r\n    var internalSubscriptionsSlice = createSlice({\r\n        name: reducerPath + \"/internalSubscriptions\",\r\n        initialState: initialState,\r\n        reducers: {\r\n            subscriptionsUpdated: {\r\n                reducer: function (state, action) {\r\n                    return applyPatches(state, action.payload);\r\n                },\r\n                prepare: prepareAutoBatched()\r\n            }\r\n        }\r\n    });\r\n    var configSlice = createSlice({\r\n        name: reducerPath + \"/config\",\r\n        initialState: __spreadValues({\r\n            online: isOnline(),\r\n            focused: isDocumentVisible(),\r\n            middlewareRegistered: false\r\n        }, config),\r\n        reducers: {\r\n            middlewareRegistered: function (state, _j) {\r\n                var payload = _j.payload;\r\n                state.middlewareRegistered = state.middlewareRegistered === \"conflict\" || apiUid !== payload ? \"conflict\" : true;\r\n            }\r\n        },\r\n        extraReducers: function (builder) {\r\n            builder.addCase(onOnline, function (state) {\r\n                state.online = true;\r\n            }).addCase(onOffline, function (state) {\r\n                state.online = false;\r\n            }).addCase(onFocus, function (state) {\r\n                state.focused = true;\r\n            }).addCase(onFocusLost, function (state) {\r\n                state.focused = false;\r\n            }).addMatcher(hasRehydrationInfo, function (draft) { return __spreadValues({}, draft); });\r\n        }\r\n    });\r\n    var combinedReducer = combineReducers({\r\n        queries: querySlice.reducer,\r\n        mutations: mutationSlice.reducer,\r\n        provided: invalidationSlice.reducer,\r\n        subscriptions: internalSubscriptionsSlice.reducer,\r\n        config: configSlice.reducer\r\n    });\r\n    var reducer = function (state, action) { return combinedReducer(resetApiState.match(action) ? void 0 : state, action); };\r\n    var actions = __spreadProps(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, configSlice.actions), querySlice.actions), subscriptionSlice.actions), internalSubscriptionsSlice.actions), mutationSlice.actions), invalidationSlice.actions), {\r\n        unsubscribeMutationResult: mutationSlice.actions.removeMutationResult,\r\n        resetApiState: resetApiState\r\n    });\r\n    return { reducer: reducer, actions: actions };\r\n}\r\n// src/query/core/buildSelectors.ts\r\nvar skipToken = /* @__PURE__ */ Symbol.for(\"RTKQ/skipToken\");\r\nvar skipSelector = skipToken;\r\nvar initialSubState = {\r\n    status: QueryStatus.uninitialized\r\n};\r\nvar defaultQuerySubState = /* @__PURE__ */ createNextState2(initialSubState, function () {\r\n});\r\nvar defaultMutationSubState = /* @__PURE__ */ createNextState2(initialSubState, function () {\r\n});\r\nfunction buildSelectors(_j) {\r\n    var serializeQueryArgs = _j.serializeQueryArgs, reducerPath = _j.reducerPath;\r\n    var selectSkippedQuery = function (state) { return defaultQuerySubState; };\r\n    var selectSkippedMutation = function (state) { return defaultMutationSubState; };\r\n    return { buildQuerySelector: buildQuerySelector, buildMutationSelector: buildMutationSelector, selectInvalidatedBy: selectInvalidatedBy };\r\n    function withRequestFlags(substate) {\r\n        return __spreadValues(__spreadValues({}, substate), getRequestStatusFlags(substate.status));\r\n    }\r\n    function selectInternalState(rootState) {\r\n        var state = rootState[reducerPath];\r\n        if (process.env.NODE_ENV !== \"production\") {\r\n            if (!state) {\r\n                if (selectInternalState.triggered)\r\n                    return state;\r\n                selectInternalState.triggered = true;\r\n                console.error(\"Error: No data found at `state.\" + reducerPath + \"`. Did you forget to add the reducer to the store?\");\r\n            }\r\n        }\r\n        return state;\r\n    }\r\n    function buildQuerySelector(endpointName, endpointDefinition) {\r\n        return function (queryArgs) {\r\n            var serializedArgs = serializeQueryArgs({\r\n                queryArgs: queryArgs,\r\n                endpointDefinition: endpointDefinition,\r\n                endpointName: endpointName\r\n            });\r\n            var selectQuerySubstate = function (state) {\r\n                var _a, _b, _c;\r\n                return (_c = (_b = (_a = selectInternalState(state)) == null ? void 0 : _a.queries) == null ? void 0 : _b[serializedArgs]) != null ? _c : defaultQuerySubState;\r\n            };\r\n            var finalSelectQuerySubState = queryArgs === skipToken ? selectSkippedQuery : selectQuerySubstate;\r\n            return createSelector(finalSelectQuerySubState, withRequestFlags);\r\n        };\r\n    }\r\n    function buildMutationSelector() {\r\n        return function (id) {\r\n            var _a;\r\n            var mutationId;\r\n            if (typeof id === \"object\") {\r\n                mutationId = (_a = getMutationCacheKey(id)) != null ? _a : skipToken;\r\n            }\r\n            else {\r\n                mutationId = id;\r\n            }\r\n            var selectMutationSubstate = function (state) {\r\n                var _a2, _b, _c;\r\n                return (_c = (_b = (_a2 = selectInternalState(state)) == null ? void 0 : _a2.mutations) == null ? void 0 : _b[mutationId]) != null ? _c : defaultMutationSubState;\r\n            };\r\n            var finalSelectMutationSubstate = mutationId === skipToken ? selectSkippedMutation : selectMutationSubstate;\r\n            return createSelector(finalSelectMutationSubstate, withRequestFlags);\r\n        };\r\n    }\r\n    function selectInvalidatedBy(state, tags) {\r\n        var _a;\r\n        var apiState = state[reducerPath];\r\n        var toInvalidate = new Set();\r\n        for (var _j = 0, _k = tags.map(expandTagDescription); _j < _k.length; _j++) {\r\n            var tag = _k[_j];\r\n            var provided = apiState.provided[tag.type];\r\n            if (!provided) {\r\n                continue;\r\n            }\r\n            var invalidateSubscriptions = (_a = tag.id !== void 0 ? provided[tag.id] : flatten(Object.values(provided))) != null ? _a : [];\r\n            for (var _l = 0, invalidateSubscriptions_1 = invalidateSubscriptions; _l < invalidateSubscriptions_1.length; _l++) {\r\n                var invalidate = invalidateSubscriptions_1[_l];\r\n                toInvalidate.add(invalidate);\r\n            }\r\n        }\r\n        return flatten(Array.from(toInvalidate.values()).map(function (queryCacheKey) {\r\n            var querySubState = apiState.queries[queryCacheKey];\r\n            return querySubState ? [\r\n                {\r\n                    queryCacheKey: queryCacheKey,\r\n                    endpointName: querySubState.endpointName,\r\n                    originalArgs: querySubState.originalArgs\r\n                }\r\n            ] : [];\r\n        }));\r\n    }\r\n}\r\n// src/query/defaultSerializeQueryArgs.ts\r\nimport { isPlainObject as isPlainObject3 } from \"@reduxjs/toolkit\";\r\nvar cache = WeakMap ? new WeakMap() : void 0;\r\nvar defaultSerializeQueryArgs = function (_j) {\r\n    var endpointName = _j.endpointName, queryArgs = _j.queryArgs;\r\n    var serialized = \"\";\r\n    var cached = cache == null ? void 0 : cache.get(queryArgs);\r\n    if (typeof cached === \"string\") {\r\n        serialized = cached;\r\n    }\r\n    else {\r\n        var stringified = JSON.stringify(queryArgs, function (key, value) { return isPlainObject3(value) ? Object.keys(value).sort().reduce(function (acc, key2) {\r\n            acc[key2] = value[key2];\r\n            return acc;\r\n        }, {}) : value; });\r\n        if (isPlainObject3(queryArgs)) {\r\n            cache == null ? void 0 : cache.set(queryArgs, stringified);\r\n        }\r\n        serialized = stringified;\r\n    }\r\n    return endpointName + \"(\" + serialized + \")\";\r\n};\r\n// src/query/createApi.ts\r\nimport { nanoid } from \"@reduxjs/toolkit\";\r\nimport { defaultMemoize } from \"reselect\";\r\nfunction buildCreateApi() {\r\n    var modules = [];\r\n    for (var _j = 0; _j < arguments.length; _j++) {\r\n        modules[_j] = arguments[_j];\r\n    }\r\n    return function baseCreateApi(options) {\r\n        var extractRehydrationInfo = defaultMemoize(function (action) {\r\n            var _a, _b;\r\n            return (_b = options.extractRehydrationInfo) == null ? void 0 : _b.call(options, action, {\r\n                reducerPath: (_a = options.reducerPath) != null ? _a : \"api\"\r\n            });\r\n        });\r\n        var optionsWithDefaults = __spreadProps(__spreadValues({\r\n            reducerPath: \"api\",\r\n            keepUnusedDataFor: 60,\r\n            refetchOnMountOrArgChange: false,\r\n            refetchOnFocus: false,\r\n            refetchOnReconnect: false\r\n        }, options), {\r\n            extractRehydrationInfo: extractRehydrationInfo,\r\n            serializeQueryArgs: function (queryArgsApi) {\r\n                var finalSerializeQueryArgs = defaultSerializeQueryArgs;\r\n                if (\"serializeQueryArgs\" in queryArgsApi.endpointDefinition) {\r\n                    var endpointSQA_1 = queryArgsApi.endpointDefinition.serializeQueryArgs;\r\n                    finalSerializeQueryArgs = function (queryArgsApi2) {\r\n                        var initialResult = endpointSQA_1(queryArgsApi2);\r\n                        if (typeof initialResult === \"string\") {\r\n                            return initialResult;\r\n                        }\r\n                        else {\r\n                            return defaultSerializeQueryArgs(__spreadProps(__spreadValues({}, queryArgsApi2), {\r\n                                queryArgs: initialResult\r\n                            }));\r\n                        }\r\n                    };\r\n                }\r\n                else if (options.serializeQueryArgs) {\r\n                    finalSerializeQueryArgs = options.serializeQueryArgs;\r\n                }\r\n                return finalSerializeQueryArgs(queryArgsApi);\r\n            },\r\n            tagTypes: __spreadArray([], options.tagTypes || [])\r\n        });\r\n        var context = {\r\n            endpointDefinitions: {},\r\n            batch: function (fn) {\r\n                fn();\r\n            },\r\n            apiUid: nanoid(),\r\n            extractRehydrationInfo: extractRehydrationInfo,\r\n            hasRehydrationInfo: defaultMemoize(function (action) { return extractRehydrationInfo(action) != null; })\r\n        };\r\n        var api = {\r\n            injectEndpoints: injectEndpoints,\r\n            enhanceEndpoints: function (_j) {\r\n                var addTagTypes = _j.addTagTypes, endpoints = _j.endpoints;\r\n                if (addTagTypes) {\r\n                    for (var _k = 0, addTagTypes_1 = addTagTypes; _k < addTagTypes_1.length; _k++) {\r\n                        var eT = addTagTypes_1[_k];\r\n                        if (!optionsWithDefaults.tagTypes.includes(eT)) {\r\n                            ;\r\n                            optionsWithDefaults.tagTypes.push(eT);\r\n                        }\r\n                    }\r\n                }\r\n                if (endpoints) {\r\n                    for (var _l = 0, _m = Object.entries(endpoints); _l < _m.length; _l++) {\r\n                        var _o = _m[_l], endpointName = _o[0], partialDefinition = _o[1];\r\n                        if (typeof partialDefinition === \"function\") {\r\n                            partialDefinition(context.endpointDefinitions[endpointName]);\r\n                        }\r\n                        else {\r\n                            Object.assign(context.endpointDefinitions[endpointName] || {}, partialDefinition);\r\n                        }\r\n                    }\r\n                }\r\n                return api;\r\n            }\r\n        };\r\n        var initializedModules = modules.map(function (m) { return m.init(api, optionsWithDefaults, context); });\r\n        function injectEndpoints(inject) {\r\n            var evaluatedEndpoints = inject.endpoints({\r\n                query: function (x) { return __spreadProps(__spreadValues({}, x), { type: DefinitionType.query }); },\r\n                mutation: function (x) { return __spreadProps(__spreadValues({}, x), { type: DefinitionType.mutation }); }\r\n            });\r\n            for (var _j = 0, _k = Object.entries(evaluatedEndpoints); _j < _k.length; _j++) {\r\n                var _l = _k[_j], endpointName = _l[0], definition = _l[1];\r\n                if (!inject.overrideExisting && endpointName in context.endpointDefinitions) {\r\n                    if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\r\n                        console.error(\"called `injectEndpoints` to override already-existing endpointName \" + endpointName + \" without specifying `overrideExisting: true`\");\r\n                    }\r\n                    continue;\r\n                }\r\n                context.endpointDefinitions[endpointName] = definition;\r\n                for (var _m = 0, initializedModules_1 = initializedModules; _m < initializedModules_1.length; _m++) {\r\n                    var m = initializedModules_1[_m];\r\n                    m.injectEndpoint(endpointName, definition);\r\n                }\r\n            }\r\n            return api;\r\n        }\r\n        return api.injectEndpoints({ endpoints: options.endpoints });\r\n    };\r\n}\r\n// src/query/fakeBaseQuery.ts\r\nfunction fakeBaseQuery() {\r\n    return function () {\r\n        throw new Error(\"When using `fakeBaseQuery`, all queries & mutations must use the `queryFn` definition syntax.\");\r\n    };\r\n}\r\n// src/query/core/buildMiddleware/index.ts\r\nimport { createAction as createAction3 } from \"@reduxjs/toolkit\";\r\n// src/query/core/buildMiddleware/cacheCollection.ts\r\nfunction isObjectEmpty(obj) {\r\n    for (var k in obj) {\r\n        return false;\r\n    }\r\n    return true;\r\n}\r\nvar THIRTY_TWO_BIT_MAX_TIMER_SECONDS = 2147483647 / 1e3 - 1;\r\nvar buildCacheCollectionHandler = function (_j) {\r\n    var reducerPath = _j.reducerPath, api = _j.api, context = _j.context, internalState = _j.internalState;\r\n    var _k = api.internalActions, removeQueryResult = _k.removeQueryResult, unsubscribeQueryResult = _k.unsubscribeQueryResult;\r\n    function anySubscriptionsRemainingForKey(queryCacheKey) {\r\n        var subscriptions = internalState.currentSubscriptions[queryCacheKey];\r\n        return !!subscriptions && !isObjectEmpty(subscriptions);\r\n    }\r\n    var currentRemovalTimeouts = {};\r\n    var handler = function (action, mwApi, internalState2) {\r\n        var _a;\r\n        if (unsubscribeQueryResult.match(action)) {\r\n            var state = mwApi.getState()[reducerPath];\r\n            var queryCacheKey = action.payload.queryCacheKey;\r\n            handleUnsubscribe(queryCacheKey, (_a = state.queries[queryCacheKey]) == null ? void 0 : _a.endpointName, mwApi, state.config);\r\n        }\r\n        if (api.util.resetApiState.match(action)) {\r\n            for (var _j = 0, _k = Object.entries(currentRemovalTimeouts); _j < _k.length; _j++) {\r\n                var _l = _k[_j], key = _l[0], timeout = _l[1];\r\n                if (timeout)\r\n                    clearTimeout(timeout);\r\n                delete currentRemovalTimeouts[key];\r\n            }\r\n        }\r\n        if (context.hasRehydrationInfo(action)) {\r\n            var state = mwApi.getState()[reducerPath];\r\n            var queries = context.extractRehydrationInfo(action).queries;\r\n            for (var _m = 0, _o = Object.entries(queries); _m < _o.length; _m++) {\r\n                var _p = _o[_m], queryCacheKey = _p[0], queryState = _p[1];\r\n                handleUnsubscribe(queryCacheKey, queryState == null ? void 0 : queryState.endpointName, mwApi, state.config);\r\n            }\r\n        }\r\n    };\r\n    function handleUnsubscribe(queryCacheKey, endpointName, api2, config) {\r\n        var _a;\r\n        var endpointDefinition = context.endpointDefinitions[endpointName];\r\n        var keepUnusedDataFor = (_a = endpointDefinition == null ? void 0 : endpointDefinition.keepUnusedDataFor) != null ? _a : config.keepUnusedDataFor;\r\n        if (keepUnusedDataFor === Infinity) {\r\n            return;\r\n        }\r\n        var finalKeepUnusedDataFor = Math.max(0, Math.min(keepUnusedDataFor, THIRTY_TWO_BIT_MAX_TIMER_SECONDS));\r\n        if (!anySubscriptionsRemainingForKey(queryCacheKey)) {\r\n            var currentTimeout = currentRemovalTimeouts[queryCacheKey];\r\n            if (currentTimeout) {\r\n                clearTimeout(currentTimeout);\r\n            }\r\n            currentRemovalTimeouts[queryCacheKey] = setTimeout(function () {\r\n                if (!anySubscriptionsRemainingForKey(queryCacheKey)) {\r\n                    api2.dispatch(removeQueryResult({ queryCacheKey: queryCacheKey }));\r\n                }\r\n                delete currentRemovalTimeouts[queryCacheKey];\r\n            }, finalKeepUnusedDataFor * 1e3);\r\n        }\r\n    }\r\n    return handler;\r\n};\r\n// src/query/core/buildMiddleware/invalidationByTags.ts\r\nimport { isAnyOf as isAnyOf2, isFulfilled as isFulfilled3, isRejectedWithValue as isRejectedWithValue3 } from \"@reduxjs/toolkit\";\r\nvar buildInvalidationByTagsHandler = function (_j) {\r\n    var reducerPath = _j.reducerPath, context = _j.context, endpointDefinitions = _j.context.endpointDefinitions, mutationThunk = _j.mutationThunk, api = _j.api, assertTagType = _j.assertTagType, refetchQuery = _j.refetchQuery;\r\n    var removeQueryResult = api.internalActions.removeQueryResult;\r\n    var isThunkActionWithTags = isAnyOf2(isFulfilled3(mutationThunk), isRejectedWithValue3(mutationThunk));\r\n    var handler = function (action, mwApi) {\r\n        if (isThunkActionWithTags(action)) {\r\n            invalidateTags(calculateProvidedByThunk(action, \"invalidatesTags\", endpointDefinitions, assertTagType), mwApi);\r\n        }\r\n        if (api.util.invalidateTags.match(action)) {\r\n            invalidateTags(calculateProvidedBy(action.payload, void 0, void 0, void 0, void 0, assertTagType), mwApi);\r\n        }\r\n    };\r\n    function invalidateTags(tags, mwApi) {\r\n        var rootState = mwApi.getState();\r\n        var state = rootState[reducerPath];\r\n        var toInvalidate = api.util.selectInvalidatedBy(rootState, tags);\r\n        context.batch(function () {\r\n            var _a;\r\n            var valuesArray = Array.from(toInvalidate.values());\r\n            for (var _j = 0, valuesArray_1 = valuesArray; _j < valuesArray_1.length; _j++) {\r\n                var queryCacheKey = valuesArray_1[_j].queryCacheKey;\r\n                var querySubState = state.queries[queryCacheKey];\r\n                var subscriptionSubState = (_a = state.subscriptions[queryCacheKey]) != null ? _a : {};\r\n                if (querySubState) {\r\n                    if (Object.keys(subscriptionSubState).length === 0) {\r\n                        mwApi.dispatch(removeQueryResult({\r\n                            queryCacheKey: queryCacheKey\r\n                        }));\r\n                    }\r\n                    else if (querySubState.status !== QueryStatus.uninitialized) {\r\n                        mwApi.dispatch(refetchQuery(querySubState, queryCacheKey));\r\n                    }\r\n                }\r\n            }\r\n        });\r\n    }\r\n    return handler;\r\n};\r\n// src/query/core/buildMiddleware/polling.ts\r\nvar buildPollingHandler = function (_j) {\r\n    var reducerPath = _j.reducerPath, queryThunk = _j.queryThunk, api = _j.api, refetchQuery = _j.refetchQuery, internalState = _j.internalState;\r\n    var currentPolls = {};\r\n    var handler = function (action, mwApi) {\r\n        if (api.internalActions.updateSubscriptionOptions.match(action) || api.internalActions.unsubscribeQueryResult.match(action)) {\r\n            updatePollingInterval(action.payload, mwApi);\r\n        }\r\n        if (queryThunk.pending.match(action) || queryThunk.rejected.match(action) && action.meta.condition) {\r\n            updatePollingInterval(action.meta.arg, mwApi);\r\n        }\r\n        if (queryThunk.fulfilled.match(action) || queryThunk.rejected.match(action) && !action.meta.condition) {\r\n            startNextPoll(action.meta.arg, mwApi);\r\n        }\r\n        if (api.util.resetApiState.match(action)) {\r\n            clearPolls();\r\n        }\r\n    };\r\n    function startNextPoll(_j, api2) {\r\n        var queryCacheKey = _j.queryCacheKey;\r\n        var state = api2.getState()[reducerPath];\r\n        var querySubState = state.queries[queryCacheKey];\r\n        var subscriptions = internalState.currentSubscriptions[queryCacheKey];\r\n        if (!querySubState || querySubState.status === QueryStatus.uninitialized)\r\n            return;\r\n        var lowestPollingInterval = findLowestPollingInterval(subscriptions);\r\n        if (!Number.isFinite(lowestPollingInterval))\r\n            return;\r\n        var currentPoll = currentPolls[queryCacheKey];\r\n        if (currentPoll == null ? void 0 : currentPoll.timeout) {\r\n            clearTimeout(currentPoll.timeout);\r\n            currentPoll.timeout = void 0;\r\n        }\r\n        var nextPollTimestamp = Date.now() + lowestPollingInterval;\r\n        var currentInterval = currentPolls[queryCacheKey] = {\r\n            nextPollTimestamp: nextPollTimestamp,\r\n            pollingInterval: lowestPollingInterval,\r\n            timeout: setTimeout(function () {\r\n                currentInterval.timeout = void 0;\r\n                api2.dispatch(refetchQuery(querySubState, queryCacheKey));\r\n            }, lowestPollingInterval)\r\n        };\r\n    }\r\n    function updatePollingInterval(_j, api2) {\r\n        var queryCacheKey = _j.queryCacheKey;\r\n        var state = api2.getState()[reducerPath];\r\n        var querySubState = state.queries[queryCacheKey];\r\n        var subscriptions = internalState.currentSubscriptions[queryCacheKey];\r\n        if (!querySubState || querySubState.status === QueryStatus.uninitialized) {\r\n            return;\r\n        }\r\n        var lowestPollingInterval = findLowestPollingInterval(subscriptions);\r\n        if (!Number.isFinite(lowestPollingInterval)) {\r\n            cleanupPollForKey(queryCacheKey);\r\n            return;\r\n        }\r\n        var currentPoll = currentPolls[queryCacheKey];\r\n        var nextPollTimestamp = Date.now() + lowestPollingInterval;\r\n        if (!currentPoll || nextPollTimestamp < currentPoll.nextPollTimestamp) {\r\n            startNextPoll({ queryCacheKey: queryCacheKey }, api2);\r\n        }\r\n    }\r\n    function cleanupPollForKey(key) {\r\n        var existingPoll = currentPolls[key];\r\n        if (existingPoll == null ? void 0 : existingPoll.timeout) {\r\n            clearTimeout(existingPoll.timeout);\r\n        }\r\n        delete currentPolls[key];\r\n    }\r\n    function clearPolls() {\r\n        for (var _j = 0, _k = Object.keys(currentPolls); _j < _k.length; _j++) {\r\n            var key = _k[_j];\r\n            cleanupPollForKey(key);\r\n        }\r\n    }\r\n    function findLowestPollingInterval(subscribers) {\r\n        if (subscribers === void 0) { subscribers = {}; }\r\n        var lowestPollingInterval = Number.POSITIVE_INFINITY;\r\n        for (var key in subscribers) {\r\n            if (!!subscribers[key].pollingInterval) {\r\n                lowestPollingInterval = Math.min(subscribers[key].pollingInterval, lowestPollingInterval);\r\n            }\r\n        }\r\n        return lowestPollingInterval;\r\n    }\r\n    return handler;\r\n};\r\n// src/query/core/buildMiddleware/windowEventHandling.ts\r\nvar buildWindowEventHandler = function (_j) {\r\n    var reducerPath = _j.reducerPath, context = _j.context, api = _j.api, refetchQuery = _j.refetchQuery, internalState = _j.internalState;\r\n    var removeQueryResult = api.internalActions.removeQueryResult;\r\n    var handler = function (action, mwApi) {\r\n        if (onFocus.match(action)) {\r\n            refetchValidQueries(mwApi, \"refetchOnFocus\");\r\n        }\r\n        if (onOnline.match(action)) {\r\n            refetchValidQueries(mwApi, \"refetchOnReconnect\");\r\n        }\r\n    };\r\n    function refetchValidQueries(api2, type) {\r\n        var state = api2.getState()[reducerPath];\r\n        var queries = state.queries;\r\n        var subscriptions = internalState.currentSubscriptions;\r\n        context.batch(function () {\r\n            for (var _j = 0, _k = Object.keys(subscriptions); _j < _k.length; _j++) {\r\n                var queryCacheKey = _k[_j];\r\n                var querySubState = queries[queryCacheKey];\r\n                var subscriptionSubState = subscriptions[queryCacheKey];\r\n                if (!subscriptionSubState || !querySubState)\r\n                    continue;\r\n                var shouldRefetch = Object.values(subscriptionSubState).some(function (sub) { return sub[type] === true; }) || Object.values(subscriptionSubState).every(function (sub) { return sub[type] === void 0; }) && state.config[type];\r\n                if (shouldRefetch) {\r\n                    if (Object.keys(subscriptionSubState).length === 0) {\r\n                        api2.dispatch(removeQueryResult({\r\n                            queryCacheKey: queryCacheKey\r\n                        }));\r\n                    }\r\n                    else if (querySubState.status !== QueryStatus.uninitialized) {\r\n                        api2.dispatch(refetchQuery(querySubState, queryCacheKey));\r\n                    }\r\n                }\r\n            }\r\n        });\r\n    }\r\n    return handler;\r\n};\r\n// src/query/core/buildMiddleware/cacheLifecycle.ts\r\nimport { isAsyncThunkAction, isFulfilled as isFulfilled4 } from \"@reduxjs/toolkit\";\r\nvar neverResolvedError = new Error(\"Promise never resolved before cacheEntryRemoved.\");\r\nvar buildCacheLifecycleHandler = function (_j) {\r\n    var api = _j.api, reducerPath = _j.reducerPath, context = _j.context, queryThunk = _j.queryThunk, mutationThunk = _j.mutationThunk, internalState = _j.internalState;\r\n    var isQueryThunk = isAsyncThunkAction(queryThunk);\r\n    var isMutationThunk = isAsyncThunkAction(mutationThunk);\r\n    var isFulfilledThunk = isFulfilled4(queryThunk, mutationThunk);\r\n    var lifecycleMap = {};\r\n    var handler = function (action, mwApi, stateBefore) {\r\n        var cacheKey = getCacheKey(action);\r\n        if (queryThunk.pending.match(action)) {\r\n            var oldState = stateBefore[reducerPath].queries[cacheKey];\r\n            var state = mwApi.getState()[reducerPath].queries[cacheKey];\r\n            if (!oldState && state) {\r\n                handleNewKey(action.meta.arg.endpointName, action.meta.arg.originalArgs, cacheKey, mwApi, action.meta.requestId);\r\n            }\r\n        }\r\n        else if (mutationThunk.pending.match(action)) {\r\n            var state = mwApi.getState()[reducerPath].mutations[cacheKey];\r\n            if (state) {\r\n                handleNewKey(action.meta.arg.endpointName, action.meta.arg.originalArgs, cacheKey, mwApi, action.meta.requestId);\r\n            }\r\n        }\r\n        else if (isFulfilledThunk(action)) {\r\n            var lifecycle = lifecycleMap[cacheKey];\r\n            if (lifecycle == null ? void 0 : lifecycle.valueResolved) {\r\n                lifecycle.valueResolved({\r\n                    data: action.payload,\r\n                    meta: action.meta.baseQueryMeta\r\n                });\r\n                delete lifecycle.valueResolved;\r\n            }\r\n        }\r\n        else if (api.internalActions.removeQueryResult.match(action) || api.internalActions.removeMutationResult.match(action)) {\r\n            var lifecycle = lifecycleMap[cacheKey];\r\n            if (lifecycle) {\r\n                delete lifecycleMap[cacheKey];\r\n                lifecycle.cacheEntryRemoved();\r\n            }\r\n        }\r\n        else if (api.util.resetApiState.match(action)) {\r\n            for (var _j = 0, _k = Object.entries(lifecycleMap); _j < _k.length; _j++) {\r\n                var _l = _k[_j], cacheKey2 = _l[0], lifecycle = _l[1];\r\n                delete lifecycleMap[cacheKey2];\r\n                lifecycle.cacheEntryRemoved();\r\n            }\r\n        }\r\n    };\r\n    function getCacheKey(action) {\r\n        if (isQueryThunk(action))\r\n            return action.meta.arg.queryCacheKey;\r\n        if (isMutationThunk(action))\r\n            return action.meta.requestId;\r\n        if (api.internalActions.removeQueryResult.match(action))\r\n            return action.payload.queryCacheKey;\r\n        if (api.internalActions.removeMutationResult.match(action))\r\n            return getMutationCacheKey(action.payload);\r\n        return \"\";\r\n    }\r\n    function handleNewKey(endpointName, originalArgs, queryCacheKey, mwApi, requestId) {\r\n        var endpointDefinition = context.endpointDefinitions[endpointName];\r\n        var onCacheEntryAdded = endpointDefinition == null ? void 0 : endpointDefinition.onCacheEntryAdded;\r\n        if (!onCacheEntryAdded)\r\n            return;\r\n        var lifecycle = {};\r\n        var cacheEntryRemoved = new Promise(function (resolve) {\r\n            lifecycle.cacheEntryRemoved = resolve;\r\n        });\r\n        var cacheDataLoaded = Promise.race([\r\n            new Promise(function (resolve) {\r\n                lifecycle.valueResolved = resolve;\r\n            }),\r\n            cacheEntryRemoved.then(function () {\r\n                throw neverResolvedError;\r\n            })\r\n        ]);\r\n        cacheDataLoaded.catch(function () {\r\n        });\r\n        lifecycleMap[queryCacheKey] = lifecycle;\r\n        var selector = api.endpoints[endpointName].select(endpointDefinition.type === DefinitionType.query ? originalArgs : queryCacheKey);\r\n        var extra = mwApi.dispatch(function (_, __, extra2) { return extra2; });\r\n        var lifecycleApi = __spreadProps(__spreadValues({}, mwApi), {\r\n            getCacheEntry: function () { return selector(mwApi.getState()); },\r\n            requestId: requestId,\r\n            extra: extra,\r\n            updateCachedData: endpointDefinition.type === DefinitionType.query ? function (updateRecipe) { return mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)); } : void 0,\r\n            cacheDataLoaded: cacheDataLoaded,\r\n            cacheEntryRemoved: cacheEntryRemoved\r\n        });\r\n        var runningHandler = onCacheEntryAdded(originalArgs, lifecycleApi);\r\n        Promise.resolve(runningHandler).catch(function (e) {\r\n            if (e === neverResolvedError)\r\n                return;\r\n            throw e;\r\n        });\r\n    }\r\n    return handler;\r\n};\r\n// src/query/core/buildMiddleware/queryLifecycle.ts\r\nimport { isPending as isPending2, isRejected as isRejected2, isFulfilled as isFulfilled5 } from \"@reduxjs/toolkit\";\r\nvar buildQueryLifecycleHandler = function (_j) {\r\n    var api = _j.api, context = _j.context, queryThunk = _j.queryThunk, mutationThunk = _j.mutationThunk;\r\n    var isPendingThunk = isPending2(queryThunk, mutationThunk);\r\n    var isRejectedThunk = isRejected2(queryThunk, mutationThunk);\r\n    var isFullfilledThunk = isFulfilled5(queryThunk, mutationThunk);\r\n    var lifecycleMap = {};\r\n    var handler = function (action, mwApi) {\r\n        var _a, _b, _c;\r\n        if (isPendingThunk(action)) {\r\n            var _j = action.meta, requestId = _j.requestId, _k = _j.arg, endpointName_1 = _k.endpointName, originalArgs_1 = _k.originalArgs;\r\n            var endpointDefinition = context.endpointDefinitions[endpointName_1];\r\n            var onQueryStarted = endpointDefinition == null ? void 0 : endpointDefinition.onQueryStarted;\r\n            if (onQueryStarted) {\r\n                var lifecycle_1 = {};\r\n                var queryFulfilled = new Promise(function (resolve, reject) {\r\n                    lifecycle_1.resolve = resolve;\r\n                    lifecycle_1.reject = reject;\r\n                });\r\n                queryFulfilled.catch(function () {\r\n                });\r\n                lifecycleMap[requestId] = lifecycle_1;\r\n                var selector_1 = api.endpoints[endpointName_1].select(endpointDefinition.type === DefinitionType.query ? originalArgs_1 : requestId);\r\n                var extra = mwApi.dispatch(function (_, __, extra2) { return extra2; });\r\n                var lifecycleApi = __spreadProps(__spreadValues({}, mwApi), {\r\n                    getCacheEntry: function () { return selector_1(mwApi.getState()); },\r\n                    requestId: requestId,\r\n                    extra: extra,\r\n                    updateCachedData: endpointDefinition.type === DefinitionType.query ? function (updateRecipe) { return mwApi.dispatch(api.util.updateQueryData(endpointName_1, originalArgs_1, updateRecipe)); } : void 0,\r\n                    queryFulfilled: queryFulfilled\r\n                });\r\n                onQueryStarted(originalArgs_1, lifecycleApi);\r\n            }\r\n        }\r\n        else if (isFullfilledThunk(action)) {\r\n            var _l = action.meta, requestId = _l.requestId, baseQueryMeta = _l.baseQueryMeta;\r\n            (_a = lifecycleMap[requestId]) == null ? void 0 : _a.resolve({\r\n                data: action.payload,\r\n                meta: baseQueryMeta\r\n            });\r\n            delete lifecycleMap[requestId];\r\n        }\r\n        else if (isRejectedThunk(action)) {\r\n            var _m = action.meta, requestId = _m.requestId, rejectedWithValue = _m.rejectedWithValue, baseQueryMeta = _m.baseQueryMeta;\r\n            (_c = lifecycleMap[requestId]) == null ? void 0 : _c.reject({\r\n                error: (_b = action.payload) != null ? _b : action.error,\r\n                isUnhandledError: !rejectedWithValue,\r\n                meta: baseQueryMeta\r\n            });\r\n            delete lifecycleMap[requestId];\r\n        }\r\n    };\r\n    return handler;\r\n};\r\n// src/query/core/buildMiddleware/devMiddleware.ts\r\nvar buildDevCheckHandler = function (_j) {\r\n    var api = _j.api, apiUid = _j.context.apiUid, reducerPath = _j.reducerPath;\r\n    return function (action, mwApi) {\r\n        var _a, _b;\r\n        if (api.util.resetApiState.match(action)) {\r\n            mwApi.dispatch(api.internalActions.middlewareRegistered(apiUid));\r\n        }\r\n        if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\r\n            if (api.internalActions.middlewareRegistered.match(action) && action.payload === apiUid && ((_b = (_a = mwApi.getState()[reducerPath]) == null ? void 0 : _a.config) == null ? void 0 : _b.middlewareRegistered) === \"conflict\") {\r\n                console.warn(\"There is a mismatch between slice and middleware for the reducerPath \\\"\" + reducerPath + \"\\\".\\nYou can only have one api per reducer path, this will lead to crashes in various situations!\" + (reducerPath === \"api\" ? \"\\nIf you have multiple apis, you *have* to specify the reducerPath option when using createApi!\" : \"\"));\r\n            }\r\n        }\r\n    };\r\n};\r\n// src/query/core/buildMiddleware/batchActions.ts\r\nimport { produceWithPatches as produceWithPatches2 } from \"immer\";\r\nvar promise;\r\nvar queueMicrotaskShim = typeof queueMicrotask === \"function\" ? queueMicrotask.bind(typeof window !== \"undefined\" ? window : typeof global !== \"undefined\" ? global : globalThis) : function (cb) { return (promise || (promise = Promise.resolve())).then(cb).catch(function (err) { return setTimeout(function () {\r\n    throw err;\r\n}, 0); }); };\r\nvar buildBatchedActionsHandler = function (_j) {\r\n    var api = _j.api, queryThunk = _j.queryThunk, internalState = _j.internalState;\r\n    var subscriptionsPrefix = api.reducerPath + \"/subscriptions\";\r\n    var previousSubscriptions = null;\r\n    var dispatchQueued = false;\r\n    var _k = api.internalActions, updateSubscriptionOptions = _k.updateSubscriptionOptions, unsubscribeQueryResult = _k.unsubscribeQueryResult;\r\n    var actuallyMutateSubscriptions = function (mutableState, action) {\r\n        var _a, _b, _c, _d, _e, _f, _g, _h, _i;\r\n        if (updateSubscriptionOptions.match(action)) {\r\n            var _j = action.payload, queryCacheKey = _j.queryCacheKey, requestId = _j.requestId, options = _j.options;\r\n            if ((_a = mutableState == null ? void 0 : mutableState[queryCacheKey]) == null ? void 0 : _a[requestId]) {\r\n                mutableState[queryCacheKey][requestId] = options;\r\n            }\r\n            return true;\r\n        }\r\n        if (unsubscribeQueryResult.match(action)) {\r\n            var _k = action.payload, queryCacheKey = _k.queryCacheKey, requestId = _k.requestId;\r\n            if (mutableState[queryCacheKey]) {\r\n                delete mutableState[queryCacheKey][requestId];\r\n            }\r\n            return true;\r\n        }\r\n        if (api.internalActions.removeQueryResult.match(action)) {\r\n            delete mutableState[action.payload.queryCacheKey];\r\n            return true;\r\n        }\r\n        if (queryThunk.pending.match(action)) {\r\n            var _l = action.meta, arg = _l.arg, requestId = _l.requestId;\r\n            if (arg.subscribe) {\r\n                var substate = (_c = mutableState[_b = arg.queryCacheKey]) != null ? _c : mutableState[_b] = {};\r\n                substate[requestId] = (_e = (_d = arg.subscriptionOptions) != null ? _d : substate[requestId]) != null ? _e : {};\r\n                return true;\r\n            }\r\n        }\r\n        if (queryThunk.rejected.match(action)) {\r\n            var _m = action.meta, condition = _m.condition, arg = _m.arg, requestId = _m.requestId;\r\n            if (condition && arg.subscribe) {\r\n                var substate = (_g = mutableState[_f = arg.queryCacheKey]) != null ? _g : mutableState[_f] = {};\r\n                substate[requestId] = (_i = (_h = arg.subscriptionOptions) != null ? _h : substate[requestId]) != null ? _i : {};\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    };\r\n    return function (action, mwApi) {\r\n        var _a, _b;\r\n        if (!previousSubscriptions) {\r\n            previousSubscriptions = JSON.parse(JSON.stringify(internalState.currentSubscriptions));\r\n        }\r\n        if (api.util.resetApiState.match(action)) {\r\n            previousSubscriptions = internalState.currentSubscriptions = {};\r\n            return [true, false];\r\n        }\r\n        if (api.internalActions.internal_probeSubscription.match(action)) {\r\n            var _j = action.payload, queryCacheKey = _j.queryCacheKey, requestId = _j.requestId;\r\n            var hasSubscription = !!((_a = internalState.currentSubscriptions[queryCacheKey]) == null ? void 0 : _a[requestId]);\r\n            return [false, hasSubscription];\r\n        }\r\n        var didMutate = actuallyMutateSubscriptions(internalState.currentSubscriptions, action);\r\n        if (didMutate) {\r\n            if (!dispatchQueued) {\r\n                queueMicrotaskShim(function () {\r\n                    var newSubscriptions = JSON.parse(JSON.stringify(internalState.currentSubscriptions));\r\n                    var _j = produceWithPatches2(previousSubscriptions, function () { return newSubscriptions; }), patches = _j[1];\r\n                    mwApi.next(api.internalActions.subscriptionsUpdated(patches));\r\n                    previousSubscriptions = newSubscriptions;\r\n                    dispatchQueued = false;\r\n                });\r\n                dispatchQueued = true;\r\n            }\r\n            var isSubscriptionSliceAction = !!((_b = action.type) == null ? void 0 : _b.startsWith(subscriptionsPrefix));\r\n            var isAdditionalSubscriptionAction = queryThunk.rejected.match(action) && action.meta.condition && !!action.meta.arg.subscribe;\r\n            var actionShouldContinue = !isSubscriptionSliceAction && !isAdditionalSubscriptionAction;\r\n            return [actionShouldContinue, false];\r\n        }\r\n        return [true, false];\r\n    };\r\n};\r\n// src/query/core/buildMiddleware/index.ts\r\nfunction buildMiddleware(input) {\r\n    var reducerPath = input.reducerPath, queryThunk = input.queryThunk, api = input.api, context = input.context;\r\n    var apiUid = context.apiUid;\r\n    var actions = {\r\n        invalidateTags: createAction3(reducerPath + \"/invalidateTags\")\r\n    };\r\n    var isThisApiSliceAction = function (action) {\r\n        return !!action && typeof action.type === \"string\" && action.type.startsWith(reducerPath + \"/\");\r\n    };\r\n    var handlerBuilders = [\r\n        buildDevCheckHandler,\r\n        buildCacheCollectionHandler,\r\n        buildInvalidationByTagsHandler,\r\n        buildPollingHandler,\r\n        buildCacheLifecycleHandler,\r\n        buildQueryLifecycleHandler\r\n    ];\r\n    var middleware = function (mwApi) {\r\n        var initialized2 = false;\r\n        var internalState = {\r\n            currentSubscriptions: {}\r\n        };\r\n        var builderArgs = __spreadProps(__spreadValues({}, input), {\r\n            internalState: internalState,\r\n            refetchQuery: refetchQuery\r\n        });\r\n        var handlers = handlerBuilders.map(function (build) { return build(builderArgs); });\r\n        var batchedActionsHandler = buildBatchedActionsHandler(builderArgs);\r\n        var windowEventsHandler = buildWindowEventHandler(builderArgs);\r\n        return function (next) {\r\n            return function (action) {\r\n                if (!initialized2) {\r\n                    initialized2 = true;\r\n                    mwApi.dispatch(api.internalActions.middlewareRegistered(apiUid));\r\n                }\r\n                var mwApiWithNext = __spreadProps(__spreadValues({}, mwApi), { next: next });\r\n                var stateBefore = mwApi.getState();\r\n                var _j = batchedActionsHandler(action, mwApiWithNext, stateBefore), actionShouldContinue = _j[0], hasSubscription = _j[1];\r\n                var res;\r\n                if (actionShouldContinue) {\r\n                    res = next(action);\r\n                }\r\n                else {\r\n                    res = hasSubscription;\r\n                }\r\n                if (!!mwApi.getState()[reducerPath]) {\r\n                    windowEventsHandler(action, mwApiWithNext, stateBefore);\r\n                    if (isThisApiSliceAction(action) || context.hasRehydrationInfo(action)) {\r\n                        for (var _k = 0, handlers_1 = handlers; _k < handlers_1.length; _k++) {\r\n                            var handler = handlers_1[_k];\r\n                            handler(action, mwApiWithNext, stateBefore);\r\n                        }\r\n                    }\r\n                }\r\n                return res;\r\n            };\r\n        };\r\n    };\r\n    return { middleware: middleware, actions: actions };\r\n    function refetchQuery(querySubState, queryCacheKey, override) {\r\n        if (override === void 0) { override = {}; }\r\n        return queryThunk(__spreadValues({\r\n            type: \"query\",\r\n            endpointName: querySubState.endpointName,\r\n            originalArgs: querySubState.originalArgs,\r\n            subscribe: false,\r\n            forceRefetch: true,\r\n            queryCacheKey: queryCacheKey\r\n        }, override));\r\n    }\r\n}\r\n// src/query/tsHelpers.ts\r\nfunction assertCast(v) {\r\n}\r\nfunction safeAssign(target) {\r\n    var args = [];\r\n    for (var _j = 1; _j < arguments.length; _j++) {\r\n        args[_j - 1] = arguments[_j];\r\n    }\r\n    Object.assign.apply(Object, __spreadArray([target], args));\r\n}\r\n// src/query/core/module.ts\r\nimport { enablePatches } from \"immer\";\r\nvar coreModuleName = /* @__PURE__ */ Symbol();\r\nvar coreModule = function () { return ({\r\n    name: coreModuleName,\r\n    init: function (api, _j, context) {\r\n        var baseQuery = _j.baseQuery, tagTypes = _j.tagTypes, reducerPath = _j.reducerPath, serializeQueryArgs = _j.serializeQueryArgs, keepUnusedDataFor = _j.keepUnusedDataFor, refetchOnMountOrArgChange = _j.refetchOnMountOrArgChange, refetchOnFocus = _j.refetchOnFocus, refetchOnReconnect = _j.refetchOnReconnect;\r\n        enablePatches();\r\n        assertCast(serializeQueryArgs);\r\n        var assertTagType = function (tag) {\r\n            if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\r\n                if (!tagTypes.includes(tag.type)) {\r\n                    console.error(\"Tag type '\" + tag.type + \"' was used, but not specified in `tagTypes`!\");\r\n                }\r\n            }\r\n            return tag;\r\n        };\r\n        Object.assign(api, {\r\n            reducerPath: reducerPath,\r\n            endpoints: {},\r\n            internalActions: {\r\n                onOnline: onOnline,\r\n                onOffline: onOffline,\r\n                onFocus: onFocus,\r\n                onFocusLost: onFocusLost\r\n            },\r\n            util: {}\r\n        });\r\n        var _k = buildThunks({\r\n            baseQuery: baseQuery,\r\n            reducerPath: reducerPath,\r\n            context: context,\r\n            api: api,\r\n            serializeQueryArgs: serializeQueryArgs,\r\n            assertTagType: assertTagType\r\n        }), queryThunk = _k.queryThunk, mutationThunk = _k.mutationThunk, patchQueryData = _k.patchQueryData, updateQueryData = _k.updateQueryData, upsertQueryData = _k.upsertQueryData, prefetch = _k.prefetch, buildMatchThunkActions = _k.buildMatchThunkActions;\r\n        var _l = buildSlice({\r\n            context: context,\r\n            queryThunk: queryThunk,\r\n            mutationThunk: mutationThunk,\r\n            reducerPath: reducerPath,\r\n            assertTagType: assertTagType,\r\n            config: {\r\n                refetchOnFocus: refetchOnFocus,\r\n                refetchOnReconnect: refetchOnReconnect,\r\n                refetchOnMountOrArgChange: refetchOnMountOrArgChange,\r\n                keepUnusedDataFor: keepUnusedDataFor,\r\n                reducerPath: reducerPath\r\n            }\r\n        }), reducer = _l.reducer, sliceActions = _l.actions;\r\n        safeAssign(api.util, {\r\n            patchQueryData: patchQueryData,\r\n            updateQueryData: updateQueryData,\r\n            upsertQueryData: upsertQueryData,\r\n            prefetch: prefetch,\r\n            resetApiState: sliceActions.resetApiState\r\n        });\r\n        safeAssign(api.internalActions, sliceActions);\r\n        var _m = buildMiddleware({\r\n            reducerPath: reducerPath,\r\n            context: context,\r\n            queryThunk: queryThunk,\r\n            mutationThunk: mutationThunk,\r\n            api: api,\r\n            assertTagType: assertTagType\r\n        }), middleware = _m.middleware, middlewareActions = _m.actions;\r\n        safeAssign(api.util, middlewareActions);\r\n        safeAssign(api, { reducer: reducer, middleware: middleware });\r\n        var _o = buildSelectors({\r\n            serializeQueryArgs: serializeQueryArgs,\r\n            reducerPath: reducerPath\r\n        }), buildQuerySelector = _o.buildQuerySelector, buildMutationSelector = _o.buildMutationSelector, selectInvalidatedBy = _o.selectInvalidatedBy;\r\n        safeAssign(api.util, { selectInvalidatedBy: selectInvalidatedBy });\r\n        var _p = buildInitiate({\r\n            queryThunk: queryThunk,\r\n            mutationThunk: mutationThunk,\r\n            api: api,\r\n            serializeQueryArgs: serializeQueryArgs,\r\n            context: context\r\n        }), buildInitiateQuery = _p.buildInitiateQuery, buildInitiateMutation = _p.buildInitiateMutation, getRunningMutationThunk = _p.getRunningMutationThunk, getRunningMutationsThunk = _p.getRunningMutationsThunk, getRunningQueriesThunk = _p.getRunningQueriesThunk, getRunningQueryThunk = _p.getRunningQueryThunk, getRunningOperationPromises = _p.getRunningOperationPromises, removalWarning = _p.removalWarning;\r\n        safeAssign(api.util, {\r\n            getRunningOperationPromises: getRunningOperationPromises,\r\n            getRunningOperationPromise: removalWarning,\r\n            getRunningMutationThunk: getRunningMutationThunk,\r\n            getRunningMutationsThunk: getRunningMutationsThunk,\r\n            getRunningQueryThunk: getRunningQueryThunk,\r\n            getRunningQueriesThunk: getRunningQueriesThunk\r\n        });\r\n        return {\r\n            name: coreModuleName,\r\n            injectEndpoint: function (endpointName, definition) {\r\n                var _a, _b;\r\n                var anyApi = api;\r\n                (_b = (_a = anyApi.endpoints)[endpointName]) != null ? _b : _a[endpointName] = {};\r\n                if (isQueryDefinition(definition)) {\r\n                    safeAssign(anyApi.endpoints[endpointName], {\r\n                        name: endpointName,\r\n                        select: buildQuerySelector(endpointName, definition),\r\n                        initiate: buildInitiateQuery(endpointName, definition)\r\n                    }, buildMatchThunkActions(queryThunk, endpointName));\r\n                }\r\n                else if (isMutationDefinition(definition)) {\r\n                    safeAssign(anyApi.endpoints[endpointName], {\r\n                        name: endpointName,\r\n                        select: buildMutationSelector(),\r\n                        initiate: buildInitiateMutation(endpointName)\r\n                    }, buildMatchThunkActions(mutationThunk, endpointName));\r\n                }\r\n            }\r\n        };\r\n    }\r\n}); };\r\n// src/query/core/index.ts\r\nvar createApi = /* @__PURE__ */ buildCreateApi(coreModule());\r\nexport { QueryStatus, buildCreateApi, copyWithStructuralSharing, coreModule, coreModuleName, createApi, defaultSerializeQueryArgs, fakeBaseQuery, fetchBaseQuery, retry, setupListeners, skipSelector, skipToken };\r\n//# sourceMappingURL=rtk-query.esm.js.map","var __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        if (typeof b !== \"function\" && b !== null)\r\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nvar __generator = (this && this.__generator) || function (thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n};\r\nvar __spreadArray = (this && this.__spreadArray) || function (to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n};\r\nvar __defProp = Object.defineProperty;\r\nvar __defProps = Object.defineProperties;\r\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\r\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\r\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\r\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\r\nvar __defNormalProp = function (obj, key, value) { return key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value: value }) : obj[key] = value; };\r\nvar __spreadValues = function (a, b) {\r\n    for (var prop in b || (b = {}))\r\n        if (__hasOwnProp.call(b, prop))\r\n            __defNormalProp(a, prop, b[prop]);\r\n    if (__getOwnPropSymbols)\r\n        for (var _i = 0, _c = __getOwnPropSymbols(b); _i < _c.length; _i++) {\r\n            var prop = _c[_i];\r\n            if (__propIsEnum.call(b, prop))\r\n                __defNormalProp(a, prop, b[prop]);\r\n        }\r\n    return a;\r\n};\r\nvar __spreadProps = function (a, b) { return __defProps(a, __getOwnPropDescs(b)); };\r\nvar __async = function (__this, __arguments, generator) {\r\n    return new Promise(function (resolve, reject) {\r\n        var fulfilled = function (value) {\r\n            try {\r\n                step(generator.next(value));\r\n            }\r\n            catch (e) {\r\n                reject(e);\r\n            }\r\n        };\r\n        var rejected = function (value) {\r\n            try {\r\n                step(generator.throw(value));\r\n            }\r\n            catch (e) {\r\n                reject(e);\r\n            }\r\n        };\r\n        var step = function (x) { return x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); };\r\n        step((generator = generator.apply(__this, __arguments)).next());\r\n    });\r\n};\r\n// src/index.ts\r\nimport { enableES5 } from \"immer\";\r\nexport * from \"redux\";\r\nimport { default as default2, current as current2, freeze, original, isDraft as isDraft4 } from \"immer\";\r\nimport { createSelector as createSelector2 } from \"reselect\";\r\n// src/createDraftSafeSelector.ts\r\nimport { current, isDraft } from \"immer\";\r\nimport { createSelector } from \"reselect\";\r\nvar createDraftSafeSelector = function () {\r\n    var args = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        args[_i] = arguments[_i];\r\n    }\r\n    var selector = createSelector.apply(void 0, args);\r\n    var wrappedSelector = function (value) {\r\n        var rest = [];\r\n        for (var _i = 1; _i < arguments.length; _i++) {\r\n            rest[_i - 1] = arguments[_i];\r\n        }\r\n        return selector.apply(void 0, __spreadArray([isDraft(value) ? current(value) : value], rest));\r\n    };\r\n    return wrappedSelector;\r\n};\r\n// src/configureStore.ts\r\nimport { createStore, compose as compose2, applyMiddleware, combineReducers } from \"redux\";\r\n// src/devtoolsExtension.ts\r\nimport { compose } from \"redux\";\r\nvar composeWithDevTools = typeof window !== \"undefined\" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function () {\r\n    if (arguments.length === 0)\r\n        return void 0;\r\n    if (typeof arguments[0] === \"object\")\r\n        return compose;\r\n    return compose.apply(null, arguments);\r\n};\r\nvar devToolsEnhancer = typeof window !== \"undefined\" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function () {\r\n    return function (noop2) {\r\n        return noop2;\r\n    };\r\n};\r\n// src/isPlainObject.ts\r\nfunction isPlainObject(value) {\r\n    if (typeof value !== \"object\" || value === null)\r\n        return false;\r\n    var proto = Object.getPrototypeOf(value);\r\n    if (proto === null)\r\n        return true;\r\n    var baseProto = proto;\r\n    while (Object.getPrototypeOf(baseProto) !== null) {\r\n        baseProto = Object.getPrototypeOf(baseProto);\r\n    }\r\n    return proto === baseProto;\r\n}\r\n// src/getDefaultMiddleware.ts\r\nimport thunkMiddleware from \"redux-thunk\";\r\n// src/tsHelpers.ts\r\nvar hasMatchFunction = function (v) {\r\n    return v && typeof v.match === \"function\";\r\n};\r\n// src/createAction.ts\r\nfunction createAction(type, prepareAction) {\r\n    function actionCreator() {\r\n        var args = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            args[_i] = arguments[_i];\r\n        }\r\n        if (prepareAction) {\r\n            var prepared = prepareAction.apply(void 0, args);\r\n            if (!prepared) {\r\n                throw new Error(\"prepareAction did not return an object\");\r\n            }\r\n            return __spreadValues(__spreadValues({\r\n                type: type,\r\n                payload: prepared.payload\r\n            }, \"meta\" in prepared && { meta: prepared.meta }), \"error\" in prepared && { error: prepared.error });\r\n        }\r\n        return { type: type, payload: args[0] };\r\n    }\r\n    actionCreator.toString = function () { return \"\" + type; };\r\n    actionCreator.type = type;\r\n    actionCreator.match = function (action) { return action.type === type; };\r\n    return actionCreator;\r\n}\r\nfunction isAction(action) {\r\n    return isPlainObject(action) && \"type\" in action;\r\n}\r\nfunction isActionCreator(action) {\r\n    return typeof action === \"function\" && \"type\" in action && hasMatchFunction(action);\r\n}\r\nfunction isFSA(action) {\r\n    return isAction(action) && typeof action.type === \"string\" && Object.keys(action).every(isValidKey);\r\n}\r\nfunction isValidKey(key) {\r\n    return [\"type\", \"payload\", \"error\", \"meta\"].indexOf(key) > -1;\r\n}\r\nfunction getType(actionCreator) {\r\n    return \"\" + actionCreator;\r\n}\r\n// src/actionCreatorInvariantMiddleware.ts\r\nfunction getMessage(type) {\r\n    var splitType = type ? (\"\" + type).split(\"/\") : [];\r\n    var actionName = splitType[splitType.length - 1] || \"actionCreator\";\r\n    return \"Detected an action creator with type \\\"\" + (type || \"unknown\") + \"\\\" being dispatched. \\nMake sure you're calling the action creator before dispatching, i.e. `dispatch(\" + actionName + \"())` instead of `dispatch(\" + actionName + \")`. This is necessary even if the action has no payload.\";\r\n}\r\nfunction createActionCreatorInvariantMiddleware(options) {\r\n    if (options === void 0) { options = {}; }\r\n    if (process.env.NODE_ENV === \"production\") {\r\n        return function () { return function (next) { return function (action) { return next(action); }; }; };\r\n    }\r\n    var _c = options.isActionCreator, isActionCreator2 = _c === void 0 ? isActionCreator : _c;\r\n    return function () { return function (next) { return function (action) {\r\n        if (isActionCreator2(action)) {\r\n            console.warn(getMessage(action.type));\r\n        }\r\n        return next(action);\r\n    }; }; };\r\n}\r\n// src/utils.ts\r\nimport createNextState, { isDraftable } from \"immer\";\r\nfunction getTimeMeasureUtils(maxDelay, fnName) {\r\n    var elapsed = 0;\r\n    return {\r\n        measureTime: function (fn) {\r\n            var started = Date.now();\r\n            try {\r\n                return fn();\r\n            }\r\n            finally {\r\n                var finished = Date.now();\r\n                elapsed += finished - started;\r\n            }\r\n        },\r\n        warnIfExceeded: function () {\r\n            if (elapsed > maxDelay) {\r\n                console.warn(fnName + \" took \" + elapsed + \"ms, which is more than the warning threshold of \" + maxDelay + \"ms. \\nIf your state or actions are very large, you may want to disable the middleware as it might cause too much of a slowdown in development mode. See https://redux-toolkit.js.org/api/getDefaultMiddleware for instructions.\\nIt is disabled in production builds, so you don't need to worry about that.\");\r\n            }\r\n        }\r\n    };\r\n}\r\nvar MiddlewareArray = /** @class */ (function (_super) {\r\n    __extends(MiddlewareArray, _super);\r\n    function MiddlewareArray() {\r\n        var args = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            args[_i] = arguments[_i];\r\n        }\r\n        var _this = _super.apply(this, args) || this;\r\n        Object.setPrototypeOf(_this, MiddlewareArray.prototype);\r\n        return _this;\r\n    }\r\n    Object.defineProperty(MiddlewareArray, Symbol.species, {\r\n        get: function () {\r\n            return MiddlewareArray;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    MiddlewareArray.prototype.concat = function () {\r\n        var arr = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            arr[_i] = arguments[_i];\r\n        }\r\n        return _super.prototype.concat.apply(this, arr);\r\n    };\r\n    MiddlewareArray.prototype.prepend = function () {\r\n        var arr = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            arr[_i] = arguments[_i];\r\n        }\r\n        if (arr.length === 1 && Array.isArray(arr[0])) {\r\n            return new (MiddlewareArray.bind.apply(MiddlewareArray, __spreadArray([void 0], arr[0].concat(this))))();\r\n        }\r\n        return new (MiddlewareArray.bind.apply(MiddlewareArray, __spreadArray([void 0], arr.concat(this))))();\r\n    };\r\n    return MiddlewareArray;\r\n}(Array));\r\nvar EnhancerArray = /** @class */ (function (_super) {\r\n    __extends(EnhancerArray, _super);\r\n    function EnhancerArray() {\r\n        var args = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            args[_i] = arguments[_i];\r\n        }\r\n        var _this = _super.apply(this, args) || this;\r\n        Object.setPrototypeOf(_this, EnhancerArray.prototype);\r\n        return _this;\r\n    }\r\n    Object.defineProperty(EnhancerArray, Symbol.species, {\r\n        get: function () {\r\n            return EnhancerArray;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    EnhancerArray.prototype.concat = function () {\r\n        var arr = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            arr[_i] = arguments[_i];\r\n        }\r\n        return _super.prototype.concat.apply(this, arr);\r\n    };\r\n    EnhancerArray.prototype.prepend = function () {\r\n        var arr = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            arr[_i] = arguments[_i];\r\n        }\r\n        if (arr.length === 1 && Array.isArray(arr[0])) {\r\n            return new (EnhancerArray.bind.apply(EnhancerArray, __spreadArray([void 0], arr[0].concat(this))))();\r\n        }\r\n        return new (EnhancerArray.bind.apply(EnhancerArray, __spreadArray([void 0], arr.concat(this))))();\r\n    };\r\n    return EnhancerArray;\r\n}(Array));\r\nfunction freezeDraftable(val) {\r\n    return isDraftable(val) ? createNextState(val, function () {\r\n    }) : val;\r\n}\r\n// src/immutableStateInvariantMiddleware.ts\r\nvar isProduction = process.env.NODE_ENV === \"production\";\r\nvar prefix = \"Invariant failed\";\r\nfunction invariant(condition, message) {\r\n    if (condition) {\r\n        return;\r\n    }\r\n    if (isProduction) {\r\n        throw new Error(prefix);\r\n    }\r\n    throw new Error(prefix + \": \" + (message || \"\"));\r\n}\r\nfunction stringify(obj, serializer, indent, decycler) {\r\n    return JSON.stringify(obj, getSerialize(serializer, decycler), indent);\r\n}\r\nfunction getSerialize(serializer, decycler) {\r\n    var stack = [], keys = [];\r\n    if (!decycler)\r\n        decycler = function (_, value) {\r\n            if (stack[0] === value)\r\n                return \"[Circular ~]\";\r\n            return \"[Circular ~.\" + keys.slice(0, stack.indexOf(value)).join(\".\") + \"]\";\r\n        };\r\n    return function (key, value) {\r\n        if (stack.length > 0) {\r\n            var thisPos = stack.indexOf(this);\r\n            ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);\r\n            ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);\r\n            if (~stack.indexOf(value))\r\n                value = decycler.call(this, key, value);\r\n        }\r\n        else\r\n            stack.push(value);\r\n        return serializer == null ? value : serializer.call(this, key, value);\r\n    };\r\n}\r\nfunction isImmutableDefault(value) {\r\n    return typeof value !== \"object\" || value == null || Object.isFrozen(value);\r\n}\r\nfunction trackForMutations(isImmutable, ignorePaths, obj) {\r\n    var trackedProperties = trackProperties(isImmutable, ignorePaths, obj);\r\n    return {\r\n        detectMutations: function () {\r\n            return detectMutations(isImmutable, ignorePaths, trackedProperties, obj);\r\n        }\r\n    };\r\n}\r\nfunction trackProperties(isImmutable, ignorePaths, obj, path, checkedObjects) {\r\n    if (ignorePaths === void 0) { ignorePaths = []; }\r\n    if (path === void 0) { path = \"\"; }\r\n    if (checkedObjects === void 0) { checkedObjects = new Set(); }\r\n    var tracked = { value: obj };\r\n    if (!isImmutable(obj) && !checkedObjects.has(obj)) {\r\n        checkedObjects.add(obj);\r\n        tracked.children = {};\r\n        for (var key in obj) {\r\n            var childPath = path ? path + \".\" + key : key;\r\n            if (ignorePaths.length && ignorePaths.indexOf(childPath) !== -1) {\r\n                continue;\r\n            }\r\n            tracked.children[key] = trackProperties(isImmutable, ignorePaths, obj[key], childPath);\r\n        }\r\n    }\r\n    return tracked;\r\n}\r\nfunction detectMutations(isImmutable, ignoredPaths, trackedProperty, obj, sameParentRef, path) {\r\n    if (ignoredPaths === void 0) { ignoredPaths = []; }\r\n    if (sameParentRef === void 0) { sameParentRef = false; }\r\n    if (path === void 0) { path = \"\"; }\r\n    var prevObj = trackedProperty ? trackedProperty.value : void 0;\r\n    var sameRef = prevObj === obj;\r\n    if (sameParentRef && !sameRef && !Number.isNaN(obj)) {\r\n        return { wasMutated: true, path: path };\r\n    }\r\n    if (isImmutable(prevObj) || isImmutable(obj)) {\r\n        return { wasMutated: false };\r\n    }\r\n    var keysToDetect = {};\r\n    for (var key in trackedProperty.children) {\r\n        keysToDetect[key] = true;\r\n    }\r\n    for (var key in obj) {\r\n        keysToDetect[key] = true;\r\n    }\r\n    var hasIgnoredPaths = ignoredPaths.length > 0;\r\n    var _loop_1 = function (key) {\r\n        var nestedPath = path ? path + \".\" + key : key;\r\n        if (hasIgnoredPaths) {\r\n            var hasMatches = ignoredPaths.some(function (ignored) {\r\n                if (ignored instanceof RegExp) {\r\n                    return ignored.test(nestedPath);\r\n                }\r\n                return nestedPath === ignored;\r\n            });\r\n            if (hasMatches) {\r\n                return \"continue\";\r\n            }\r\n        }\r\n        var result = detectMutations(isImmutable, ignoredPaths, trackedProperty.children[key], obj[key], sameRef, nestedPath);\r\n        if (result.wasMutated) {\r\n            return { value: result };\r\n        }\r\n    };\r\n    for (var key in keysToDetect) {\r\n        var state_1 = _loop_1(key);\r\n        if (typeof state_1 === \"object\")\r\n            return state_1.value;\r\n    }\r\n    return { wasMutated: false };\r\n}\r\nfunction createImmutableStateInvariantMiddleware(options) {\r\n    if (options === void 0) { options = {}; }\r\n    if (process.env.NODE_ENV === \"production\") {\r\n        return function () { return function (next) { return function (action) { return next(action); }; }; };\r\n    }\r\n    var _c = options.isImmutable, isImmutable = _c === void 0 ? isImmutableDefault : _c, ignoredPaths = options.ignoredPaths, _d = options.warnAfter, warnAfter = _d === void 0 ? 32 : _d, ignore = options.ignore;\r\n    ignoredPaths = ignoredPaths || ignore;\r\n    var track = trackForMutations.bind(null, isImmutable, ignoredPaths);\r\n    return function (_c) {\r\n        var getState = _c.getState;\r\n        var state = getState();\r\n        var tracker = track(state);\r\n        var result;\r\n        return function (next) { return function (action) {\r\n            var measureUtils = getTimeMeasureUtils(warnAfter, \"ImmutableStateInvariantMiddleware\");\r\n            measureUtils.measureTime(function () {\r\n                state = getState();\r\n                result = tracker.detectMutations();\r\n                tracker = track(state);\r\n                invariant(!result.wasMutated, \"A state mutation was detected between dispatches, in the path '\" + (result.path || \"\") + \"'.  This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)\");\r\n            });\r\n            var dispatchedAction = next(action);\r\n            measureUtils.measureTime(function () {\r\n                state = getState();\r\n                result = tracker.detectMutations();\r\n                tracker = track(state);\r\n                result.wasMutated && invariant(!result.wasMutated, \"A state mutation was detected inside a dispatch, in the path: \" + (result.path || \"\") + \". Take a look at the reducer(s) handling the action \" + stringify(action) + \". (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)\");\r\n            });\r\n            measureUtils.warnIfExceeded();\r\n            return dispatchedAction;\r\n        }; };\r\n    };\r\n}\r\n// src/serializableStateInvariantMiddleware.ts\r\nfunction isPlain(val) {\r\n    var type = typeof val;\r\n    return val == null || type === \"string\" || type === \"boolean\" || type === \"number\" || Array.isArray(val) || isPlainObject(val);\r\n}\r\nfunction findNonSerializableValue(value, path, isSerializable, getEntries, ignoredPaths, cache) {\r\n    if (path === void 0) { path = \"\"; }\r\n    if (isSerializable === void 0) { isSerializable = isPlain; }\r\n    if (ignoredPaths === void 0) { ignoredPaths = []; }\r\n    var foundNestedSerializable;\r\n    if (!isSerializable(value)) {\r\n        return {\r\n            keyPath: path || \"<root>\",\r\n            value: value\r\n        };\r\n    }\r\n    if (typeof value !== \"object\" || value === null) {\r\n        return false;\r\n    }\r\n    if (cache == null ? void 0 : cache.has(value))\r\n        return false;\r\n    var entries = getEntries != null ? getEntries(value) : Object.entries(value);\r\n    var hasIgnoredPaths = ignoredPaths.length > 0;\r\n    var _loop_2 = function (key, nestedValue) {\r\n        var nestedPath = path ? path + \".\" + key : key;\r\n        if (hasIgnoredPaths) {\r\n            var hasMatches = ignoredPaths.some(function (ignored) {\r\n                if (ignored instanceof RegExp) {\r\n                    return ignored.test(nestedPath);\r\n                }\r\n                return nestedPath === ignored;\r\n            });\r\n            if (hasMatches) {\r\n                return \"continue\";\r\n            }\r\n        }\r\n        if (!isSerializable(nestedValue)) {\r\n            return { value: {\r\n                    keyPath: nestedPath,\r\n                    value: nestedValue\r\n                } };\r\n        }\r\n        if (typeof nestedValue === \"object\") {\r\n            foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries, ignoredPaths, cache);\r\n            if (foundNestedSerializable) {\r\n                return { value: foundNestedSerializable };\r\n            }\r\n        }\r\n    };\r\n    for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\r\n        var _c = entries_1[_i], key = _c[0], nestedValue = _c[1];\r\n        var state_2 = _loop_2(key, nestedValue);\r\n        if (typeof state_2 === \"object\")\r\n            return state_2.value;\r\n    }\r\n    if (cache && isNestedFrozen(value))\r\n        cache.add(value);\r\n    return false;\r\n}\r\nfunction isNestedFrozen(value) {\r\n    if (!Object.isFrozen(value))\r\n        return false;\r\n    for (var _i = 0, _c = Object.values(value); _i < _c.length; _i++) {\r\n        var nestedValue = _c[_i];\r\n        if (typeof nestedValue !== \"object\" || nestedValue === null)\r\n            continue;\r\n        if (!isNestedFrozen(nestedValue))\r\n            return false;\r\n    }\r\n    return true;\r\n}\r\nfunction createSerializableStateInvariantMiddleware(options) {\r\n    if (options === void 0) { options = {}; }\r\n    if (process.env.NODE_ENV === \"production\") {\r\n        return function () { return function (next) { return function (action) { return next(action); }; }; };\r\n    }\r\n    var _c = options.isSerializable, isSerializable = _c === void 0 ? isPlain : _c, getEntries = options.getEntries, _d = options.ignoredActions, ignoredActions = _d === void 0 ? [] : _d, _e = options.ignoredActionPaths, ignoredActionPaths = _e === void 0 ? [\"meta.arg\", \"meta.baseQueryMeta\"] : _e, _f = options.ignoredPaths, ignoredPaths = _f === void 0 ? [] : _f, _g = options.warnAfter, warnAfter = _g === void 0 ? 32 : _g, _h = options.ignoreState, ignoreState = _h === void 0 ? false : _h, _j = options.ignoreActions, ignoreActions = _j === void 0 ? false : _j, _k = options.disableCache, disableCache = _k === void 0 ? false : _k;\r\n    var cache = !disableCache && WeakSet ? new WeakSet() : void 0;\r\n    return function (storeAPI) { return function (next) { return function (action) {\r\n        var result = next(action);\r\n        var measureUtils = getTimeMeasureUtils(warnAfter, \"SerializableStateInvariantMiddleware\");\r\n        if (!ignoreActions && !(ignoredActions.length && ignoredActions.indexOf(action.type) !== -1)) {\r\n            measureUtils.measureTime(function () {\r\n                var foundActionNonSerializableValue = findNonSerializableValue(action, \"\", isSerializable, getEntries, ignoredActionPaths, cache);\r\n                if (foundActionNonSerializableValue) {\r\n                    var keyPath = foundActionNonSerializableValue.keyPath, value = foundActionNonSerializableValue.value;\r\n                    console.error(\"A non-serializable value was detected in an action, in the path: `\" + keyPath + \"`. Value:\", value, \"\\nTake a look at the logic that dispatched this action: \", action, \"\\n(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)\", \"\\n(To allow non-serializable values see: https://redux-toolkit.js.org/usage/usage-guide#working-with-non-serializable-data)\");\r\n                }\r\n            });\r\n        }\r\n        if (!ignoreState) {\r\n            measureUtils.measureTime(function () {\r\n                var state = storeAPI.getState();\r\n                var foundStateNonSerializableValue = findNonSerializableValue(state, \"\", isSerializable, getEntries, ignoredPaths, cache);\r\n                if (foundStateNonSerializableValue) {\r\n                    var keyPath = foundStateNonSerializableValue.keyPath, value = foundStateNonSerializableValue.value;\r\n                    console.error(\"A non-serializable value was detected in the state, in the path: `\" + keyPath + \"`. Value:\", value, \"\\nTake a look at the reducer(s) handling this action type: \" + action.type + \".\\n(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)\");\r\n                }\r\n            });\r\n            measureUtils.warnIfExceeded();\r\n        }\r\n        return result;\r\n    }; }; };\r\n}\r\n// src/getDefaultMiddleware.ts\r\nfunction isBoolean(x) {\r\n    return typeof x === \"boolean\";\r\n}\r\nfunction curryGetDefaultMiddleware() {\r\n    return function curriedGetDefaultMiddleware(options) {\r\n        return getDefaultMiddleware(options);\r\n    };\r\n}\r\nfunction getDefaultMiddleware(options) {\r\n    if (options === void 0) { options = {}; }\r\n    var _c = options.thunk, thunk = _c === void 0 ? true : _c, _d = options.immutableCheck, immutableCheck = _d === void 0 ? true : _d, _e = options.serializableCheck, serializableCheck = _e === void 0 ? true : _e, _f = options.actionCreatorCheck, actionCreatorCheck = _f === void 0 ? true : _f;\r\n    var middlewareArray = new MiddlewareArray();\r\n    if (thunk) {\r\n        if (isBoolean(thunk)) {\r\n            middlewareArray.push(thunkMiddleware);\r\n        }\r\n        else {\r\n            middlewareArray.push(thunkMiddleware.withExtraArgument(thunk.extraArgument));\r\n        }\r\n    }\r\n    if (process.env.NODE_ENV !== \"production\") {\r\n        if (immutableCheck) {\r\n            var immutableOptions = {};\r\n            if (!isBoolean(immutableCheck)) {\r\n                immutableOptions = immutableCheck;\r\n            }\r\n            middlewareArray.unshift(createImmutableStateInvariantMiddleware(immutableOptions));\r\n        }\r\n        if (serializableCheck) {\r\n            var serializableOptions = {};\r\n            if (!isBoolean(serializableCheck)) {\r\n                serializableOptions = serializableCheck;\r\n            }\r\n            middlewareArray.push(createSerializableStateInvariantMiddleware(serializableOptions));\r\n        }\r\n        if (actionCreatorCheck) {\r\n            var actionCreatorOptions = {};\r\n            if (!isBoolean(actionCreatorCheck)) {\r\n                actionCreatorOptions = actionCreatorCheck;\r\n            }\r\n            middlewareArray.unshift(createActionCreatorInvariantMiddleware(actionCreatorOptions));\r\n        }\r\n    }\r\n    return middlewareArray;\r\n}\r\n// src/configureStore.ts\r\nvar IS_PRODUCTION = process.env.NODE_ENV === \"production\";\r\nfunction configureStore(options) {\r\n    var curriedGetDefaultMiddleware = curryGetDefaultMiddleware();\r\n    var _c = options || {}, _d = _c.reducer, reducer = _d === void 0 ? void 0 : _d, _e = _c.middleware, middleware = _e === void 0 ? curriedGetDefaultMiddleware() : _e, _f = _c.devTools, devTools = _f === void 0 ? true : _f, _g = _c.preloadedState, preloadedState = _g === void 0 ? void 0 : _g, _h = _c.enhancers, enhancers = _h === void 0 ? void 0 : _h;\r\n    var rootReducer;\r\n    if (typeof reducer === \"function\") {\r\n        rootReducer = reducer;\r\n    }\r\n    else if (isPlainObject(reducer)) {\r\n        rootReducer = combineReducers(reducer);\r\n    }\r\n    else {\r\n        throw new Error('\"reducer\" is a required argument, and must be a function or an object of functions that can be passed to combineReducers');\r\n    }\r\n    var finalMiddleware = middleware;\r\n    if (typeof finalMiddleware === \"function\") {\r\n        finalMiddleware = finalMiddleware(curriedGetDefaultMiddleware);\r\n        if (!IS_PRODUCTION && !Array.isArray(finalMiddleware)) {\r\n            throw new Error(\"when using a middleware builder function, an array of middleware must be returned\");\r\n        }\r\n    }\r\n    if (!IS_PRODUCTION && finalMiddleware.some(function (item) { return typeof item !== \"function\"; })) {\r\n        throw new Error(\"each middleware provided to configureStore must be a function\");\r\n    }\r\n    var middlewareEnhancer = applyMiddleware.apply(void 0, finalMiddleware);\r\n    var finalCompose = compose2;\r\n    if (devTools) {\r\n        finalCompose = composeWithDevTools(__spreadValues({\r\n            trace: !IS_PRODUCTION\r\n        }, typeof devTools === \"object\" && devTools));\r\n    }\r\n    var defaultEnhancers = new EnhancerArray(middlewareEnhancer);\r\n    var storeEnhancers = defaultEnhancers;\r\n    if (Array.isArray(enhancers)) {\r\n        storeEnhancers = __spreadArray([middlewareEnhancer], enhancers);\r\n    }\r\n    else if (typeof enhancers === \"function\") {\r\n        storeEnhancers = enhancers(defaultEnhancers);\r\n    }\r\n    var composedEnhancer = finalCompose.apply(void 0, storeEnhancers);\r\n    return createStore(rootReducer, preloadedState, composedEnhancer);\r\n}\r\n// src/createReducer.ts\r\nimport createNextState2, { isDraft as isDraft2, isDraftable as isDraftable2 } from \"immer\";\r\n// src/mapBuilders.ts\r\nfunction executeReducerBuilderCallback(builderCallback) {\r\n    var actionsMap = {};\r\n    var actionMatchers = [];\r\n    var defaultCaseReducer;\r\n    var builder = {\r\n        addCase: function (typeOrActionCreator, reducer) {\r\n            if (process.env.NODE_ENV !== \"production\") {\r\n                if (actionMatchers.length > 0) {\r\n                    throw new Error(\"`builder.addCase` should only be called before calling `builder.addMatcher`\");\r\n                }\r\n                if (defaultCaseReducer) {\r\n                    throw new Error(\"`builder.addCase` should only be called before calling `builder.addDefaultCase`\");\r\n                }\r\n            }\r\n            var type = typeof typeOrActionCreator === \"string\" ? typeOrActionCreator : typeOrActionCreator.type;\r\n            if (!type) {\r\n                throw new Error(\"`builder.addCase` cannot be called with an empty action type\");\r\n            }\r\n            if (type in actionsMap) {\r\n                throw new Error(\"`builder.addCase` cannot be called with two reducers for the same action type\");\r\n            }\r\n            actionsMap[type] = reducer;\r\n            return builder;\r\n        },\r\n        addMatcher: function (matcher, reducer) {\r\n            if (process.env.NODE_ENV !== \"production\") {\r\n                if (defaultCaseReducer) {\r\n                    throw new Error(\"`builder.addMatcher` should only be called before calling `builder.addDefaultCase`\");\r\n                }\r\n            }\r\n            actionMatchers.push({ matcher: matcher, reducer: reducer });\r\n            return builder;\r\n        },\r\n        addDefaultCase: function (reducer) {\r\n            if (process.env.NODE_ENV !== \"production\") {\r\n                if (defaultCaseReducer) {\r\n                    throw new Error(\"`builder.addDefaultCase` can only be called once\");\r\n                }\r\n            }\r\n            defaultCaseReducer = reducer;\r\n            return builder;\r\n        }\r\n    };\r\n    builderCallback(builder);\r\n    return [actionsMap, actionMatchers, defaultCaseReducer];\r\n}\r\n// src/createReducer.ts\r\nfunction isStateFunction(x) {\r\n    return typeof x === \"function\";\r\n}\r\nvar hasWarnedAboutObjectNotation = false;\r\nfunction createReducer(initialState, mapOrBuilderCallback, actionMatchers, defaultCaseReducer) {\r\n    if (actionMatchers === void 0) { actionMatchers = []; }\r\n    if (process.env.NODE_ENV !== \"production\") {\r\n        if (typeof mapOrBuilderCallback === \"object\") {\r\n            if (!hasWarnedAboutObjectNotation) {\r\n                hasWarnedAboutObjectNotation = true;\r\n                console.warn(\"The object notation for `createReducer` is deprecated, and will be removed in RTK 2.0. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer\");\r\n            }\r\n        }\r\n    }\r\n    var _c = typeof mapOrBuilderCallback === \"function\" ? executeReducerBuilderCallback(mapOrBuilderCallback) : [mapOrBuilderCallback, actionMatchers, defaultCaseReducer], actionsMap = _c[0], finalActionMatchers = _c[1], finalDefaultCaseReducer = _c[2];\r\n    var getInitialState;\r\n    if (isStateFunction(initialState)) {\r\n        getInitialState = function () { return freezeDraftable(initialState()); };\r\n    }\r\n    else {\r\n        var frozenInitialState_1 = freezeDraftable(initialState);\r\n        getInitialState = function () { return frozenInitialState_1; };\r\n    }\r\n    function reducer(state, action) {\r\n        if (state === void 0) { state = getInitialState(); }\r\n        var caseReducers = __spreadArray([\r\n            actionsMap[action.type]\r\n        ], finalActionMatchers.filter(function (_c) {\r\n            var matcher = _c.matcher;\r\n            return matcher(action);\r\n        }).map(function (_c) {\r\n            var reducer2 = _c.reducer;\r\n            return reducer2;\r\n        }));\r\n        if (caseReducers.filter(function (cr) { return !!cr; }).length === 0) {\r\n            caseReducers = [finalDefaultCaseReducer];\r\n        }\r\n        return caseReducers.reduce(function (previousState, caseReducer) {\r\n            if (caseReducer) {\r\n                if (isDraft2(previousState)) {\r\n                    var draft = previousState;\r\n                    var result = caseReducer(draft, action);\r\n                    if (result === void 0) {\r\n                        return previousState;\r\n                    }\r\n                    return result;\r\n                }\r\n                else if (!isDraftable2(previousState)) {\r\n                    var result = caseReducer(previousState, action);\r\n                    if (result === void 0) {\r\n                        if (previousState === null) {\r\n                            return previousState;\r\n                        }\r\n                        throw Error(\"A case reducer on a non-draftable value must not return undefined\");\r\n                    }\r\n                    return result;\r\n                }\r\n                else {\r\n                    return createNextState2(previousState, function (draft) {\r\n                        return caseReducer(draft, action);\r\n                    });\r\n                }\r\n            }\r\n            return previousState;\r\n        }, state);\r\n    }\r\n    reducer.getInitialState = getInitialState;\r\n    return reducer;\r\n}\r\n// src/createSlice.ts\r\nvar hasWarnedAboutObjectNotation2 = false;\r\nfunction getType2(slice, actionKey) {\r\n    return slice + \"/\" + actionKey;\r\n}\r\nfunction createSlice(options) {\r\n    var name = options.name;\r\n    if (!name) {\r\n        throw new Error(\"`name` is a required option for createSlice\");\r\n    }\r\n    if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\r\n        if (options.initialState === void 0) {\r\n            console.error(\"You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`\");\r\n        }\r\n    }\r\n    var initialState = typeof options.initialState == \"function\" ? options.initialState : freezeDraftable(options.initialState);\r\n    var reducers = options.reducers || {};\r\n    var reducerNames = Object.keys(reducers);\r\n    var sliceCaseReducersByName = {};\r\n    var sliceCaseReducersByType = {};\r\n    var actionCreators = {};\r\n    reducerNames.forEach(function (reducerName) {\r\n        var maybeReducerWithPrepare = reducers[reducerName];\r\n        var type = getType2(name, reducerName);\r\n        var caseReducer;\r\n        var prepareCallback;\r\n        if (\"reducer\" in maybeReducerWithPrepare) {\r\n            caseReducer = maybeReducerWithPrepare.reducer;\r\n            prepareCallback = maybeReducerWithPrepare.prepare;\r\n        }\r\n        else {\r\n            caseReducer = maybeReducerWithPrepare;\r\n        }\r\n        sliceCaseReducersByName[reducerName] = caseReducer;\r\n        sliceCaseReducersByType[type] = caseReducer;\r\n        actionCreators[reducerName] = prepareCallback ? createAction(type, prepareCallback) : createAction(type);\r\n    });\r\n    function buildReducer() {\r\n        if (process.env.NODE_ENV !== \"production\") {\r\n            if (typeof options.extraReducers === \"object\") {\r\n                if (!hasWarnedAboutObjectNotation2) {\r\n                    hasWarnedAboutObjectNotation2 = true;\r\n                    console.warn(\"The object notation for `createSlice.extraReducers` is deprecated, and will be removed in RTK 2.0. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice\");\r\n                }\r\n            }\r\n        }\r\n        var _c = typeof options.extraReducers === \"function\" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers], _d = _c[0], extraReducers = _d === void 0 ? {} : _d, _e = _c[1], actionMatchers = _e === void 0 ? [] : _e, _f = _c[2], defaultCaseReducer = _f === void 0 ? void 0 : _f;\r\n        var finalCaseReducers = __spreadValues(__spreadValues({}, extraReducers), sliceCaseReducersByType);\r\n        return createReducer(initialState, function (builder) {\r\n            for (var key in finalCaseReducers) {\r\n                builder.addCase(key, finalCaseReducers[key]);\r\n            }\r\n            for (var _i = 0, actionMatchers_1 = actionMatchers; _i < actionMatchers_1.length; _i++) {\r\n                var m = actionMatchers_1[_i];\r\n                builder.addMatcher(m.matcher, m.reducer);\r\n            }\r\n            if (defaultCaseReducer) {\r\n                builder.addDefaultCase(defaultCaseReducer);\r\n            }\r\n        });\r\n    }\r\n    var _reducer;\r\n    return {\r\n        name: name,\r\n        reducer: function (state, action) {\r\n            if (!_reducer)\r\n                _reducer = buildReducer();\r\n            return _reducer(state, action);\r\n        },\r\n        actions: actionCreators,\r\n        caseReducers: sliceCaseReducersByName,\r\n        getInitialState: function () {\r\n            if (!_reducer)\r\n                _reducer = buildReducer();\r\n            return _reducer.getInitialState();\r\n        }\r\n    };\r\n}\r\n// src/entities/entity_state.ts\r\nfunction getInitialEntityState() {\r\n    return {\r\n        ids: [],\r\n        entities: {}\r\n    };\r\n}\r\nfunction createInitialStateFactory() {\r\n    function getInitialState(additionalState) {\r\n        if (additionalState === void 0) { additionalState = {}; }\r\n        return Object.assign(getInitialEntityState(), additionalState);\r\n    }\r\n    return { getInitialState: getInitialState };\r\n}\r\n// src/entities/state_selectors.ts\r\nfunction createSelectorsFactory() {\r\n    function getSelectors(selectState) {\r\n        var selectIds = function (state) { return state.ids; };\r\n        var selectEntities = function (state) { return state.entities; };\r\n        var selectAll = createDraftSafeSelector(selectIds, selectEntities, function (ids, entities) { return ids.map(function (id) { return entities[id]; }); });\r\n        var selectId = function (_, id) { return id; };\r\n        var selectById = function (entities, id) { return entities[id]; };\r\n        var selectTotal = createDraftSafeSelector(selectIds, function (ids) { return ids.length; });\r\n        if (!selectState) {\r\n            return {\r\n                selectIds: selectIds,\r\n                selectEntities: selectEntities,\r\n                selectAll: selectAll,\r\n                selectTotal: selectTotal,\r\n                selectById: createDraftSafeSelector(selectEntities, selectId, selectById)\r\n            };\r\n        }\r\n        var selectGlobalizedEntities = createDraftSafeSelector(selectState, selectEntities);\r\n        return {\r\n            selectIds: createDraftSafeSelector(selectState, selectIds),\r\n            selectEntities: selectGlobalizedEntities,\r\n            selectAll: createDraftSafeSelector(selectState, selectAll),\r\n            selectTotal: createDraftSafeSelector(selectState, selectTotal),\r\n            selectById: createDraftSafeSelector(selectGlobalizedEntities, selectId, selectById)\r\n        };\r\n    }\r\n    return { getSelectors: getSelectors };\r\n}\r\n// src/entities/state_adapter.ts\r\nimport createNextState3, { isDraft as isDraft3 } from \"immer\";\r\nfunction createSingleArgumentStateOperator(mutator) {\r\n    var operator = createStateOperator(function (_, state) { return mutator(state); });\r\n    return function operation(state) {\r\n        return operator(state, void 0);\r\n    };\r\n}\r\nfunction createStateOperator(mutator) {\r\n    return function operation(state, arg) {\r\n        function isPayloadActionArgument(arg2) {\r\n            return isFSA(arg2);\r\n        }\r\n        var runMutator = function (draft) {\r\n            if (isPayloadActionArgument(arg)) {\r\n                mutator(arg.payload, draft);\r\n            }\r\n            else {\r\n                mutator(arg, draft);\r\n            }\r\n        };\r\n        if (isDraft3(state)) {\r\n            runMutator(state);\r\n            return state;\r\n        }\r\n        else {\r\n            return createNextState3(state, runMutator);\r\n        }\r\n    };\r\n}\r\n// src/entities/utils.ts\r\nfunction selectIdValue(entity, selectId) {\r\n    var key = selectId(entity);\r\n    if (process.env.NODE_ENV !== \"production\" && key === void 0) {\r\n        console.warn(\"The entity passed to the `selectId` implementation returned undefined.\", \"You should probably provide your own `selectId` implementation.\", \"The entity that was passed:\", entity, \"The `selectId` implementation:\", selectId.toString());\r\n    }\r\n    return key;\r\n}\r\nfunction ensureEntitiesArray(entities) {\r\n    if (!Array.isArray(entities)) {\r\n        entities = Object.values(entities);\r\n    }\r\n    return entities;\r\n}\r\nfunction splitAddedUpdatedEntities(newEntities, selectId, state) {\r\n    newEntities = ensureEntitiesArray(newEntities);\r\n    var added = [];\r\n    var updated = [];\r\n    for (var _i = 0, newEntities_1 = newEntities; _i < newEntities_1.length; _i++) {\r\n        var entity = newEntities_1[_i];\r\n        var id = selectIdValue(entity, selectId);\r\n        if (id in state.entities) {\r\n            updated.push({ id: id, changes: entity });\r\n        }\r\n        else {\r\n            added.push(entity);\r\n        }\r\n    }\r\n    return [added, updated];\r\n}\r\n// src/entities/unsorted_state_adapter.ts\r\nfunction createUnsortedStateAdapter(selectId) {\r\n    function addOneMutably(entity, state) {\r\n        var key = selectIdValue(entity, selectId);\r\n        if (key in state.entities) {\r\n            return;\r\n        }\r\n        state.ids.push(key);\r\n        state.entities[key] = entity;\r\n    }\r\n    function addManyMutably(newEntities, state) {\r\n        newEntities = ensureEntitiesArray(newEntities);\r\n        for (var _i = 0, newEntities_2 = newEntities; _i < newEntities_2.length; _i++) {\r\n            var entity = newEntities_2[_i];\r\n            addOneMutably(entity, state);\r\n        }\r\n    }\r\n    function setOneMutably(entity, state) {\r\n        var key = selectIdValue(entity, selectId);\r\n        if (!(key in state.entities)) {\r\n            state.ids.push(key);\r\n        }\r\n        state.entities[key] = entity;\r\n    }\r\n    function setManyMutably(newEntities, state) {\r\n        newEntities = ensureEntitiesArray(newEntities);\r\n        for (var _i = 0, newEntities_3 = newEntities; _i < newEntities_3.length; _i++) {\r\n            var entity = newEntities_3[_i];\r\n            setOneMutably(entity, state);\r\n        }\r\n    }\r\n    function setAllMutably(newEntities, state) {\r\n        newEntities = ensureEntitiesArray(newEntities);\r\n        state.ids = [];\r\n        state.entities = {};\r\n        addManyMutably(newEntities, state);\r\n    }\r\n    function removeOneMutably(key, state) {\r\n        return removeManyMutably([key], state);\r\n    }\r\n    function removeManyMutably(keys, state) {\r\n        var didMutate = false;\r\n        keys.forEach(function (key) {\r\n            if (key in state.entities) {\r\n                delete state.entities[key];\r\n                didMutate = true;\r\n            }\r\n        });\r\n        if (didMutate) {\r\n            state.ids = state.ids.filter(function (id) { return id in state.entities; });\r\n        }\r\n    }\r\n    function removeAllMutably(state) {\r\n        Object.assign(state, {\r\n            ids: [],\r\n            entities: {}\r\n        });\r\n    }\r\n    function takeNewKey(keys, update, state) {\r\n        var original2 = state.entities[update.id];\r\n        var updated = Object.assign({}, original2, update.changes);\r\n        var newKey = selectIdValue(updated, selectId);\r\n        var hasNewKey = newKey !== update.id;\r\n        if (hasNewKey) {\r\n            keys[update.id] = newKey;\r\n            delete state.entities[update.id];\r\n        }\r\n        state.entities[newKey] = updated;\r\n        return hasNewKey;\r\n    }\r\n    function updateOneMutably(update, state) {\r\n        return updateManyMutably([update], state);\r\n    }\r\n    function updateManyMutably(updates, state) {\r\n        var newKeys = {};\r\n        var updatesPerEntity = {};\r\n        updates.forEach(function (update) {\r\n            if (update.id in state.entities) {\r\n                updatesPerEntity[update.id] = {\r\n                    id: update.id,\r\n                    changes: __spreadValues(__spreadValues({}, updatesPerEntity[update.id] ? updatesPerEntity[update.id].changes : null), update.changes)\r\n                };\r\n            }\r\n        });\r\n        updates = Object.values(updatesPerEntity);\r\n        var didMutateEntities = updates.length > 0;\r\n        if (didMutateEntities) {\r\n            var didMutateIds = updates.filter(function (update) { return takeNewKey(newKeys, update, state); }).length > 0;\r\n            if (didMutateIds) {\r\n                state.ids = Object.keys(state.entities);\r\n            }\r\n        }\r\n    }\r\n    function upsertOneMutably(entity, state) {\r\n        return upsertManyMutably([entity], state);\r\n    }\r\n    function upsertManyMutably(newEntities, state) {\r\n        var _c = splitAddedUpdatedEntities(newEntities, selectId, state), added = _c[0], updated = _c[1];\r\n        updateManyMutably(updated, state);\r\n        addManyMutably(added, state);\r\n    }\r\n    return {\r\n        removeAll: createSingleArgumentStateOperator(removeAllMutably),\r\n        addOne: createStateOperator(addOneMutably),\r\n        addMany: createStateOperator(addManyMutably),\r\n        setOne: createStateOperator(setOneMutably),\r\n        setMany: createStateOperator(setManyMutably),\r\n        setAll: createStateOperator(setAllMutably),\r\n        updateOne: createStateOperator(updateOneMutably),\r\n        updateMany: createStateOperator(updateManyMutably),\r\n        upsertOne: createStateOperator(upsertOneMutably),\r\n        upsertMany: createStateOperator(upsertManyMutably),\r\n        removeOne: createStateOperator(removeOneMutably),\r\n        removeMany: createStateOperator(removeManyMutably)\r\n    };\r\n}\r\n// src/entities/sorted_state_adapter.ts\r\nfunction createSortedStateAdapter(selectId, sort) {\r\n    var _c = createUnsortedStateAdapter(selectId), removeOne = _c.removeOne, removeMany = _c.removeMany, removeAll = _c.removeAll;\r\n    function addOneMutably(entity, state) {\r\n        return addManyMutably([entity], state);\r\n    }\r\n    function addManyMutably(newEntities, state) {\r\n        newEntities = ensureEntitiesArray(newEntities);\r\n        var models = newEntities.filter(function (model) { return !(selectIdValue(model, selectId) in state.entities); });\r\n        if (models.length !== 0) {\r\n            merge(models, state);\r\n        }\r\n    }\r\n    function setOneMutably(entity, state) {\r\n        return setManyMutably([entity], state);\r\n    }\r\n    function setManyMutably(newEntities, state) {\r\n        newEntities = ensureEntitiesArray(newEntities);\r\n        if (newEntities.length !== 0) {\r\n            merge(newEntities, state);\r\n        }\r\n    }\r\n    function setAllMutably(newEntities, state) {\r\n        newEntities = ensureEntitiesArray(newEntities);\r\n        state.entities = {};\r\n        state.ids = [];\r\n        addManyMutably(newEntities, state);\r\n    }\r\n    function updateOneMutably(update, state) {\r\n        return updateManyMutably([update], state);\r\n    }\r\n    function updateManyMutably(updates, state) {\r\n        var appliedUpdates = false;\r\n        for (var _i = 0, updates_1 = updates; _i < updates_1.length; _i++) {\r\n            var update = updates_1[_i];\r\n            var entity = state.entities[update.id];\r\n            if (!entity) {\r\n                continue;\r\n            }\r\n            appliedUpdates = true;\r\n            Object.assign(entity, update.changes);\r\n            var newId = selectId(entity);\r\n            if (update.id !== newId) {\r\n                delete state.entities[update.id];\r\n                state.entities[newId] = entity;\r\n            }\r\n        }\r\n        if (appliedUpdates) {\r\n            resortEntities(state);\r\n        }\r\n    }\r\n    function upsertOneMutably(entity, state) {\r\n        return upsertManyMutably([entity], state);\r\n    }\r\n    function upsertManyMutably(newEntities, state) {\r\n        var _c = splitAddedUpdatedEntities(newEntities, selectId, state), added = _c[0], updated = _c[1];\r\n        updateManyMutably(updated, state);\r\n        addManyMutably(added, state);\r\n    }\r\n    function areArraysEqual(a, b) {\r\n        if (a.length !== b.length) {\r\n            return false;\r\n        }\r\n        for (var i = 0; i < a.length && i < b.length; i++) {\r\n            if (a[i] === b[i]) {\r\n                continue;\r\n            }\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n    function merge(models, state) {\r\n        models.forEach(function (model) {\r\n            state.entities[selectId(model)] = model;\r\n        });\r\n        resortEntities(state);\r\n    }\r\n    function resortEntities(state) {\r\n        var allEntities = Object.values(state.entities);\r\n        allEntities.sort(sort);\r\n        var newSortedIds = allEntities.map(selectId);\r\n        var ids = state.ids;\r\n        if (!areArraysEqual(ids, newSortedIds)) {\r\n            state.ids = newSortedIds;\r\n        }\r\n    }\r\n    return {\r\n        removeOne: removeOne,\r\n        removeMany: removeMany,\r\n        removeAll: removeAll,\r\n        addOne: createStateOperator(addOneMutably),\r\n        updateOne: createStateOperator(updateOneMutably),\r\n        upsertOne: createStateOperator(upsertOneMutably),\r\n        setOne: createStateOperator(setOneMutably),\r\n        setMany: createStateOperator(setManyMutably),\r\n        setAll: createStateOperator(setAllMutably),\r\n        addMany: createStateOperator(addManyMutably),\r\n        updateMany: createStateOperator(updateManyMutably),\r\n        upsertMany: createStateOperator(upsertManyMutably)\r\n    };\r\n}\r\n// src/entities/create_adapter.ts\r\nfunction createEntityAdapter(options) {\r\n    if (options === void 0) { options = {}; }\r\n    var _c = __spreadValues({\r\n        sortComparer: false,\r\n        selectId: function (instance) { return instance.id; }\r\n    }, options), selectId = _c.selectId, sortComparer = _c.sortComparer;\r\n    var stateFactory = createInitialStateFactory();\r\n    var selectorsFactory = createSelectorsFactory();\r\n    var stateAdapter = sortComparer ? createSortedStateAdapter(selectId, sortComparer) : createUnsortedStateAdapter(selectId);\r\n    return __spreadValues(__spreadValues(__spreadValues({\r\n        selectId: selectId,\r\n        sortComparer: sortComparer\r\n    }, stateFactory), selectorsFactory), stateAdapter);\r\n}\r\n// src/nanoid.ts\r\nvar urlAlphabet = \"ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW\";\r\nvar nanoid = function (size) {\r\n    if (size === void 0) { size = 21; }\r\n    var id = \"\";\r\n    var i = size;\r\n    while (i--) {\r\n        id += urlAlphabet[Math.random() * 64 | 0];\r\n    }\r\n    return id;\r\n};\r\n// src/createAsyncThunk.ts\r\nvar commonProperties = [\r\n    \"name\",\r\n    \"message\",\r\n    \"stack\",\r\n    \"code\"\r\n];\r\nvar RejectWithValue = /** @class */ (function () {\r\n    function RejectWithValue(payload, meta) {\r\n        this.payload = payload;\r\n        this.meta = meta;\r\n    }\r\n    return RejectWithValue;\r\n}());\r\nvar FulfillWithMeta = /** @class */ (function () {\r\n    function FulfillWithMeta(payload, meta) {\r\n        this.payload = payload;\r\n        this.meta = meta;\r\n    }\r\n    return FulfillWithMeta;\r\n}());\r\nvar miniSerializeError = function (value) {\r\n    if (typeof value === \"object\" && value !== null) {\r\n        var simpleError = {};\r\n        for (var _i = 0, commonProperties_1 = commonProperties; _i < commonProperties_1.length; _i++) {\r\n            var property = commonProperties_1[_i];\r\n            if (typeof value[property] === \"string\") {\r\n                simpleError[property] = value[property];\r\n            }\r\n        }\r\n        return simpleError;\r\n    }\r\n    return { message: String(value) };\r\n};\r\nvar createAsyncThunk = (function () {\r\n    function createAsyncThunk2(typePrefix, payloadCreator, options) {\r\n        var fulfilled = createAction(typePrefix + \"/fulfilled\", function (payload, requestId, arg, meta) { return ({\r\n            payload: payload,\r\n            meta: __spreadProps(__spreadValues({}, meta || {}), {\r\n                arg: arg,\r\n                requestId: requestId,\r\n                requestStatus: \"fulfilled\"\r\n            })\r\n        }); });\r\n        var pending = createAction(typePrefix + \"/pending\", function (requestId, arg, meta) { return ({\r\n            payload: void 0,\r\n            meta: __spreadProps(__spreadValues({}, meta || {}), {\r\n                arg: arg,\r\n                requestId: requestId,\r\n                requestStatus: \"pending\"\r\n            })\r\n        }); });\r\n        var rejected = createAction(typePrefix + \"/rejected\", function (error, requestId, arg, payload, meta) { return ({\r\n            payload: payload,\r\n            error: (options && options.serializeError || miniSerializeError)(error || \"Rejected\"),\r\n            meta: __spreadProps(__spreadValues({}, meta || {}), {\r\n                arg: arg,\r\n                requestId: requestId,\r\n                rejectedWithValue: !!payload,\r\n                requestStatus: \"rejected\",\r\n                aborted: (error == null ? void 0 : error.name) === \"AbortError\",\r\n                condition: (error == null ? void 0 : error.name) === \"ConditionError\"\r\n            })\r\n        }); });\r\n        var displayedWarning = false;\r\n        var AC = typeof AbortController !== \"undefined\" ? AbortController : /** @class */ (function () {\r\n            function class_1() {\r\n                this.signal = {\r\n                    aborted: false,\r\n                    addEventListener: function () {\r\n                    },\r\n                    dispatchEvent: function () {\r\n                        return false;\r\n                    },\r\n                    onabort: function () {\r\n                    },\r\n                    removeEventListener: function () {\r\n                    },\r\n                    reason: void 0,\r\n                    throwIfAborted: function () {\r\n                    }\r\n                };\r\n            }\r\n            class_1.prototype.abort = function () {\r\n                if (process.env.NODE_ENV !== \"production\") {\r\n                    if (!displayedWarning) {\r\n                        displayedWarning = true;\r\n                        console.info(\"This platform does not implement AbortController. \\nIf you want to use the AbortController to react to `abort` events, please consider importing a polyfill like 'abortcontroller-polyfill/dist/abortcontroller-polyfill-only'.\");\r\n                    }\r\n                }\r\n            };\r\n            return class_1;\r\n        }());\r\n        function actionCreator(arg) {\r\n            return function (dispatch, getState, extra) {\r\n                var requestId = (options == null ? void 0 : options.idGenerator) ? options.idGenerator(arg) : nanoid();\r\n                var abortController = new AC();\r\n                var abortReason;\r\n                var started = false;\r\n                function abort(reason) {\r\n                    abortReason = reason;\r\n                    abortController.abort();\r\n                }\r\n                var promise2 = function () {\r\n                    return __async(this, null, function () {\r\n                        var _a, _b, finalAction, conditionResult, abortedPromise, err_1, skipDispatch;\r\n                        return __generator(this, function (_c) {\r\n                            switch (_c.label) {\r\n                                case 0:\r\n                                    _c.trys.push([0, 4, , 5]);\r\n                                    conditionResult = (_a = options == null ? void 0 : options.condition) == null ? void 0 : _a.call(options, arg, { getState: getState, extra: extra });\r\n                                    if (!isThenable(conditionResult)) return [3 /*break*/, 2];\r\n                                    return [4 /*yield*/, conditionResult];\r\n                                case 1:\r\n                                    conditionResult = _c.sent();\r\n                                    _c.label = 2;\r\n                                case 2:\r\n                                    if (conditionResult === false || abortController.signal.aborted) {\r\n                                        throw {\r\n                                            name: \"ConditionError\",\r\n                                            message: \"Aborted due to condition callback returning false.\"\r\n                                        };\r\n                                    }\r\n                                    started = true;\r\n                                    abortedPromise = new Promise(function (_, reject) { return abortController.signal.addEventListener(\"abort\", function () { return reject({\r\n                                        name: \"AbortError\",\r\n                                        message: abortReason || \"Aborted\"\r\n                                    }); }); });\r\n                                    dispatch(pending(requestId, arg, (_b = options == null ? void 0 : options.getPendingMeta) == null ? void 0 : _b.call(options, { requestId: requestId, arg: arg }, { getState: getState, extra: extra })));\r\n                                    return [4 /*yield*/, Promise.race([\r\n                                            abortedPromise,\r\n                                            Promise.resolve(payloadCreator(arg, {\r\n                                                dispatch: dispatch,\r\n                                                getState: getState,\r\n                                                extra: extra,\r\n                                                requestId: requestId,\r\n                                                signal: abortController.signal,\r\n                                                abort: abort,\r\n                                                rejectWithValue: function (value, meta) {\r\n                                                    return new RejectWithValue(value, meta);\r\n                                                },\r\n                                                fulfillWithValue: function (value, meta) {\r\n                                                    return new FulfillWithMeta(value, meta);\r\n                                                }\r\n                                            })).then(function (result) {\r\n                                                if (result instanceof RejectWithValue) {\r\n                                                    throw result;\r\n                                                }\r\n                                                if (result instanceof FulfillWithMeta) {\r\n                                                    return fulfilled(result.payload, requestId, arg, result.meta);\r\n                                                }\r\n                                                return fulfilled(result, requestId, arg);\r\n                                            })\r\n                                        ])];\r\n                                case 3:\r\n                                    finalAction = _c.sent();\r\n                                    return [3 /*break*/, 5];\r\n                                case 4:\r\n                                    err_1 = _c.sent();\r\n                                    finalAction = err_1 instanceof RejectWithValue ? rejected(null, requestId, arg, err_1.payload, err_1.meta) : rejected(err_1, requestId, arg);\r\n                                    return [3 /*break*/, 5];\r\n                                case 5:\r\n                                    skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;\r\n                                    if (!skipDispatch) {\r\n                                        dispatch(finalAction);\r\n                                    }\r\n                                    return [2 /*return*/, finalAction];\r\n                            }\r\n                        });\r\n                    });\r\n                }();\r\n                return Object.assign(promise2, {\r\n                    abort: abort,\r\n                    requestId: requestId,\r\n                    arg: arg,\r\n                    unwrap: function () {\r\n                        return promise2.then(unwrapResult);\r\n                    }\r\n                });\r\n            };\r\n        }\r\n        return Object.assign(actionCreator, {\r\n            pending: pending,\r\n            rejected: rejected,\r\n            fulfilled: fulfilled,\r\n            typePrefix: typePrefix\r\n        });\r\n    }\r\n    createAsyncThunk2.withTypes = function () { return createAsyncThunk2; };\r\n    return createAsyncThunk2;\r\n})();\r\nfunction unwrapResult(action) {\r\n    if (action.meta && action.meta.rejectedWithValue) {\r\n        throw action.payload;\r\n    }\r\n    if (action.error) {\r\n        throw action.error;\r\n    }\r\n    return action.payload;\r\n}\r\nfunction isThenable(value) {\r\n    return value !== null && typeof value === \"object\" && typeof value.then === \"function\";\r\n}\r\n// src/matchers.ts\r\nvar matches = function (matcher, action) {\r\n    if (hasMatchFunction(matcher)) {\r\n        return matcher.match(action);\r\n    }\r\n    else {\r\n        return matcher(action);\r\n    }\r\n};\r\nfunction isAnyOf() {\r\n    var matchers = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        matchers[_i] = arguments[_i];\r\n    }\r\n    return function (action) {\r\n        return matchers.some(function (matcher) { return matches(matcher, action); });\r\n    };\r\n}\r\nfunction isAllOf() {\r\n    var matchers = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        matchers[_i] = arguments[_i];\r\n    }\r\n    return function (action) {\r\n        return matchers.every(function (matcher) { return matches(matcher, action); });\r\n    };\r\n}\r\nfunction hasExpectedRequestMetadata(action, validStatus) {\r\n    if (!action || !action.meta)\r\n        return false;\r\n    var hasValidRequestId = typeof action.meta.requestId === \"string\";\r\n    var hasValidRequestStatus = validStatus.indexOf(action.meta.requestStatus) > -1;\r\n    return hasValidRequestId && hasValidRequestStatus;\r\n}\r\nfunction isAsyncThunkArray(a) {\r\n    return typeof a[0] === \"function\" && \"pending\" in a[0] && \"fulfilled\" in a[0] && \"rejected\" in a[0];\r\n}\r\nfunction isPending() {\r\n    var asyncThunks = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        asyncThunks[_i] = arguments[_i];\r\n    }\r\n    if (asyncThunks.length === 0) {\r\n        return function (action) { return hasExpectedRequestMetadata(action, [\"pending\"]); };\r\n    }\r\n    if (!isAsyncThunkArray(asyncThunks)) {\r\n        return isPending()(asyncThunks[0]);\r\n    }\r\n    return function (action) {\r\n        var matchers = asyncThunks.map(function (asyncThunk) { return asyncThunk.pending; });\r\n        var combinedMatcher = isAnyOf.apply(void 0, matchers);\r\n        return combinedMatcher(action);\r\n    };\r\n}\r\nfunction isRejected() {\r\n    var asyncThunks = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        asyncThunks[_i] = arguments[_i];\r\n    }\r\n    if (asyncThunks.length === 0) {\r\n        return function (action) { return hasExpectedRequestMetadata(action, [\"rejected\"]); };\r\n    }\r\n    if (!isAsyncThunkArray(asyncThunks)) {\r\n        return isRejected()(asyncThunks[0]);\r\n    }\r\n    return function (action) {\r\n        var matchers = asyncThunks.map(function (asyncThunk) { return asyncThunk.rejected; });\r\n        var combinedMatcher = isAnyOf.apply(void 0, matchers);\r\n        return combinedMatcher(action);\r\n    };\r\n}\r\nfunction isRejectedWithValue() {\r\n    var asyncThunks = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        asyncThunks[_i] = arguments[_i];\r\n    }\r\n    var hasFlag = function (action) {\r\n        return action && action.meta && action.meta.rejectedWithValue;\r\n    };\r\n    if (asyncThunks.length === 0) {\r\n        return function (action) {\r\n            var combinedMatcher = isAllOf(isRejected.apply(void 0, asyncThunks), hasFlag);\r\n            return combinedMatcher(action);\r\n        };\r\n    }\r\n    if (!isAsyncThunkArray(asyncThunks)) {\r\n        return isRejectedWithValue()(asyncThunks[0]);\r\n    }\r\n    return function (action) {\r\n        var combinedMatcher = isAllOf(isRejected.apply(void 0, asyncThunks), hasFlag);\r\n        return combinedMatcher(action);\r\n    };\r\n}\r\nfunction isFulfilled() {\r\n    var asyncThunks = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        asyncThunks[_i] = arguments[_i];\r\n    }\r\n    if (asyncThunks.length === 0) {\r\n        return function (action) { return hasExpectedRequestMetadata(action, [\"fulfilled\"]); };\r\n    }\r\n    if (!isAsyncThunkArray(asyncThunks)) {\r\n        return isFulfilled()(asyncThunks[0]);\r\n    }\r\n    return function (action) {\r\n        var matchers = asyncThunks.map(function (asyncThunk) { return asyncThunk.fulfilled; });\r\n        var combinedMatcher = isAnyOf.apply(void 0, matchers);\r\n        return combinedMatcher(action);\r\n    };\r\n}\r\nfunction isAsyncThunkAction() {\r\n    var asyncThunks = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        asyncThunks[_i] = arguments[_i];\r\n    }\r\n    if (asyncThunks.length === 0) {\r\n        return function (action) { return hasExpectedRequestMetadata(action, [\"pending\", \"fulfilled\", \"rejected\"]); };\r\n    }\r\n    if (!isAsyncThunkArray(asyncThunks)) {\r\n        return isAsyncThunkAction()(asyncThunks[0]);\r\n    }\r\n    return function (action) {\r\n        var matchers = [];\r\n        for (var _i = 0, asyncThunks_1 = asyncThunks; _i < asyncThunks_1.length; _i++) {\r\n            var asyncThunk = asyncThunks_1[_i];\r\n            matchers.push(asyncThunk.pending, asyncThunk.rejected, asyncThunk.fulfilled);\r\n        }\r\n        var combinedMatcher = isAnyOf.apply(void 0, matchers);\r\n        return combinedMatcher(action);\r\n    };\r\n}\r\n// src/listenerMiddleware/utils.ts\r\nvar assertFunction = function (func, expected) {\r\n    if (typeof func !== \"function\") {\r\n        throw new TypeError(expected + \" is not a function\");\r\n    }\r\n};\r\nvar noop = function () {\r\n};\r\nvar catchRejection = function (promise2, onError) {\r\n    if (onError === void 0) { onError = noop; }\r\n    promise2.catch(onError);\r\n    return promise2;\r\n};\r\nvar addAbortSignalListener = function (abortSignal, callback) {\r\n    abortSignal.addEventListener(\"abort\", callback, { once: true });\r\n    return function () { return abortSignal.removeEventListener(\"abort\", callback); };\r\n};\r\nvar abortControllerWithReason = function (abortController, reason) {\r\n    var signal = abortController.signal;\r\n    if (signal.aborted) {\r\n        return;\r\n    }\r\n    if (!(\"reason\" in signal)) {\r\n        Object.defineProperty(signal, \"reason\", {\r\n            enumerable: true,\r\n            value: reason,\r\n            configurable: true,\r\n            writable: true\r\n        });\r\n    }\r\n    ;\r\n    abortController.abort(reason);\r\n};\r\n// src/listenerMiddleware/exceptions.ts\r\nvar task = \"task\";\r\nvar listener = \"listener\";\r\nvar completed = \"completed\";\r\nvar cancelled = \"cancelled\";\r\nvar taskCancelled = \"task-\" + cancelled;\r\nvar taskCompleted = \"task-\" + completed;\r\nvar listenerCancelled = listener + \"-\" + cancelled;\r\nvar listenerCompleted = listener + \"-\" + completed;\r\nvar TaskAbortError = /** @class */ (function () {\r\n    function TaskAbortError(code) {\r\n        this.code = code;\r\n        this.name = \"TaskAbortError\";\r\n        this.message = task + \" \" + cancelled + \" (reason: \" + code + \")\";\r\n    }\r\n    return TaskAbortError;\r\n}());\r\n// src/listenerMiddleware/task.ts\r\nvar validateActive = function (signal) {\r\n    if (signal.aborted) {\r\n        throw new TaskAbortError(signal.reason);\r\n    }\r\n};\r\nfunction raceWithSignal(signal, promise2) {\r\n    var cleanup = noop;\r\n    return new Promise(function (resolve, reject) {\r\n        var notifyRejection = function () { return reject(new TaskAbortError(signal.reason)); };\r\n        if (signal.aborted) {\r\n            notifyRejection();\r\n            return;\r\n        }\r\n        cleanup = addAbortSignalListener(signal, notifyRejection);\r\n        promise2.finally(function () { return cleanup(); }).then(resolve, reject);\r\n    }).finally(function () {\r\n        cleanup = noop;\r\n    });\r\n}\r\nvar runTask = function (task2, cleanUp) { return __async(void 0, null, function () {\r\n    var value, error_1;\r\n    return __generator(this, function (_c) {\r\n        switch (_c.label) {\r\n            case 0:\r\n                _c.trys.push([0, 3, 4, 5]);\r\n                return [4 /*yield*/, Promise.resolve()];\r\n            case 1:\r\n                _c.sent();\r\n                return [4 /*yield*/, task2()];\r\n            case 2:\r\n                value = _c.sent();\r\n                return [2 /*return*/, {\r\n                        status: \"ok\",\r\n                        value: value\r\n                    }];\r\n            case 3:\r\n                error_1 = _c.sent();\r\n                return [2 /*return*/, {\r\n                        status: error_1 instanceof TaskAbortError ? \"cancelled\" : \"rejected\",\r\n                        error: error_1\r\n                    }];\r\n            case 4:\r\n                cleanUp == null ? void 0 : cleanUp();\r\n                return [7 /*endfinally*/];\r\n            case 5: return [2 /*return*/];\r\n        }\r\n    });\r\n}); };\r\nvar createPause = function (signal) {\r\n    return function (promise2) {\r\n        return catchRejection(raceWithSignal(signal, promise2).then(function (output) {\r\n            validateActive(signal);\r\n            return output;\r\n        }));\r\n    };\r\n};\r\nvar createDelay = function (signal) {\r\n    var pause = createPause(signal);\r\n    return function (timeoutMs) {\r\n        return pause(new Promise(function (resolve) { return setTimeout(resolve, timeoutMs); }));\r\n    };\r\n};\r\n// src/listenerMiddleware/index.ts\r\nvar assign = Object.assign;\r\nvar INTERNAL_NIL_TOKEN = {};\r\nvar alm = \"listenerMiddleware\";\r\nvar createFork = function (parentAbortSignal, parentBlockingPromises) {\r\n    var linkControllers = function (controller) { return addAbortSignalListener(parentAbortSignal, function () { return abortControllerWithReason(controller, parentAbortSignal.reason); }); };\r\n    return function (taskExecutor, opts) {\r\n        assertFunction(taskExecutor, \"taskExecutor\");\r\n        var childAbortController = new AbortController();\r\n        linkControllers(childAbortController);\r\n        var result = runTask(function () { return __async(void 0, null, function () {\r\n            var result2;\r\n            return __generator(this, function (_c) {\r\n                switch (_c.label) {\r\n                    case 0:\r\n                        validateActive(parentAbortSignal);\r\n                        validateActive(childAbortController.signal);\r\n                        return [4 /*yield*/, taskExecutor({\r\n                                pause: createPause(childAbortController.signal),\r\n                                delay: createDelay(childAbortController.signal),\r\n                                signal: childAbortController.signal\r\n                            })];\r\n                    case 1:\r\n                        result2 = _c.sent();\r\n                        validateActive(childAbortController.signal);\r\n                        return [2 /*return*/, result2];\r\n                }\r\n            });\r\n        }); }, function () { return abortControllerWithReason(childAbortController, taskCompleted); });\r\n        if (opts == null ? void 0 : opts.autoJoin) {\r\n            parentBlockingPromises.push(result);\r\n        }\r\n        return {\r\n            result: createPause(parentAbortSignal)(result),\r\n            cancel: function () {\r\n                abortControllerWithReason(childAbortController, taskCancelled);\r\n            }\r\n        };\r\n    };\r\n};\r\nvar createTakePattern = function (startListening, signal) {\r\n    var take = function (predicate, timeout) { return __async(void 0, null, function () {\r\n        var unsubscribe, tuplePromise, promises, output;\r\n        return __generator(this, function (_c) {\r\n            switch (_c.label) {\r\n                case 0:\r\n                    validateActive(signal);\r\n                    unsubscribe = function () {\r\n                    };\r\n                    tuplePromise = new Promise(function (resolve, reject) {\r\n                        var stopListening = startListening({\r\n                            predicate: predicate,\r\n                            effect: function (action, listenerApi) {\r\n                                listenerApi.unsubscribe();\r\n                                resolve([\r\n                                    action,\r\n                                    listenerApi.getState(),\r\n                                    listenerApi.getOriginalState()\r\n                                ]);\r\n                            }\r\n                        });\r\n                        unsubscribe = function () {\r\n                            stopListening();\r\n                            reject();\r\n                        };\r\n                    });\r\n                    promises = [\r\n                        tuplePromise\r\n                    ];\r\n                    if (timeout != null) {\r\n                        promises.push(new Promise(function (resolve) { return setTimeout(resolve, timeout, null); }));\r\n                    }\r\n                    _c.label = 1;\r\n                case 1:\r\n                    _c.trys.push([1, , 3, 4]);\r\n                    return [4 /*yield*/, raceWithSignal(signal, Promise.race(promises))];\r\n                case 2:\r\n                    output = _c.sent();\r\n                    validateActive(signal);\r\n                    return [2 /*return*/, output];\r\n                case 3:\r\n                    unsubscribe();\r\n                    return [7 /*endfinally*/];\r\n                case 4: return [2 /*return*/];\r\n            }\r\n        });\r\n    }); };\r\n    return function (predicate, timeout) { return catchRejection(take(predicate, timeout)); };\r\n};\r\nvar getListenerEntryPropsFrom = function (options) {\r\n    var type = options.type, actionCreator = options.actionCreator, matcher = options.matcher, predicate = options.predicate, effect = options.effect;\r\n    if (type) {\r\n        predicate = createAction(type).match;\r\n    }\r\n    else if (actionCreator) {\r\n        type = actionCreator.type;\r\n        predicate = actionCreator.match;\r\n    }\r\n    else if (matcher) {\r\n        predicate = matcher;\r\n    }\r\n    else if (predicate) {\r\n    }\r\n    else {\r\n        throw new Error(\"Creating or removing a listener requires one of the known fields for matching an action\");\r\n    }\r\n    assertFunction(effect, \"options.listener\");\r\n    return { predicate: predicate, type: type, effect: effect };\r\n};\r\nvar createListenerEntry = function (options) {\r\n    var _c = getListenerEntryPropsFrom(options), type = _c.type, predicate = _c.predicate, effect = _c.effect;\r\n    var id = nanoid();\r\n    var entry = {\r\n        id: id,\r\n        effect: effect,\r\n        type: type,\r\n        predicate: predicate,\r\n        pending: new Set(),\r\n        unsubscribe: function () {\r\n            throw new Error(\"Unsubscribe not initialized\");\r\n        }\r\n    };\r\n    return entry;\r\n};\r\nvar cancelActiveListeners = function (entry) {\r\n    entry.pending.forEach(function (controller) {\r\n        abortControllerWithReason(controller, listenerCancelled);\r\n    });\r\n};\r\nvar createClearListenerMiddleware = function (listenerMap) {\r\n    return function () {\r\n        listenerMap.forEach(cancelActiveListeners);\r\n        listenerMap.clear();\r\n    };\r\n};\r\nvar safelyNotifyError = function (errorHandler, errorToNotify, errorInfo) {\r\n    try {\r\n        errorHandler(errorToNotify, errorInfo);\r\n    }\r\n    catch (errorHandlerError) {\r\n        setTimeout(function () {\r\n            throw errorHandlerError;\r\n        }, 0);\r\n    }\r\n};\r\nvar addListener = createAction(alm + \"/add\");\r\nvar clearAllListeners = createAction(alm + \"/removeAll\");\r\nvar removeListener = createAction(alm + \"/remove\");\r\nvar defaultErrorHandler = function () {\r\n    var args = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        args[_i] = arguments[_i];\r\n    }\r\n    console.error.apply(console, __spreadArray([alm + \"/error\"], args));\r\n};\r\nfunction createListenerMiddleware(middlewareOptions) {\r\n    var _this = this;\r\n    if (middlewareOptions === void 0) { middlewareOptions = {}; }\r\n    var listenerMap = new Map();\r\n    var extra = middlewareOptions.extra, _c = middlewareOptions.onError, onError = _c === void 0 ? defaultErrorHandler : _c;\r\n    assertFunction(onError, \"onError\");\r\n    var insertEntry = function (entry) {\r\n        entry.unsubscribe = function () { return listenerMap.delete(entry.id); };\r\n        listenerMap.set(entry.id, entry);\r\n        return function (cancelOptions) {\r\n            entry.unsubscribe();\r\n            if (cancelOptions == null ? void 0 : cancelOptions.cancelActive) {\r\n                cancelActiveListeners(entry);\r\n            }\r\n        };\r\n    };\r\n    var findListenerEntry = function (comparator) {\r\n        for (var _i = 0, _c = Array.from(listenerMap.values()); _i < _c.length; _i++) {\r\n            var entry = _c[_i];\r\n            if (comparator(entry)) {\r\n                return entry;\r\n            }\r\n        }\r\n        return void 0;\r\n    };\r\n    var startListening = function (options) {\r\n        var entry = findListenerEntry(function (existingEntry) { return existingEntry.effect === options.effect; });\r\n        if (!entry) {\r\n            entry = createListenerEntry(options);\r\n        }\r\n        return insertEntry(entry);\r\n    };\r\n    var stopListening = function (options) {\r\n        var _c = getListenerEntryPropsFrom(options), type = _c.type, effect = _c.effect, predicate = _c.predicate;\r\n        var entry = findListenerEntry(function (entry2) {\r\n            var matchPredicateOrType = typeof type === \"string\" ? entry2.type === type : entry2.predicate === predicate;\r\n            return matchPredicateOrType && entry2.effect === effect;\r\n        });\r\n        if (entry) {\r\n            entry.unsubscribe();\r\n            if (options.cancelActive) {\r\n                cancelActiveListeners(entry);\r\n            }\r\n        }\r\n        return !!entry;\r\n    };\r\n    var notifyListener = function (entry, action, api, getOriginalState) { return __async(_this, null, function () {\r\n        var internalTaskController, take, autoJoinPromises, listenerError_1;\r\n        return __generator(this, function (_c) {\r\n            switch (_c.label) {\r\n                case 0:\r\n                    internalTaskController = new AbortController();\r\n                    take = createTakePattern(startListening, internalTaskController.signal);\r\n                    autoJoinPromises = [];\r\n                    _c.label = 1;\r\n                case 1:\r\n                    _c.trys.push([1, 3, 4, 6]);\r\n                    entry.pending.add(internalTaskController);\r\n                    return [4 /*yield*/, Promise.resolve(entry.effect(action, assign({}, api, {\r\n                            getOriginalState: getOriginalState,\r\n                            condition: function (predicate, timeout) { return take(predicate, timeout).then(Boolean); },\r\n                            take: take,\r\n                            delay: createDelay(internalTaskController.signal),\r\n                            pause: createPause(internalTaskController.signal),\r\n                            extra: extra,\r\n                            signal: internalTaskController.signal,\r\n                            fork: createFork(internalTaskController.signal, autoJoinPromises),\r\n                            unsubscribe: entry.unsubscribe,\r\n                            subscribe: function () {\r\n                                listenerMap.set(entry.id, entry);\r\n                            },\r\n                            cancelActiveListeners: function () {\r\n                                entry.pending.forEach(function (controller, _, set) {\r\n                                    if (controller !== internalTaskController) {\r\n                                        abortControllerWithReason(controller, listenerCancelled);\r\n                                        set.delete(controller);\r\n                                    }\r\n                                });\r\n                            }\r\n                        })))];\r\n                case 2:\r\n                    _c.sent();\r\n                    return [3 /*break*/, 6];\r\n                case 3:\r\n                    listenerError_1 = _c.sent();\r\n                    if (!(listenerError_1 instanceof TaskAbortError)) {\r\n                        safelyNotifyError(onError, listenerError_1, {\r\n                            raisedBy: \"effect\"\r\n                        });\r\n                    }\r\n                    return [3 /*break*/, 6];\r\n                case 4: return [4 /*yield*/, Promise.allSettled(autoJoinPromises)];\r\n                case 5:\r\n                    _c.sent();\r\n                    abortControllerWithReason(internalTaskController, listenerCompleted);\r\n                    entry.pending.delete(internalTaskController);\r\n                    return [7 /*endfinally*/];\r\n                case 6: return [2 /*return*/];\r\n            }\r\n        });\r\n    }); };\r\n    var clearListenerMiddleware = createClearListenerMiddleware(listenerMap);\r\n    var middleware = function (api) { return function (next) { return function (action) {\r\n        if (!isAction(action)) {\r\n            return next(action);\r\n        }\r\n        if (addListener.match(action)) {\r\n            return startListening(action.payload);\r\n        }\r\n        if (clearAllListeners.match(action)) {\r\n            clearListenerMiddleware();\r\n            return;\r\n        }\r\n        if (removeListener.match(action)) {\r\n            return stopListening(action.payload);\r\n        }\r\n        var originalState = api.getState();\r\n        var getOriginalState = function () {\r\n            if (originalState === INTERNAL_NIL_TOKEN) {\r\n                throw new Error(alm + \": getOriginalState can only be called synchronously\");\r\n            }\r\n            return originalState;\r\n        };\r\n        var result;\r\n        try {\r\n            result = next(action);\r\n            if (listenerMap.size > 0) {\r\n                var currentState = api.getState();\r\n                var listenerEntries = Array.from(listenerMap.values());\r\n                for (var _i = 0, listenerEntries_1 = listenerEntries; _i < listenerEntries_1.length; _i++) {\r\n                    var entry = listenerEntries_1[_i];\r\n                    var runListener = false;\r\n                    try {\r\n                        runListener = entry.predicate(action, currentState, originalState);\r\n                    }\r\n                    catch (predicateError) {\r\n                        runListener = false;\r\n                        safelyNotifyError(onError, predicateError, {\r\n                            raisedBy: \"predicate\"\r\n                        });\r\n                    }\r\n                    if (!runListener) {\r\n                        continue;\r\n                    }\r\n                    notifyListener(entry, action, api, getOriginalState);\r\n                }\r\n            }\r\n        }\r\n        finally {\r\n            originalState = INTERNAL_NIL_TOKEN;\r\n        }\r\n        return result;\r\n    }; }; };\r\n    return {\r\n        middleware: middleware,\r\n        startListening: startListening,\r\n        stopListening: stopListening,\r\n        clearListeners: clearListenerMiddleware\r\n    };\r\n}\r\n// src/autoBatchEnhancer.ts\r\nvar SHOULD_AUTOBATCH = \"RTK_autoBatch\";\r\nvar prepareAutoBatched = function () { return function (payload) {\r\n    var _c;\r\n    return ({\r\n        payload: payload,\r\n        meta: (_c = {}, _c[SHOULD_AUTOBATCH] = true, _c)\r\n    });\r\n}; };\r\nvar promise;\r\nvar queueMicrotaskShim = typeof queueMicrotask === \"function\" ? queueMicrotask.bind(typeof window !== \"undefined\" ? window : typeof global !== \"undefined\" ? global : globalThis) : function (cb) { return (promise || (promise = Promise.resolve())).then(cb).catch(function (err) { return setTimeout(function () {\r\n    throw err;\r\n}, 0); }); };\r\nvar createQueueWithTimer = function (timeout) {\r\n    return function (notify) {\r\n        setTimeout(notify, timeout);\r\n    };\r\n};\r\nvar rAF = typeof window !== \"undefined\" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10);\r\nvar autoBatchEnhancer = function (options) {\r\n    if (options === void 0) { options = { type: \"raf\" }; }\r\n    return function (next) { return function () {\r\n        var args = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            args[_i] = arguments[_i];\r\n        }\r\n        var store = next.apply(void 0, args);\r\n        var notifying = true;\r\n        var shouldNotifyAtEndOfTick = false;\r\n        var notificationQueued = false;\r\n        var listeners = new Set();\r\n        var queueCallback = options.type === \"tick\" ? queueMicrotaskShim : options.type === \"raf\" ? rAF : options.type === \"callback\" ? options.queueNotification : createQueueWithTimer(options.timeout);\r\n        var notifyListeners = function () {\r\n            notificationQueued = false;\r\n            if (shouldNotifyAtEndOfTick) {\r\n                shouldNotifyAtEndOfTick = false;\r\n                listeners.forEach(function (l) { return l(); });\r\n            }\r\n        };\r\n        return Object.assign({}, store, {\r\n            subscribe: function (listener2) {\r\n                var wrappedListener = function () { return notifying && listener2(); };\r\n                var unsubscribe = store.subscribe(wrappedListener);\r\n                listeners.add(listener2);\r\n                return function () {\r\n                    unsubscribe();\r\n                    listeners.delete(listener2);\r\n                };\r\n            },\r\n            dispatch: function (action) {\r\n                var _a;\r\n                try {\r\n                    notifying = !((_a = action == null ? void 0 : action.meta) == null ? void 0 : _a[SHOULD_AUTOBATCH]);\r\n                    shouldNotifyAtEndOfTick = !notifying;\r\n                    if (shouldNotifyAtEndOfTick) {\r\n                        if (!notificationQueued) {\r\n                            notificationQueued = true;\r\n                            queueCallback(notifyListeners);\r\n                        }\r\n                    }\r\n                    return store.dispatch(action);\r\n                }\r\n                finally {\r\n                    notifying = true;\r\n                }\r\n            }\r\n        });\r\n    }; };\r\n};\r\n// src/index.ts\r\nenableES5();\r\nexport { EnhancerArray, MiddlewareArray, SHOULD_AUTOBATCH, TaskAbortError, addListener, autoBatchEnhancer, clearAllListeners, configureStore, createAction, createActionCreatorInvariantMiddleware, createAsyncThunk, createDraftSafeSelector, createEntityAdapter, createImmutableStateInvariantMiddleware, createListenerMiddleware, default2 as createNextState, createReducer, createSelector2 as createSelector, createSerializableStateInvariantMiddleware, createSlice, current2 as current, findNonSerializableValue, freeze, getDefaultMiddleware, getType, isAction, isActionCreator, isAllOf, isAnyOf, isAsyncThunkAction, isDraft4 as isDraft, isFSA as isFluxStandardAction, isFulfilled, isImmutableDefault, isPending, isPlain, isPlainObject, isRejected, isRejectedWithValue, miniSerializeError, nanoid, original, prepareAutoBatched, removeListener, unwrapResult };\r\n//# sourceMappingURL=redux-toolkit.esm.js.map","/**\n * @remix-run/router v1.22.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Actions represent the type of change to a location value.\n */\nvar Action;\n(function (Action) {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Action[\"Pop\"] = \"POP\";\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Action[\"Push\"] = \"PUSH\";\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\nconst PopStateEventType = \"popstate\";\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    initialEntries = [\"/\"],\n    initialIndex,\n    v5Compat = false\n  } = options;\n  let entries; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === \"string\" ? null : entry.state, index === 0 ? \"default\" : undefined));\n  let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);\n  let action = Action.Pop;\n  let listener = null;\n  function clampIndex(n) {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation() {\n    return entries[index];\n  }\n  function createMemoryLocation(to, state, key) {\n    if (state === void 0) {\n      state = null;\n    }\n    let location = createLocation(entries ? getCurrentLocation().pathname : \"/\", to, state, key);\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n    return location;\n  }\n  function createHref(to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  let history = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\"\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 1\n        });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 0\n        });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta\n        });\n      }\n    },\n    listen(fn) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    }\n  };\n  return history;\n}\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createBrowserLocation(window, globalHistory) {\n    let {\n      pathname,\n      search,\n      hash\n    } = window.location;\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createBrowserHref(window, to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);\n}\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createHashLocation(window, globalHistory) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\"\n    } = parsePath(window.location.hash.substr(1));\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createHashHref(window, to) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n  function validateHashLocation(location, to) {\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\");\n  }\n  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);\n}\nfunction invariant(value, message) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n    try {\n      // Welcome to debugging history!\n      //\n      // This error is thrown as a convenience, so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location, index) {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index\n  };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\nfunction createLocation(current, to, state, key) {\n  if (state === void 0) {\n    state = null;\n  }\n  let location = _extends({\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\"\n  }, typeof to === \"string\" ? parsePath(to) : to, {\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: to && to.key || key || createKey()\n  });\n  return location;\n}\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nfunction createPath(_ref) {\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\"\n  } = _ref;\n  if (search && search !== \"?\") pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\") pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nfunction parsePath(path) {\n  let parsedPath = {};\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n  return parsedPath;\n}\nfunction getUrlBasedHistory(getLocation, createHref, validateLocation, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    window = document.defaultView,\n    v5Compat = false\n  } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener = null;\n  let index = getIndex();\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), \"\");\n  }\n  function getIndex() {\n    let state = globalHistory.state || {\n      idx: null\n    };\n    return state.idx;\n  }\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({\n        action,\n        location: history.location,\n        delta\n      });\n    }\n  }\n  function push(to, state) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 1\n      });\n    }\n  }\n  function replace(to, state) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 0\n      });\n    }\n  }\n  function createURL(to) {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base = window.location.origin !== \"null\" ? window.location.origin : window.location.href;\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(base, \"No window.location.(origin|href) available to create URL for href: \" + href);\n    return new URL(href, base);\n  }\n  let history = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    }\n  };\n  return history;\n}\n//#endregion\n\nvar ResultType;\n(function (ResultType) {\n  ResultType[\"data\"] = \"data\";\n  ResultType[\"deferred\"] = \"deferred\";\n  ResultType[\"redirect\"] = \"redirect\";\n  ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\nconst immutableRouteKeys = new Set([\"lazy\", \"caseSensitive\", \"path\", \"id\", \"index\", \"children\"]);\nfunction isIndexRoute(route) {\n  return route.index === true;\n}\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nfunction convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  if (manifest === void 0) {\n    manifest = {};\n  }\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, String(index)];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(route.index !== true || !route.children, \"Cannot specify children on an index route\");\n    invariant(!manifest[id], \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, mapRouteProperties(route), {\n        id\n      });\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {\n        id,\n        children: undefined\n      });\n      manifest[id] = pathOrLayoutRoute;\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);\n      }\n      return pathOrLayoutRoute;\n    }\n  });\n}\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/v6/utils/match-routes\n */\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n  return matchRoutesImpl(routes, locationArg, basename, false);\n}\nfunction matchRoutesImpl(routes, locationArg, basename, allowPartial) {\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n  if (pathname == null) {\n    return null;\n  }\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch(branches[i], decoded, allowPartial);\n  }\n  return matches;\n}\nfunction convertRouteMatchToUiMatch(match, loaderData) {\n  let {\n    route,\n    pathname,\n    params\n  } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle\n  };\n}\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n  let flattenRoute = (route, index, relativePath) => {\n    let meta = {\n      relativePath: relativePath === undefined ? route.path || \"\" : relativePath,\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(meta.relativePath.startsWith(parentPath), \"Absolute route path \\\"\" + meta.relativePath + \"\\\" nested under path \" + (\"\\\"\" + parentPath + \"\\\" is not valid. An absolute child route path \") + \"must start with the combined path of all its parent routes.\");\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n    // Add the children before adding this route to the array, so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n      // Our types know better, but runtime JS may not!\n      // @ts-expect-error\n      route.index !== true, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\"));\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  };\n  routes.forEach((route, index) => {\n    var _route$path;\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !((_route$path = route.path) != null && _route$path.includes(\"?\"))) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n  return branches;\n}\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path) {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n  let [first, ...rest] = segments;\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n  let result = [];\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(...restExploded.map(subpath => subpath === \"\" ? required : [required, subpath].join(\"/\")));\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map(exploded => path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded);\n}\nfunction rankRouteBranches(branches) {\n  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first\n  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));\n}\nconst paramRe = /^:[\\w-]+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = s => s === \"*\";\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\nfunction compareIndexes(a, b) {\n  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n  return siblings ?\n  // If two routes are siblings, we should try to match the earlier sibling\n  // first. This allows people to have fine-grained control over the matching\n  // behavior by simply putting routes with identical paths in the order they\n  // want them tried.\n  a[a.length - 1] - b[b.length - 1] :\n  // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\nfunction matchRouteBranch(branch, pathname, allowPartial) {\n  if (allowPartial === void 0) {\n    allowPartial = false;\n  }\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname = matchedPathname === \"/\" ? pathname : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath({\n      path: meta.relativePath,\n      caseSensitive: meta.caseSensitive,\n      end\n    }, remainingPathname);\n    let route = meta.route;\n    if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {\n      match = matchPath({\n        path: meta.relativePath,\n        caseSensitive: meta.caseSensitive,\n        end: false\n      }, remainingPathname);\n    }\n    if (!match) {\n      return null;\n    }\n    Object.assign(matchedParams, match.params);\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n      route\n    });\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n  return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/v6/utils/generate-path\n */\nfunction generatePath(originalPath, params) {\n  if (params === void 0) {\n    params = {};\n  }\n  let path = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(false, \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n    path = path.replace(/\\*$/, \"/*\");\n  }\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n  const stringify = p => p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n  const segments = path.split(/\\/+/).map((segment, index, array) => {\n    const isLastSegment = index === array.length - 1;\n    // only apply the splat if it's the last segment\n    if (isLastSegment && segment === \"*\") {\n      const star = \"*\";\n      // Apply the splat\n      return stringify(params[star]);\n    }\n    const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n    if (keyMatch) {\n      const [, key, optional] = keyMatch;\n      let param = params[key];\n      invariant(optional === \"?\" || param != null, \"Missing \\\":\" + key + \"\\\" param\");\n      return stringify(param);\n    }\n    // Remove any optional markers from optional static segments\n    return segment.replace(/\\?$/g, \"\");\n  })\n  // Remove empty segments\n  .filter(segment => !!segment);\n  return prefix + segments.join(\"/\");\n}\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/v6/utils/match-path\n */\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);\n  let match = pathname.match(matcher);\n  if (!match) return null;\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params = compiledParams.reduce((memo, _ref, index) => {\n    let {\n      paramName,\n      isOptional\n    } = _ref;\n    // We need to compute the pathnameBase here using the raw splat value\n    // instead of using params[\"*\"] later because it will be decoded then\n    if (paramName === \"*\") {\n      let splatValue = captureGroups[index] || \"\";\n      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n    }\n    const value = captureGroups[index];\n    if (isOptional && !value) {\n      memo[paramName] = undefined;\n    } else {\n      memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n    }\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n  if (end === void 0) {\n    end = true;\n  }\n  warning(path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"), \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n  let params = [];\n  let regexpSource = \"^\" + path.replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n  .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n  .replace(/[\\\\.*+^${}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n  .replace(/\\/:([\\w-]+)(\\?)?/g, (_, paramName, isOptional) => {\n    params.push({\n      paramName,\n      isOptional: isOptional != null\n    });\n    return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n  });\n  if (path.endsWith(\"*\")) {\n    params.push({\n      paramName: \"*\"\n    });\n    regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // Already matched the initial /, just match the rest\n    : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else ;\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, params];\n}\nfunction decodePath(value) {\n  try {\n    return value.split(\"/\").map(v => decodeURIComponent(v).replace(/\\//g, \"%2F\")).join(\"/\");\n  } catch (error) {\n    warning(false, \"The URL path \\\"\" + value + \"\\\" could not be decoded because it is is a \" + \"malformed URL segment. This is probably due to a bad percent \" + (\"encoding (\" + error + \").\"));\n    return value;\n  }\n}\n/**\n * @private\n */\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\") ? basename.length - 1 : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n  return pathname.slice(startIndex) || \"/\";\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/v6/utils/resolve-path\n */\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\"\n  } = typeof to === \"string\" ? parsePath(to) : to;\n  let pathname = toPathname ? toPathname.startsWith(\"/\") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash)\n  };\n}\nfunction resolvePathname(relativePath, fromPathname) {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n  relativeSegments.forEach(segment => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\nfunction getInvalidPathError(char, field, dest, path) {\n  return \"Cannot include a '\" + char + \"' character in a manually specified \" + (\"`to.\" + field + \"` field [\" + JSON.stringify(path) + \"].  Please separate it out to the \") + (\"`to.\" + dest + \"` field. Alternatively you may provide the full path as \") + \"a string in <Link to=\\\"...\\\"> and the router will parse it for you.\";\n}\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nfunction getPathContributingMatches(matches) {\n  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nfunction getResolveToMatches(matches, v7_relativeSplatPath) {\n  let pathMatches = getPathContributingMatches(matches);\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);\n  }\n  return pathMatches.map(match => match.pathnameBase);\n}\n/**\n * @private\n */\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n  if (isPathRelative === void 0) {\n    isPathRelative = false;\n  }\n  let to;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = _extends({}, toArg);\n    invariant(!to.pathname || !to.pathname.includes(\"?\"), getInvalidPathError(\"?\", \"pathname\", \"search\", to));\n    invariant(!to.pathname || !to.pathname.includes(\"#\"), getInvalidPathError(\"#\", \"pathname\", \"hash\", to));\n    invariant(!to.search || !to.search.includes(\"#\"), getInvalidPathError(\"#\", \"search\", \"hash\", to));\n  }\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n  let from;\n  // Routing is relative to the current pathname if explicitly requested.\n  //\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n      to.pathname = toSegments.join(\"/\");\n    }\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n  let path = resolvePath(to, from);\n  // Ensure the pathname has a trailing slash if the original \"to\" had one\n  let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n    path.pathname += \"/\";\n  }\n  return path;\n}\n/**\n * @private\n */\nfunction getToPathname(to) {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || to.pathname === \"\" ? \"/\" : typeof to === \"string\" ? parsePath(to).pathname : to.pathname;\n}\n/**\n * @private\n */\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n *\n * @deprecated The `json` method is deprecated in favor of returning raw objects.\n * This method will be removed in v7.\n */\nconst json = function json(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n  return new Response(JSON.stringify(data), _extends({}, responseInit, {\n    headers\n  }));\n};\nclass DataWithResponseInit {\n  constructor(data, init) {\n    this.type = \"DataWithResponseInit\";\n    this.data = data;\n    this.init = init || null;\n  }\n}\n/**\n * Create \"responses\" that contain `status`/`headers` without forcing\n * serialization into an actual `Response` - used by Remix single fetch\n */\nfunction data(data, init) {\n  return new DataWithResponseInit(data, typeof init === \"number\" ? {\n    status: init\n  } : init);\n}\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n  constructor(data, responseInit) {\n    this.pendingKeysSet = new Set();\n    this.subscribers = new Set();\n    this.deferredKeys = [];\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\");\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject;\n    this.abortPromise = new Promise((_, r) => reject = r);\n    this.controller = new AbortController();\n    let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n    this.data = Object.entries(data).reduce((acc, _ref2) => {\n      let [key, value] = _ref2;\n      return Object.assign(acc, {\n        [key]: this.trackPromise(key, value)\n      });\n    }, {});\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n    this.init = responseInit;\n  }\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n    Object.defineProperty(promise, \"_tracked\", {\n      get: () => true\n    });\n    return promise;\n  }\n  onSettle(promise, key, error, data) {\n    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      return Promise.reject(error);\n    }\n    this.pendingKeysSet.delete(key);\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\"Deferred data for key \\\"\" + key + \"\\\" resolved/rejected with `undefined`, \" + \"you must resolve/reject with a value or `null`.\");\n      Object.defineProperty(promise, \"_error\", {\n        get: () => undefinedError\n      });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    this.emit(false, key);\n    return data;\n  }\n  emit(aborted, settledKey) {\n    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));\n  }\n  subscribe(fn) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n  async resolveData(signal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise(resolve => {\n        this.subscribe(aborted => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n  get unwrappedData() {\n    invariant(this.data !== null && this.done, \"Can only unwrap data on initialized and settled deferreds\");\n    return Object.entries(this.data).reduce((acc, _ref3) => {\n      let [key, value] = _ref3;\n      return Object.assign(acc, {\n        [key]: unwrapTrackedPromise(value)\n      });\n    }, {});\n  }\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\nfunction isTrackedPromise(value) {\n  return value instanceof Promise && value._tracked === true;\n}\nfunction unwrapTrackedPromise(value) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\n/**\n * @deprecated The `defer` method is deprecated in favor of returning raw\n * objects. This method will be removed in v7.\n */\nconst defer = function defer(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  return new DeferredData(data, responseInit);\n};\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirect = function redirect(url, init) {\n  if (init === void 0) {\n    init = 302;\n  }\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = {\n      status: responseInit\n    };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n  return new Response(null, _extends({}, responseInit, {\n    headers\n  }));\n};\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirectDocument = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n/**\n * A redirect response that will perform a `history.replaceState` instead of a\n * `history.pushState` for client-side navigation redirects.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst replace = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Replace\", \"true\");\n  return response;\n};\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nclass ErrorResponseImpl {\n  constructor(status, statusText, data, internal) {\n    if (internal === void 0) {\n      internal = false;\n    }\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nfunction isRouteErrorResponse(error) {\n  return error != null && typeof error.status === \"number\" && typeof error.statusText === \"string\" && typeof error.internal === \"boolean\" && \"data\" in error;\n}\n\nconst validMutationMethodsArr = [\"post\", \"put\", \"patch\", \"delete\"];\nconst validMutationMethods = new Set(validMutationMethodsArr);\nconst validRequestMethodsArr = [\"get\", ...validMutationMethodsArr];\nconst validRequestMethods = new Set(validRequestMethodsArr);\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_BLOCKER = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined\n};\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nconst defaultMapRouteProperties = route => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary)\n});\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Create a router and listen to history POP navigations\n */\nfunction createRouter(init) {\n  const routerWindow = init.window ? init.window : typeof window !== \"undefined\" ? window : undefined;\n  const isBrowser = typeof routerWindow !== \"undefined\" && typeof routerWindow.document !== \"undefined\" && typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let mapRouteProperties;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Routes keyed by ID\n  let manifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);\n  let inFlightDataRoutes;\n  let basename = init.basename || \"/\";\n  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;\n  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;\n  // Config driven behavior flags\n  let future = _extends({\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false,\n    v7_skipActionErrorRevalidation: false\n  }, init.future);\n  // Cleanup function for history\n  let unlistenHistory = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialMatchesIsFOW = false;\n  let initialErrors = null;\n  if (initialMatches == null && !patchRoutesOnNavigationImpl) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname\n    });\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and\n  // our initial match is a splat route, clear them out so we run through lazy\n  // discovery on hydration in case there's a more accurate lazy route match.\n  // In SSR apps (with `hydrationData`), we expect that the server will send\n  // up the proper matched routes so we don't want to run lazy discovery on\n  // initial hydration and want to hydrate into the splat route.\n  if (initialMatches && !init.hydrationData) {\n    let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);\n    if (fogOfWar.active) {\n      initialMatches = null;\n    }\n  }\n  let initialized;\n  if (!initialMatches) {\n    initialized = false;\n    initialMatches = [];\n    // If partial hydration and fog of war is enabled, we will be running\n    // `patchRoutesOnNavigation` during hydration so include any partial matches as\n    // the initial matches so we can properly render `HydrateFallback`'s\n    if (future.v7_partialHydration) {\n      let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);\n      if (fogOfWar.active && fogOfWar.matches) {\n        initialMatchesIsFOW = true;\n        initialMatches = fogOfWar.matches;\n      }\n    }\n  } else if (initialMatches.some(m => m.route.lazy)) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!initialMatches.some(m => m.route.loader)) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);\n      initialized = initialMatches.slice(0, idx + 1).every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\n    } else {\n      initialized = initialMatches.every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n  let router;\n  let state = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: init.hydrationData && init.hydrationData.loaderData || {},\n    actionData: init.hydrationData && init.hydrationData.actionData || null,\n    errors: init.hydrationData && init.hydrationData.errors || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map()\n  };\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction = Action.Pop;\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n  // AbortController for the active navigation\n  let pendingNavigationController;\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions = new Map();\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener = null;\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes = [];\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads = new Set();\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map();\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map();\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set();\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map();\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map();\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set();\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map();\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map();\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let unblockBlockerHistoryUpdate = undefined;\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(_ref => {\n      let {\n        action: historyAction,\n        location,\n        delta\n      } = _ref;\n      // Ignore this event if it was just us resetting the URL from a\n      // blocked POP navigation\n      if (unblockBlockerHistoryUpdate) {\n        unblockBlockerHistoryUpdate();\n        unblockBlockerHistoryUpdate = undefined;\n        return;\n      }\n      warning(blockerFunctions.size === 0 || delta != null, \"You are trying to use a blocker on a POP navigation to a location \" + \"that was not created by @remix-run/router. This will fail silently in \" + \"production. This can happen if you are navigating outside the router \" + \"via `window.history.pushState`/`window.location.hash` instead of using \" + \"router navigation APIs.  This can also happen if you are using \" + \"createHashRouter and the user manually changes the URL.\");\n      let blockerKey = shouldBlockNavigation({\n        currentLocation: state.location,\n        nextLocation: location,\n        historyAction\n      });\n      if (blockerKey && delta != null) {\n        // Restore the URL to match the current UI, but don't update router state\n        let nextHistoryUpdatePromise = new Promise(resolve => {\n          unblockBlockerHistoryUpdate = resolve;\n        });\n        init.history.go(delta * -1);\n        // Put the blocker into a blocked state\n        updateBlocker(blockerKey, {\n          state: \"blocked\",\n          location,\n          proceed() {\n            updateBlocker(blockerKey, {\n              state: \"proceeding\",\n              proceed: undefined,\n              reset: undefined,\n              location\n            });\n            // Re-do the same POP navigation we just blocked, after the url\n            // restoration is also complete.  See:\n            // https://github.com/remix-run/react-router/issues/11613\n            nextHistoryUpdatePromise.then(() => init.history.go(delta));\n          },\n          reset() {\n            let blockers = new Map(state.blockers);\n            blockers.set(blockerKey, IDLE_BLOCKER);\n            updateState({\n              blockers\n            });\n          }\n        });\n        return;\n      }\n      return startNavigation(historyAction, location);\n    });\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () => routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(Action.Pop, state.location, {\n        initialHydration: true\n      });\n    }\n    return router;\n  }\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n  // Subscribe to state updates for the router\n  function subscribe(fn) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n  // Update our state and notify the calling context of the change\n  function updateState(newState, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state = _extends({}, state, newState);\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers = [];\n    let deletedFetchersKeys = [];\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n    // Remove any lingering deleted fetchers that have already been removed\n    // from state.fetchers\n    deletedFetchers.forEach(key => {\n      if (!state.fetchers.has(key) && !fetchControllers.has(key)) {\n        deletedFetchersKeys.push(key);\n      }\n    });\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach(subscriber => subscriber(state, {\n      deletedFetchers: deletedFetchersKeys,\n      viewTransitionOpts: opts.viewTransitionOpts,\n      flushSync: opts.flushSync === true\n    }));\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach(key => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach(key => deleteFetcher(key));\n    } else {\n      // We already called deleteFetcher() on these, can remove them from this\n      // Set now that we've handed the keys off to the data layer\n      deletedFetchersKeys.forEach(key => deletedFetchers.delete(key));\n    }\n  }\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(location, newState, _temp) {\n    var _location$state, _location$state2;\n    let {\n      flushSync\n    } = _temp === void 0 ? {} : _temp;\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === \"loading\" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;\n    let actionData;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;\n    // Commit any in-flight routes at the end of the HMR revalidation \"navigation\"\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === Action.Replace) {\n      init.history.replace(location, location.state);\n    }\n    let viewTransitionOpts;\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === Action.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location\n      };\n    }\n    updateState(_extends({}, newState, {\n      actionData,\n      loaderData,\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset,\n      blockers\n    }), {\n      viewTransitionOpts,\n      flushSync: flushSync === true\n    });\n    // Reset stateful navigation vars\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n  }\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(to, opts) {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n    let historyAction = Action.Push;\n    if (userReplace === true) {\n      historyAction = Action.Replace;\n    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = Action.Replace;\n    }\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    let flushSync = (opts && opts.flushSync) === true;\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction\n    });\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey, IDLE_BLOCKER);\n          updateState({\n            blockers\n          });\n        }\n      });\n      return;\n    }\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.viewTransition,\n      flushSync\n    });\n  }\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({\n      revalidation: \"loading\"\n    });\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true\n      });\n      return;\n    }\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(pendingAction || state.historyAction, state.navigation.location, {\n      overrideNavigation: state.navigation,\n      // Proxy through any rending view transition\n      enableViewTransition: pendingViewTransitionEnabled === true\n    });\n  }\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(historyAction, location, opts) {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = opts != null && opts.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ?\n    // `matchRoutes()` has already been called if we're in here via `router.initialize()`\n    state.matches : matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let {\n        error,\n        notFoundMatches,\n        route\n      } = handleNavigational404(location.pathname);\n      completeNavigation(location, {\n        matches: notFoundMatches,\n        loaderData: {},\n        errors: {\n          [route.id]: error\n        }\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial hydration will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {\n      completeNavigation(location, {\n        matches\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);\n    let pendingActionResult;\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingActionResult = [findNearestBoundary(matches).route.id, {\n        type: ResultType.error,\n        error: opts.pendingError\n      }];\n    } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {\n      // Call action if we received an action submission\n      let actionResult = await handleAction(request, location, opts.submission, matches, fogOfWar.active, {\n        replace: opts.replace,\n        flushSync\n      });\n      if (actionResult.shortCircuited) {\n        return;\n      }\n      // If we received a 404 from handleAction, it's because we couldn't lazily\n      // discover the destination route so we don't want to call loaders\n      if (actionResult.pendingActionResult) {\n        let [routeId, result] = actionResult.pendingActionResult;\n        if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {\n          pendingNavigationController = null;\n          completeNavigation(location, {\n            matches: actionResult.matches,\n            loaderData: {},\n            errors: {\n              [routeId]: result.error\n            }\n          });\n          return;\n        }\n      }\n      matches = actionResult.matches || matches;\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // No need to do fog of war matching again on loader execution\n      fogOfWar.active = false;\n      // Create a GET request for the loaders\n      request = createClientSideRequest(init.history, request.url, request.signal);\n    }\n    // Call loaders\n    let {\n      shortCircuited,\n      matches: updatedMatches,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);\n    if (shortCircuited) {\n      return;\n    }\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n    completeNavigation(location, _extends({\n      matches: updatedMatches || matches\n    }, getActionDataForCommit(pendingActionResult), {\n      loaderData,\n      errors\n    }));\n  }\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(request, location, submission, matches, isFogOfWar, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    interruptActiveLoads();\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({\n      navigation\n    }, {\n      flushSync: opts.flushSync === true\n    });\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);\n      if (discoverResult.type === \"aborted\") {\n        return {\n          shortCircuited: true\n        };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          pendingActionResult: [boundaryId, {\n            type: ResultType.error,\n            error: discoverResult.error\n          }]\n        };\n      } else if (!discoverResult.matches) {\n        let {\n          notFoundMatches,\n          error,\n          route\n        } = handleNavigational404(location.pathname);\n        return {\n          matches: notFoundMatches,\n          pendingActionResult: [route.id, {\n            type: ResultType.error,\n            error\n          }]\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n    // Call our action and get the result\n    let result;\n    let actionMatch = getTargetMatch(matches, location);\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id\n        })\n      };\n    } else {\n      let results = await callDataStrategy(\"action\", state, request, [actionMatch], matches, null);\n      result = results[actionMatch.route.id];\n      if (request.signal.aborted) {\n        return {\n          shortCircuited: true\n        };\n      }\n    }\n    if (isRedirectResult(result)) {\n      let replace;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        let location = normalizeRedirectLocation(result.response.headers.get(\"Location\"), new URL(request.url), basename);\n        replace = location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(request, result, true, {\n        submission,\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n      // By default, all submissions to the current location are REPLACE\n      // navigations, but if the action threw an error that'll be rendered in\n      // an errorElement, we fall back to PUSH so that the user can use the\n      // back button to get back to the pre-submission form location to try\n      // again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n      return {\n        matches,\n        pendingActionResult: [boundaryMatch.route.id, result]\n      };\n    }\n    return {\n      matches,\n      pendingActionResult: [actionMatch.route.id, result]\n    };\n  }\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since it's not a \"navigation\"\n    let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);\n    // When fog of war is enabled, we enter our `loading` state earlier so we\n    // can discover new routes during the `loading` state.  We skip this if\n    // we've already run actions since we would have done our matching already.\n    // If the children() function threw then, we want to proceed with the\n    // partial matches it discovered.\n    if (isFogOfWar) {\n      if (shouldUpdateNavigationState) {\n        let actionData = getUpdatedActionData(pendingActionResult);\n        updateState(_extends({\n          navigation: loadingNavigation\n        }, actionData !== undefined ? {\n          actionData\n        } : {}), {\n          flushSync\n        });\n      }\n      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);\n      if (discoverResult.type === \"aborted\") {\n        return {\n          shortCircuited: true\n        };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          loaderData: {},\n          errors: {\n            [boundaryId]: discoverResult.error\n          }\n        };\n      } else if (!discoverResult.matches) {\n        let {\n          error,\n          notFoundMatches,\n          route\n        } = handleNavigational404(location.pathname);\n        return {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error\n          }\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));\n    pendingNavigationLoadId = ++incrementingLoadId;\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(location, _extends({\n        matches,\n        loaderData: {},\n        // Commit pending error if we're short circuiting\n        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {\n          [pendingActionResult[0]]: pendingActionResult[1].error\n        } : null\n      }, getActionDataForCommit(pendingActionResult), updatedFetchers ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    if (shouldUpdateNavigationState) {\n      let updates = {};\n      if (!isFogOfWar) {\n        // Only update navigation/actionNData if we didn't already do it above\n        updates.navigation = loadingNavigation;\n        let actionData = getUpdatedActionData(pendingActionResult);\n        if (actionData !== undefined) {\n          updates.actionData = actionData;\n        }\n      }\n      if (revalidatingFetchers.length > 0) {\n        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);\n      }\n      updateState(updates, {\n        flushSync\n      });\n    }\n    revalidatingFetchers.forEach(rf => {\n      abortFetcher(rf.key);\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    let {\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, request);\n    if (request.signal.aborted) {\n      return {\n        shortCircuited: true\n      };\n    }\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe(aborted => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n    // Preserve SSR errors during partial hydration\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      errors = _extends({}, state.errors, errors);\n    }\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n    return _extends({\n      matches,\n      loaderData,\n      errors\n    }, shouldUpdateFetchers ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n  function getUpdatedActionData(pendingActionResult) {\n    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {\n      // This is cast to `any` currently because `RouteData`uses any and it\n      // would be a breaking change to use any.\n      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`\n      return {\n        [pendingActionResult[0]]: pendingActionResult[1].data\n      };\n    } else if (state.actionData) {\n      if (Object.keys(state.actionData).length === 0) {\n        return null;\n      } else {\n        return state.actionData;\n      }\n    }\n  }\n  function getUpdatedRevalidatingFetchers(revalidatingFetchers) {\n    revalidatingFetchers.forEach(rf => {\n      let fetcher = state.fetchers.get(rf.key);\n      let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);\n      state.fetchers.set(rf.key, revalidatingFetcher);\n    });\n    return new Map(state.fetchers);\n  }\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(key, routeId, href, opts) {\n    if (isServer) {\n      throw new Error(\"router.fetch() was called during the server render, but it shouldn't be. \" + \"You are likely calling a useFetcher() method in the body of your component. \" + \"Try moving it to a useEffect or a callback.\");\n    }\n    abortFetcher(key);\n    let flushSync = (opts && opts.flushSync) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n    if (!matches) {\n      setFetcherError(key, routeId, getInternalRouterError(404, {\n        pathname: normalizedPath\n      }), {\n        flushSync\n      });\n      return;\n    }\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);\n    if (error) {\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    let match = getTargetMatch(matches, path);\n    let preventScrollReset = (opts && opts.preventScrollReset) === true;\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);\n      return;\n    }\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, {\n      routeId,\n      path\n    });\n    handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);\n  }\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n    function detectAndHandle405Error(m) {\n      if (!m.route.action && !m.route.lazy) {\n        let error = getInternalRouterError(405, {\n          method: submission.formMethod,\n          pathname: path,\n          routeId: routeId\n        });\n        setFetcherError(key, routeId, error, {\n          flushSync\n        });\n        return true;\n      }\n      return false;\n    }\n    if (!isFogOfWar && detectAndHandle405Error(match)) {\n      return;\n    }\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync\n    });\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(requestMatches, new URL(fetchRequest.url).pathname, fetchRequest.signal);\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, {\n          flushSync\n        });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(key, routeId, getInternalRouterError(404, {\n          pathname: path\n        }), {\n          flushSync\n        });\n        return;\n      } else {\n        requestMatches = discoverResult.matches;\n        match = getTargetMatch(requestMatches, path);\n        if (detectAndHandle405Error(match)) {\n          return;\n        }\n      }\n    }\n    // Call the action for the fetcher\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\"action\", state, fetchRequest, [match], requestMatches, key);\n    let actionResult = actionResults[match.route.id];\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(fetchRequest, actionResult, false, {\n            fetcherSubmission: submission,\n            preventScrollReset\n          });\n        }\n      }\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches = state.navigation.state !== \"idle\" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {\n      let staleKey = rf.key;\n      let existingFetcher = state.fetchers.get(staleKey);\n      let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);\n      state.fetchers.set(staleKey, revalidatingFetcher);\n      abortFetcher(staleKey);\n      if (rf.controller) {\n        fetchControllers.set(staleKey, rf.controller);\n      }\n    });\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));\n    abortController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    let {\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n    if (abortController.signal.aborted) {\n      return;\n    }\n    abortController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      return startRedirectNavigation(revalidationRequest, redirect.result, false, {\n        preventScrollReset\n      });\n    }\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      return startRedirectNavigation(revalidationRequest, redirect.result, false, {\n        preventScrollReset\n      });\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n    abortStaleFetchLoads(loadId);\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (state.navigation.state === \"loading\" && loadId > pendingNavigationLoadId) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers)\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),\n        fetchers: new Map(state.fetchers)\n      });\n      isRevalidationRequired = false;\n    }\n  }\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {\n      flushSync\n    });\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(matches, new URL(fetchRequest.url).pathname, fetchRequest.signal);\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, {\n          flushSync\n        });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(key, routeId, getInternalRouterError(404, {\n          pathname: path\n        }), {\n          flushSync\n        });\n        return;\n      } else {\n        matches = discoverResult.matches;\n        match = getTargetMatch(matches, path);\n      }\n    }\n    // Call the loader for this fetcher route match\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\"loader\", state, fetchRequest, [match], matches, key);\n    let result = results[match.route.id];\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;\n    }\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(fetchRequest, result, false, {\n          preventScrollReset\n        });\n        return;\n      }\n    }\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(request, redirect, isNavigation, _temp2) {\n    let {\n      submission,\n      fetcherSubmission,\n      preventScrollReset,\n      replace\n    } = _temp2 === void 0 ? {} : _temp2;\n    if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n      isRevalidationRequired = true;\n    }\n    let location = redirect.response.headers.get(\"Location\");\n    invariant(location, \"Expected a Location header on the redirect Response\");\n    location = normalizeRedirectLocation(location, new URL(request.url), basename);\n    let redirectLocation = createLocation(state.location, location, {\n      _isRedirect: true\n    });\n    if (isBrowser) {\n      let isDocumentReload = false;\n      if (redirect.response.headers.has(\"X-Remix-Reload-Document\")) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(location)) {\n        const url = init.history.createURL(location);\n        isDocumentReload =\n        // Hard reload if it's an absolute URL to a new origin\n        url.origin !== routerWindow.location.origin ||\n        // Hard reload if it's an absolute URL that does not match our basename\n        stripBasename(url.pathname, basename) == null;\n      }\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(location);\n        } else {\n          routerWindow.location.assign(location);\n        }\n        return;\n      }\n    }\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true || redirect.response.headers.has(\"X-Remix-Replace\") ? Action.Replace : Action.Push;\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let {\n      formMethod,\n      formAction,\n      formEncType\n    } = state.navigation;\n    if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: _extends({}, activeSubmission, {\n          formAction: location\n        }),\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(redirectLocation, submission);\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined\n      });\n    }\n  }\n  // Utility wrapper for calling dataStrategy client-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(type, state, request, matchesToLoad, matches, fetcherKey) {\n    let results;\n    let dataResults = {};\n    try {\n      results = await callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties);\n    } catch (e) {\n      // If the outer dataStrategy method throws, just return the error for all\n      // matches - and it'll naturally bubble to the root\n      matchesToLoad.forEach(m => {\n        dataResults[m.route.id] = {\n          type: ResultType.error,\n          error: e\n        };\n      });\n      return dataResults;\n    }\n    for (let [routeId, result] of Object.entries(results)) {\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result;\n        dataResults[routeId] = {\n          type: ResultType.redirect,\n          response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, future.v7_relativeSplatPath)\n        };\n      } else {\n        dataResults[routeId] = await convertDataStrategyResultToDataResult(result);\n      }\n    }\n    return dataResults;\n  }\n  async function callLoadersAndMaybeResolveData(state, matches, matchesToLoad, fetchersToLoad, request) {\n    let currentMatches = state.matches;\n    // Kick off loaders and fetchers in parallel\n    let loaderResultsPromise = callDataStrategy(\"loader\", state, request, matchesToLoad, matches, null);\n    let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async f => {\n      if (f.matches && f.match && f.controller) {\n        let results = await callDataStrategy(\"loader\", state, createClientSideRequest(init.history, f.path, f.controller.signal), [f.match], f.matches, f.key);\n        let result = results[f.match.route.id];\n        // Fetcher results are keyed by fetcher key from here on out, not routeId\n        return {\n          [f.key]: result\n        };\n      } else {\n        return Promise.resolve({\n          [f.key]: {\n            type: ResultType.error,\n            error: getInternalRouterError(404, {\n              pathname: f.path\n            })\n          }\n        });\n      }\n    }));\n    let loaderResults = await loaderResultsPromise;\n    let fetcherResults = (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {});\n    await Promise.all([resolveNavigationDeferredResults(matches, loaderResults, request.signal, currentMatches, state.loaderData), resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad)]);\n    return {\n      loaderResults,\n      fetcherResults\n    };\n  }\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.add(key);\n      }\n      abortFetcher(key);\n    });\n  }\n  function updateFetcherState(key, fetcher, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function setFetcherError(key, routeId, error, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState({\n      errors: {\n        [boundaryMatch.route.id]: error\n      },\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function getFetcher(key) {\n    activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n    // If this fetcher was previously marked for deletion, unmark it since we\n    // have a new instance\n    if (deletedFetchers.has(key)) {\n      deletedFetchers.delete(key);\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n  function deleteFetcher(key) {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (fetchControllers.has(key) && !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    // If we opted into the flag we can clear this now since we're calling\n    // deleteFetcher() at the end of updateState() and we've already handed the\n    // deleted fetcher keys off to the data layer.\n    // If not, we're eagerly calling deleteFetcher() and we need to keep this\n    // Set populated until the next updateState call, and we'll clear\n    // `deletedFetchers` then\n    if (future.v7_fetcherPersist) {\n      deletedFetchers.delete(key);\n    }\n    cancelledFetcherLoads.delete(key);\n    state.fetchers.delete(key);\n  }\n  function deleteFetcherAndUpdateState(key) {\n    let count = (activeFetchers.get(key) || 0) - 1;\n    if (count <= 0) {\n      activeFetchers.delete(key);\n      deletedFetchers.add(key);\n      if (!future.v7_fetcherPersist) {\n        deleteFetcher(key);\n      }\n    } else {\n      activeFetchers.set(key, count);\n    }\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n  }\n  function abortFetcher(key) {\n    let controller = fetchControllers.get(key);\n    if (controller) {\n      controller.abort();\n      fetchControllers.delete(key);\n    }\n  }\n  function markFetchersDone(keys) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  function markFetchRedirectsDone() {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, \"Expected fetcher: \" + key);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n  function abortStaleFetchLoads(landedId) {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, \"Expected fetcher: \" + key);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n  function getBlocker(key, fn) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n    return blocker;\n  }\n  function deleteBlocker(key) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key, newBlocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(blocker.state === \"unblocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"proceeding\" || blocker.state === \"blocked\" && newBlocker.state === \"unblocked\" || blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\", \"Invalid blocker state transition: \" + blocker.state + \" -> \" + newBlocker.state);\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({\n      blockers\n    });\n  }\n  function shouldBlockNavigation(_ref2) {\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = _ref2;\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({\n      currentLocation,\n      nextLocation,\n      historyAction\n    })) {\n      return blockerKey;\n    }\n  }\n  function handleNavigational404(pathname) {\n    let error = getInternalRouterError(404, {\n      pathname\n    });\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(routesToUse);\n    // Cancel all pending deferred on 404s since we don't keep any routes\n    cancelActiveDeferreds();\n    return {\n      notFoundMatches: matches,\n      route,\n      error\n    };\n  }\n  function cancelActiveDeferreds(predicate) {\n    let cancelledRouteIds = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(positions, getPosition, getKey) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({\n          restoreScrollPosition: y\n        });\n      }\n    }\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n  function getScrollKey(location, matches) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));\n      return key || location.key;\n    }\n    return location.key;\n  }\n  function saveScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n  function getSavedScrollPosition(location, matches) {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n  function checkFogOfWar(matches, routesToUse, pathname) {\n    if (patchRoutesOnNavigationImpl) {\n      if (!matches) {\n        let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n        return {\n          active: true,\n          matches: fogMatches || []\n        };\n      } else {\n        if (Object.keys(matches[0].params).length > 0) {\n          // If we matched a dynamic param or a splat, it might only be because\n          // we haven't yet discovered other routes that would match with a\n          // higher score.  Call patchRoutesOnNavigation just to be sure\n          let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n          return {\n            active: true,\n            matches: partialMatches\n          };\n        }\n      }\n    }\n    return {\n      active: false,\n      matches: null\n    };\n  }\n  async function discoverRoutes(matches, pathname, signal) {\n    if (!patchRoutesOnNavigationImpl) {\n      return {\n        type: \"success\",\n        matches\n      };\n    }\n    let partialMatches = matches;\n    while (true) {\n      let isNonHMR = inFlightDataRoutes == null;\n      let routesToUse = inFlightDataRoutes || dataRoutes;\n      let localManifest = manifest;\n      try {\n        await patchRoutesOnNavigationImpl({\n          signal,\n          path: pathname,\n          matches: partialMatches,\n          patch: (routeId, children) => {\n            if (signal.aborted) return;\n            patchRoutesImpl(routeId, children, routesToUse, localManifest, mapRouteProperties);\n          }\n        });\n      } catch (e) {\n        return {\n          type: \"error\",\n          error: e,\n          partialMatches\n        };\n      } finally {\n        // If we are not in the middle of an HMR revalidation and we changed the\n        // routes, provide a new identity so when we `updateState` at the end of\n        // this navigation/fetch `router.routes` will be a new identity and\n        // trigger a re-run of memoized `router.routes` dependencies.\n        // HMR will already update the identity and reflow when it lands\n        // `inFlightDataRoutes` in `completeNavigation`\n        if (isNonHMR && !signal.aborted) {\n          dataRoutes = [...dataRoutes];\n        }\n      }\n      if (signal.aborted) {\n        return {\n          type: \"aborted\"\n        };\n      }\n      let newMatches = matchRoutes(routesToUse, pathname, basename);\n      if (newMatches) {\n        return {\n          type: \"success\",\n          matches: newMatches\n        };\n      }\n      let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n      // Avoid loops if the second pass results in the same partial matches\n      if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {\n        return {\n          type: \"success\",\n          matches: null\n        };\n      }\n      partialMatches = newPartialMatches;\n    }\n  }\n  function _internalSetRoutes(newRoutes) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);\n  }\n  function patchRoutes(routeId, children) {\n    let isNonHMR = inFlightDataRoutes == null;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties);\n    // If we are not in the middle of an HMR revalidation and we changed the\n    // routes, provide a new identity and trigger a reflow via `updateState`\n    // to re-run memoized `router.routes` dependencies.\n    // HMR will already update the identity and reflow when it lands\n    // `inFlightDataRoutes` in `completeNavigation`\n    if (isNonHMR) {\n      dataRoutes = [...dataRoutes];\n      updateState({});\n    }\n  }\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: to => init.history.createHref(to),\n    encodeLocation: to => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    patchRoutes,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes\n  };\n  return router;\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\nconst UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\nfunction createStaticHandler(routes, opts) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to createStaticHandler\");\n  let manifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties;\n  if (opts != null && opts.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts != null && opts.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future = _extends({\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false\n  }, opts ? opts.future : null);\n  let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   *\n   * - `opts.requestContext` is an optional server context that will be passed\n   *   to actions/loaders in the `context` parameter\n   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent\n   *   the bubbling of errors which allows single-fetch-type implementations\n   *   where the client will handle the bubbling and we may need to return data\n   *   for the handling route\n   */\n  async function query(request, _temp3) {\n    let {\n      requestContext,\n      skipLoaderErrorBubbling,\n      dataStrategy\n    } = _temp3 === void 0 ? {} : _temp3;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, {\n        method\n      });\n      let {\n        matches: methodNotAllowedMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);\n    if (isResponse(result)) {\n      return result;\n    }\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return _extends({\n      location,\n      basename\n    }, result);\n  }\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   *\n   * - `opts.routeId` allows you to specify the specific route handler to call.\n   *   If not provided the handler will determine the proper route by matching\n   *   against `request.url`\n   * - `opts.requestContext` is an optional server context that will be passed\n   *    to actions/loaders in the `context` parameter\n   */\n  async function queryRoute(request, _temp4) {\n    let {\n      routeId,\n      requestContext,\n      dataStrategy\n    } = _temp4 === void 0 ? {} : _temp4;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, {\n        method\n      });\n    } else if (!matches) {\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match);\n    if (isResponse(result)) {\n      return result;\n    }\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n    if (result.loaderData) {\n      var _result$activeDeferre;\n      let data = Object.values(result.loaderData)[0];\n      if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n    return undefined;\n  }\n  async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch) {\n    invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch != null);\n        return result;\n      }\n      let result = await loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch);\n      return isResponse(result) ? result : _extends({}, result, {\n        actionData: null,\n        actionHeaders: {}\n      });\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction for a\n      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early\n      // and then return or throw the raw Response here accordingly\n      if (isDataStrategyResult(e) && isResponse(e.result)) {\n        if (e.type === ResultType.error) {\n          throw e.result;\n        }\n        return e.result;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n  async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {\n    let result;\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    } else {\n      let results = await callDataStrategy(\"action\", request, [actionMatch], matches, isRouteRequest, requestContext, dataStrategy);\n      result = results[actionMatch.route.id];\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\n      }\n    }\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.response.status,\n        headers: {\n          Location: result.response.headers.get(\"Location\")\n        }\n      });\n    }\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    }\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: {\n          [actionMatch.route.id]: result.data\n        },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal\n    });\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);\n      let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);\n      // action status codes take precedence over loader status codes\n      return _extends({}, context, {\n        statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,\n        actionData: null,\n        actionHeaders: _extends({}, result.headers ? {\n          [actionMatch.route.id]: result.headers\n        } : {})\n      });\n    }\n    let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null);\n    return _extends({}, context, {\n      actionData: {\n        [actionMatch.route.id]: result.data\n      }\n    }, result.statusCode ? {\n      statusCode: result.statusCode\n    } : {}, {\n      actionHeaders: result.headers ? {\n        [actionMatch.route.id]: result.headers\n      } : {}\n    });\n  }\n  async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {\n    let isRouteRequest = routeMatch != null;\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch == null ? void 0 : routeMatch.route.id\n      });\n    }\n    let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;\n    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce((acc, m) => Object.assign(acc, {\n          [m.route.id]: null\n        }), {}),\n        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {\n          [pendingActionResult[0]]: pendingActionResult[1].error\n        } : null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let results = await callDataStrategy(\"loader\", request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy);\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\n    }\n    // Process and commit output from loaders\n    let activeDeferreds = new Map();\n    let context = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));\n    matches.forEach(match => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n    return _extends({}, context, {\n      matches,\n      activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null\n    });\n  }\n  // Utility wrapper for calling dataStrategy server-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {\n    let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, type, null, request, matchesToLoad, matches, null, manifest, mapRouteProperties, requestContext);\n    let dataResults = {};\n    await Promise.all(matches.map(async match => {\n      if (!(match.route.id in results)) {\n        return;\n      }\n      let result = results[match.route.id];\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result;\n        // Throw redirects and let the server handle them with an HTTP redirect\n        throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename, future.v7_relativeSplatPath);\n      }\n      if (isResponse(result.result) && isRouteRequest) {\n        // For SSR single-route requests, we want to hand Responses back\n        // directly without unwrapping\n        throw result;\n      }\n      dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);\n    }));\n    return dataResults;\n  }\n  return {\n    dataRoutes,\n    query,\n    queryRoute\n  };\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nfunction getStaticContextFromError(routes, context, error) {\n  let newContext = _extends({}, context, {\n    statusCode: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error\n    }\n  });\n  return newContext;\n}\nfunction throwStaticHandlerAbortedError(request, isRouteRequest, future) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(method + \"() call aborted: \" + request.method + \" \" + request.url);\n}\nfunction isSubmissionNavigation(opts) {\n  return opts != null && (\"formData\" in opts && opts.formData != null || \"body\" in opts && opts.body !== undefined);\n}\nfunction normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {\n  let contextualMatches;\n  let activeRouteMatch;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n  // Resolve the relative path\n  let path = resolveTo(to ? to : \".\", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === \"path\");\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n  // Account for `?index` params when routing to the current location\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch) {\n    let nakedIndex = hasNakedIndexQuery(path.search);\n    if (activeRouteMatch.route.index && !nakedIndex) {\n      // Add one when we're targeting an index route\n      path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n    } else if (!activeRouteMatch.route.index && nakedIndex) {\n      // Remove existing ones when we're not\n      let params = new URLSearchParams(path.search);\n      let indexValues = params.getAll(\"index\");\n      params.delete(\"index\");\n      indexValues.filter(v => v).forEach(v => params.append(\"index\", v));\n      let qs = params.toString();\n      path.search = qs ? \"?\" + qs : \"\";\n    }\n  }\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return {\n      path\n    };\n  }\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, {\n        method: opts.formMethod\n      })\n    };\n  }\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, {\n      type: \"invalid-body\"\n    })\n  });\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();\n  let formAction = stripHashFromPath(path);\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      let text = typeof opts.body === \"string\" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?\n      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n      Array.from(opts.body.entries()).reduce((acc, _ref3) => {\n        let [name, value] = _ref3;\n        return \"\" + acc + name + \"=\" + value + \"\\n\";\n      }, \"\") : String(opts.body);\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text\n        }\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      try {\n        let json = typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined\n          }\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n  invariant(typeof FormData === \"function\", \"FormData is not available in this environment\");\n  let searchParams;\n  let formData;\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n  let submission = {\n    formMethod,\n    formAction,\n    formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined\n  };\n  if (isMutationMethod(submission.formMethod)) {\n    return {\n      path,\n      submission\n    };\n  }\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = \"?\" + searchParams;\n  return {\n    path: createPath(parsedPath),\n    submission\n  };\n}\n// Filter out all routes at/below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {\n  if (includeBoundary === void 0) {\n    includeBoundary = false;\n  }\n  let index = matches.findIndex(m => m.route.id === boundaryId);\n  if (index >= 0) {\n    return matches.slice(0, includeBoundary ? index + 1 : index);\n  }\n  return matches;\n}\nfunction getMatchesToLoad(history, state, matches, submission, location, initialHydration, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {\n  let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryMatches = matches;\n  if (initialHydration && state.errors) {\n    // On initial hydration, only consider matches up to _and including_ the boundary.\n    // This is inclusive to handle cases where a server loader ran successfully,\n    // a child server loader bubbled up to this route, but this route has\n    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that\n    // we have a complete version of `loaderData`\n    boundaryMatches = getLoaderMatchesUntilBoundary(matches, Object.keys(state.errors)[0], true);\n  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {\n    // If an action threw an error, we call loaders up to, but not including the\n    // boundary\n    boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);\n  }\n  // Don't revalidate loaders by default after action 4xx/5xx responses\n  // when the flag is enabled.  They can still opt-into revalidation via\n  // `shouldRevalidate` via `actionResult`\n  let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : undefined;\n  let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let {\n      route\n    } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n    if (route.loader == null) {\n      return false;\n    }\n    if (initialHydration) {\n      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);\n    }\n    // Always call the loader on new route instances and pending defer cancellations\n    if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {\n      return true;\n    }\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n    return shouldRevalidateLoader(match, _extends({\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params\n    }, submission, {\n      actionResult,\n      actionStatus,\n      defaultShouldRevalidate: shouldSkipRevalidation ? false :\n      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n      isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||\n      // Search params affect all loaders\n      currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)\n    }));\n  });\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial hydration (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (initialHydration || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {\n      return;\n    }\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null\n      });\n      return;\n    }\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.has(key)) {\n      // Always mark for revalidation if the fetcher was cancelled\n      cancelledFetcherLoads.delete(key);\n      shouldRevalidate = true;\n    } else if (fetcher && fetcher.state !== \"idle\" && fetcher.data === undefined) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params\n      }, submission, {\n        actionResult,\n        actionStatus,\n        defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired\n      }));\n    }\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController()\n      });\n    }\n  });\n  return [navigationMatches, revalidatingFetchers];\n}\nfunction shouldLoadRouteOnHydration(route, loaderData, errors) {\n  // We dunno if we have a loader - gotta find out!\n  if (route.lazy) {\n    return true;\n  }\n  // No loader, nothing to initialize\n  if (!route.loader) {\n    return false;\n  }\n  let hasData = loaderData != null && loaderData[route.id] !== undefined;\n  let hasError = errors != null && errors[route.id] !== undefined;\n  // Don't run if we error'd during SSR\n  if (!hasData && hasError) {\n    return false;\n  }\n  // Explicitly opting-in to running on hydration\n  if (typeof route.loader === \"function\" && route.loader.hydrate === true) {\n    return true;\n  }\n  // Otherwise, run if we're not yet initialized with anything\n  return !hasData && !hasError;\n}\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n  let isNew =\n  // [a] -> [a, b]\n  !currentMatch ||\n  // [a, b] -> [a, c]\n  match.route.id !== currentMatch.route.id;\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\nfunction isNewRouteInstance(currentMatch, match) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    currentPath != null && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\nfunction shouldRevalidateLoader(loaderMatch, arg) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n  return arg.defaultShouldRevalidate;\n}\nfunction patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {\n  var _childrenToPatch;\n  let childrenToPatch;\n  if (routeId) {\n    let route = manifest[routeId];\n    invariant(route, \"No route found to patch children into: routeId = \" + routeId);\n    if (!route.children) {\n      route.children = [];\n    }\n    childrenToPatch = route.children;\n  } else {\n    childrenToPatch = routesToUse;\n  }\n  // Don't patch in routes we already know about so that `patch` is idempotent\n  // to simplify user-land code. This is useful because we re-call the\n  // `patchRoutesOnNavigation` function for matched routes with params.\n  let uniqueChildren = children.filter(newRoute => !childrenToPatch.some(existingRoute => isSameRoute(newRoute, existingRoute)));\n  let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties, [routeId || \"_\", \"patch\", String(((_childrenToPatch = childrenToPatch) == null ? void 0 : _childrenToPatch.length) || \"0\")], manifest);\n  childrenToPatch.push(...newRoutes);\n}\nfunction isSameRoute(newRoute, existingRoute) {\n  // Most optimal check is by id\n  if (\"id\" in newRoute && \"id\" in existingRoute && newRoute.id === existingRoute.id) {\n    return true;\n  }\n  // Second is by pathing differences\n  if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) {\n    return false;\n  }\n  // Pathless layout routes are trickier since we need to check children.\n  // If they have no children then they're the same as far as we can tell\n  if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) {\n    return true;\n  }\n  // Otherwise, we look to see if every child in the new route is already\n  // represented in the existing route's children\n  return newRoute.children.every((aChild, i) => {\n    var _existingRoute$childr;\n    return (_existingRoute$childr = existingRoute.children) == null ? void 0 : _existingRoute$childr.some(bChild => isSameRoute(aChild, bChild));\n  });\n}\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(route, mapRouteProperties, manifest) {\n  if (!route.lazy) {\n    return;\n  }\n  let lazyRoute = await route.lazy();\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue = routeToUpdate[lazyRouteProperty];\n    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&\n    // This property isn't static since it should always be updated based\n    // on the route updates\n    lazyRouteProperty !== \"hasErrorBoundary\";\n    warning(!isPropertyStaticallyDefined, \"Route \\\"\" + routeToUpdate.id + \"\\\" has a static property \\\"\" + lazyRouteProperty + \"\\\" \" + \"defined but its lazy function is also returning a value for this property. \" + (\"The lazy route property \\\"\" + lazyRouteProperty + \"\\\" will be ignored.\"));\n    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {\n      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];\n    }\n  }\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {\n    lazy: undefined\n  }));\n}\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nasync function defaultDataStrategy(_ref4) {\n  let {\n    matches\n  } = _ref4;\n  let matchesToLoad = matches.filter(m => m.shouldLoad);\n  let results = await Promise.all(matchesToLoad.map(m => m.resolve()));\n  return results.reduce((acc, result, i) => Object.assign(acc, {\n    [matchesToLoad[i].route.id]: result\n  }), {});\n}\nasync function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties, requestContext) {\n  let loadRouteDefinitionsPromises = matches.map(m => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties, manifest) : undefined);\n  let dsMatches = matches.map((match, i) => {\n    let loadRoutePromise = loadRouteDefinitionsPromises[i];\n    let shouldLoad = matchesToLoad.some(m => m.route.id === match.route.id);\n    // `resolve` encapsulates route.lazy(), executing the loader/action,\n    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users\n    // can pass a callback to take fine-grained control over the execution\n    // of the loader/action\n    let resolve = async handlerOverride => {\n      if (handlerOverride && request.method === \"GET\" && (match.route.lazy || match.route.loader)) {\n        shouldLoad = true;\n      }\n      return shouldLoad ? callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, requestContext) : Promise.resolve({\n        type: ResultType.data,\n        result: undefined\n      });\n    };\n    return _extends({}, match, {\n      shouldLoad,\n      resolve\n    });\n  });\n  // Send all matches here to allow for a middleware-type implementation.\n  // handler will be a no-op for unneeded routes and we filter those results\n  // back out below.\n  let results = await dataStrategyImpl({\n    matches: dsMatches,\n    request,\n    params: matches[0].params,\n    fetcherKey,\n    context: requestContext\n  });\n  // Wait for all routes to load here but 'swallow the error since we want\n  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -\n  // called from `match.resolve()`\n  try {\n    await Promise.all(loadRouteDefinitionsPromises);\n  } catch (e) {\n    // No-op\n  }\n  return results;\n}\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {\n  let result;\n  let onReject;\n  let runHandler = handler => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject;\n    // This will never resolve so safe to type it as Promise<DataStrategyResult> to\n    // satisfy the function return value\n    let abortPromise = new Promise((_, r) => reject = r);\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n    let actualHandler = ctx => {\n      if (typeof handler !== \"function\") {\n        return Promise.reject(new Error(\"You cannot call the handler for a route which defines a boolean \" + (\"\\\"\" + type + \"\\\" [routeId: \" + match.route.id + \"]\")));\n      }\n      return handler({\n        request,\n        params: match.params,\n        context: staticContext\n      }, ...(ctx !== undefined ? [ctx] : []));\n    };\n    let handlerPromise = (async () => {\n      try {\n        let val = await (handlerOverride ? handlerOverride(ctx => actualHandler(ctx)) : actualHandler());\n        return {\n          type: \"data\",\n          result: val\n        };\n      } catch (e) {\n        return {\n          type: \"error\",\n          result: e\n        };\n      }\n    })();\n    return Promise.race([handlerPromise, abortPromise]);\n  };\n  try {\n    let handler = match.route[type];\n    // If we have a route.lazy promise, await that first\n    if (loadRoutePromise) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let [value] = await Promise.all([\n        // If the handler throws, don't let it immediately bubble out,\n        // since we need to let the lazy() execution finish so we know if this\n        // route has a boundary that can handle the error\n        runHandler(handler).catch(e => {\n          handlerError = e;\n        }), loadRoutePromise]);\n        if (handlerError !== undefined) {\n          throw handlerError;\n        }\n        result = value;\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadRoutePromise;\n        handler = match.route[type];\n        if (handler) {\n          // Handler still runs even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return {\n            type: ResultType.data,\n            result: undefined\n          };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n    invariant(result.result !== undefined, \"You defined \" + (type === \"action\" ? \"an action\" : \"a loader\") + \" for route \" + (\"\\\"\" + match.route.id + \"\\\" but didn't return anything from your `\" + type + \"` \") + \"function. Please return a value or `null`.\");\n  } catch (e) {\n    // We should already be catching and converting normal handler executions to\n    // DataStrategyResults and returning them, so anything that throws here is an\n    // unexpected error we still need to wrap\n    return {\n      type: ResultType.error,\n      result: e\n    };\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n  return result;\n}\nasync function convertDataStrategyResultToDataResult(dataStrategyResult) {\n  let {\n    result,\n    type\n  } = dataStrategyResult;\n  if (isResponse(result)) {\n    let data;\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n    if (type === ResultType.error) {\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(result.status, result.statusText, data),\n        statusCode: result.status,\n        headers: result.headers\n      };\n    }\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers\n    };\n  }\n  if (type === ResultType.error) {\n    if (isDataWithResponseInit(result)) {\n      var _result$init3, _result$init4;\n      if (result.data instanceof Error) {\n        var _result$init, _result$init2;\n        return {\n          type: ResultType.error,\n          error: result.data,\n          statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,\n          headers: (_result$init2 = result.init) != null && _result$init2.headers ? new Headers(result.init.headers) : undefined\n        };\n      }\n      // Convert thrown data() to ErrorResponse instances\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(((_result$init3 = result.init) == null ? void 0 : _result$init3.status) || 500, undefined, result.data),\n        statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n        headers: (_result$init4 = result.init) != null && _result$init4.headers ? new Headers(result.init.headers) : undefined\n      };\n    }\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : undefined\n    };\n  }\n  if (isDeferredData(result)) {\n    var _result$init5, _result$init6;\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,\n      headers: ((_result$init6 = result.init) == null ? void 0 : _result$init6.headers) && new Headers(result.init.headers)\n    };\n  }\n  if (isDataWithResponseInit(result)) {\n    var _result$init7, _result$init8;\n    return {\n      type: ResultType.data,\n      data: result.data,\n      statusCode: (_result$init7 = result.init) == null ? void 0 : _result$init7.status,\n      headers: (_result$init8 = result.init) != null && _result$init8.headers ? new Headers(result.init.headers) : undefined\n    };\n  }\n  return {\n    type: ResultType.data,\n    data: result\n  };\n}\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {\n  let location = response.headers.get(\"Location\");\n  invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\");\n  if (!ABSOLUTE_URL_REGEX.test(location)) {\n    let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);\n    location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);\n    response.headers.set(\"Location\", location);\n  }\n  return response;\n}\nfunction normalizeRedirectLocation(location, currentUrl, basename) {\n  if (ABSOLUTE_URL_REGEX.test(location)) {\n    // Strip off the protocol+origin for same-origin + same-basename absolute redirects\n    let normalizedLocation = location;\n    let url = normalizedLocation.startsWith(\"//\") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);\n    let isSameBasename = stripBasename(url.pathname, basename) != null;\n    if (url.origin === currentUrl.origin && isSameBasename) {\n      return url.pathname + url.search + url.hash;\n    }\n  }\n  return location;\n}\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(history, location, signal, submission) {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let {\n      formMethod,\n      formEncType\n    } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({\n        \"Content-Type\": formEncType\n      });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (formEncType === \"application/x-www-form-urlencoded\" && submission.formData) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n  return new Request(url, init);\n}\nfunction convertFormDataToSearchParams(formData) {\n  let searchParams = new URLSearchParams();\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n  return searchParams;\n}\nfunction convertSearchParamsToFormData(searchParams) {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\nfunction processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {\n  // Fill in loaderData/errors from our loaders\n  let loaderData = {};\n  let errors = null;\n  let statusCode;\n  let foundError = false;\n  let loaderHeaders = {};\n  let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;\n  // Process loader results into state.loaderData/state.errors\n  matches.forEach(match => {\n    if (!(match.route.id in results)) {\n      return;\n    }\n    let id = match.route.id;\n    let result = results[id];\n    invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n    if (isErrorResult(result)) {\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError !== undefined) {\n        error = pendingError;\n        pendingError = undefined;\n      }\n      errors = errors || {};\n      if (skipLoaderErrorBubbling) {\n        errors[id] = error;\n      } else {\n        // Look upwards from the matched route for the closest ancestor error\n        // boundary, defaulting to the root match.  Prefer higher error values\n        // if lower errors bubble to the same boundary\n        let boundaryMatch = findNearestBoundary(matches, id);\n        if (errors[boundaryMatch.route.id] == null) {\n          errors[boundaryMatch.route.id] = error;\n        }\n      }\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode != null && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      } else {\n        loaderData[id] = result.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      }\n    }\n  });\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError !== undefined && pendingActionResult) {\n    errors = {\n      [pendingActionResult[0]]: pendingError\n    };\n    loaderData[pendingActionResult[0]] = undefined;\n  }\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders\n  };\n}\nfunction processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {\n  let {\n    loaderData,\n    errors\n  } = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble\n  );\n  // Process results from our revalidating fetchers\n  revalidatingFetchers.forEach(rf => {\n    let {\n      key,\n      match,\n      controller\n    } = rf;\n    let result = fetcherResults[key];\n    invariant(result, \"Did not find corresponding fetcher result\");\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      return;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = _extends({}, errors, {\n          [boundaryMatch.route.id]: result.error\n        });\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  });\n  return {\n    loaderData,\n    errors\n  };\n}\nfunction mergeLoaderData(loaderData, newLoaderData, matches, errors) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\nfunction getActionDataForCommit(pendingActionResult) {\n  if (!pendingActionResult) {\n    return {};\n  }\n  return isErrorResult(pendingActionResult[1]) ? {\n    // Clear out prior actionData on errors\n    actionData: {}\n  } : {\n    actionData: {\n      [pendingActionResult[0]]: pendingActionResult[1].data\n    }\n  };\n}\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(matches, routeId) {\n  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];\n  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];\n}\nfunction getShortCircuitMatches(routes) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-error-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route\n  };\n}\nfunction getInternalRouterError(status, _temp5) {\n  let {\n    pathname,\n    routeId,\n    method,\n    type,\n    message\n  } = _temp5 === void 0 ? {} : _temp5;\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide a `loader` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = \"Route \\\"\" + routeId + \"\\\" does not match URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = \"No route matches URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method.toUpperCase() + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide an `action` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (method) {\n      errorMessage = \"Invalid request method \\\"\" + method.toUpperCase() + \"\\\"\";\n    }\n  }\n  return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);\n}\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(results) {\n  let entries = Object.entries(results);\n  for (let i = entries.length - 1; i >= 0; i--) {\n    let [key, result] = entries[i];\n    if (isRedirectResult(result)) {\n      return {\n        key,\n        result\n      };\n    }\n  }\n}\nfunction stripHashFromPath(path) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath(_extends({}, parsedPath, {\n    hash: \"\"\n  }));\n}\nfunction isHashChangeOnly(a, b) {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\nfunction isDataStrategyResult(result) {\n  return result != null && typeof result === \"object\" && \"type\" in result && \"result\" in result && (result.type === ResultType.data || result.type === ResultType.error);\n}\nfunction isRedirectDataStrategyResultResult(result) {\n  return isResponse(result.result) && redirectStatusCodes.has(result.result.status);\n}\nfunction isDeferredResult(result) {\n  return result.type === ResultType.deferred;\n}\nfunction isErrorResult(result) {\n  return result.type === ResultType.error;\n}\nfunction isRedirectResult(result) {\n  return (result && result.type) === ResultType.redirect;\n}\nfunction isDataWithResponseInit(value) {\n  return typeof value === \"object\" && value != null && \"type\" in value && \"data\" in value && \"init\" in value && value.type === \"DataWithResponseInit\";\n}\nfunction isDeferredData(value) {\n  let deferred = value;\n  return deferred && typeof deferred === \"object\" && typeof deferred.data === \"object\" && typeof deferred.subscribe === \"function\" && typeof deferred.cancel === \"function\" && typeof deferred.resolveData === \"function\";\n}\nfunction isResponse(value) {\n  return value != null && typeof value.status === \"number\" && typeof value.statusText === \"string\" && typeof value.headers === \"object\" && typeof value.body !== \"undefined\";\n}\nfunction isRedirectResponse(result) {\n  if (!isResponse(result)) {\n    return false;\n  }\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\nfunction isValidMethod(method) {\n  return validRequestMethods.has(method.toLowerCase());\n}\nfunction isMutationMethod(method) {\n  return validMutationMethods.has(method.toLowerCase());\n}\nasync function resolveNavigationDeferredResults(matches, results, signal, currentMatches, currentLoaderData) {\n  let entries = Object.entries(results);\n  for (let index = 0; index < entries.length; index++) {\n    let [routeId, result] = entries[index];\n    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);\n    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n    if (isDeferredResult(result) && isRevalidatingLoader) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      await resolveDeferredData(result, signal, false).then(result => {\n        if (result) {\n          results[routeId] = result;\n        }\n      });\n    }\n  }\n}\nasync function resolveFetcherDeferredResults(matches, results, revalidatingFetchers) {\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let {\n      key,\n      routeId,\n      controller\n    } = revalidatingFetchers[index];\n    let result = results[key];\n    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n    if (isDeferredResult(result)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      invariant(controller, \"Expected an AbortController for revalidating fetcher deferred result\");\n      await resolveDeferredData(result, controller.signal, true).then(result => {\n        if (result) {\n          results[key] = result;\n        }\n      });\n    }\n  }\n}\nasync function resolveDeferredData(result, signal, unwrap) {\n  if (unwrap === void 0) {\n    unwrap = false;\n  }\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n  }\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data\n  };\n}\nfunction hasNakedIndexQuery(search) {\n  return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n}\nfunction getTargetMatch(matches, location) {\n  let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || \"\")) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\nfunction getSubmissionFromNavigation(navigation) {\n  let {\n    formMethod,\n    formAction,\n    formEncType,\n    text,\n    formData,\n    json\n  } = navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined\n    };\n  }\n}\nfunction getLoadingNavigation(location, submission) {\n  if (submission) {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text\n    };\n    return navigation;\n  } else {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined\n    };\n    return navigation;\n  }\n}\nfunction getSubmittingNavigation(location, submission) {\n  let navigation = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text\n  };\n  return navigation;\n}\nfunction getLoadingFetcher(submission, data) {\n  if (submission) {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data\n    };\n    return fetcher;\n  } else {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data\n    };\n    return fetcher;\n  }\n}\nfunction getSubmittingFetcher(submission, existingFetcher) {\n  let fetcher = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined\n  };\n  return fetcher;\n}\nfunction getDoneFetcher(data) {\n  let fetcher = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data\n  };\n  return fetcher;\n}\nfunction restoreAppliedTransitions(_window, transitions) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\nfunction persistAppliedTransitions(_window, transitions) {\n  if (transitions.size > 0) {\n    let json = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));\n    } catch (error) {\n      warning(false, \"Failed to save applied view transitions in sessionStorage (\" + error + \").\");\n    }\n  }\n}\n//#endregion\n\nexport { AbortedDeferredError, Action, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, decodePath as UNSAFE_decodePath, getResolveToMatches as UNSAFE_getResolveToMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, data, defer, generatePath, getStaticContextFromError, getToPathname, isDataWithResponseInit, isDeferredData, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, redirectDocument, replace, resolvePath, resolveTo, stripBasename };\n//# sourceMappingURL=router.js.map\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; };\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    defineProperty(generator, \"_invoke\", { value: makeInvokeMethod(innerFn, self, context) });\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = GeneratorFunctionPrototype;\n  defineProperty(Gp, \"constructor\", { value: GeneratorFunctionPrototype, configurable: true });\n  defineProperty(\n    GeneratorFunctionPrototype,\n    \"constructor\",\n    { value: GeneratorFunction, configurable: true }\n  );\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    defineProperty(this, \"_invoke\", { value: enqueue });\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  });\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var methodName = context.method;\n    var method = delegate.iterator[methodName];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method, or a missing .next mehtod, always terminate the\n      // yield* loop.\n      context.delegate = null;\n\n      // Note: [\"return\"] must be used for ES3 parsing compatibility.\n      if (methodName === \"throw\" && delegate.iterator[\"return\"]) {\n        // If the delegate iterator has a return method, give it a\n        // chance to clean up.\n        context.method = \"return\";\n        context.arg = undefined;\n        maybeInvokeDelegate(delegate, context);\n\n        if (context.method === \"throw\") {\n          // If maybeInvokeDelegate(context) changed context.method from\n          // \"return\" to \"throw\", let that override the TypeError below.\n          return ContinueSentinel;\n        }\n      }\n      if (methodName !== \"return\") {\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a '\" + methodName + \"' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  define(Gp, iteratorSymbol, function() {\n    return this;\n  });\n\n  define(Gp, \"toString\", function() {\n    return \"[object Generator]\";\n  });\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(val) {\n    var object = Object(val);\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, in modern engines\n  // we can explicitly access globalThis. In older engines we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","// Cache implementation based on Erik Rasmussen's `lru-memoize`:\n// https://github.com/erikras/lru-memoize\nvar NOT_FOUND = 'NOT_FOUND';\n\nfunction createSingletonCache(equals) {\n  var entry;\n  return {\n    get: function get(key) {\n      if (entry && equals(entry.key, key)) {\n        return entry.value;\n      }\n\n      return NOT_FOUND;\n    },\n    put: function put(key, value) {\n      entry = {\n        key: key,\n        value: value\n      };\n    },\n    getEntries: function getEntries() {\n      return entry ? [entry] : [];\n    },\n    clear: function clear() {\n      entry = undefined;\n    }\n  };\n}\n\nfunction createLruCache(maxSize, equals) {\n  var entries = [];\n\n  function get(key) {\n    var cacheIndex = entries.findIndex(function (entry) {\n      return equals(key, entry.key);\n    }); // We found a cached entry\n\n    if (cacheIndex > -1) {\n      var entry = entries[cacheIndex]; // Cached entry not at top of cache, move it to the top\n\n      if (cacheIndex > 0) {\n        entries.splice(cacheIndex, 1);\n        entries.unshift(entry);\n      }\n\n      return entry.value;\n    } // No entry found in cache, return sentinel\n\n\n    return NOT_FOUND;\n  }\n\n  function put(key, value) {\n    if (get(key) === NOT_FOUND) {\n      // TODO Is unshift slow?\n      entries.unshift({\n        key: key,\n        value: value\n      });\n\n      if (entries.length > maxSize) {\n        entries.pop();\n      }\n    }\n  }\n\n  function getEntries() {\n    return entries;\n  }\n\n  function clear() {\n    entries = [];\n  }\n\n  return {\n    get: get,\n    put: put,\n    getEntries: getEntries,\n    clear: clear\n  };\n}\n\nexport var defaultEqualityCheck = function defaultEqualityCheck(a, b) {\n  return a === b;\n};\nexport function createCacheKeyComparator(equalityCheck) {\n  return function areArgumentsShallowlyEqual(prev, next) {\n    if (prev === null || next === null || prev.length !== next.length) {\n      return false;\n    } // Do this in a for loop (and not a `forEach` or an `every`) so we can determine equality as fast as possible.\n\n\n    var length = prev.length;\n\n    for (var i = 0; i < length; i++) {\n      if (!equalityCheck(prev[i], next[i])) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n// defaultMemoize now supports a configurable cache size with LRU behavior,\n// and optional comparison of the result value with existing values\nexport function defaultMemoize(func, equalityCheckOrOptions) {\n  var providedOptions = typeof equalityCheckOrOptions === 'object' ? equalityCheckOrOptions : {\n    equalityCheck: equalityCheckOrOptions\n  };\n  var _providedOptions$equa = providedOptions.equalityCheck,\n      equalityCheck = _providedOptions$equa === void 0 ? defaultEqualityCheck : _providedOptions$equa,\n      _providedOptions$maxS = providedOptions.maxSize,\n      maxSize = _providedOptions$maxS === void 0 ? 1 : _providedOptions$maxS,\n      resultEqualityCheck = providedOptions.resultEqualityCheck;\n  var comparator = createCacheKeyComparator(equalityCheck);\n  var cache = maxSize === 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator); // we reference arguments instead of spreading them for performance reasons\n\n  function memoized() {\n    var value = cache.get(arguments);\n\n    if (value === NOT_FOUND) {\n      // @ts-ignore\n      value = func.apply(null, arguments);\n\n      if (resultEqualityCheck) {\n        var entries = cache.getEntries();\n        var matchingEntry = entries.find(function (entry) {\n          return resultEqualityCheck(entry.value, value);\n        });\n\n        if (matchingEntry) {\n          value = matchingEntry.value;\n        }\n      }\n\n      cache.put(arguments, value);\n    }\n\n    return value;\n  }\n\n  memoized.clearCache = function () {\n    return cache.clear();\n  };\n\n  return memoized;\n}","import { defaultMemoize, defaultEqualityCheck } from './defaultMemoize';\nexport { defaultMemoize, defaultEqualityCheck };\n\nfunction getDependencies(funcs) {\n  var dependencies = Array.isArray(funcs[0]) ? funcs[0] : funcs;\n\n  if (!dependencies.every(function (dep) {\n    return typeof dep === 'function';\n  })) {\n    var dependencyTypes = dependencies.map(function (dep) {\n      return typeof dep === 'function' ? \"function \" + (dep.name || 'unnamed') + \"()\" : typeof dep;\n    }).join(', ');\n    throw new Error(\"createSelector expects all input-selectors to be functions, but received the following types: [\" + dependencyTypes + \"]\");\n  }\n\n  return dependencies;\n}\n\nexport function createSelectorCreator(memoize) {\n  for (var _len = arguments.length, memoizeOptionsFromArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    memoizeOptionsFromArgs[_key - 1] = arguments[_key];\n  }\n\n  var createSelector = function createSelector() {\n    for (var _len2 = arguments.length, funcs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      funcs[_key2] = arguments[_key2];\n    }\n\n    var _recomputations = 0;\n\n    var _lastResult; // Due to the intricacies of rest params, we can't do an optional arg after `...funcs`.\n    // So, start by declaring the default value here.\n    // (And yes, the words 'memoize' and 'options' appear too many times in this next sequence.)\n\n\n    var directlyPassedOptions = {\n      memoizeOptions: undefined\n    }; // Normally, the result func or \"output selector\" is the last arg\n\n    var resultFunc = funcs.pop(); // If the result func is actually an _object_, assume it's our options object\n\n    if (typeof resultFunc === 'object') {\n      directlyPassedOptions = resultFunc; // and pop the real result func off\n\n      resultFunc = funcs.pop();\n    }\n\n    if (typeof resultFunc !== 'function') {\n      throw new Error(\"createSelector expects an output function after the inputs, but received: [\" + typeof resultFunc + \"]\");\n    } // Determine which set of options we're using. Prefer options passed directly,\n    // but fall back to options given to createSelectorCreator.\n\n\n    var _directlyPassedOption = directlyPassedOptions,\n        _directlyPassedOption2 = _directlyPassedOption.memoizeOptions,\n        memoizeOptions = _directlyPassedOption2 === void 0 ? memoizeOptionsFromArgs : _directlyPassedOption2; // Simplifying assumption: it's unlikely that the first options arg of the provided memoizer\n    // is an array. In most libs I've looked at, it's an equality function or options object.\n    // Based on that, if `memoizeOptions` _is_ an array, we assume it's a full\n    // user-provided array of options. Otherwise, it must be just the _first_ arg, and so\n    // we wrap it in an array so we can apply it.\n\n    var finalMemoizeOptions = Array.isArray(memoizeOptions) ? memoizeOptions : [memoizeOptions];\n    var dependencies = getDependencies(funcs);\n    var memoizedResultFunc = memoize.apply(void 0, [function recomputationWrapper() {\n      _recomputations++; // apply arguments instead of spreading for performance.\n\n      return resultFunc.apply(null, arguments);\n    }].concat(finalMemoizeOptions)); // If a selector is called with the exact same arguments we don't need to traverse our dependencies again.\n\n    var selector = memoize(function dependenciesChecker() {\n      var params = [];\n      var length = dependencies.length;\n\n      for (var i = 0; i < length; i++) {\n        // apply arguments instead of spreading and mutate a local list of params for performance.\n        // @ts-ignore\n        params.push(dependencies[i].apply(null, arguments));\n      } // apply arguments instead of spreading for performance.\n\n\n      _lastResult = memoizedResultFunc.apply(null, params);\n      return _lastResult;\n    });\n    Object.assign(selector, {\n      resultFunc: resultFunc,\n      memoizedResultFunc: memoizedResultFunc,\n      dependencies: dependencies,\n      lastResult: function lastResult() {\n        return _lastResult;\n      },\n      recomputations: function recomputations() {\n        return _recomputations;\n      },\n      resetRecomputations: function resetRecomputations() {\n        return _recomputations = 0;\n      }\n    });\n    return selector;\n  }; // @ts-ignore\n\n\n  return createSelector;\n}\nexport var createSelector = /* #__PURE__ */createSelectorCreator(defaultMemoize);\n// Manual definition of state and output arguments\nexport var createStructuredSelector = function createStructuredSelector(selectors, selectorCreator) {\n  if (selectorCreator === void 0) {\n    selectorCreator = createSelector;\n  }\n\n  if (typeof selectors !== 'object') {\n    throw new Error('createStructuredSelector expects first argument to be an object ' + (\"where each property is a selector, instead received a \" + typeof selectors));\n  }\n\n  var objectKeys = Object.keys(selectors);\n  var resultSelector = selectorCreator( // @ts-ignore\n  objectKeys.map(function (key) {\n    return selectors[key];\n  }), function () {\n    for (var _len3 = arguments.length, values = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n      values[_key3] = arguments[_key3];\n    }\n\n    return values.reduce(function (composition, value, index) {\n      composition[objectKeys[index]] = value;\n      return composition;\n    }, {});\n  });\n  return resultSelector;\n};","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subject_1 = require('./Subject');\nvar ObjectUnsubscribedError_1 = require('./util/ObjectUnsubscribedError');\n/**\n * @class BehaviorSubject<T>\n */\nvar BehaviorSubject = (function (_super) {\n    __extends(BehaviorSubject, _super);\n    function BehaviorSubject(_value) {\n        _super.call(this);\n        this._value = _value;\n    }\n    Object.defineProperty(BehaviorSubject.prototype, \"value\", {\n        get: function () {\n            return this.getValue();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /** @deprecated internal use only */ BehaviorSubject.prototype._subscribe = function (subscriber) {\n        var subscription = _super.prototype._subscribe.call(this, subscriber);\n        if (subscription && !subscription.closed) {\n            subscriber.next(this._value);\n        }\n        return subscription;\n    };\n    BehaviorSubject.prototype.getValue = function () {\n        if (this.hasError) {\n            throw this.thrownError;\n        }\n        else if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else {\n            return this._value;\n        }\n    };\n    BehaviorSubject.prototype.next = function (value) {\n        _super.prototype.next.call(this, this._value = value);\n    };\n    return BehaviorSubject;\n}(Subject_1.Subject));\nexports.BehaviorSubject = BehaviorSubject;\n//# sourceMappingURL=BehaviorSubject.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('./Subscriber');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar InnerSubscriber = (function (_super) {\n    __extends(InnerSubscriber, _super);\n    function InnerSubscriber(parent, outerValue, outerIndex) {\n        _super.call(this);\n        this.parent = parent;\n        this.outerValue = outerValue;\n        this.outerIndex = outerIndex;\n        this.index = 0;\n    }\n    InnerSubscriber.prototype._next = function (value) {\n        this.parent.notifyNext(this.outerValue, value, this.outerIndex, this.index++, this);\n    };\n    InnerSubscriber.prototype._error = function (error) {\n        this.parent.notifyError(error, this);\n        this.unsubscribe();\n    };\n    InnerSubscriber.prototype._complete = function () {\n        this.parent.notifyComplete(this);\n        this.unsubscribe();\n    };\n    return InnerSubscriber;\n}(Subscriber_1.Subscriber));\nexports.InnerSubscriber = InnerSubscriber;\n//# sourceMappingURL=InnerSubscriber.js.map","\"use strict\";\nvar Observable_1 = require('./Observable');\n/**\n * Represents a push-based event or value that an {@link Observable} can emit.\n * This class is particularly useful for operators that manage notifications,\n * like {@link materialize}, {@link dematerialize}, {@link observeOn}, and\n * others. Besides wrapping the actual delivered value, it also annotates it\n * with metadata of, for instance, what type of push message it is (`next`,\n * `error`, or `complete`).\n *\n * @see {@link materialize}\n * @see {@link dematerialize}\n * @see {@link observeOn}\n *\n * @class Notification<T>\n */\nvar Notification = (function () {\n    function Notification(kind, value, error) {\n        this.kind = kind;\n        this.value = value;\n        this.error = error;\n        this.hasValue = kind === 'N';\n    }\n    /**\n     * Delivers to the given `observer` the value wrapped by this Notification.\n     * @param {Observer} observer\n     * @return\n     */\n    Notification.prototype.observe = function (observer) {\n        switch (this.kind) {\n            case 'N':\n                return observer.next && observer.next(this.value);\n            case 'E':\n                return observer.error && observer.error(this.error);\n            case 'C':\n                return observer.complete && observer.complete();\n        }\n    };\n    /**\n     * Given some {@link Observer} callbacks, deliver the value represented by the\n     * current Notification to the correctly corresponding callback.\n     * @param {function(value: T): void} next An Observer `next` callback.\n     * @param {function(err: any): void} [error] An Observer `error` callback.\n     * @param {function(): void} [complete] An Observer `complete` callback.\n     * @return {any}\n     */\n    Notification.prototype.do = function (next, error, complete) {\n        var kind = this.kind;\n        switch (kind) {\n            case 'N':\n                return next && next(this.value);\n            case 'E':\n                return error && error(this.error);\n            case 'C':\n                return complete && complete();\n        }\n    };\n    /**\n     * Takes an Observer or its individual callback functions, and calls `observe`\n     * or `do` methods accordingly.\n     * @param {Observer|function(value: T): void} nextOrObserver An Observer or\n     * the `next` callback.\n     * @param {function(err: any): void} [error] An Observer `error` callback.\n     * @param {function(): void} [complete] An Observer `complete` callback.\n     * @return {any}\n     */\n    Notification.prototype.accept = function (nextOrObserver, error, complete) {\n        if (nextOrObserver && typeof nextOrObserver.next === 'function') {\n            return this.observe(nextOrObserver);\n        }\n        else {\n            return this.do(nextOrObserver, error, complete);\n        }\n    };\n    /**\n     * Returns a simple Observable that just delivers the notification represented\n     * by this Notification instance.\n     * @return {any}\n     */\n    Notification.prototype.toObservable = function () {\n        var kind = this.kind;\n        switch (kind) {\n            case 'N':\n                return Observable_1.Observable.of(this.value);\n            case 'E':\n                return Observable_1.Observable.throw(this.error);\n            case 'C':\n                return Observable_1.Observable.empty();\n        }\n        throw new Error('unexpected notification kind value');\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `next` from a\n     * given value.\n     * @param {T} value The `next` value.\n     * @return {Notification<T>} The \"next\" Notification representing the\n     * argument.\n     */\n    Notification.createNext = function (value) {\n        if (typeof value !== 'undefined') {\n            return new Notification('N', value);\n        }\n        return Notification.undefinedValueNotification;\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `error` from a\n     * given error.\n     * @param {any} [err] The `error` error.\n     * @return {Notification<T>} The \"error\" Notification representing the\n     * argument.\n     */\n    Notification.createError = function (err) {\n        return new Notification('E', undefined, err);\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `complete`.\n     * @return {Notification<any>} The valueless \"complete\" Notification.\n     */\n    Notification.createComplete = function () {\n        return Notification.completeNotification;\n    };\n    Notification.completeNotification = new Notification('C');\n    Notification.undefinedValueNotification = new Notification('N', undefined);\n    return Notification;\n}());\nexports.Notification = Notification;\n//# sourceMappingURL=Notification.js.map","\"use strict\";\nvar root_1 = require('./util/root');\nvar toSubscriber_1 = require('./util/toSubscriber');\nvar observable_1 = require('./symbol/observable');\nvar pipe_1 = require('./util/pipe');\n/**\n * A representation of any set of values over any amount of time. This is the most basic building block\n * of RxJS.\n *\n * @class Observable<T>\n */\nvar Observable = (function () {\n    /**\n     * @constructor\n     * @param {Function} subscribe the function that is called when the Observable is\n     * initially subscribed to. This function is given a Subscriber, to which new values\n     * can be `next`ed, or an `error` method can be called to raise an error, or\n     * `complete` can be called to notify of a successful completion.\n     */\n    function Observable(subscribe) {\n        this._isScalar = false;\n        if (subscribe) {\n            this._subscribe = subscribe;\n        }\n    }\n    /**\n     * Creates a new Observable, with this Observable as the source, and the passed\n     * operator defined as the new observable's operator.\n     * @method lift\n     * @param {Operator} operator the operator defining the operation to take on the observable\n     * @return {Observable} a new observable with the Operator applied\n     */\n    Observable.prototype.lift = function (operator) {\n        var observable = new Observable();\n        observable.source = this;\n        observable.operator = operator;\n        return observable;\n    };\n    /**\n     * Invokes an execution of an Observable and registers Observer handlers for notifications it will emit.\n     *\n     * <span class=\"informal\">Use it when you have all these Observables, but still nothing is happening.</span>\n     *\n     * `subscribe` is not a regular operator, but a method that calls Observable's internal `subscribe` function. It\n     * might be for example a function that you passed to a {@link create} static factory, but most of the time it is\n     * a library implementation, which defines what and when will be emitted by an Observable. This means that calling\n     * `subscribe` is actually the moment when Observable starts its work, not when it is created, as it is often\n     * thought.\n     *\n     * Apart from starting the execution of an Observable, this method allows you to listen for values\n     * that an Observable emits, as well as for when it completes or errors. You can achieve this in two\n     * following ways.\n     *\n     * The first way is creating an object that implements {@link Observer} interface. It should have methods\n     * defined by that interface, but note that it should be just a regular JavaScript object, which you can create\n     * yourself in any way you want (ES6 class, classic function constructor, object literal etc.). In particular do\n     * not attempt to use any RxJS implementation details to create Observers - you don't need them. Remember also\n     * that your object does not have to implement all methods. If you find yourself creating a method that doesn't\n     * do anything, you can simply omit it. Note however, that if `error` method is not provided, all errors will\n     * be left uncaught.\n     *\n     * The second way is to give up on Observer object altogether and simply provide callback functions in place of its methods.\n     * This means you can provide three functions as arguments to `subscribe`, where first function is equivalent\n     * of a `next` method, second of an `error` method and third of a `complete` method. Just as in case of Observer,\n     * if you do not need to listen for something, you can omit a function, preferably by passing `undefined` or `null`,\n     * since `subscribe` recognizes these functions by where they were placed in function call. When it comes\n     * to `error` function, just as before, if not provided, errors emitted by an Observable will be thrown.\n     *\n     * Whatever style of calling `subscribe` you use, in both cases it returns a Subscription object.\n     * This object allows you to call `unsubscribe` on it, which in turn will stop work that an Observable does and will clean\n     * up all resources that an Observable used. Note that cancelling a subscription will not call `complete` callback\n     * provided to `subscribe` function, which is reserved for a regular completion signal that comes from an Observable.\n     *\n     * Remember that callbacks provided to `subscribe` are not guaranteed to be called asynchronously.\n     * It is an Observable itself that decides when these functions will be called. For example {@link of}\n     * by default emits all its values synchronously. Always check documentation for how given Observable\n     * will behave when subscribed and if its default behavior can be modified with a {@link Scheduler}.\n     *\n     * @example <caption>Subscribe with an Observer</caption>\n     * const sumObserver = {\n     *   sum: 0,\n     *   next(value) {\n     *     console.log('Adding: ' + value);\n     *     this.sum = this.sum + value;\n     *   },\n     *   error() { // We actually could just remove this method,\n     *   },        // since we do not really care about errors right now.\n     *   complete() {\n     *     console.log('Sum equals: ' + this.sum);\n     *   }\n     * };\n     *\n     * Rx.Observable.of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes.\n     * .subscribe(sumObserver);\n     *\n     * // Logs:\n     * // \"Adding: 1\"\n     * // \"Adding: 2\"\n     * // \"Adding: 3\"\n     * // \"Sum equals: 6\"\n     *\n     *\n     * @example <caption>Subscribe with functions</caption>\n     * let sum = 0;\n     *\n     * Rx.Observable.of(1, 2, 3)\n     * .subscribe(\n     *   function(value) {\n     *     console.log('Adding: ' + value);\n     *     sum = sum + value;\n     *   },\n     *   undefined,\n     *   function() {\n     *     console.log('Sum equals: ' + sum);\n     *   }\n     * );\n     *\n     * // Logs:\n     * // \"Adding: 1\"\n     * // \"Adding: 2\"\n     * // \"Adding: 3\"\n     * // \"Sum equals: 6\"\n     *\n     *\n     * @example <caption>Cancel a subscription</caption>\n     * const subscription = Rx.Observable.interval(1000).subscribe(\n     *   num => console.log(num),\n     *   undefined,\n     *   () => console.log('completed!') // Will not be called, even\n     * );                                // when cancelling subscription\n     *\n     *\n     * setTimeout(() => {\n     *   subscription.unsubscribe();\n     *   console.log('unsubscribed!');\n     * }, 2500);\n     *\n     * // Logs:\n     * // 0 after 1s\n     * // 1 after 2s\n     * // \"unsubscribed!\" after 2.5s\n     *\n     *\n     * @param {Observer|Function} observerOrNext (optional) Either an observer with methods to be called,\n     *  or the first of three possible handlers, which is the handler for each value emitted from the subscribed\n     *  Observable.\n     * @param {Function} error (optional) A handler for a terminal event resulting from an error. If no error handler is provided,\n     *  the error will be thrown as unhandled.\n     * @param {Function} complete (optional) A handler for a terminal event resulting from successful completion.\n     * @return {ISubscription} a subscription reference to the registered handlers\n     * @method subscribe\n     */\n    Observable.prototype.subscribe = function (observerOrNext, error, complete) {\n        var operator = this.operator;\n        var sink = toSubscriber_1.toSubscriber(observerOrNext, error, complete);\n        if (operator) {\n            operator.call(sink, this.source);\n        }\n        else {\n            sink.add(this.source || !sink.syncErrorThrowable ? this._subscribe(sink) : this._trySubscribe(sink));\n        }\n        if (sink.syncErrorThrowable) {\n            sink.syncErrorThrowable = false;\n            if (sink.syncErrorThrown) {\n                throw sink.syncErrorValue;\n            }\n        }\n        return sink;\n    };\n    Observable.prototype._trySubscribe = function (sink) {\n        try {\n            return this._subscribe(sink);\n        }\n        catch (err) {\n            sink.syncErrorThrown = true;\n            sink.syncErrorValue = err;\n            sink.error(err);\n        }\n    };\n    /**\n     * @method forEach\n     * @param {Function} next a handler for each value emitted by the observable\n     * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise\n     * @return {Promise} a promise that either resolves on observable completion or\n     *  rejects with the handled error\n     */\n    Observable.prototype.forEach = function (next, PromiseCtor) {\n        var _this = this;\n        if (!PromiseCtor) {\n            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {\n                PromiseCtor = root_1.root.Rx.config.Promise;\n            }\n            else if (root_1.root.Promise) {\n                PromiseCtor = root_1.root.Promise;\n            }\n        }\n        if (!PromiseCtor) {\n            throw new Error('no Promise impl found');\n        }\n        return new PromiseCtor(function (resolve, reject) {\n            // Must be declared in a separate statement to avoid a RefernceError when\n            // accessing subscription below in the closure due to Temporal Dead Zone.\n            var subscription;\n            subscription = _this.subscribe(function (value) {\n                if (subscription) {\n                    // if there is a subscription, then we can surmise\n                    // the next handling is asynchronous. Any errors thrown\n                    // need to be rejected explicitly and unsubscribe must be\n                    // called manually\n                    try {\n                        next(value);\n                    }\n                    catch (err) {\n                        reject(err);\n                        subscription.unsubscribe();\n                    }\n                }\n                else {\n                    // if there is NO subscription, then we're getting a nexted\n                    // value synchronously during subscription. We can just call it.\n                    // If it errors, Observable's `subscribe` will ensure the\n                    // unsubscription logic is called, then synchronously rethrow the error.\n                    // After that, Promise will trap the error and send it\n                    // down the rejection path.\n                    next(value);\n                }\n            }, reject, resolve);\n        });\n    };\n    /** @deprecated internal use only */ Observable.prototype._subscribe = function (subscriber) {\n        return this.source.subscribe(subscriber);\n    };\n    /**\n     * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable\n     * @method Symbol.observable\n     * @return {Observable} this instance of the observable\n     */\n    Observable.prototype[observable_1.observable] = function () {\n        return this;\n    };\n    /* tslint:enable:max-line-length */\n    /**\n     * Used to stitch together functional operators into a chain.\n     * @method pipe\n     * @return {Observable} the Observable result of all of the operators having\n     * been called in the order they were passed in.\n     *\n     * @example\n     *\n     * import { map, filter, scan } from 'rxjs/operators';\n     *\n     * Rx.Observable.interval(1000)\n     *   .pipe(\n     *     filter(x => x % 2 === 0),\n     *     map(x => x + x),\n     *     scan((acc, x) => acc + x)\n     *   )\n     *   .subscribe(x => console.log(x))\n     */\n    Observable.prototype.pipe = function () {\n        var operations = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            operations[_i - 0] = arguments[_i];\n        }\n        if (operations.length === 0) {\n            return this;\n        }\n        return pipe_1.pipeFromArray(operations)(this);\n    };\n    /* tslint:enable:max-line-length */\n    Observable.prototype.toPromise = function (PromiseCtor) {\n        var _this = this;\n        if (!PromiseCtor) {\n            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {\n                PromiseCtor = root_1.root.Rx.config.Promise;\n            }\n            else if (root_1.root.Promise) {\n                PromiseCtor = root_1.root.Promise;\n            }\n        }\n        if (!PromiseCtor) {\n            throw new Error('no Promise impl found');\n        }\n        return new PromiseCtor(function (resolve, reject) {\n            var value;\n            _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });\n        });\n    };\n    // HACK: Since TypeScript inherits static properties too, we have to\n    // fight against TypeScript here so Subject can have a different static create signature\n    /**\n     * Creates a new cold Observable by calling the Observable constructor\n     * @static true\n     * @owner Observable\n     * @method create\n     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor\n     * @return {Observable} a new cold observable\n     */\n    Observable.create = function (subscribe) {\n        return new Observable(subscribe);\n    };\n    return Observable;\n}());\nexports.Observable = Observable;\n//# sourceMappingURL=Observable.js.map","\"use strict\";\nexports.empty = {\n    closed: true,\n    next: function (value) { },\n    error: function (err) { throw err; },\n    complete: function () { }\n};\n//# sourceMappingURL=Observer.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('./Subscriber');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar OuterSubscriber = (function (_super) {\n    __extends(OuterSubscriber, _super);\n    function OuterSubscriber() {\n        _super.apply(this, arguments);\n    }\n    OuterSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.destination.next(innerValue);\n    };\n    OuterSubscriber.prototype.notifyError = function (error, innerSub) {\n        this.destination.error(error);\n    };\n    OuterSubscriber.prototype.notifyComplete = function (innerSub) {\n        this.destination.complete();\n    };\n    return OuterSubscriber;\n}(Subscriber_1.Subscriber));\nexports.OuterSubscriber = OuterSubscriber;\n//# sourceMappingURL=OuterSubscriber.js.map","\"use strict\";\n/**\n * An execution context and a data structure to order tasks and schedule their\n * execution. Provides a notion of (potentially virtual) time, through the\n * `now()` getter method.\n *\n * Each unit of work in a Scheduler is called an {@link Action}.\n *\n * ```ts\n * class Scheduler {\n *   now(): number;\n *   schedule(work, delay?, state?): Subscription;\n * }\n * ```\n *\n * @class Scheduler\n */\nvar Scheduler = (function () {\n    function Scheduler(SchedulerAction, now) {\n        if (now === void 0) { now = Scheduler.now; }\n        this.SchedulerAction = SchedulerAction;\n        this.now = now;\n    }\n    /**\n     * Schedules a function, `work`, for execution. May happen at some point in\n     * the future, according to the `delay` parameter, if specified. May be passed\n     * some context object, `state`, which will be passed to the `work` function.\n     *\n     * The given arguments will be processed an stored as an Action object in a\n     * queue of actions.\n     *\n     * @param {function(state: ?T): ?Subscription} work A function representing a\n     * task, or some unit of work to be executed by the Scheduler.\n     * @param {number} [delay] Time to wait before executing the work, where the\n     * time unit is implicit and defined by the Scheduler itself.\n     * @param {T} [state] Some contextual data that the `work` function uses when\n     * called by the Scheduler.\n     * @return {Subscription} A subscription in order to be able to unsubscribe\n     * the scheduled work.\n     */\n    Scheduler.prototype.schedule = function (work, delay, state) {\n        if (delay === void 0) { delay = 0; }\n        return new this.SchedulerAction(this, work).schedule(state, delay);\n    };\n    Scheduler.now = Date.now ? Date.now : function () { return +new Date(); };\n    return Scheduler;\n}());\nexports.Scheduler = Scheduler;\n//# sourceMappingURL=Scheduler.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('./Observable');\nvar Subscriber_1 = require('./Subscriber');\nvar Subscription_1 = require('./Subscription');\nvar ObjectUnsubscribedError_1 = require('./util/ObjectUnsubscribedError');\nvar SubjectSubscription_1 = require('./SubjectSubscription');\nvar rxSubscriber_1 = require('./symbol/rxSubscriber');\n/**\n * @class SubjectSubscriber<T>\n */\nvar SubjectSubscriber = (function (_super) {\n    __extends(SubjectSubscriber, _super);\n    function SubjectSubscriber(destination) {\n        _super.call(this, destination);\n        this.destination = destination;\n    }\n    return SubjectSubscriber;\n}(Subscriber_1.Subscriber));\nexports.SubjectSubscriber = SubjectSubscriber;\n/**\n * @class Subject<T>\n */\nvar Subject = (function (_super) {\n    __extends(Subject, _super);\n    function Subject() {\n        _super.call(this);\n        this.observers = [];\n        this.closed = false;\n        this.isStopped = false;\n        this.hasError = false;\n        this.thrownError = null;\n    }\n    Subject.prototype[rxSubscriber_1.rxSubscriber] = function () {\n        return new SubjectSubscriber(this);\n    };\n    Subject.prototype.lift = function (operator) {\n        var subject = new AnonymousSubject(this, this);\n        subject.operator = operator;\n        return subject;\n    };\n    Subject.prototype.next = function (value) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        if (!this.isStopped) {\n            var observers = this.observers;\n            var len = observers.length;\n            var copy = observers.slice();\n            for (var i = 0; i < len; i++) {\n                copy[i].next(value);\n            }\n        }\n    };\n    Subject.prototype.error = function (err) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        this.hasError = true;\n        this.thrownError = err;\n        this.isStopped = true;\n        var observers = this.observers;\n        var len = observers.length;\n        var copy = observers.slice();\n        for (var i = 0; i < len; i++) {\n            copy[i].error(err);\n        }\n        this.observers.length = 0;\n    };\n    Subject.prototype.complete = function () {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        this.isStopped = true;\n        var observers = this.observers;\n        var len = observers.length;\n        var copy = observers.slice();\n        for (var i = 0; i < len; i++) {\n            copy[i].complete();\n        }\n        this.observers.length = 0;\n    };\n    Subject.prototype.unsubscribe = function () {\n        this.isStopped = true;\n        this.closed = true;\n        this.observers = null;\n    };\n    Subject.prototype._trySubscribe = function (subscriber) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else {\n            return _super.prototype._trySubscribe.call(this, subscriber);\n        }\n    };\n    /** @deprecated internal use only */ Subject.prototype._subscribe = function (subscriber) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else if (this.hasError) {\n            subscriber.error(this.thrownError);\n            return Subscription_1.Subscription.EMPTY;\n        }\n        else if (this.isStopped) {\n            subscriber.complete();\n            return Subscription_1.Subscription.EMPTY;\n        }\n        else {\n            this.observers.push(subscriber);\n            return new SubjectSubscription_1.SubjectSubscription(this, subscriber);\n        }\n    };\n    Subject.prototype.asObservable = function () {\n        var observable = new Observable_1.Observable();\n        observable.source = this;\n        return observable;\n    };\n    Subject.create = function (destination, source) {\n        return new AnonymousSubject(destination, source);\n    };\n    return Subject;\n}(Observable_1.Observable));\nexports.Subject = Subject;\n/**\n * @class AnonymousSubject<T>\n */\nvar AnonymousSubject = (function (_super) {\n    __extends(AnonymousSubject, _super);\n    function AnonymousSubject(destination, source) {\n        _super.call(this);\n        this.destination = destination;\n        this.source = source;\n    }\n    AnonymousSubject.prototype.next = function (value) {\n        var destination = this.destination;\n        if (destination && destination.next) {\n            destination.next(value);\n        }\n    };\n    AnonymousSubject.prototype.error = function (err) {\n        var destination = this.destination;\n        if (destination && destination.error) {\n            this.destination.error(err);\n        }\n    };\n    AnonymousSubject.prototype.complete = function () {\n        var destination = this.destination;\n        if (destination && destination.complete) {\n            this.destination.complete();\n        }\n    };\n    /** @deprecated internal use only */ AnonymousSubject.prototype._subscribe = function (subscriber) {\n        var source = this.source;\n        if (source) {\n            return this.source.subscribe(subscriber);\n        }\n        else {\n            return Subscription_1.Subscription.EMPTY;\n        }\n    };\n    return AnonymousSubject;\n}(Subject));\nexports.AnonymousSubject = AnonymousSubject;\n//# sourceMappingURL=Subject.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscription_1 = require('./Subscription');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SubjectSubscription = (function (_super) {\n    __extends(SubjectSubscription, _super);\n    function SubjectSubscription(subject, subscriber) {\n        _super.call(this);\n        this.subject = subject;\n        this.subscriber = subscriber;\n        this.closed = false;\n    }\n    SubjectSubscription.prototype.unsubscribe = function () {\n        if (this.closed) {\n            return;\n        }\n        this.closed = true;\n        var subject = this.subject;\n        var observers = subject.observers;\n        this.subject = null;\n        if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {\n            return;\n        }\n        var subscriberIndex = observers.indexOf(this.subscriber);\n        if (subscriberIndex !== -1) {\n            observers.splice(subscriberIndex, 1);\n        }\n    };\n    return SubjectSubscription;\n}(Subscription_1.Subscription));\nexports.SubjectSubscription = SubjectSubscription;\n//# sourceMappingURL=SubjectSubscription.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isFunction_1 = require('./util/isFunction');\nvar Subscription_1 = require('./Subscription');\nvar Observer_1 = require('./Observer');\nvar rxSubscriber_1 = require('./symbol/rxSubscriber');\n/**\n * Implements the {@link Observer} interface and extends the\n * {@link Subscription} class. While the {@link Observer} is the public API for\n * consuming the values of an {@link Observable}, all Observers get converted to\n * a Subscriber, in order to provide Subscription-like capabilities such as\n * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for\n * implementing operators, but it is rarely used as a public API.\n *\n * @class Subscriber<T>\n */\nvar Subscriber = (function (_super) {\n    __extends(Subscriber, _super);\n    /**\n     * @param {Observer|function(value: T): void} [destinationOrNext] A partially\n     * defined Observer or a `next` callback function.\n     * @param {function(e: ?any): void} [error] The `error` callback of an\n     * Observer.\n     * @param {function(): void} [complete] The `complete` callback of an\n     * Observer.\n     */\n    function Subscriber(destinationOrNext, error, complete) {\n        _super.call(this);\n        this.syncErrorValue = null;\n        this.syncErrorThrown = false;\n        this.syncErrorThrowable = false;\n        this.isStopped = false;\n        switch (arguments.length) {\n            case 0:\n                this.destination = Observer_1.empty;\n                break;\n            case 1:\n                if (!destinationOrNext) {\n                    this.destination = Observer_1.empty;\n                    break;\n                }\n                if (typeof destinationOrNext === 'object') {\n                    // HACK(benlesh): To resolve an issue where Node users may have multiple\n                    // copies of rxjs in their node_modules directory.\n                    if (isTrustedSubscriber(destinationOrNext)) {\n                        var trustedSubscriber = destinationOrNext[rxSubscriber_1.rxSubscriber]();\n                        this.syncErrorThrowable = trustedSubscriber.syncErrorThrowable;\n                        this.destination = trustedSubscriber;\n                        trustedSubscriber.add(this);\n                    }\n                    else {\n                        this.syncErrorThrowable = true;\n                        this.destination = new SafeSubscriber(this, destinationOrNext);\n                    }\n                    break;\n                }\n            default:\n                this.syncErrorThrowable = true;\n                this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);\n                break;\n        }\n    }\n    Subscriber.prototype[rxSubscriber_1.rxSubscriber] = function () { return this; };\n    /**\n     * A static factory for a Subscriber, given a (potentially partial) definition\n     * of an Observer.\n     * @param {function(x: ?T): void} [next] The `next` callback of an Observer.\n     * @param {function(e: ?any): void} [error] The `error` callback of an\n     * Observer.\n     * @param {function(): void} [complete] The `complete` callback of an\n     * Observer.\n     * @return {Subscriber<T>} A Subscriber wrapping the (partially defined)\n     * Observer represented by the given arguments.\n     */\n    Subscriber.create = function (next, error, complete) {\n        var subscriber = new Subscriber(next, error, complete);\n        subscriber.syncErrorThrowable = false;\n        return subscriber;\n    };\n    /**\n     * The {@link Observer} callback to receive notifications of type `next` from\n     * the Observable, with a value. The Observable may call this method 0 or more\n     * times.\n     * @param {T} [value] The `next` value.\n     * @return {void}\n     */\n    Subscriber.prototype.next = function (value) {\n        if (!this.isStopped) {\n            this._next(value);\n        }\n    };\n    /**\n     * The {@link Observer} callback to receive notifications of type `error` from\n     * the Observable, with an attached {@link Error}. Notifies the Observer that\n     * the Observable has experienced an error condition.\n     * @param {any} [err] The `error` exception.\n     * @return {void}\n     */\n    Subscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._error(err);\n        }\n    };\n    /**\n     * The {@link Observer} callback to receive a valueless notification of type\n     * `complete` from the Observable. Notifies the Observer that the Observable\n     * has finished sending push-based notifications.\n     * @return {void}\n     */\n    Subscriber.prototype.complete = function () {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._complete();\n        }\n    };\n    Subscriber.prototype.unsubscribe = function () {\n        if (this.closed) {\n            return;\n        }\n        this.isStopped = true;\n        _super.prototype.unsubscribe.call(this);\n    };\n    Subscriber.prototype._next = function (value) {\n        this.destination.next(value);\n    };\n    Subscriber.prototype._error = function (err) {\n        this.destination.error(err);\n        this.unsubscribe();\n    };\n    Subscriber.prototype._complete = function () {\n        this.destination.complete();\n        this.unsubscribe();\n    };\n    /** @deprecated internal use only */ Subscriber.prototype._unsubscribeAndRecycle = function () {\n        var _a = this, _parent = _a._parent, _parents = _a._parents;\n        this._parent = null;\n        this._parents = null;\n        this.unsubscribe();\n        this.closed = false;\n        this.isStopped = false;\n        this._parent = _parent;\n        this._parents = _parents;\n        return this;\n    };\n    return Subscriber;\n}(Subscription_1.Subscription));\nexports.Subscriber = Subscriber;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SafeSubscriber = (function (_super) {\n    __extends(SafeSubscriber, _super);\n    function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) {\n        _super.call(this);\n        this._parentSubscriber = _parentSubscriber;\n        var next;\n        var context = this;\n        if (isFunction_1.isFunction(observerOrNext)) {\n            next = observerOrNext;\n        }\n        else if (observerOrNext) {\n            next = observerOrNext.next;\n            error = observerOrNext.error;\n            complete = observerOrNext.complete;\n            if (observerOrNext !== Observer_1.empty) {\n                context = Object.create(observerOrNext);\n                if (isFunction_1.isFunction(context.unsubscribe)) {\n                    this.add(context.unsubscribe.bind(context));\n                }\n                context.unsubscribe = this.unsubscribe.bind(this);\n            }\n        }\n        this._context = context;\n        this._next = next;\n        this._error = error;\n        this._complete = complete;\n    }\n    SafeSubscriber.prototype.next = function (value) {\n        if (!this.isStopped && this._next) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (!_parentSubscriber.syncErrorThrowable) {\n                this.__tryOrUnsub(this._next, value);\n            }\n            else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._error) {\n                if (!_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(this._error, err);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, this._error, err);\n                    this.unsubscribe();\n                }\n            }\n            else if (!_parentSubscriber.syncErrorThrowable) {\n                this.unsubscribe();\n                throw err;\n            }\n            else {\n                _parentSubscriber.syncErrorValue = err;\n                _parentSubscriber.syncErrorThrown = true;\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.complete = function () {\n        var _this = this;\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._complete) {\n                var wrappedComplete = function () { return _this._complete.call(_this._context); };\n                if (!_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(wrappedComplete);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, wrappedComplete);\n                    this.unsubscribe();\n                }\n            }\n            else {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            this.unsubscribe();\n            throw err;\n        }\n    };\n    SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            parent.syncErrorValue = err;\n            parent.syncErrorThrown = true;\n            return true;\n        }\n        return false;\n    };\n    /** @deprecated internal use only */ SafeSubscriber.prototype._unsubscribe = function () {\n        var _parentSubscriber = this._parentSubscriber;\n        this._context = null;\n        this._parentSubscriber = null;\n        _parentSubscriber.unsubscribe();\n    };\n    return SafeSubscriber;\n}(Subscriber));\nfunction isTrustedSubscriber(obj) {\n    return obj instanceof Subscriber || ('syncErrorThrowable' in obj && obj[rxSubscriber_1.rxSubscriber]);\n}\n//# sourceMappingURL=Subscriber.js.map","\"use strict\";\nvar isArray_1 = require('./util/isArray');\nvar isObject_1 = require('./util/isObject');\nvar isFunction_1 = require('./util/isFunction');\nvar tryCatch_1 = require('./util/tryCatch');\nvar errorObject_1 = require('./util/errorObject');\nvar UnsubscriptionError_1 = require('./util/UnsubscriptionError');\n/**\n * Represents a disposable resource, such as the execution of an Observable. A\n * Subscription has one important method, `unsubscribe`, that takes no argument\n * and just disposes the resource held by the subscription.\n *\n * Additionally, subscriptions may be grouped together through the `add()`\n * method, which will attach a child Subscription to the current Subscription.\n * When a Subscription is unsubscribed, all its children (and its grandchildren)\n * will be unsubscribed as well.\n *\n * @class Subscription\n */\nvar Subscription = (function () {\n    /**\n     * @param {function(): void} [unsubscribe] A function describing how to\n     * perform the disposal of resources when the `unsubscribe` method is called.\n     */\n    function Subscription(unsubscribe) {\n        /**\n         * A flag to indicate whether this Subscription has already been unsubscribed.\n         * @type {boolean}\n         */\n        this.closed = false;\n        this._parent = null;\n        this._parents = null;\n        this._subscriptions = null;\n        if (unsubscribe) {\n            this._unsubscribe = unsubscribe;\n        }\n    }\n    /**\n     * Disposes the resources held by the subscription. May, for instance, cancel\n     * an ongoing Observable execution or cancel any other type of work that\n     * started when the Subscription was created.\n     * @return {void}\n     */\n    Subscription.prototype.unsubscribe = function () {\n        var hasErrors = false;\n        var errors;\n        if (this.closed) {\n            return;\n        }\n        var _a = this, _parent = _a._parent, _parents = _a._parents, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;\n        this.closed = true;\n        this._parent = null;\n        this._parents = null;\n        // null out _subscriptions first so any child subscriptions that attempt\n        // to remove themselves from this subscription will noop\n        this._subscriptions = null;\n        var index = -1;\n        var len = _parents ? _parents.length : 0;\n        // if this._parent is null, then so is this._parents, and we\n        // don't have to remove ourselves from any parent subscriptions.\n        while (_parent) {\n            _parent.remove(this);\n            // if this._parents is null or index >= len,\n            // then _parent is set to null, and the loop exits\n            _parent = ++index < len && _parents[index] || null;\n        }\n        if (isFunction_1.isFunction(_unsubscribe)) {\n            var trial = tryCatch_1.tryCatch(_unsubscribe).call(this);\n            if (trial === errorObject_1.errorObject) {\n                hasErrors = true;\n                errors = errors || (errorObject_1.errorObject.e instanceof UnsubscriptionError_1.UnsubscriptionError ?\n                    flattenUnsubscriptionErrors(errorObject_1.errorObject.e.errors) : [errorObject_1.errorObject.e]);\n            }\n        }\n        if (isArray_1.isArray(_subscriptions)) {\n            index = -1;\n            len = _subscriptions.length;\n            while (++index < len) {\n                var sub = _subscriptions[index];\n                if (isObject_1.isObject(sub)) {\n                    var trial = tryCatch_1.tryCatch(sub.unsubscribe).call(sub);\n                    if (trial === errorObject_1.errorObject) {\n                        hasErrors = true;\n                        errors = errors || [];\n                        var err = errorObject_1.errorObject.e;\n                        if (err instanceof UnsubscriptionError_1.UnsubscriptionError) {\n                            errors = errors.concat(flattenUnsubscriptionErrors(err.errors));\n                        }\n                        else {\n                            errors.push(err);\n                        }\n                    }\n                }\n            }\n        }\n        if (hasErrors) {\n            throw new UnsubscriptionError_1.UnsubscriptionError(errors);\n        }\n    };\n    /**\n     * Adds a tear down to be called during the unsubscribe() of this\n     * Subscription.\n     *\n     * If the tear down being added is a subscription that is already\n     * unsubscribed, is the same reference `add` is being called on, or is\n     * `Subscription.EMPTY`, it will not be added.\n     *\n     * If this subscription is already in an `closed` state, the passed\n     * tear down logic will be executed immediately.\n     *\n     * @param {TeardownLogic} teardown The additional logic to execute on\n     * teardown.\n     * @return {Subscription} Returns the Subscription used or created to be\n     * added to the inner subscriptions list. This Subscription can be used with\n     * `remove()` to remove the passed teardown logic from the inner subscriptions\n     * list.\n     */\n    Subscription.prototype.add = function (teardown) {\n        if (!teardown || (teardown === Subscription.EMPTY)) {\n            return Subscription.EMPTY;\n        }\n        if (teardown === this) {\n            return this;\n        }\n        var subscription = teardown;\n        switch (typeof teardown) {\n            case 'function':\n                subscription = new Subscription(teardown);\n            case 'object':\n                if (subscription.closed || typeof subscription.unsubscribe !== 'function') {\n                    return subscription;\n                }\n                else if (this.closed) {\n                    subscription.unsubscribe();\n                    return subscription;\n                }\n                else if (typeof subscription._addParent !== 'function' /* quack quack */) {\n                    var tmp = subscription;\n                    subscription = new Subscription();\n                    subscription._subscriptions = [tmp];\n                }\n                break;\n            default:\n                throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');\n        }\n        var subscriptions = this._subscriptions || (this._subscriptions = []);\n        subscriptions.push(subscription);\n        subscription._addParent(this);\n        return subscription;\n    };\n    /**\n     * Removes a Subscription from the internal list of subscriptions that will\n     * unsubscribe during the unsubscribe process of this Subscription.\n     * @param {Subscription} subscription The subscription to remove.\n     * @return {void}\n     */\n    Subscription.prototype.remove = function (subscription) {\n        var subscriptions = this._subscriptions;\n        if (subscriptions) {\n            var subscriptionIndex = subscriptions.indexOf(subscription);\n            if (subscriptionIndex !== -1) {\n                subscriptions.splice(subscriptionIndex, 1);\n            }\n        }\n    };\n    Subscription.prototype._addParent = function (parent) {\n        var _a = this, _parent = _a._parent, _parents = _a._parents;\n        if (!_parent || _parent === parent) {\n            // If we don't have a parent, or the new parent is the same as the\n            // current parent, then set this._parent to the new parent.\n            this._parent = parent;\n        }\n        else if (!_parents) {\n            // If there's already one parent, but not multiple, allocate an Array to\n            // store the rest of the parent Subscriptions.\n            this._parents = [parent];\n        }\n        else if (_parents.indexOf(parent) === -1) {\n            // Only add the new parent to the _parents list if it's not already there.\n            _parents.push(parent);\n        }\n    };\n    Subscription.EMPTY = (function (empty) {\n        empty.closed = true;\n        return empty;\n    }(new Subscription()));\n    return Subscription;\n}());\nexports.Subscription = Subscription;\nfunction flattenUnsubscriptionErrors(errors) {\n    return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError_1.UnsubscriptionError) ? err.errors : err); }, []);\n}\n//# sourceMappingURL=Subscription.js.map","\"use strict\";\nvar Observable_1 = require('../../../Observable');\nvar ajax_1 = require('../../../observable/dom/ajax');\nObservable_1.Observable.ajax = ajax_1.ajax;\n//# sourceMappingURL=ajax.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar empty_1 = require('../../observable/empty');\nObservable_1.Observable.empty = empty_1.empty;\n//# sourceMappingURL=empty.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar from_1 = require('../../observable/from');\nObservable_1.Observable.from = from_1.from;\n//# sourceMappingURL=from.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar interval_1 = require('../../observable/interval');\nObservable_1.Observable.interval = interval_1.interval;\n//# sourceMappingURL=interval.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar of_1 = require('../../observable/of');\nObservable_1.Observable.of = of_1.of;\n//# sourceMappingURL=of.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar throw_1 = require('../../observable/throw');\nObservable_1.Observable.throw = throw_1._throw;\n//# sourceMappingURL=throw.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar catch_1 = require('../../operator/catch');\nObservable_1.Observable.prototype.catch = catch_1._catch;\nObservable_1.Observable.prototype._catch = catch_1._catch;\n//# sourceMappingURL=catch.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar combineLatest_1 = require('../../operator/combineLatest');\nObservable_1.Observable.prototype.combineLatest = combineLatest_1.combineLatest;\n//# sourceMappingURL=combineLatest.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar concatMap_1 = require('../../operator/concatMap');\nObservable_1.Observable.prototype.concatMap = concatMap_1.concatMap;\n//# sourceMappingURL=concatMap.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar count_1 = require('../../operator/count');\nObservable_1.Observable.prototype.count = count_1.count;\n//# sourceMappingURL=count.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar delay_1 = require('../../operator/delay');\nObservable_1.Observable.prototype.delay = delay_1.delay;\n//# sourceMappingURL=delay.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar do_1 = require('../../operator/do');\nObservable_1.Observable.prototype.do = do_1._do;\nObservable_1.Observable.prototype._do = do_1._do;\n//# sourceMappingURL=do.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar filter_1 = require('../../operator/filter');\nObservable_1.Observable.prototype.filter = filter_1.filter;\n//# sourceMappingURL=filter.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar map_1 = require('../../operator/map');\nObservable_1.Observable.prototype.map = map_1.map;\n//# sourceMappingURL=map.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar mergeMap_1 = require('../../operator/mergeMap');\nObservable_1.Observable.prototype.mergeMap = mergeMap_1.mergeMap;\nObservable_1.Observable.prototype.flatMap = mergeMap_1.mergeMap;\n//# sourceMappingURL=mergeMap.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar retryWhen_1 = require('../../operator/retryWhen');\nObservable_1.Observable.prototype.retryWhen = retryWhen_1.retryWhen;\n//# sourceMappingURL=retryWhen.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar share_1 = require('../../operator/share');\nObservable_1.Observable.prototype.share = share_1.share;\n//# sourceMappingURL=share.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar take_1 = require('../../operator/take');\nObservable_1.Observable.prototype.take = take_1.take;\n//# sourceMappingURL=take.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\nvar ScalarObservable_1 = require('./ScalarObservable');\nvar EmptyObservable_1 = require('./EmptyObservable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ArrayLikeObservable = (function (_super) {\n    __extends(ArrayLikeObservable, _super);\n    function ArrayLikeObservable(arrayLike, scheduler) {\n        _super.call(this);\n        this.arrayLike = arrayLike;\n        this.scheduler = scheduler;\n        if (!scheduler && arrayLike.length === 1) {\n            this._isScalar = true;\n            this.value = arrayLike[0];\n        }\n    }\n    ArrayLikeObservable.create = function (arrayLike, scheduler) {\n        var length = arrayLike.length;\n        if (length === 0) {\n            return new EmptyObservable_1.EmptyObservable();\n        }\n        else if (length === 1) {\n            return new ScalarObservable_1.ScalarObservable(arrayLike[0], scheduler);\n        }\n        else {\n            return new ArrayLikeObservable(arrayLike, scheduler);\n        }\n    };\n    ArrayLikeObservable.dispatch = function (state) {\n        var arrayLike = state.arrayLike, index = state.index, length = state.length, subscriber = state.subscriber;\n        if (subscriber.closed) {\n            return;\n        }\n        if (index >= length) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(arrayLike[index]);\n        state.index = index + 1;\n        this.schedule(state);\n    };\n    /** @deprecated internal use only */ ArrayLikeObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var _a = this, arrayLike = _a.arrayLike, scheduler = _a.scheduler;\n        var length = arrayLike.length;\n        if (scheduler) {\n            return scheduler.schedule(ArrayLikeObservable.dispatch, 0, {\n                arrayLike: arrayLike, index: index, length: length, subscriber: subscriber\n            });\n        }\n        else {\n            for (var i = 0; i < length && !subscriber.closed; i++) {\n                subscriber.next(arrayLike[i]);\n            }\n            subscriber.complete();\n        }\n    };\n    return ArrayLikeObservable;\n}(Observable_1.Observable));\nexports.ArrayLikeObservable = ArrayLikeObservable;\n//# sourceMappingURL=ArrayLikeObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\nvar ScalarObservable_1 = require('./ScalarObservable');\nvar EmptyObservable_1 = require('./EmptyObservable');\nvar isScheduler_1 = require('../util/isScheduler');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ArrayObservable = (function (_super) {\n    __extends(ArrayObservable, _super);\n    function ArrayObservable(array, scheduler) {\n        _super.call(this);\n        this.array = array;\n        this.scheduler = scheduler;\n        if (!scheduler && array.length === 1) {\n            this._isScalar = true;\n            this.value = array[0];\n        }\n    }\n    ArrayObservable.create = function (array, scheduler) {\n        return new ArrayObservable(array, scheduler);\n    };\n    /**\n     * Creates an Observable that emits some values you specify as arguments,\n     * immediately one after the other, and then emits a complete notification.\n     *\n     * <span class=\"informal\">Emits the arguments you provide, then completes.\n     * </span>\n     *\n     * <img src=\"./img/of.png\" width=\"100%\">\n     *\n     * This static operator is useful for creating a simple Observable that only\n     * emits the arguments given, and the complete notification thereafter. It can\n     * be used for composing with other Observables, such as with {@link concat}.\n     * By default, it uses a `null` IScheduler, which means the `next`\n     * notifications are sent synchronously, although with a different IScheduler\n     * it is possible to determine when those notifications will be delivered.\n     *\n     * @example <caption>Emit 10, 20, 30, then 'a', 'b', 'c', then start ticking every second.</caption>\n     * var numbers = Rx.Observable.of(10, 20, 30);\n     * var letters = Rx.Observable.of('a', 'b', 'c');\n     * var interval = Rx.Observable.interval(1000);\n     * var result = numbers.concat(letters).concat(interval);\n     * result.subscribe(x => console.log(x));\n     *\n     * @see {@link create}\n     * @see {@link empty}\n     * @see {@link never}\n     * @see {@link throw}\n     *\n     * @param {...T} values Arguments that represent `next` values to be emitted.\n     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling\n     * the emissions of the `next` notifications.\n     * @return {Observable<T>} An Observable that emits each given input value.\n     * @static true\n     * @name of\n     * @owner Observable\n     */\n    ArrayObservable.of = function () {\n        var array = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            array[_i - 0] = arguments[_i];\n        }\n        var scheduler = array[array.length - 1];\n        if (isScheduler_1.isScheduler(scheduler)) {\n            array.pop();\n        }\n        else {\n            scheduler = null;\n        }\n        var len = array.length;\n        if (len > 1) {\n            return new ArrayObservable(array, scheduler);\n        }\n        else if (len === 1) {\n            return new ScalarObservable_1.ScalarObservable(array[0], scheduler);\n        }\n        else {\n            return new EmptyObservable_1.EmptyObservable(scheduler);\n        }\n    };\n    ArrayObservable.dispatch = function (state) {\n        var array = state.array, index = state.index, count = state.count, subscriber = state.subscriber;\n        if (index >= count) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(array[index]);\n        if (subscriber.closed) {\n            return;\n        }\n        state.index = index + 1;\n        this.schedule(state);\n    };\n    /** @deprecated internal use only */ ArrayObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var array = this.array;\n        var count = array.length;\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(ArrayObservable.dispatch, 0, {\n                array: array, index: index, count: count, subscriber: subscriber\n            });\n        }\n        else {\n            for (var i = 0; i < count && !subscriber.closed; i++) {\n                subscriber.next(array[i]);\n            }\n            subscriber.complete();\n        }\n    };\n    return ArrayObservable;\n}(Observable_1.Observable));\nexports.ArrayObservable = ArrayObservable;\n//# sourceMappingURL=ArrayObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subject_1 = require('../Subject');\nvar Observable_1 = require('../Observable');\nvar Subscriber_1 = require('../Subscriber');\nvar Subscription_1 = require('../Subscription');\nvar refCount_1 = require('../operators/refCount');\n/**\n * @class ConnectableObservable<T>\n */\nvar ConnectableObservable = (function (_super) {\n    __extends(ConnectableObservable, _super);\n    function ConnectableObservable(/** @deprecated internal use only */ source, \n        /** @deprecated internal use only */ subjectFactory) {\n        _super.call(this);\n        this.source = source;\n        this.subjectFactory = subjectFactory;\n        /** @deprecated internal use only */ this._refCount = 0;\n        this._isComplete = false;\n    }\n    /** @deprecated internal use only */ ConnectableObservable.prototype._subscribe = function (subscriber) {\n        return this.getSubject().subscribe(subscriber);\n    };\n    /** @deprecated internal use only */ ConnectableObservable.prototype.getSubject = function () {\n        var subject = this._subject;\n        if (!subject || subject.isStopped) {\n            this._subject = this.subjectFactory();\n        }\n        return this._subject;\n    };\n    ConnectableObservable.prototype.connect = function () {\n        var connection = this._connection;\n        if (!connection) {\n            this._isComplete = false;\n            connection = this._connection = new Subscription_1.Subscription();\n            connection.add(this.source\n                .subscribe(new ConnectableSubscriber(this.getSubject(), this)));\n            if (connection.closed) {\n                this._connection = null;\n                connection = Subscription_1.Subscription.EMPTY;\n            }\n            else {\n                this._connection = connection;\n            }\n        }\n        return connection;\n    };\n    ConnectableObservable.prototype.refCount = function () {\n        return refCount_1.refCount()(this);\n    };\n    return ConnectableObservable;\n}(Observable_1.Observable));\nexports.ConnectableObservable = ConnectableObservable;\nvar connectableProto = ConnectableObservable.prototype;\nexports.connectableObservableDescriptor = {\n    operator: { value: null },\n    _refCount: { value: 0, writable: true },\n    _subject: { value: null, writable: true },\n    _connection: { value: null, writable: true },\n    _subscribe: { value: connectableProto._subscribe },\n    _isComplete: { value: connectableProto._isComplete, writable: true },\n    getSubject: { value: connectableProto.getSubject },\n    connect: { value: connectableProto.connect },\n    refCount: { value: connectableProto.refCount }\n};\nvar ConnectableSubscriber = (function (_super) {\n    __extends(ConnectableSubscriber, _super);\n    function ConnectableSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    ConnectableSubscriber.prototype._error = function (err) {\n        this._unsubscribe();\n        _super.prototype._error.call(this, err);\n    };\n    ConnectableSubscriber.prototype._complete = function () {\n        this.connectable._isComplete = true;\n        this._unsubscribe();\n        _super.prototype._complete.call(this);\n    };\n    /** @deprecated internal use only */ ConnectableSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (connectable) {\n            this.connectable = null;\n            var connection = connectable._connection;\n            connectable._refCount = 0;\n            connectable._subject = null;\n            connectable._connection = null;\n            if (connection) {\n                connection.unsubscribe();\n            }\n        }\n    };\n    return ConnectableSubscriber;\n}(Subject_1.SubjectSubscriber));\nvar RefCountOperator = (function () {\n    function RefCountOperator(connectable) {\n        this.connectable = connectable;\n    }\n    RefCountOperator.prototype.call = function (subscriber, source) {\n        var connectable = this.connectable;\n        connectable._refCount++;\n        var refCounter = new RefCountSubscriber(subscriber, connectable);\n        var subscription = source.subscribe(refCounter);\n        if (!refCounter.closed) {\n            refCounter.connection = connectable.connect();\n        }\n        return subscription;\n    };\n    return RefCountOperator;\n}());\nvar RefCountSubscriber = (function (_super) {\n    __extends(RefCountSubscriber, _super);\n    function RefCountSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    /** @deprecated internal use only */ RefCountSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (!connectable) {\n            this.connection = null;\n            return;\n        }\n        this.connectable = null;\n        var refCount = connectable._refCount;\n        if (refCount <= 0) {\n            this.connection = null;\n            return;\n        }\n        connectable._refCount = refCount - 1;\n        if (refCount > 1) {\n            this.connection = null;\n            return;\n        }\n        ///\n        // Compare the local RefCountSubscriber's connection Subscription to the\n        // connection Subscription on the shared ConnectableObservable. In cases\n        // where the ConnectableObservable source synchronously emits values, and\n        // the RefCountSubscriber's downstream Observers synchronously unsubscribe,\n        // execution continues to here before the RefCountOperator has a chance to\n        // supply the RefCountSubscriber with the shared connection Subscription.\n        // For example:\n        // ```\n        // Observable.range(0, 10)\n        //   .publish()\n        //   .refCount()\n        //   .take(5)\n        //   .subscribe();\n        // ```\n        // In order to account for this case, RefCountSubscriber should only dispose\n        // the ConnectableObservable's shared connection Subscription if the\n        // connection Subscription exists, *and* either:\n        //   a. RefCountSubscriber doesn't have a reference to the shared connection\n        //      Subscription yet, or,\n        //   b. RefCountSubscriber's connection Subscription reference is identical\n        //      to the shared connection Subscription\n        ///\n        var connection = this.connection;\n        var sharedConnection = connectable._connection;\n        this.connection = null;\n        if (sharedConnection && (!connection || sharedConnection === connection)) {\n            sharedConnection.unsubscribe();\n        }\n    };\n    return RefCountSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=ConnectableObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar EmptyObservable = (function (_super) {\n    __extends(EmptyObservable, _super);\n    function EmptyObservable(scheduler) {\n        _super.call(this);\n        this.scheduler = scheduler;\n    }\n    /**\n     * Creates an Observable that emits no items to the Observer and immediately\n     * emits a complete notification.\n     *\n     * <span class=\"informal\">Just emits 'complete', and nothing else.\n     * </span>\n     *\n     * <img src=\"./img/empty.png\" width=\"100%\">\n     *\n     * This static operator is useful for creating a simple Observable that only\n     * emits the complete notification. It can be used for composing with other\n     * Observables, such as in a {@link mergeMap}.\n     *\n     * @example <caption>Emit the number 7, then complete.</caption>\n     * var result = Rx.Observable.empty().startWith(7);\n     * result.subscribe(x => console.log(x));\n     *\n     * @example <caption>Map and flatten only odd numbers to the sequence 'a', 'b', 'c'</caption>\n     * var interval = Rx.Observable.interval(1000);\n     * var result = interval.mergeMap(x =>\n     *   x % 2 === 1 ? Rx.Observable.of('a', 'b', 'c') : Rx.Observable.empty()\n     * );\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following to the console:\n     * // x is equal to the count on the interval eg(0,1,2,3,...)\n     * // x will occur every 1000ms\n     * // if x % 2 is equal to 1 print abc\n     * // if x % 2 is not equal to 1 nothing will be output\n     *\n     * @see {@link create}\n     * @see {@link never}\n     * @see {@link of}\n     * @see {@link throw}\n     *\n     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling\n     * the emission of the complete notification.\n     * @return {Observable} An \"empty\" Observable: emits only the complete\n     * notification.\n     * @static true\n     * @name empty\n     * @owner Observable\n     */\n    EmptyObservable.create = function (scheduler) {\n        return new EmptyObservable(scheduler);\n    };\n    EmptyObservable.dispatch = function (arg) {\n        var subscriber = arg.subscriber;\n        subscriber.complete();\n    };\n    /** @deprecated internal use only */ EmptyObservable.prototype._subscribe = function (subscriber) {\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(EmptyObservable.dispatch, 0, { subscriber: subscriber });\n        }\n        else {\n            subscriber.complete();\n        }\n    };\n    return EmptyObservable;\n}(Observable_1.Observable));\nexports.EmptyObservable = EmptyObservable;\n//# sourceMappingURL=EmptyObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ErrorObservable = (function (_super) {\n    __extends(ErrorObservable, _super);\n    function ErrorObservable(error, scheduler) {\n        _super.call(this);\n        this.error = error;\n        this.scheduler = scheduler;\n    }\n    /**\n     * Creates an Observable that emits no items to the Observer and immediately\n     * emits an error notification.\n     *\n     * <span class=\"informal\">Just emits 'error', and nothing else.\n     * </span>\n     *\n     * <img src=\"./img/throw.png\" width=\"100%\">\n     *\n     * This static operator is useful for creating a simple Observable that only\n     * emits the error notification. It can be used for composing with other\n     * Observables, such as in a {@link mergeMap}.\n     *\n     * @example <caption>Emit the number 7, then emit an error.</caption>\n     * var result = Rx.Observable.throw(new Error('oops!')).startWith(7);\n     * result.subscribe(x => console.log(x), e => console.error(e));\n     *\n     * @example <caption>Map and flatten numbers to the sequence 'a', 'b', 'c', but throw an error for 13</caption>\n     * var interval = Rx.Observable.interval(1000);\n     * var result = interval.mergeMap(x =>\n     *   x === 13 ?\n     *     Rx.Observable.throw('Thirteens are bad') :\n     *     Rx.Observable.of('a', 'b', 'c')\n     * );\n     * result.subscribe(x => console.log(x), e => console.error(e));\n     *\n     * @see {@link create}\n     * @see {@link empty}\n     * @see {@link never}\n     * @see {@link of}\n     *\n     * @param {any} error The particular Error to pass to the error notification.\n     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling\n     * the emission of the error notification.\n     * @return {Observable} An error Observable: emits only the error notification\n     * using the given error argument.\n     * @static true\n     * @name throw\n     * @owner Observable\n     */\n    ErrorObservable.create = function (error, scheduler) {\n        return new ErrorObservable(error, scheduler);\n    };\n    ErrorObservable.dispatch = function (arg) {\n        var error = arg.error, subscriber = arg.subscriber;\n        subscriber.error(error);\n    };\n    /** @deprecated internal use only */ ErrorObservable.prototype._subscribe = function (subscriber) {\n        var error = this.error;\n        var scheduler = this.scheduler;\n        subscriber.syncErrorThrowable = true;\n        if (scheduler) {\n            return scheduler.schedule(ErrorObservable.dispatch, 0, {\n                error: error, subscriber: subscriber\n            });\n        }\n        else {\n            subscriber.error(error);\n        }\n    };\n    return ErrorObservable;\n}(Observable_1.Observable));\nexports.ErrorObservable = ErrorObservable;\n//# sourceMappingURL=ErrorObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isArray_1 = require('../util/isArray');\nvar isArrayLike_1 = require('../util/isArrayLike');\nvar isPromise_1 = require('../util/isPromise');\nvar PromiseObservable_1 = require('./PromiseObservable');\nvar IteratorObservable_1 = require('./IteratorObservable');\nvar ArrayObservable_1 = require('./ArrayObservable');\nvar ArrayLikeObservable_1 = require('./ArrayLikeObservable');\nvar iterator_1 = require('../symbol/iterator');\nvar Observable_1 = require('../Observable');\nvar observeOn_1 = require('../operators/observeOn');\nvar observable_1 = require('../symbol/observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar FromObservable = (function (_super) {\n    __extends(FromObservable, _super);\n    function FromObservable(ish, scheduler) {\n        _super.call(this, null);\n        this.ish = ish;\n        this.scheduler = scheduler;\n    }\n    /**\n     * Creates an Observable from an Array, an array-like object, a Promise, an\n     * iterable object, or an Observable-like object.\n     *\n     * <span class=\"informal\">Converts almost anything to an Observable.</span>\n     *\n     * <img src=\"./img/from.png\" width=\"100%\">\n     *\n     * Convert various other objects and data types into Observables. `from`\n     * converts a Promise or an array-like or an\n     * [iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)\n     * object into an Observable that emits the items in that promise or array or\n     * iterable. A String, in this context, is treated as an array of characters.\n     * Observable-like objects (contains a function named with the ES2015 Symbol\n     * for Observable) can also be converted through this operator.\n     *\n     * @example <caption>Converts an array to an Observable</caption>\n     * var array = [10, 20, 30];\n     * var result = Rx.Observable.from(array);\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following:\n     * // 10 20 30\n     *\n     * @example <caption>Convert an infinite iterable (from a generator) to an Observable</caption>\n     * function* generateDoubles(seed) {\n     *   var i = seed;\n     *   while (true) {\n     *     yield i;\n     *     i = 2 * i; // double it\n     *   }\n     * }\n     *\n     * var iterator = generateDoubles(3);\n     * var result = Rx.Observable.from(iterator).take(10);\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following:\n     * // 3 6 12 24 48 96 192 384 768 1536\n     *\n     * @see {@link create}\n     * @see {@link fromEvent}\n     * @see {@link fromEventPattern}\n     * @see {@link fromPromise}\n     *\n     * @param {ObservableInput<T>} ish A subscribable object, a Promise, an\n     * Observable-like, an Array, an iterable or an array-like object to be\n     * converted.\n     * @param {Scheduler} [scheduler] The scheduler on which to schedule the\n     * emissions of values.\n     * @return {Observable<T>} The Observable whose values are originally from the\n     * input object that was converted.\n     * @static true\n     * @name from\n     * @owner Observable\n     */\n    FromObservable.create = function (ish, scheduler) {\n        if (ish != null) {\n            if (typeof ish[observable_1.observable] === 'function') {\n                if (ish instanceof Observable_1.Observable && !scheduler) {\n                    return ish;\n                }\n                return new FromObservable(ish, scheduler);\n            }\n            else if (isArray_1.isArray(ish)) {\n                return new ArrayObservable_1.ArrayObservable(ish, scheduler);\n            }\n            else if (isPromise_1.isPromise(ish)) {\n                return new PromiseObservable_1.PromiseObservable(ish, scheduler);\n            }\n            else if (typeof ish[iterator_1.iterator] === 'function' || typeof ish === 'string') {\n                return new IteratorObservable_1.IteratorObservable(ish, scheduler);\n            }\n            else if (isArrayLike_1.isArrayLike(ish)) {\n                return new ArrayLikeObservable_1.ArrayLikeObservable(ish, scheduler);\n            }\n        }\n        throw new TypeError((ish !== null && typeof ish || ish) + ' is not observable');\n    };\n    /** @deprecated internal use only */ FromObservable.prototype._subscribe = function (subscriber) {\n        var ish = this.ish;\n        var scheduler = this.scheduler;\n        if (scheduler == null) {\n            return ish[observable_1.observable]().subscribe(subscriber);\n        }\n        else {\n            return ish[observable_1.observable]().subscribe(new observeOn_1.ObserveOnSubscriber(subscriber, scheduler, 0));\n        }\n    };\n    return FromObservable;\n}(Observable_1.Observable));\nexports.FromObservable = FromObservable;\n//# sourceMappingURL=FromObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isNumeric_1 = require('../util/isNumeric');\nvar Observable_1 = require('../Observable');\nvar async_1 = require('../scheduler/async');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar IntervalObservable = (function (_super) {\n    __extends(IntervalObservable, _super);\n    function IntervalObservable(period, scheduler) {\n        if (period === void 0) { period = 0; }\n        if (scheduler === void 0) { scheduler = async_1.async; }\n        _super.call(this);\n        this.period = period;\n        this.scheduler = scheduler;\n        if (!isNumeric_1.isNumeric(period) || period < 0) {\n            this.period = 0;\n        }\n        if (!scheduler || typeof scheduler.schedule !== 'function') {\n            this.scheduler = async_1.async;\n        }\n    }\n    /**\n     * Creates an Observable that emits sequential numbers every specified\n     * interval of time, on a specified IScheduler.\n     *\n     * <span class=\"informal\">Emits incremental numbers periodically in time.\n     * </span>\n     *\n     * <img src=\"./img/interval.png\" width=\"100%\">\n     *\n     * `interval` returns an Observable that emits an infinite sequence of\n     * ascending integers, with a constant interval of time of your choosing\n     * between those emissions. The first emission is not sent immediately, but\n     * only after the first period has passed. By default, this operator uses the\n     * `async` IScheduler to provide a notion of time, but you may pass any\n     * IScheduler to it.\n     *\n     * @example <caption>Emits ascending numbers, one every second (1000ms)</caption>\n     * var numbers = Rx.Observable.interval(1000);\n     * numbers.subscribe(x => console.log(x));\n     *\n     * @see {@link timer}\n     * @see {@link delay}\n     *\n     * @param {number} [period=0] The interval size in milliseconds (by default)\n     * or the time unit determined by the scheduler's clock.\n     * @param {Scheduler} [scheduler=async] The IScheduler to use for scheduling\n     * the emission of values, and providing a notion of \"time\".\n     * @return {Observable} An Observable that emits a sequential number each time\n     * interval.\n     * @static true\n     * @name interval\n     * @owner Observable\n     */\n    IntervalObservable.create = function (period, scheduler) {\n        if (period === void 0) { period = 0; }\n        if (scheduler === void 0) { scheduler = async_1.async; }\n        return new IntervalObservable(period, scheduler);\n    };\n    IntervalObservable.dispatch = function (state) {\n        var index = state.index, subscriber = state.subscriber, period = state.period;\n        subscriber.next(index);\n        if (subscriber.closed) {\n            return;\n        }\n        state.index += 1;\n        this.schedule(state, period);\n    };\n    /** @deprecated internal use only */ IntervalObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var period = this.period;\n        var scheduler = this.scheduler;\n        subscriber.add(scheduler.schedule(IntervalObservable.dispatch, period, {\n            index: index, subscriber: subscriber, period: period\n        }));\n    };\n    return IntervalObservable;\n}(Observable_1.Observable));\nexports.IntervalObservable = IntervalObservable;\n//# sourceMappingURL=IntervalObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../util/root');\nvar Observable_1 = require('../Observable');\nvar iterator_1 = require('../symbol/iterator');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar IteratorObservable = (function (_super) {\n    __extends(IteratorObservable, _super);\n    function IteratorObservable(iterator, scheduler) {\n        _super.call(this);\n        this.scheduler = scheduler;\n        if (iterator == null) {\n            throw new Error('iterator cannot be null.');\n        }\n        this.iterator = getIterator(iterator);\n    }\n    IteratorObservable.create = function (iterator, scheduler) {\n        return new IteratorObservable(iterator, scheduler);\n    };\n    IteratorObservable.dispatch = function (state) {\n        var index = state.index, hasError = state.hasError, iterator = state.iterator, subscriber = state.subscriber;\n        if (hasError) {\n            subscriber.error(state.error);\n            return;\n        }\n        var result = iterator.next();\n        if (result.done) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(result.value);\n        state.index = index + 1;\n        if (subscriber.closed) {\n            if (typeof iterator.return === 'function') {\n                iterator.return();\n            }\n            return;\n        }\n        this.schedule(state);\n    };\n    /** @deprecated internal use only */ IteratorObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var _a = this, iterator = _a.iterator, scheduler = _a.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(IteratorObservable.dispatch, 0, {\n                index: index, iterator: iterator, subscriber: subscriber\n            });\n        }\n        else {\n            do {\n                var result = iterator.next();\n                if (result.done) {\n                    subscriber.complete();\n                    break;\n                }\n                else {\n                    subscriber.next(result.value);\n                }\n                if (subscriber.closed) {\n                    if (typeof iterator.return === 'function') {\n                        iterator.return();\n                    }\n                    break;\n                }\n            } while (true);\n        }\n    };\n    return IteratorObservable;\n}(Observable_1.Observable));\nexports.IteratorObservable = IteratorObservable;\nvar StringIterator = (function () {\n    function StringIterator(str, idx, len) {\n        if (idx === void 0) { idx = 0; }\n        if (len === void 0) { len = str.length; }\n        this.str = str;\n        this.idx = idx;\n        this.len = len;\n    }\n    StringIterator.prototype[iterator_1.iterator] = function () { return (this); };\n    StringIterator.prototype.next = function () {\n        return this.idx < this.len ? {\n            done: false,\n            value: this.str.charAt(this.idx++)\n        } : {\n            done: true,\n            value: undefined\n        };\n    };\n    return StringIterator;\n}());\nvar ArrayIterator = (function () {\n    function ArrayIterator(arr, idx, len) {\n        if (idx === void 0) { idx = 0; }\n        if (len === void 0) { len = toLength(arr); }\n        this.arr = arr;\n        this.idx = idx;\n        this.len = len;\n    }\n    ArrayIterator.prototype[iterator_1.iterator] = function () { return this; };\n    ArrayIterator.prototype.next = function () {\n        return this.idx < this.len ? {\n            done: false,\n            value: this.arr[this.idx++]\n        } : {\n            done: true,\n            value: undefined\n        };\n    };\n    return ArrayIterator;\n}());\nfunction getIterator(obj) {\n    var i = obj[iterator_1.iterator];\n    if (!i && typeof obj === 'string') {\n        return new StringIterator(obj);\n    }\n    if (!i && obj.length !== undefined) {\n        return new ArrayIterator(obj);\n    }\n    if (!i) {\n        throw new TypeError('object is not iterable');\n    }\n    return obj[iterator_1.iterator]();\n}\nvar maxSafeInteger = Math.pow(2, 53) - 1;\nfunction toLength(o) {\n    var len = +o.length;\n    if (isNaN(len)) {\n        return 0;\n    }\n    if (len === 0 || !numberIsFinite(len)) {\n        return len;\n    }\n    len = sign(len) * Math.floor(Math.abs(len));\n    if (len <= 0) {\n        return 0;\n    }\n    if (len > maxSafeInteger) {\n        return maxSafeInteger;\n    }\n    return len;\n}\nfunction numberIsFinite(value) {\n    return typeof value === 'number' && root_1.root.isFinite(value);\n}\nfunction sign(value) {\n    var valueAsNumber = +value;\n    if (valueAsNumber === 0) {\n        return valueAsNumber;\n    }\n    if (isNaN(valueAsNumber)) {\n        return valueAsNumber;\n    }\n    return valueAsNumber < 0 ? -1 : 1;\n}\n//# sourceMappingURL=IteratorObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../util/root');\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar PromiseObservable = (function (_super) {\n    __extends(PromiseObservable, _super);\n    function PromiseObservable(promise, scheduler) {\n        _super.call(this);\n        this.promise = promise;\n        this.scheduler = scheduler;\n    }\n    /**\n     * Converts a Promise to an Observable.\n     *\n     * <span class=\"informal\">Returns an Observable that just emits the Promise's\n     * resolved value, then completes.</span>\n     *\n     * Converts an ES2015 Promise or a Promises/A+ spec compliant Promise to an\n     * Observable. If the Promise resolves with a value, the output Observable\n     * emits that resolved value as a `next`, and then completes. If the Promise\n     * is rejected, then the output Observable emits the corresponding Error.\n     *\n     * @example <caption>Convert the Promise returned by Fetch to an Observable</caption>\n     * var result = Rx.Observable.fromPromise(fetch('http://myserver.com/'));\n     * result.subscribe(x => console.log(x), e => console.error(e));\n     *\n     * @see {@link bindCallback}\n     * @see {@link from}\n     *\n     * @param {PromiseLike<T>} promise The promise to be converted.\n     * @param {Scheduler} [scheduler] An optional IScheduler to use for scheduling\n     * the delivery of the resolved value (or the rejection).\n     * @return {Observable<T>} An Observable which wraps the Promise.\n     * @static true\n     * @name fromPromise\n     * @owner Observable\n     */\n    PromiseObservable.create = function (promise, scheduler) {\n        return new PromiseObservable(promise, scheduler);\n    };\n    /** @deprecated internal use only */ PromiseObservable.prototype._subscribe = function (subscriber) {\n        var _this = this;\n        var promise = this.promise;\n        var scheduler = this.scheduler;\n        if (scheduler == null) {\n            if (this._isScalar) {\n                if (!subscriber.closed) {\n                    subscriber.next(this.value);\n                    subscriber.complete();\n                }\n            }\n            else {\n                promise.then(function (value) {\n                    _this.value = value;\n                    _this._isScalar = true;\n                    if (!subscriber.closed) {\n                        subscriber.next(value);\n                        subscriber.complete();\n                    }\n                }, function (err) {\n                    if (!subscriber.closed) {\n                        subscriber.error(err);\n                    }\n                })\n                    .then(null, function (err) {\n                    // escape the promise trap, throw unhandled errors\n                    root_1.root.setTimeout(function () { throw err; });\n                });\n            }\n        }\n        else {\n            if (this._isScalar) {\n                if (!subscriber.closed) {\n                    return scheduler.schedule(dispatchNext, 0, { value: this.value, subscriber: subscriber });\n                }\n            }\n            else {\n                promise.then(function (value) {\n                    _this.value = value;\n                    _this._isScalar = true;\n                    if (!subscriber.closed) {\n                        subscriber.add(scheduler.schedule(dispatchNext, 0, { value: value, subscriber: subscriber }));\n                    }\n                }, function (err) {\n                    if (!subscriber.closed) {\n                        subscriber.add(scheduler.schedule(dispatchError, 0, { err: err, subscriber: subscriber }));\n                    }\n                })\n                    .then(null, function (err) {\n                    // escape the promise trap, throw unhandled errors\n                    root_1.root.setTimeout(function () { throw err; });\n                });\n            }\n        }\n    };\n    return PromiseObservable;\n}(Observable_1.Observable));\nexports.PromiseObservable = PromiseObservable;\nfunction dispatchNext(arg) {\n    var value = arg.value, subscriber = arg.subscriber;\n    if (!subscriber.closed) {\n        subscriber.next(value);\n        subscriber.complete();\n    }\n}\nfunction dispatchError(arg) {\n    var err = arg.err, subscriber = arg.subscriber;\n    if (!subscriber.closed) {\n        subscriber.error(err);\n    }\n}\n//# sourceMappingURL=PromiseObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ScalarObservable = (function (_super) {\n    __extends(ScalarObservable, _super);\n    function ScalarObservable(value, scheduler) {\n        _super.call(this);\n        this.value = value;\n        this.scheduler = scheduler;\n        this._isScalar = true;\n        if (scheduler) {\n            this._isScalar = false;\n        }\n    }\n    ScalarObservable.create = function (value, scheduler) {\n        return new ScalarObservable(value, scheduler);\n    };\n    ScalarObservable.dispatch = function (state) {\n        var done = state.done, value = state.value, subscriber = state.subscriber;\n        if (done) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(value);\n        if (subscriber.closed) {\n            return;\n        }\n        state.done = true;\n        this.schedule(state);\n    };\n    /** @deprecated internal use only */ ScalarObservable.prototype._subscribe = function (subscriber) {\n        var value = this.value;\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(ScalarObservable.dispatch, 0, {\n                done: false, value: value, subscriber: subscriber\n            });\n        }\n        else {\n            subscriber.next(value);\n            if (!subscriber.closed) {\n                subscriber.complete();\n            }\n        }\n    };\n    return ScalarObservable;\n}(Observable_1.Observable));\nexports.ScalarObservable = ScalarObservable;\n//# sourceMappingURL=ScalarObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../../util/root');\nvar tryCatch_1 = require('../../util/tryCatch');\nvar errorObject_1 = require('../../util/errorObject');\nvar Observable_1 = require('../../Observable');\nvar Subscriber_1 = require('../../Subscriber');\nvar map_1 = require('../../operators/map');\nfunction getCORSRequest() {\n    if (root_1.root.XMLHttpRequest) {\n        return new root_1.root.XMLHttpRequest();\n    }\n    else if (!!root_1.root.XDomainRequest) {\n        return new root_1.root.XDomainRequest();\n    }\n    else {\n        throw new Error('CORS is not supported by your browser');\n    }\n}\nfunction getXMLHttpRequest() {\n    if (root_1.root.XMLHttpRequest) {\n        return new root_1.root.XMLHttpRequest();\n    }\n    else {\n        var progId = void 0;\n        try {\n            var progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];\n            for (var i = 0; i < 3; i++) {\n                try {\n                    progId = progIds[i];\n                    if (new root_1.root.ActiveXObject(progId)) {\n                        break;\n                    }\n                }\n                catch (e) {\n                }\n            }\n            return new root_1.root.ActiveXObject(progId);\n        }\n        catch (e) {\n            throw new Error('XMLHttpRequest is not supported by your browser');\n        }\n    }\n}\nfunction ajaxGet(url, headers) {\n    if (headers === void 0) { headers = null; }\n    return new AjaxObservable({ method: 'GET', url: url, headers: headers });\n}\nexports.ajaxGet = ajaxGet;\n;\nfunction ajaxPost(url, body, headers) {\n    return new AjaxObservable({ method: 'POST', url: url, body: body, headers: headers });\n}\nexports.ajaxPost = ajaxPost;\n;\nfunction ajaxDelete(url, headers) {\n    return new AjaxObservable({ method: 'DELETE', url: url, headers: headers });\n}\nexports.ajaxDelete = ajaxDelete;\n;\nfunction ajaxPut(url, body, headers) {\n    return new AjaxObservable({ method: 'PUT', url: url, body: body, headers: headers });\n}\nexports.ajaxPut = ajaxPut;\n;\nfunction ajaxPatch(url, body, headers) {\n    return new AjaxObservable({ method: 'PATCH', url: url, body: body, headers: headers });\n}\nexports.ajaxPatch = ajaxPatch;\n;\nvar mapResponse = map_1.map(function (x, index) { return x.response; });\nfunction ajaxGetJSON(url, headers) {\n    return mapResponse(new AjaxObservable({\n        method: 'GET',\n        url: url,\n        responseType: 'json',\n        headers: headers\n    }));\n}\nexports.ajaxGetJSON = ajaxGetJSON;\n;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar AjaxObservable = (function (_super) {\n    __extends(AjaxObservable, _super);\n    function AjaxObservable(urlOrRequest) {\n        _super.call(this);\n        var request = {\n            async: true,\n            createXHR: function () {\n                return this.crossDomain ? getCORSRequest.call(this) : getXMLHttpRequest();\n            },\n            crossDomain: false,\n            withCredentials: false,\n            headers: {},\n            method: 'GET',\n            responseType: 'json',\n            timeout: 0\n        };\n        if (typeof urlOrRequest === 'string') {\n            request.url = urlOrRequest;\n        }\n        else {\n            for (var prop in urlOrRequest) {\n                if (urlOrRequest.hasOwnProperty(prop)) {\n                    request[prop] = urlOrRequest[prop];\n                }\n            }\n        }\n        this.request = request;\n    }\n    /** @deprecated internal use only */ AjaxObservable.prototype._subscribe = function (subscriber) {\n        return new AjaxSubscriber(subscriber, this.request);\n    };\n    /**\n     * Creates an observable for an Ajax request with either a request object with\n     * url, headers, etc or a string for a URL.\n     *\n     * @example\n     * source = Rx.Observable.ajax('/products');\n     * source = Rx.Observable.ajax({ url: 'products', method: 'GET' });\n     *\n     * @param {string|Object} request Can be one of the following:\n     *   A string of the URL to make the Ajax call.\n     *   An object with the following properties\n     *   - url: URL of the request\n     *   - body: The body of the request\n     *   - method: Method of the request, such as GET, POST, PUT, PATCH, DELETE\n     *   - async: Whether the request is async\n     *   - headers: Optional headers\n     *   - crossDomain: true if a cross domain request, else false\n     *   - createXHR: a function to override if you need to use an alternate\n     *   XMLHttpRequest implementation.\n     *   - resultSelector: a function to use to alter the output value type of\n     *   the Observable. Gets {@link AjaxResponse} as an argument.\n     * @return {Observable} An observable sequence containing the XMLHttpRequest.\n     * @static true\n     * @name ajax\n     * @owner Observable\n    */\n    AjaxObservable.create = (function () {\n        var create = function (urlOrRequest) {\n            return new AjaxObservable(urlOrRequest);\n        };\n        create.get = ajaxGet;\n        create.post = ajaxPost;\n        create.delete = ajaxDelete;\n        create.put = ajaxPut;\n        create.patch = ajaxPatch;\n        create.getJSON = ajaxGetJSON;\n        return create;\n    })();\n    return AjaxObservable;\n}(Observable_1.Observable));\nexports.AjaxObservable = AjaxObservable;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar AjaxSubscriber = (function (_super) {\n    __extends(AjaxSubscriber, _super);\n    function AjaxSubscriber(destination, request) {\n        _super.call(this, destination);\n        this.request = request;\n        this.done = false;\n        var headers = request.headers = request.headers || {};\n        // force CORS if requested\n        if (!request.crossDomain && !headers['X-Requested-With']) {\n            headers['X-Requested-With'] = 'XMLHttpRequest';\n        }\n        // ensure content type is set\n        if (!('Content-Type' in headers) && !(root_1.root.FormData && request.body instanceof root_1.root.FormData) && typeof request.body !== 'undefined') {\n            headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';\n        }\n        // properly serialize body\n        request.body = this.serializeBody(request.body, request.headers['Content-Type']);\n        this.send();\n    }\n    AjaxSubscriber.prototype.next = function (e) {\n        this.done = true;\n        var _a = this, xhr = _a.xhr, request = _a.request, destination = _a.destination;\n        var response = new AjaxResponse(e, xhr, request);\n        destination.next(response);\n    };\n    AjaxSubscriber.prototype.send = function () {\n        var _a = this, request = _a.request, _b = _a.request, user = _b.user, method = _b.method, url = _b.url, async = _b.async, password = _b.password, headers = _b.headers, body = _b.body;\n        var createXHR = request.createXHR;\n        var xhr = tryCatch_1.tryCatch(createXHR).call(request);\n        if (xhr === errorObject_1.errorObject) {\n            this.error(errorObject_1.errorObject.e);\n        }\n        else {\n            this.xhr = xhr;\n            // set up the events before open XHR\n            // https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest\n            // You need to add the event listeners before calling open() on the request.\n            // Otherwise the progress events will not fire.\n            this.setupEvents(xhr, request);\n            // open XHR\n            var result = void 0;\n            if (user) {\n                result = tryCatch_1.tryCatch(xhr.open).call(xhr, method, url, async, user, password);\n            }\n            else {\n                result = tryCatch_1.tryCatch(xhr.open).call(xhr, method, url, async);\n            }\n            if (result === errorObject_1.errorObject) {\n                this.error(errorObject_1.errorObject.e);\n                return null;\n            }\n            // timeout, responseType and withCredentials can be set once the XHR is open\n            if (async) {\n                xhr.timeout = request.timeout;\n                xhr.responseType = request.responseType;\n            }\n            if ('withCredentials' in xhr) {\n                xhr.withCredentials = !!request.withCredentials;\n            }\n            // set headers\n            this.setHeaders(xhr, headers);\n            // finally send the request\n            result = body ? tryCatch_1.tryCatch(xhr.send).call(xhr, body) : tryCatch_1.tryCatch(xhr.send).call(xhr);\n            if (result === errorObject_1.errorObject) {\n                this.error(errorObject_1.errorObject.e);\n                return null;\n            }\n        }\n        return xhr;\n    };\n    AjaxSubscriber.prototype.serializeBody = function (body, contentType) {\n        if (!body || typeof body === 'string') {\n            return body;\n        }\n        else if (root_1.root.FormData && body instanceof root_1.root.FormData) {\n            return body;\n        }\n        if (contentType) {\n            var splitIndex = contentType.indexOf(';');\n            if (splitIndex !== -1) {\n                contentType = contentType.substring(0, splitIndex);\n            }\n        }\n        switch (contentType) {\n            case 'application/x-www-form-urlencoded':\n                return Object.keys(body).map(function (key) { return (encodeURIComponent(key) + \"=\" + encodeURIComponent(body[key])); }).join('&');\n            case 'application/json':\n                return JSON.stringify(body);\n            default:\n                return body;\n        }\n    };\n    AjaxSubscriber.prototype.setHeaders = function (xhr, headers) {\n        for (var key in headers) {\n            if (headers.hasOwnProperty(key)) {\n                xhr.setRequestHeader(key, headers[key]);\n            }\n        }\n    };\n    AjaxSubscriber.prototype.setupEvents = function (xhr, request) {\n        var progressSubscriber = request.progressSubscriber;\n        function xhrTimeout(e) {\n            var _a = xhrTimeout, subscriber = _a.subscriber, progressSubscriber = _a.progressSubscriber, request = _a.request;\n            if (progressSubscriber) {\n                progressSubscriber.error(e);\n            }\n            subscriber.error(new AjaxTimeoutError(this, request)); //TODO: Make betterer.\n        }\n        ;\n        xhr.ontimeout = xhrTimeout;\n        xhrTimeout.request = request;\n        xhrTimeout.subscriber = this;\n        xhrTimeout.progressSubscriber = progressSubscriber;\n        if (xhr.upload && 'withCredentials' in xhr) {\n            if (progressSubscriber) {\n                var xhrProgress_1;\n                xhrProgress_1 = function (e) {\n                    var progressSubscriber = xhrProgress_1.progressSubscriber;\n                    progressSubscriber.next(e);\n                };\n                if (root_1.root.XDomainRequest) {\n                    xhr.onprogress = xhrProgress_1;\n                }\n                else {\n                    xhr.upload.onprogress = xhrProgress_1;\n                }\n                xhrProgress_1.progressSubscriber = progressSubscriber;\n            }\n            var xhrError_1;\n            xhrError_1 = function (e) {\n                var _a = xhrError_1, progressSubscriber = _a.progressSubscriber, subscriber = _a.subscriber, request = _a.request;\n                if (progressSubscriber) {\n                    progressSubscriber.error(e);\n                }\n                subscriber.error(new AjaxError('ajax error', this, request));\n            };\n            xhr.onerror = xhrError_1;\n            xhrError_1.request = request;\n            xhrError_1.subscriber = this;\n            xhrError_1.progressSubscriber = progressSubscriber;\n        }\n        function xhrReadyStateChange(e) {\n            var _a = xhrReadyStateChange, subscriber = _a.subscriber, progressSubscriber = _a.progressSubscriber, request = _a.request;\n            if (this.readyState === 4) {\n                // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)\n                var status_1 = this.status === 1223 ? 204 : this.status;\n                var response = (this.responseType === 'text' ? (this.response || this.responseText) : this.response);\n                // fix status code when it is 0 (0 status is undocumented).\n                // Occurs when accessing file resources or on Android 4.1 stock browser\n                // while retrieving files from application cache.\n                if (status_1 === 0) {\n                    status_1 = response ? 200 : 0;\n                }\n                if (200 <= status_1 && status_1 < 300) {\n                    if (progressSubscriber) {\n                        progressSubscriber.complete();\n                    }\n                    subscriber.next(e);\n                    subscriber.complete();\n                }\n                else {\n                    if (progressSubscriber) {\n                        progressSubscriber.error(e);\n                    }\n                    subscriber.error(new AjaxError('ajax error ' + status_1, this, request));\n                }\n            }\n        }\n        ;\n        xhr.onreadystatechange = xhrReadyStateChange;\n        xhrReadyStateChange.subscriber = this;\n        xhrReadyStateChange.progressSubscriber = progressSubscriber;\n        xhrReadyStateChange.request = request;\n    };\n    AjaxSubscriber.prototype.unsubscribe = function () {\n        var _a = this, done = _a.done, xhr = _a.xhr;\n        if (!done && xhr && xhr.readyState !== 4 && typeof xhr.abort === 'function') {\n            xhr.abort();\n        }\n        _super.prototype.unsubscribe.call(this);\n    };\n    return AjaxSubscriber;\n}(Subscriber_1.Subscriber));\nexports.AjaxSubscriber = AjaxSubscriber;\n/**\n * A normalized AJAX response.\n *\n * @see {@link ajax}\n *\n * @class AjaxResponse\n */\nvar AjaxResponse = (function () {\n    function AjaxResponse(originalEvent, xhr, request) {\n        this.originalEvent = originalEvent;\n        this.xhr = xhr;\n        this.request = request;\n        this.status = xhr.status;\n        this.responseType = xhr.responseType || request.responseType;\n        this.response = parseXhrResponse(this.responseType, xhr);\n    }\n    return AjaxResponse;\n}());\nexports.AjaxResponse = AjaxResponse;\n/**\n * A normalized AJAX error.\n *\n * @see {@link ajax}\n *\n * @class AjaxError\n */\nvar AjaxError = (function (_super) {\n    __extends(AjaxError, _super);\n    function AjaxError(message, xhr, request) {\n        _super.call(this, message);\n        this.message = message;\n        this.xhr = xhr;\n        this.request = request;\n        this.status = xhr.status;\n        this.responseType = xhr.responseType || request.responseType;\n        this.response = parseXhrResponse(this.responseType, xhr);\n    }\n    return AjaxError;\n}(Error));\nexports.AjaxError = AjaxError;\nfunction parseXhrResponse(responseType, xhr) {\n    switch (responseType) {\n        case 'json':\n            if ('response' in xhr) {\n                //IE does not support json as responseType, parse it internally\n                return xhr.responseType ? xhr.response : JSON.parse(xhr.response || xhr.responseText || 'null');\n            }\n            else {\n                // HACK(benlesh): TypeScript shennanigans\n                // tslint:disable-next-line:no-any latest TS seems to think xhr is \"never\" here.\n                return JSON.parse(xhr.responseText || 'null');\n            }\n        case 'xml':\n            return xhr.responseXML;\n        case 'text':\n        default:\n            // HACK(benlesh): TypeScript shennanigans\n            // tslint:disable-next-line:no-any latest TS seems to think xhr is \"never\" here.\n            return ('response' in xhr) ? xhr.response : xhr.responseText;\n    }\n}\n/**\n * @see {@link ajax}\n *\n * @class AjaxTimeoutError\n */\nvar AjaxTimeoutError = (function (_super) {\n    __extends(AjaxTimeoutError, _super);\n    function AjaxTimeoutError(xhr, request) {\n        _super.call(this, 'ajax timeout', xhr, request);\n    }\n    return AjaxTimeoutError;\n}(AjaxError));\nexports.AjaxTimeoutError = AjaxTimeoutError;\n//# sourceMappingURL=AjaxObservable.js.map","\"use strict\";\nvar AjaxObservable_1 = require('./AjaxObservable');\nexports.ajax = AjaxObservable_1.AjaxObservable.create;\n//# sourceMappingURL=ajax.js.map","\"use strict\";\nvar EmptyObservable_1 = require('./EmptyObservable');\nexports.empty = EmptyObservable_1.EmptyObservable.create;\n//# sourceMappingURL=empty.js.map","\"use strict\";\nvar FromObservable_1 = require('./FromObservable');\nexports.from = FromObservable_1.FromObservable.create;\n//# sourceMappingURL=from.js.map","\"use strict\";\nvar IntervalObservable_1 = require('./IntervalObservable');\nexports.interval = IntervalObservable_1.IntervalObservable.create;\n//# sourceMappingURL=interval.js.map","\"use strict\";\nvar ArrayObservable_1 = require('./ArrayObservable');\nexports.of = ArrayObservable_1.ArrayObservable.of;\n//# sourceMappingURL=of.js.map","\"use strict\";\nvar ErrorObservable_1 = require('./ErrorObservable');\nexports._throw = ErrorObservable_1.ErrorObservable.create;\n//# sourceMappingURL=throw.js.map","\"use strict\";\nvar catchError_1 = require('../operators/catchError');\n/**\n * Catches errors on the observable to be handled by returning a new observable or throwing an error.\n *\n * <img src=\"./img/catch.png\" width=\"100%\">\n *\n * @example <caption>Continues with a different Observable when there's an error</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n * \t   if (n == 4) {\n * \t     throw 'four!';\n *     }\n *\t   return n;\n *   })\n *   .catch(err => Observable.of('I', 'II', 'III', 'IV', 'V'))\n *   .subscribe(x => console.log(x));\n *   // 1, 2, 3, I, II, III, IV, V\n *\n * @example <caption>Retries the caught source Observable again in case of error, similar to retry() operator</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n * \t   if (n === 4) {\n * \t     throw 'four!';\n *     }\n * \t   return n;\n *   })\n *   .catch((err, caught) => caught)\n *   .take(30)\n *   .subscribe(x => console.log(x));\n *   // 1, 2, 3, 1, 2, 3, ...\n *\n * @example <caption>Throws a new error when the source Observable throws an error</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n *     if (n == 4) {\n *       throw 'four!';\n *     }\n *     return n;\n *   })\n *   .catch(err => {\n *     throw 'error in source. Details: ' + err;\n *   })\n *   .subscribe(\n *     x => console.log(x),\n *     err => console.log(err)\n *   );\n *   // 1, 2, 3, error in source. Details: four!\n *\n * @param {function} selector a function that takes as arguments `err`, which is the error, and `caught`, which\n *  is the source observable, in case you'd like to \"retry\" that observable by returning it again. Whatever observable\n *  is returned by the `selector` will be used to continue the observable chain.\n * @return {Observable} An observable that originates from either the source or the observable returned by the\n *  catch `selector` function.\n * @method catch\n * @name catch\n * @owner Observable\n */\nfunction _catch(selector) {\n    return catchError_1.catchError(selector)(this);\n}\nexports._catch = _catch;\n//# sourceMappingURL=catch.js.map","\"use strict\";\nvar combineLatest_1 = require('../operators/combineLatest');\n/* tslint:enable:max-line-length */\n/**\n * Combines multiple Observables to create an Observable whose values are\n * calculated from the latest values of each of its input Observables.\n *\n * <span class=\"informal\">Whenever any input Observable emits a value, it\n * computes a formula using the latest values from all the inputs, then emits\n * the output of that formula.</span>\n *\n * <img src=\"./img/combineLatest.png\" width=\"100%\">\n *\n * `combineLatest` combines the values from this Observable with values from\n * Observables passed as arguments. This is done by subscribing to each\n * Observable, in order, and collecting an array of each of the most recent\n * values any time any of the input Observables emits, then either taking that\n * array and passing it as arguments to an optional `project` function and\n * emitting the return value of that, or just emitting the array of recent\n * values directly if there is no `project` function.\n *\n * @example <caption>Dynamically calculate the Body-Mass Index from an Observable of weight and one for height</caption>\n * var weight = Rx.Observable.of(70, 72, 76, 79, 75);\n * var height = Rx.Observable.of(1.76, 1.77, 1.78);\n * var bmi = weight.combineLatest(height, (w, h) => w / (h * h));\n * bmi.subscribe(x => console.log('BMI is ' + x));\n *\n * // With output to console:\n * // BMI is 24.212293388429753\n * // BMI is 23.93948099205209\n * // BMI is 23.671253629592222\n *\n * @see {@link combineAll}\n * @see {@link merge}\n * @see {@link withLatestFrom}\n *\n * @param {ObservableInput} other An input Observable to combine with the source\n * Observable. More than one input Observables may be given as argument.\n * @param {function} [project] An optional function to project the values from\n * the combined latest values into a new value on the output Observable.\n * @return {Observable} An Observable of projected values from the most recent\n * values from each input Observable, or an array of the most recent values from\n * each input Observable.\n * @method combineLatest\n * @owner Observable\n */\nfunction combineLatest() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    return combineLatest_1.combineLatest.apply(void 0, observables)(this);\n}\nexports.combineLatest = combineLatest;\n//# sourceMappingURL=combineLatest.js.map","\"use strict\";\nvar concatMap_1 = require('../operators/concatMap');\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable, in a serialized fashion waiting for each one to complete before\n * merging the next.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link concatAll}.</span>\n *\n * <img src=\"./img/concatMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an (so-called \"inner\") Observable. Each new inner Observable is\n * concatenated with the previous inner Observable.\n *\n * __Warning:__ if source values arrive endlessly and faster than their\n * corresponding inner Observables can complete, it will result in memory issues\n * as inner Observables amass in an unbounded buffer waiting for their turn to\n * be subscribed to.\n *\n * Note: `concatMap` is equivalent to `mergeMap` with concurrency parameter set\n * to `1`.\n *\n * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var result = clicks.concatMap(ev => Rx.Observable.interval(1000).take(4));\n * result.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // (results are not concurrent)\n * // For every click on the \"document\" it will emit values 0 to 3 spaced\n * // on a 1000ms interval\n * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3\n *\n * @see {@link concat}\n * @see {@link concatAll}\n * @see {@link concatMapTo}\n * @see {@link exhaustMap}\n * @see {@link mergeMap}\n * @see {@link switchMap}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and taking values from each projected inner\n * Observable sequentially.\n * @method concatMap\n * @owner Observable\n */\nfunction concatMap(project, resultSelector) {\n    return concatMap_1.concatMap(project, resultSelector)(this);\n}\nexports.concatMap = concatMap;\n//# sourceMappingURL=concatMap.js.map","\"use strict\";\nvar count_1 = require('../operators/count');\n/**\n * Counts the number of emissions on the source and emits that number when the\n * source completes.\n *\n * <span class=\"informal\">Tells how many values were emitted, when the source\n * completes.</span>\n *\n * <img src=\"./img/count.png\" width=\"100%\">\n *\n * `count` transforms an Observable that emits values into an Observable that\n * emits a single value that represents the number of values emitted by the\n * source Observable. If the source Observable terminates with an error, `count`\n * will pass this error notification along without emitting a value first. If\n * the source Observable does not terminate at all, `count` will neither emit\n * a value nor terminate. This operator takes an optional `predicate` function\n * as argument, in which case the output emission will represent the number of\n * source values that matched `true` with the `predicate`.\n *\n * @example <caption>Counts how many seconds have passed before the first click happened</caption>\n * var seconds = Rx.Observable.interval(1000);\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var secondsBeforeClick = seconds.takeUntil(clicks);\n * var result = secondsBeforeClick.count();\n * result.subscribe(x => console.log(x));\n *\n * @example <caption>Counts how many odd numbers are there between 1 and 7</caption>\n * var numbers = Rx.Observable.range(1, 7);\n * var result = numbers.count(i => i % 2 === 1);\n * result.subscribe(x => console.log(x));\n *\n * // Results in:\n * // 4\n *\n * @see {@link max}\n * @see {@link min}\n * @see {@link reduce}\n *\n * @param {function(value: T, i: number, source: Observable<T>): boolean} [predicate] A\n * boolean function to select what values are to be counted. It is provided with\n * arguments of:\n * - `value`: the value from the source Observable.\n * - `index`: the (zero-based) \"index\" of the value from the source Observable.\n * - `source`: the source Observable instance itself.\n * @return {Observable} An Observable of one number that represents the count as\n * described above.\n * @method count\n * @owner Observable\n */\nfunction count(predicate) {\n    return count_1.count(predicate)(this);\n}\nexports.count = count;\n//# sourceMappingURL=count.js.map","\"use strict\";\nvar async_1 = require('../scheduler/async');\nvar delay_1 = require('../operators/delay');\n/**\n * Delays the emission of items from the source Observable by a given timeout or\n * until a given Date.\n *\n * <span class=\"informal\">Time shifts each item by some specified amount of\n * milliseconds.</span>\n *\n * <img src=\"./img/delay.png\" width=\"100%\">\n *\n * If the delay argument is a Number, this operator time shifts the source\n * Observable by that amount of time expressed in milliseconds. The relative\n * time intervals between the values are preserved.\n *\n * If the delay argument is a Date, this operator time shifts the start of the\n * Observable execution until the given date occurs.\n *\n * @example <caption>Delay each click by one second</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var delayedClicks = clicks.delay(1000); // each click emitted after 1 second\n * delayedClicks.subscribe(x => console.log(x));\n *\n * @example <caption>Delay all clicks until a future date happens</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var date = new Date('March 15, 2050 12:00:00'); // in the future\n * var delayedClicks = clicks.delay(date); // click emitted only after that date\n * delayedClicks.subscribe(x => console.log(x));\n *\n * @see {@link debounceTime}\n * @see {@link delayWhen}\n *\n * @param {number|Date} delay The delay duration in milliseconds (a `number`) or\n * a `Date` until which the emission of the source items is delayed.\n * @param {Scheduler} [scheduler=async] The IScheduler to use for\n * managing the timers that handle the time-shift for each item.\n * @return {Observable} An Observable that delays the emissions of the source\n * Observable by the specified timeout or Date.\n * @method delay\n * @owner Observable\n */\nfunction delay(delay, scheduler) {\n    if (scheduler === void 0) { scheduler = async_1.async; }\n    return delay_1.delay(delay, scheduler)(this);\n}\nexports.delay = delay;\n//# sourceMappingURL=delay.js.map","\"use strict\";\nvar tap_1 = require('../operators/tap');\n/* tslint:enable:max-line-length */\n/**\n * Perform a side effect for every emission on the source Observable, but return\n * an Observable that is identical to the source.\n *\n * <span class=\"informal\">Intercepts each emission on the source and runs a\n * function, but returns an output which is identical to the source as long as errors don't occur.</span>\n *\n * <img src=\"./img/do.png\" width=\"100%\">\n *\n * Returns a mirrored Observable of the source Observable, but modified so that\n * the provided Observer is called to perform a side effect for every value,\n * error, and completion emitted by the source. Any errors that are thrown in\n * the aforementioned Observer or handlers are safely sent down the error path\n * of the output Observable.\n *\n * This operator is useful for debugging your Observables for the correct values\n * or performing other side effects.\n *\n * Note: this is different to a `subscribe` on the Observable. If the Observable\n * returned by `do` is not subscribed, the side effects specified by the\n * Observer will never happen. `do` therefore simply spies on existing\n * execution, it does not trigger an execution to happen like `subscribe` does.\n *\n * @example <caption>Map every click to the clientX position of that click, while also logging the click event</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks\n *   .do(ev => console.log(ev))\n *   .map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link map}\n * @see {@link subscribe}\n *\n * @param {Observer|function} [nextOrObserver] A normal Observer object or a\n * callback for `next`.\n * @param {function} [error] Callback for errors in the source.\n * @param {function} [complete] Callback for the completion of the source.\n * @return {Observable} An Observable identical to the source, but runs the\n * specified Observer or callback(s) for each item.\n * @method do\n * @name do\n * @owner Observable\n */\nfunction _do(nextOrObserver, error, complete) {\n    return tap_1.tap(nextOrObserver, error, complete)(this);\n}\nexports._do = _do;\n//# sourceMappingURL=do.js.map","\"use strict\";\nvar filter_1 = require('../operators/filter');\n/* tslint:enable:max-line-length */\n/**\n * Filter items emitted by the source Observable by only emitting those that\n * satisfy a specified predicate.\n *\n * <span class=\"informal\">Like\n * [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),\n * it only emits a value from the source if it passes a criterion function.</span>\n *\n * <img src=\"./img/filter.png\" width=\"100%\">\n *\n * Similar to the well-known `Array.prototype.filter` method, this operator\n * takes values from the source Observable, passes them through a `predicate`\n * function and only emits those values that yielded `true`.\n *\n * @example <caption>Emit only click events whose target was a DIV element</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var clicksOnDivs = clicks.filter(ev => ev.target.tagName === 'DIV');\n * clicksOnDivs.subscribe(x => console.log(x));\n *\n * @see {@link distinct}\n * @see {@link distinctUntilChanged}\n * @see {@link distinctUntilKeyChanged}\n * @see {@link ignoreElements}\n * @see {@link partition}\n * @see {@link skip}\n *\n * @param {function(value: T, index: number): boolean} predicate A function that\n * evaluates each value emitted by the source Observable. If it returns `true`,\n * the value is emitted, if `false` the value is not passed to the output\n * Observable. The `index` parameter is the number `i` for the i-th source\n * emission that has happened since the subscription, starting from the number\n * `0`.\n * @param {any} [thisArg] An optional argument to determine the value of `this`\n * in the `predicate` function.\n * @return {Observable} An Observable of values from the source that were\n * allowed by the `predicate` function.\n * @method filter\n * @owner Observable\n */\nfunction filter(predicate, thisArg) {\n    return filter_1.filter(predicate, thisArg)(this);\n}\nexports.filter = filter;\n//# sourceMappingURL=filter.js.map","\"use strict\";\nvar map_1 = require('../operators/map');\n/**\n * Applies a given `project` function to each value emitted by the source\n * Observable, and emits the resulting values as an Observable.\n *\n * <span class=\"informal\">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map),\n * it passes each source value through a transformation function to get\n * corresponding output values.</span>\n *\n * <img src=\"./img/map.png\" width=\"100%\">\n *\n * Similar to the well known `Array.prototype.map` function, this operator\n * applies a projection to each value and emits that projection in the output\n * Observable.\n *\n * @example <caption>Map every click to the clientX position of that click</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks.map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link mapTo}\n * @see {@link pluck}\n *\n * @param {function(value: T, index: number): R} project The function to apply\n * to each `value` emitted by the source Observable. The `index` parameter is\n * the number `i` for the i-th emission that has happened since the\n * subscription, starting from the number `0`.\n * @param {any} [thisArg] An optional argument to define what `this` is in the\n * `project` function.\n * @return {Observable<R>} An Observable that emits the values from the source\n * Observable transformed by the given `project` function.\n * @method map\n * @owner Observable\n */\nfunction map(project, thisArg) {\n    return map_1.map(project, thisArg)(this);\n}\nexports.map = map;\n//# sourceMappingURL=map.js.map","\"use strict\";\nvar mergeMap_1 = require('../operators/mergeMap');\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link mergeAll}.</span>\n *\n * <img src=\"./img/mergeMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an Observable, and then merging those resulting Observables and\n * emitting the results of this merger.\n *\n * @example <caption>Map and flatten each letter to an Observable ticking every 1 second</caption>\n * var letters = Rx.Observable.of('a', 'b', 'c');\n * var result = letters.mergeMap(x =>\n *   Rx.Observable.interval(1000).map(i => x+i)\n * );\n * result.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // a0\n * // b0\n * // c0\n * // a1\n * // b1\n * // c1\n * // continues to list a,b,c with respective ascending integers\n *\n * @see {@link concatMap}\n * @see {@link exhaustMap}\n * @see {@link merge}\n * @see {@link mergeAll}\n * @see {@link mergeMapTo}\n * @see {@link mergeScan}\n * @see {@link switchMap}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input\n * Observables being subscribed to concurrently.\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and merging the results of the Observables obtained\n * from this transformation.\n * @method mergeMap\n * @owner Observable\n */\nfunction mergeMap(project, resultSelector, concurrent) {\n    if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n    return mergeMap_1.mergeMap(project, resultSelector, concurrent)(this);\n}\nexports.mergeMap = mergeMap;\n//# sourceMappingURL=mergeMap.js.map","\"use strict\";\nvar retryWhen_1 = require('../operators/retryWhen');\n/**\n * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable\n * calls `error`, this method will emit the Throwable that caused the error to the Observable returned from `notifier`.\n * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child\n * subscription. Otherwise this method will resubscribe to the source Observable.\n *\n * <img src=\"./img/retryWhen.png\" width=\"100%\">\n *\n * @param {function(errors: Observable): Observable} notifier - Receives an Observable of notifications with which a\n * user can `complete` or `error`, aborting the retry.\n * @return {Observable} The source Observable modified with retry logic.\n * @method retryWhen\n * @owner Observable\n */\nfunction retryWhen(notifier) {\n    return retryWhen_1.retryWhen(notifier)(this);\n}\nexports.retryWhen = retryWhen;\n//# sourceMappingURL=retryWhen.js.map","\"use strict\";\nvar share_1 = require('../operators/share');\n/**\n * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one\n * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will\n * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`.\n *\n * This behaves similarly to .publish().refCount(), with a behavior difference when the source observable emits complete.\n * .publish().refCount() will not resubscribe to the original source, however .share() will resubscribe to the original source.\n * Observable.of(\"test\").publish().refCount() will not re-emit \"test\" on new subscriptions, Observable.of(\"test\").share() will\n * re-emit \"test\" to new subscriptions.\n *\n * <img src=\"./img/share.png\" width=\"100%\">\n *\n * @return {Observable<T>} An Observable that upon connection causes the source Observable to emit items to its Observers.\n * @method share\n * @owner Observable\n */\nfunction share() {\n    return share_1.share()(this);\n}\nexports.share = share;\n;\n//# sourceMappingURL=share.js.map","\"use strict\";\nvar take_1 = require('../operators/take');\n/**\n * Emits only the first `count` values emitted by the source Observable.\n *\n * <span class=\"informal\">Takes the first `count` values from the source, then\n * completes.</span>\n *\n * <img src=\"./img/take.png\" width=\"100%\">\n *\n * `take` returns an Observable that emits only the first `count` values emitted\n * by the source Observable. If the source emits fewer than `count` values then\n * all of its values are emitted. After that, it completes, regardless if the\n * source completes.\n *\n * @example <caption>Take the first 5 seconds of an infinite 1-second interval Observable</caption>\n * var interval = Rx.Observable.interval(1000);\n * var five = interval.take(5);\n * five.subscribe(x => console.log(x));\n *\n * @see {@link takeLast}\n * @see {@link takeUntil}\n * @see {@link takeWhile}\n * @see {@link skip}\n *\n * @throws {ArgumentOutOfRangeError} When using `take(i)`, it delivers an\n * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.\n *\n * @param {number} count The maximum number of `next` values to emit.\n * @return {Observable<T>} An Observable that emits only the first `count`\n * values emitted by the source Observable, or all of the values from the source\n * if the source emits fewer than `count` values.\n * @method take\n * @owner Observable\n */\nfunction take(count) {\n    return take_1.take(count)(this);\n}\nexports.take = take;\n//# sourceMappingURL=take.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\n/**\n * Catches errors on the observable to be handled by returning a new observable or throwing an error.\n *\n * <img src=\"./img/catch.png\" width=\"100%\">\n *\n * @example <caption>Continues with a different Observable when there's an error</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n * \t   if (n == 4) {\n * \t     throw 'four!';\n *     }\n *\t   return n;\n *   })\n *   .catch(err => Observable.of('I', 'II', 'III', 'IV', 'V'))\n *   .subscribe(x => console.log(x));\n *   // 1, 2, 3, I, II, III, IV, V\n *\n * @example <caption>Retries the caught source Observable again in case of error, similar to retry() operator</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n * \t   if (n === 4) {\n * \t     throw 'four!';\n *     }\n * \t   return n;\n *   })\n *   .catch((err, caught) => caught)\n *   .take(30)\n *   .subscribe(x => console.log(x));\n *   // 1, 2, 3, 1, 2, 3, ...\n *\n * @example <caption>Throws a new error when the source Observable throws an error</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n *     if (n == 4) {\n *       throw 'four!';\n *     }\n *     return n;\n *   })\n *   .catch(err => {\n *     throw 'error in source. Details: ' + err;\n *   })\n *   .subscribe(\n *     x => console.log(x),\n *     err => console.log(err)\n *   );\n *   // 1, 2, 3, error in source. Details: four!\n *\n * @param {function} selector a function that takes as arguments `err`, which is the error, and `caught`, which\n *  is the source observable, in case you'd like to \"retry\" that observable by returning it again. Whatever observable\n *  is returned by the `selector` will be used to continue the observable chain.\n * @return {Observable} An observable that originates from either the source or the observable returned by the\n *  catch `selector` function.\n * @name catchError\n */\nfunction catchError(selector) {\n    return function catchErrorOperatorFunction(source) {\n        var operator = new CatchOperator(selector);\n        var caught = source.lift(operator);\n        return (operator.caught = caught);\n    };\n}\nexports.catchError = catchError;\nvar CatchOperator = (function () {\n    function CatchOperator(selector) {\n        this.selector = selector;\n    }\n    CatchOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new CatchSubscriber(subscriber, this.selector, this.caught));\n    };\n    return CatchOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar CatchSubscriber = (function (_super) {\n    __extends(CatchSubscriber, _super);\n    function CatchSubscriber(destination, selector, caught) {\n        _super.call(this, destination);\n        this.selector = selector;\n        this.caught = caught;\n    }\n    // NOTE: overriding `error` instead of `_error` because we don't want\n    // to have this flag this subscriber as `isStopped`. We can mimic the\n    // behavior of the RetrySubscriber (from the `retry` operator), where\n    // we unsubscribe from our source chain, reset our Subscriber flags,\n    // then subscribe to the selector result.\n    CatchSubscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            var result = void 0;\n            try {\n                result = this.selector(err, this.caught);\n            }\n            catch (err2) {\n                _super.prototype.error.call(this, err2);\n                return;\n            }\n            this._unsubscribeAndRecycle();\n            this.add(subscribeToResult_1.subscribeToResult(this, result));\n        }\n    };\n    return CatchSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=catchError.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar ArrayObservable_1 = require('../observable/ArrayObservable');\nvar isArray_1 = require('../util/isArray');\nvar OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\nvar none = {};\n/* tslint:enable:max-line-length */\n/**\n * Combines multiple Observables to create an Observable whose values are\n * calculated from the latest values of each of its input Observables.\n *\n * <span class=\"informal\">Whenever any input Observable emits a value, it\n * computes a formula using the latest values from all the inputs, then emits\n * the output of that formula.</span>\n *\n * <img src=\"./img/combineLatest.png\" width=\"100%\">\n *\n * `combineLatest` combines the values from this Observable with values from\n * Observables passed as arguments. This is done by subscribing to each\n * Observable, in order, and collecting an array of each of the most recent\n * values any time any of the input Observables emits, then either taking that\n * array and passing it as arguments to an optional `project` function and\n * emitting the return value of that, or just emitting the array of recent\n * values directly if there is no `project` function.\n *\n * @example <caption>Dynamically calculate the Body-Mass Index from an Observable of weight and one for height</caption>\n * var weight = Rx.Observable.of(70, 72, 76, 79, 75);\n * var height = Rx.Observable.of(1.76, 1.77, 1.78);\n * var bmi = weight.combineLatest(height, (w, h) => w / (h * h));\n * bmi.subscribe(x => console.log('BMI is ' + x));\n *\n * // With output to console:\n * // BMI is 24.212293388429753\n * // BMI is 23.93948099205209\n * // BMI is 23.671253629592222\n *\n * @see {@link combineAll}\n * @see {@link merge}\n * @see {@link withLatestFrom}\n *\n * @param {ObservableInput} other An input Observable to combine with the source\n * Observable. More than one input Observables may be given as argument.\n * @param {function} [project] An optional function to project the values from\n * the combined latest values into a new value on the output Observable.\n * @return {Observable} An Observable of projected values from the most recent\n * values from each input Observable, or an array of the most recent values from\n * each input Observable.\n * @method combineLatest\n * @owner Observable\n */\nfunction combineLatest() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    var project = null;\n    if (typeof observables[observables.length - 1] === 'function') {\n        project = observables.pop();\n    }\n    // if the first and only other argument besides the resultSelector is an array\n    // assume it's been called with `combineLatest([obs1, obs2, obs3], project)`\n    if (observables.length === 1 && isArray_1.isArray(observables[0])) {\n        observables = observables[0].slice();\n    }\n    return function (source) { return source.lift.call(new ArrayObservable_1.ArrayObservable([source].concat(observables)), new CombineLatestOperator(project)); };\n}\nexports.combineLatest = combineLatest;\nvar CombineLatestOperator = (function () {\n    function CombineLatestOperator(project) {\n        this.project = project;\n    }\n    CombineLatestOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new CombineLatestSubscriber(subscriber, this.project));\n    };\n    return CombineLatestOperator;\n}());\nexports.CombineLatestOperator = CombineLatestOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar CombineLatestSubscriber = (function (_super) {\n    __extends(CombineLatestSubscriber, _super);\n    function CombineLatestSubscriber(destination, project) {\n        _super.call(this, destination);\n        this.project = project;\n        this.active = 0;\n        this.values = [];\n        this.observables = [];\n    }\n    CombineLatestSubscriber.prototype._next = function (observable) {\n        this.values.push(none);\n        this.observables.push(observable);\n    };\n    CombineLatestSubscriber.prototype._complete = function () {\n        var observables = this.observables;\n        var len = observables.length;\n        if (len === 0) {\n            this.destination.complete();\n        }\n        else {\n            this.active = len;\n            this.toRespond = len;\n            for (var i = 0; i < len; i++) {\n                var observable = observables[i];\n                this.add(subscribeToResult_1.subscribeToResult(this, observable, observable, i));\n            }\n        }\n    };\n    CombineLatestSubscriber.prototype.notifyComplete = function (unused) {\n        if ((this.active -= 1) === 0) {\n            this.destination.complete();\n        }\n    };\n    CombineLatestSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        var values = this.values;\n        var oldVal = values[outerIndex];\n        var toRespond = !this.toRespond\n            ? 0\n            : oldVal === none ? --this.toRespond : this.toRespond;\n        values[outerIndex] = innerValue;\n        if (toRespond === 0) {\n            if (this.project) {\n                this._tryProject(values);\n            }\n            else {\n                this.destination.next(values.slice());\n            }\n        }\n    };\n    CombineLatestSubscriber.prototype._tryProject = function (values) {\n        var result;\n        try {\n            result = this.project.apply(this, values);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return CombineLatestSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\nexports.CombineLatestSubscriber = CombineLatestSubscriber;\n//# sourceMappingURL=combineLatest.js.map","\"use strict\";\nvar mergeMap_1 = require('./mergeMap');\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable, in a serialized fashion waiting for each one to complete before\n * merging the next.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link concatAll}.</span>\n *\n * <img src=\"./img/concatMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an (so-called \"inner\") Observable. Each new inner Observable is\n * concatenated with the previous inner Observable.\n *\n * __Warning:__ if source values arrive endlessly and faster than their\n * corresponding inner Observables can complete, it will result in memory issues\n * as inner Observables amass in an unbounded buffer waiting for their turn to\n * be subscribed to.\n *\n * Note: `concatMap` is equivalent to `mergeMap` with concurrency parameter set\n * to `1`.\n *\n * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var result = clicks.concatMap(ev => Rx.Observable.interval(1000).take(4));\n * result.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // (results are not concurrent)\n * // For every click on the \"document\" it will emit values 0 to 3 spaced\n * // on a 1000ms interval\n * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3\n *\n * @see {@link concat}\n * @see {@link concatAll}\n * @see {@link concatMapTo}\n * @see {@link exhaustMap}\n * @see {@link mergeMap}\n * @see {@link switchMap}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and taking values from each projected inner\n * Observable sequentially.\n * @method concatMap\n * @owner Observable\n */\nfunction concatMap(project, resultSelector) {\n    return mergeMap_1.mergeMap(project, resultSelector, 1);\n}\nexports.concatMap = concatMap;\n//# sourceMappingURL=concatMap.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/**\n * Counts the number of emissions on the source and emits that number when the\n * source completes.\n *\n * <span class=\"informal\">Tells how many values were emitted, when the source\n * completes.</span>\n *\n * <img src=\"./img/count.png\" width=\"100%\">\n *\n * `count` transforms an Observable that emits values into an Observable that\n * emits a single value that represents the number of values emitted by the\n * source Observable. If the source Observable terminates with an error, `count`\n * will pass this error notification along without emitting a value first. If\n * the source Observable does not terminate at all, `count` will neither emit\n * a value nor terminate. This operator takes an optional `predicate` function\n * as argument, in which case the output emission will represent the number of\n * source values that matched `true` with the `predicate`.\n *\n * @example <caption>Counts how many seconds have passed before the first click happened</caption>\n * var seconds = Rx.Observable.interval(1000);\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var secondsBeforeClick = seconds.takeUntil(clicks);\n * var result = secondsBeforeClick.count();\n * result.subscribe(x => console.log(x));\n *\n * @example <caption>Counts how many odd numbers are there between 1 and 7</caption>\n * var numbers = Rx.Observable.range(1, 7);\n * var result = numbers.count(i => i % 2 === 1);\n * result.subscribe(x => console.log(x));\n *\n * // Results in:\n * // 4\n *\n * @see {@link max}\n * @see {@link min}\n * @see {@link reduce}\n *\n * @param {function(value: T, i: number, source: Observable<T>): boolean} [predicate] A\n * boolean function to select what values are to be counted. It is provided with\n * arguments of:\n * - `value`: the value from the source Observable.\n * - `index`: the (zero-based) \"index\" of the value from the source Observable.\n * - `source`: the source Observable instance itself.\n * @return {Observable} An Observable of one number that represents the count as\n * described above.\n * @method count\n * @owner Observable\n */\nfunction count(predicate) {\n    return function (source) { return source.lift(new CountOperator(predicate, source)); };\n}\nexports.count = count;\nvar CountOperator = (function () {\n    function CountOperator(predicate, source) {\n        this.predicate = predicate;\n        this.source = source;\n    }\n    CountOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new CountSubscriber(subscriber, this.predicate, this.source));\n    };\n    return CountOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar CountSubscriber = (function (_super) {\n    __extends(CountSubscriber, _super);\n    function CountSubscriber(destination, predicate, source) {\n        _super.call(this, destination);\n        this.predicate = predicate;\n        this.source = source;\n        this.count = 0;\n        this.index = 0;\n    }\n    CountSubscriber.prototype._next = function (value) {\n        if (this.predicate) {\n            this._tryPredicate(value);\n        }\n        else {\n            this.count++;\n        }\n    };\n    CountSubscriber.prototype._tryPredicate = function (value) {\n        var result;\n        try {\n            result = this.predicate(value, this.index++, this.source);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        if (result) {\n            this.count++;\n        }\n    };\n    CountSubscriber.prototype._complete = function () {\n        this.destination.next(this.count);\n        this.destination.complete();\n    };\n    return CountSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=count.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar async_1 = require('../scheduler/async');\nvar isDate_1 = require('../util/isDate');\nvar Subscriber_1 = require('../Subscriber');\nvar Notification_1 = require('../Notification');\n/**\n * Delays the emission of items from the source Observable by a given timeout or\n * until a given Date.\n *\n * <span class=\"informal\">Time shifts each item by some specified amount of\n * milliseconds.</span>\n *\n * <img src=\"./img/delay.png\" width=\"100%\">\n *\n * If the delay argument is a Number, this operator time shifts the source\n * Observable by that amount of time expressed in milliseconds. The relative\n * time intervals between the values are preserved.\n *\n * If the delay argument is a Date, this operator time shifts the start of the\n * Observable execution until the given date occurs.\n *\n * @example <caption>Delay each click by one second</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var delayedClicks = clicks.delay(1000); // each click emitted after 1 second\n * delayedClicks.subscribe(x => console.log(x));\n *\n * @example <caption>Delay all clicks until a future date happens</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var date = new Date('March 15, 2050 12:00:00'); // in the future\n * var delayedClicks = clicks.delay(date); // click emitted only after that date\n * delayedClicks.subscribe(x => console.log(x));\n *\n * @see {@link debounceTime}\n * @see {@link delayWhen}\n *\n * @param {number|Date} delay The delay duration in milliseconds (a `number`) or\n * a `Date` until which the emission of the source items is delayed.\n * @param {Scheduler} [scheduler=async] The IScheduler to use for\n * managing the timers that handle the time-shift for each item.\n * @return {Observable} An Observable that delays the emissions of the source\n * Observable by the specified timeout or Date.\n * @method delay\n * @owner Observable\n */\nfunction delay(delay, scheduler) {\n    if (scheduler === void 0) { scheduler = async_1.async; }\n    var absoluteDelay = isDate_1.isDate(delay);\n    var delayFor = absoluteDelay ? (+delay - scheduler.now()) : Math.abs(delay);\n    return function (source) { return source.lift(new DelayOperator(delayFor, scheduler)); };\n}\nexports.delay = delay;\nvar DelayOperator = (function () {\n    function DelayOperator(delay, scheduler) {\n        this.delay = delay;\n        this.scheduler = scheduler;\n    }\n    DelayOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new DelaySubscriber(subscriber, this.delay, this.scheduler));\n    };\n    return DelayOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar DelaySubscriber = (function (_super) {\n    __extends(DelaySubscriber, _super);\n    function DelaySubscriber(destination, delay, scheduler) {\n        _super.call(this, destination);\n        this.delay = delay;\n        this.scheduler = scheduler;\n        this.queue = [];\n        this.active = false;\n        this.errored = false;\n    }\n    DelaySubscriber.dispatch = function (state) {\n        var source = state.source;\n        var queue = source.queue;\n        var scheduler = state.scheduler;\n        var destination = state.destination;\n        while (queue.length > 0 && (queue[0].time - scheduler.now()) <= 0) {\n            queue.shift().notification.observe(destination);\n        }\n        if (queue.length > 0) {\n            var delay_1 = Math.max(0, queue[0].time - scheduler.now());\n            this.schedule(state, delay_1);\n        }\n        else {\n            this.unsubscribe();\n            source.active = false;\n        }\n    };\n    DelaySubscriber.prototype._schedule = function (scheduler) {\n        this.active = true;\n        this.add(scheduler.schedule(DelaySubscriber.dispatch, this.delay, {\n            source: this, destination: this.destination, scheduler: scheduler\n        }));\n    };\n    DelaySubscriber.prototype.scheduleNotification = function (notification) {\n        if (this.errored === true) {\n            return;\n        }\n        var scheduler = this.scheduler;\n        var message = new DelayMessage(scheduler.now() + this.delay, notification);\n        this.queue.push(message);\n        if (this.active === false) {\n            this._schedule(scheduler);\n        }\n    };\n    DelaySubscriber.prototype._next = function (value) {\n        this.scheduleNotification(Notification_1.Notification.createNext(value));\n    };\n    DelaySubscriber.prototype._error = function (err) {\n        this.errored = true;\n        this.queue = [];\n        this.destination.error(err);\n    };\n    DelaySubscriber.prototype._complete = function () {\n        this.scheduleNotification(Notification_1.Notification.createComplete());\n    };\n    return DelaySubscriber;\n}(Subscriber_1.Subscriber));\nvar DelayMessage = (function () {\n    function DelayMessage(time, notification) {\n        this.time = time;\n        this.notification = notification;\n    }\n    return DelayMessage;\n}());\n//# sourceMappingURL=delay.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/* tslint:enable:max-line-length */\n/**\n * Filter items emitted by the source Observable by only emitting those that\n * satisfy a specified predicate.\n *\n * <span class=\"informal\">Like\n * [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),\n * it only emits a value from the source if it passes a criterion function.</span>\n *\n * <img src=\"./img/filter.png\" width=\"100%\">\n *\n * Similar to the well-known `Array.prototype.filter` method, this operator\n * takes values from the source Observable, passes them through a `predicate`\n * function and only emits those values that yielded `true`.\n *\n * @example <caption>Emit only click events whose target was a DIV element</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var clicksOnDivs = clicks.filter(ev => ev.target.tagName === 'DIV');\n * clicksOnDivs.subscribe(x => console.log(x));\n *\n * @see {@link distinct}\n * @see {@link distinctUntilChanged}\n * @see {@link distinctUntilKeyChanged}\n * @see {@link ignoreElements}\n * @see {@link partition}\n * @see {@link skip}\n *\n * @param {function(value: T, index: number): boolean} predicate A function that\n * evaluates each value emitted by the source Observable. If it returns `true`,\n * the value is emitted, if `false` the value is not passed to the output\n * Observable. The `index` parameter is the number `i` for the i-th source\n * emission that has happened since the subscription, starting from the number\n * `0`.\n * @param {any} [thisArg] An optional argument to determine the value of `this`\n * in the `predicate` function.\n * @return {Observable} An Observable of values from the source that were\n * allowed by the `predicate` function.\n * @method filter\n * @owner Observable\n */\nfunction filter(predicate, thisArg) {\n    return function filterOperatorFunction(source) {\n        return source.lift(new FilterOperator(predicate, thisArg));\n    };\n}\nexports.filter = filter;\nvar FilterOperator = (function () {\n    function FilterOperator(predicate, thisArg) {\n        this.predicate = predicate;\n        this.thisArg = thisArg;\n    }\n    FilterOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));\n    };\n    return FilterOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar FilterSubscriber = (function (_super) {\n    __extends(FilterSubscriber, _super);\n    function FilterSubscriber(destination, predicate, thisArg) {\n        _super.call(this, destination);\n        this.predicate = predicate;\n        this.thisArg = thisArg;\n        this.count = 0;\n    }\n    // the try catch block below is left specifically for\n    // optimization and perf reasons. a tryCatcher is not necessary here.\n    FilterSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.predicate.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        if (result) {\n            this.destination.next(value);\n        }\n    };\n    return FilterSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=filter.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/**\n * Applies a given `project` function to each value emitted by the source\n * Observable, and emits the resulting values as an Observable.\n *\n * <span class=\"informal\">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map),\n * it passes each source value through a transformation function to get\n * corresponding output values.</span>\n *\n * <img src=\"./img/map.png\" width=\"100%\">\n *\n * Similar to the well known `Array.prototype.map` function, this operator\n * applies a projection to each value and emits that projection in the output\n * Observable.\n *\n * @example <caption>Map every click to the clientX position of that click</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks.map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link mapTo}\n * @see {@link pluck}\n *\n * @param {function(value: T, index: number): R} project The function to apply\n * to each `value` emitted by the source Observable. The `index` parameter is\n * the number `i` for the i-th emission that has happened since the\n * subscription, starting from the number `0`.\n * @param {any} [thisArg] An optional argument to define what `this` is in the\n * `project` function.\n * @return {Observable<R>} An Observable that emits the values from the source\n * Observable transformed by the given `project` function.\n * @method map\n * @owner Observable\n */\nfunction map(project, thisArg) {\n    return function mapOperation(source) {\n        if (typeof project !== 'function') {\n            throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');\n        }\n        return source.lift(new MapOperator(project, thisArg));\n    };\n}\nexports.map = map;\nvar MapOperator = (function () {\n    function MapOperator(project, thisArg) {\n        this.project = project;\n        this.thisArg = thisArg;\n    }\n    MapOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));\n    };\n    return MapOperator;\n}());\nexports.MapOperator = MapOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar MapSubscriber = (function (_super) {\n    __extends(MapSubscriber, _super);\n    function MapSubscriber(destination, project, thisArg) {\n        _super.call(this, destination);\n        this.project = project;\n        this.count = 0;\n        this.thisArg = thisArg || this;\n    }\n    // NOTE: This looks unoptimized, but it's actually purposefully NOT\n    // using try/catch optimizations.\n    MapSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.project.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return MapSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=map.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar subscribeToResult_1 = require('../util/subscribeToResult');\nvar OuterSubscriber_1 = require('../OuterSubscriber');\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link mergeAll}.</span>\n *\n * <img src=\"./img/mergeMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an Observable, and then merging those resulting Observables and\n * emitting the results of this merger.\n *\n * @example <caption>Map and flatten each letter to an Observable ticking every 1 second</caption>\n * var letters = Rx.Observable.of('a', 'b', 'c');\n * var result = letters.mergeMap(x =>\n *   Rx.Observable.interval(1000).map(i => x+i)\n * );\n * result.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // a0\n * // b0\n * // c0\n * // a1\n * // b1\n * // c1\n * // continues to list a,b,c with respective ascending integers\n *\n * @see {@link concatMap}\n * @see {@link exhaustMap}\n * @see {@link merge}\n * @see {@link mergeAll}\n * @see {@link mergeMapTo}\n * @see {@link mergeScan}\n * @see {@link switchMap}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input\n * Observables being subscribed to concurrently.\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and merging the results of the Observables obtained\n * from this transformation.\n * @method mergeMap\n * @owner Observable\n */\nfunction mergeMap(project, resultSelector, concurrent) {\n    if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n    return function mergeMapOperatorFunction(source) {\n        if (typeof resultSelector === 'number') {\n            concurrent = resultSelector;\n            resultSelector = null;\n        }\n        return source.lift(new MergeMapOperator(project, resultSelector, concurrent));\n    };\n}\nexports.mergeMap = mergeMap;\nvar MergeMapOperator = (function () {\n    function MergeMapOperator(project, resultSelector, concurrent) {\n        if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n        this.project = project;\n        this.resultSelector = resultSelector;\n        this.concurrent = concurrent;\n    }\n    MergeMapOperator.prototype.call = function (observer, source) {\n        return source.subscribe(new MergeMapSubscriber(observer, this.project, this.resultSelector, this.concurrent));\n    };\n    return MergeMapOperator;\n}());\nexports.MergeMapOperator = MergeMapOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar MergeMapSubscriber = (function (_super) {\n    __extends(MergeMapSubscriber, _super);\n    function MergeMapSubscriber(destination, project, resultSelector, concurrent) {\n        if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n        _super.call(this, destination);\n        this.project = project;\n        this.resultSelector = resultSelector;\n        this.concurrent = concurrent;\n        this.hasCompleted = false;\n        this.buffer = [];\n        this.active = 0;\n        this.index = 0;\n    }\n    MergeMapSubscriber.prototype._next = function (value) {\n        if (this.active < this.concurrent) {\n            this._tryNext(value);\n        }\n        else {\n            this.buffer.push(value);\n        }\n    };\n    MergeMapSubscriber.prototype._tryNext = function (value) {\n        var result;\n        var index = this.index++;\n        try {\n            result = this.project(value, index);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.active++;\n        this._innerSub(result, value, index);\n    };\n    MergeMapSubscriber.prototype._innerSub = function (ish, value, index) {\n        this.add(subscribeToResult_1.subscribeToResult(this, ish, value, index));\n    };\n    MergeMapSubscriber.prototype._complete = function () {\n        this.hasCompleted = true;\n        if (this.active === 0 && this.buffer.length === 0) {\n            this.destination.complete();\n        }\n    };\n    MergeMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        if (this.resultSelector) {\n            this._notifyResultSelector(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        else {\n            this.destination.next(innerValue);\n        }\n    };\n    MergeMapSubscriber.prototype._notifyResultSelector = function (outerValue, innerValue, outerIndex, innerIndex) {\n        var result;\n        try {\n            result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    MergeMapSubscriber.prototype.notifyComplete = function (innerSub) {\n        var buffer = this.buffer;\n        this.remove(innerSub);\n        this.active--;\n        if (buffer.length > 0) {\n            this._next(buffer.shift());\n        }\n        else if (this.active === 0 && this.hasCompleted) {\n            this.destination.complete();\n        }\n    };\n    return MergeMapSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\nexports.MergeMapSubscriber = MergeMapSubscriber;\n//# sourceMappingURL=mergeMap.js.map","\"use strict\";\nvar ConnectableObservable_1 = require('../observable/ConnectableObservable');\n/* tslint:enable:max-line-length */\n/**\n * Returns an Observable that emits the results of invoking a specified selector on items\n * emitted by a ConnectableObservable that shares a single subscription to the underlying stream.\n *\n * <img src=\"./img/multicast.png\" width=\"100%\">\n *\n * @param {Function|Subject} subjectOrSubjectFactory - Factory function to create an intermediate subject through\n * which the source sequence's elements will be multicast to the selector function\n * or Subject to push source elements into.\n * @param {Function} [selector] - Optional selector function that can use the multicasted source stream\n * as many times as needed, without causing multiple subscriptions to the source stream.\n * Subscribers to the given source will receive all notifications of the source from the\n * time of the subscription forward.\n * @return {Observable} An Observable that emits the results of invoking the selector\n * on the items emitted by a `ConnectableObservable` that shares a single subscription to\n * the underlying stream.\n * @method multicast\n * @owner Observable\n */\nfunction multicast(subjectOrSubjectFactory, selector) {\n    return function multicastOperatorFunction(source) {\n        var subjectFactory;\n        if (typeof subjectOrSubjectFactory === 'function') {\n            subjectFactory = subjectOrSubjectFactory;\n        }\n        else {\n            subjectFactory = function subjectFactory() {\n                return subjectOrSubjectFactory;\n            };\n        }\n        if (typeof selector === 'function') {\n            return source.lift(new MulticastOperator(subjectFactory, selector));\n        }\n        var connectable = Object.create(source, ConnectableObservable_1.connectableObservableDescriptor);\n        connectable.source = source;\n        connectable.subjectFactory = subjectFactory;\n        return connectable;\n    };\n}\nexports.multicast = multicast;\nvar MulticastOperator = (function () {\n    function MulticastOperator(subjectFactory, selector) {\n        this.subjectFactory = subjectFactory;\n        this.selector = selector;\n    }\n    MulticastOperator.prototype.call = function (subscriber, source) {\n        var selector = this.selector;\n        var subject = this.subjectFactory();\n        var subscription = selector(subject).subscribe(subscriber);\n        subscription.add(source.subscribe(subject));\n        return subscription;\n    };\n    return MulticastOperator;\n}());\nexports.MulticastOperator = MulticastOperator;\n//# sourceMappingURL=multicast.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nvar Notification_1 = require('../Notification');\n/**\n *\n * Re-emits all notifications from source Observable with specified scheduler.\n *\n * <span class=\"informal\">Ensure a specific scheduler is used, from outside of an Observable.</span>\n *\n * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule\n * notifications emitted by the source Observable. It might be useful, if you do not have control over\n * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.\n *\n * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,\n * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal\n * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits\n * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.\n * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split\n * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source\n * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a\n * little bit more, to ensure that they are emitted at expected moments.\n *\n * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications\n * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`\n * will delay all notifications - including error notifications - while `delay` will pass through error\n * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator\n * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used\n * for notification emissions in general.\n *\n * @example <caption>Ensure values in subscribe are called just before browser repaint.</caption>\n * const intervals = Rx.Observable.interval(10); // Intervals are scheduled\n *                                               // with async scheduler by default...\n *\n * intervals\n * .observeOn(Rx.Scheduler.animationFrame)       // ...but we will observe on animationFrame\n * .subscribe(val => {                           // scheduler to ensure smooth animation.\n *   someDiv.style.height = val + 'px';\n * });\n *\n * @see {@link delay}\n *\n * @param {IScheduler} scheduler Scheduler that will be used to reschedule notifications from source Observable.\n * @param {number} [delay] Number of milliseconds that states with what delay every notification should be rescheduled.\n * @return {Observable<T>} Observable that emits the same notifications as the source Observable,\n * but with provided scheduler.\n *\n * @method observeOn\n * @owner Observable\n */\nfunction observeOn(scheduler, delay) {\n    if (delay === void 0) { delay = 0; }\n    return function observeOnOperatorFunction(source) {\n        return source.lift(new ObserveOnOperator(scheduler, delay));\n    };\n}\nexports.observeOn = observeOn;\nvar ObserveOnOperator = (function () {\n    function ObserveOnOperator(scheduler, delay) {\n        if (delay === void 0) { delay = 0; }\n        this.scheduler = scheduler;\n        this.delay = delay;\n    }\n    ObserveOnOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new ObserveOnSubscriber(subscriber, this.scheduler, this.delay));\n    };\n    return ObserveOnOperator;\n}());\nexports.ObserveOnOperator = ObserveOnOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar ObserveOnSubscriber = (function (_super) {\n    __extends(ObserveOnSubscriber, _super);\n    function ObserveOnSubscriber(destination, scheduler, delay) {\n        if (delay === void 0) { delay = 0; }\n        _super.call(this, destination);\n        this.scheduler = scheduler;\n        this.delay = delay;\n    }\n    ObserveOnSubscriber.dispatch = function (arg) {\n        var notification = arg.notification, destination = arg.destination;\n        notification.observe(destination);\n        this.unsubscribe();\n    };\n    ObserveOnSubscriber.prototype.scheduleMessage = function (notification) {\n        this.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination)));\n    };\n    ObserveOnSubscriber.prototype._next = function (value) {\n        this.scheduleMessage(Notification_1.Notification.createNext(value));\n    };\n    ObserveOnSubscriber.prototype._error = function (err) {\n        this.scheduleMessage(Notification_1.Notification.createError(err));\n    };\n    ObserveOnSubscriber.prototype._complete = function () {\n        this.scheduleMessage(Notification_1.Notification.createComplete());\n    };\n    return ObserveOnSubscriber;\n}(Subscriber_1.Subscriber));\nexports.ObserveOnSubscriber = ObserveOnSubscriber;\nvar ObserveOnMessage = (function () {\n    function ObserveOnMessage(notification, destination) {\n        this.notification = notification;\n        this.destination = destination;\n    }\n    return ObserveOnMessage;\n}());\nexports.ObserveOnMessage = ObserveOnMessage;\n//# sourceMappingURL=observeOn.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nfunction refCount() {\n    return function refCountOperatorFunction(source) {\n        return source.lift(new RefCountOperator(source));\n    };\n}\nexports.refCount = refCount;\nvar RefCountOperator = (function () {\n    function RefCountOperator(connectable) {\n        this.connectable = connectable;\n    }\n    RefCountOperator.prototype.call = function (subscriber, source) {\n        var connectable = this.connectable;\n        connectable._refCount++;\n        var refCounter = new RefCountSubscriber(subscriber, connectable);\n        var subscription = source.subscribe(refCounter);\n        if (!refCounter.closed) {\n            refCounter.connection = connectable.connect();\n        }\n        return subscription;\n    };\n    return RefCountOperator;\n}());\nvar RefCountSubscriber = (function (_super) {\n    __extends(RefCountSubscriber, _super);\n    function RefCountSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    /** @deprecated internal use only */ RefCountSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (!connectable) {\n            this.connection = null;\n            return;\n        }\n        this.connectable = null;\n        var refCount = connectable._refCount;\n        if (refCount <= 0) {\n            this.connection = null;\n            return;\n        }\n        connectable._refCount = refCount - 1;\n        if (refCount > 1) {\n            this.connection = null;\n            return;\n        }\n        ///\n        // Compare the local RefCountSubscriber's connection Subscription to the\n        // connection Subscription on the shared ConnectableObservable. In cases\n        // where the ConnectableObservable source synchronously emits values, and\n        // the RefCountSubscriber's downstream Observers synchronously unsubscribe,\n        // execution continues to here before the RefCountOperator has a chance to\n        // supply the RefCountSubscriber with the shared connection Subscription.\n        // For example:\n        // ```\n        // Observable.range(0, 10)\n        //   .publish()\n        //   .refCount()\n        //   .take(5)\n        //   .subscribe();\n        // ```\n        // In order to account for this case, RefCountSubscriber should only dispose\n        // the ConnectableObservable's shared connection Subscription if the\n        // connection Subscription exists, *and* either:\n        //   a. RefCountSubscriber doesn't have a reference to the shared connection\n        //      Subscription yet, or,\n        //   b. RefCountSubscriber's connection Subscription reference is identical\n        //      to the shared connection Subscription\n        ///\n        var connection = this.connection;\n        var sharedConnection = connectable._connection;\n        this.connection = null;\n        if (sharedConnection && (!connection || sharedConnection === connection)) {\n            sharedConnection.unsubscribe();\n        }\n    };\n    return RefCountSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=refCount.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subject_1 = require('../Subject');\nvar tryCatch_1 = require('../util/tryCatch');\nvar errorObject_1 = require('../util/errorObject');\nvar OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\n/**\n * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable\n * calls `error`, this method will emit the Throwable that caused the error to the Observable returned from `notifier`.\n * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child\n * subscription. Otherwise this method will resubscribe to the source Observable.\n *\n * <img src=\"./img/retryWhen.png\" width=\"100%\">\n *\n * @param {function(errors: Observable): Observable} notifier - Receives an Observable of notifications with which a\n * user can `complete` or `error`, aborting the retry.\n * @return {Observable} The source Observable modified with retry logic.\n * @method retryWhen\n * @owner Observable\n */\nfunction retryWhen(notifier) {\n    return function (source) { return source.lift(new RetryWhenOperator(notifier, source)); };\n}\nexports.retryWhen = retryWhen;\nvar RetryWhenOperator = (function () {\n    function RetryWhenOperator(notifier, source) {\n        this.notifier = notifier;\n        this.source = source;\n    }\n    RetryWhenOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new RetryWhenSubscriber(subscriber, this.notifier, this.source));\n    };\n    return RetryWhenOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar RetryWhenSubscriber = (function (_super) {\n    __extends(RetryWhenSubscriber, _super);\n    function RetryWhenSubscriber(destination, notifier, source) {\n        _super.call(this, destination);\n        this.notifier = notifier;\n        this.source = source;\n    }\n    RetryWhenSubscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            var errors = this.errors;\n            var retries = this.retries;\n            var retriesSubscription = this.retriesSubscription;\n            if (!retries) {\n                errors = new Subject_1.Subject();\n                retries = tryCatch_1.tryCatch(this.notifier)(errors);\n                if (retries === errorObject_1.errorObject) {\n                    return _super.prototype.error.call(this, errorObject_1.errorObject.e);\n                }\n                retriesSubscription = subscribeToResult_1.subscribeToResult(this, retries);\n            }\n            else {\n                this.errors = null;\n                this.retriesSubscription = null;\n            }\n            this._unsubscribeAndRecycle();\n            this.errors = errors;\n            this.retries = retries;\n            this.retriesSubscription = retriesSubscription;\n            errors.next(err);\n        }\n    };\n    /** @deprecated internal use only */ RetryWhenSubscriber.prototype._unsubscribe = function () {\n        var _a = this, errors = _a.errors, retriesSubscription = _a.retriesSubscription;\n        if (errors) {\n            errors.unsubscribe();\n            this.errors = null;\n        }\n        if (retriesSubscription) {\n            retriesSubscription.unsubscribe();\n            this.retriesSubscription = null;\n        }\n        this.retries = null;\n    };\n    RetryWhenSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        var _a = this, errors = _a.errors, retries = _a.retries, retriesSubscription = _a.retriesSubscription;\n        this.errors = null;\n        this.retries = null;\n        this.retriesSubscription = null;\n        this._unsubscribeAndRecycle();\n        this.errors = errors;\n        this.retries = retries;\n        this.retriesSubscription = retriesSubscription;\n        this.source.subscribe(this);\n    };\n    return RetryWhenSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=retryWhen.js.map","\"use strict\";\nvar multicast_1 = require('./multicast');\nvar refCount_1 = require('./refCount');\nvar Subject_1 = require('../Subject');\nfunction shareSubjectFactory() {\n    return new Subject_1.Subject();\n}\n/**\n * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one\n * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will\n * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`.\n * This is an alias for .multicast(() => new Subject()).refCount().\n *\n * <img src=\"./img/share.png\" width=\"100%\">\n *\n * @return {Observable<T>} An Observable that upon connection causes the source Observable to emit items to its Observers.\n * @method share\n * @owner Observable\n */\nfunction share() {\n    return function (source) { return refCount_1.refCount()(multicast_1.multicast(shareSubjectFactory)(source)); };\n}\nexports.share = share;\n;\n//# sourceMappingURL=share.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nvar ArgumentOutOfRangeError_1 = require('../util/ArgumentOutOfRangeError');\nvar EmptyObservable_1 = require('../observable/EmptyObservable');\n/**\n * Emits only the first `count` values emitted by the source Observable.\n *\n * <span class=\"informal\">Takes the first `count` values from the source, then\n * completes.</span>\n *\n * <img src=\"./img/take.png\" width=\"100%\">\n *\n * `take` returns an Observable that emits only the first `count` values emitted\n * by the source Observable. If the source emits fewer than `count` values then\n * all of its values are emitted. After that, it completes, regardless if the\n * source completes.\n *\n * @example <caption>Take the first 5 seconds of an infinite 1-second interval Observable</caption>\n * var interval = Rx.Observable.interval(1000);\n * var five = interval.take(5);\n * five.subscribe(x => console.log(x));\n *\n * @see {@link takeLast}\n * @see {@link takeUntil}\n * @see {@link takeWhile}\n * @see {@link skip}\n *\n * @throws {ArgumentOutOfRangeError} When using `take(i)`, it delivers an\n * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.\n *\n * @param {number} count The maximum number of `next` values to emit.\n * @return {Observable<T>} An Observable that emits only the first `count`\n * values emitted by the source Observable, or all of the values from the source\n * if the source emits fewer than `count` values.\n * @method take\n * @owner Observable\n */\nfunction take(count) {\n    return function (source) {\n        if (count === 0) {\n            return new EmptyObservable_1.EmptyObservable();\n        }\n        else {\n            return source.lift(new TakeOperator(count));\n        }\n    };\n}\nexports.take = take;\nvar TakeOperator = (function () {\n    function TakeOperator(total) {\n        this.total = total;\n        if (this.total < 0) {\n            throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError;\n        }\n    }\n    TakeOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new TakeSubscriber(subscriber, this.total));\n    };\n    return TakeOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar TakeSubscriber = (function (_super) {\n    __extends(TakeSubscriber, _super);\n    function TakeSubscriber(destination, total) {\n        _super.call(this, destination);\n        this.total = total;\n        this.count = 0;\n    }\n    TakeSubscriber.prototype._next = function (value) {\n        var total = this.total;\n        var count = ++this.count;\n        if (count <= total) {\n            this.destination.next(value);\n            if (count === total) {\n                this.destination.complete();\n                this.unsubscribe();\n            }\n        }\n    };\n    return TakeSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=take.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/* tslint:enable:max-line-length */\n/**\n * Perform a side effect for every emission on the source Observable, but return\n * an Observable that is identical to the source.\n *\n * <span class=\"informal\">Intercepts each emission on the source and runs a\n * function, but returns an output which is identical to the source as long as errors don't occur.</span>\n *\n * <img src=\"./img/do.png\" width=\"100%\">\n *\n * Returns a mirrored Observable of the source Observable, but modified so that\n * the provided Observer is called to perform a side effect for every value,\n * error, and completion emitted by the source. Any errors that are thrown in\n * the aforementioned Observer or handlers are safely sent down the error path\n * of the output Observable.\n *\n * This operator is useful for debugging your Observables for the correct values\n * or performing other side effects.\n *\n * Note: this is different to a `subscribe` on the Observable. If the Observable\n * returned by `do` is not subscribed, the side effects specified by the\n * Observer will never happen. `do` therefore simply spies on existing\n * execution, it does not trigger an execution to happen like `subscribe` does.\n *\n * @example <caption>Map every click to the clientX position of that click, while also logging the click event</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks\n *   .do(ev => console.log(ev))\n *   .map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link map}\n * @see {@link subscribe}\n *\n * @param {Observer|function} [nextOrObserver] A normal Observer object or a\n * callback for `next`.\n * @param {function} [error] Callback for errors in the source.\n * @param {function} [complete] Callback for the completion of the source.\n * @return {Observable} An Observable identical to the source, but runs the\n * specified Observer or callback(s) for each item.\n * @name tap\n */\nfunction tap(nextOrObserver, error, complete) {\n    return function tapOperatorFunction(source) {\n        return source.lift(new DoOperator(nextOrObserver, error, complete));\n    };\n}\nexports.tap = tap;\nvar DoOperator = (function () {\n    function DoOperator(nextOrObserver, error, complete) {\n        this.nextOrObserver = nextOrObserver;\n        this.error = error;\n        this.complete = complete;\n    }\n    DoOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new DoSubscriber(subscriber, this.nextOrObserver, this.error, this.complete));\n    };\n    return DoOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar DoSubscriber = (function (_super) {\n    __extends(DoSubscriber, _super);\n    function DoSubscriber(destination, nextOrObserver, error, complete) {\n        _super.call(this, destination);\n        var safeSubscriber = new Subscriber_1.Subscriber(nextOrObserver, error, complete);\n        safeSubscriber.syncErrorThrowable = true;\n        this.add(safeSubscriber);\n        this.safeSubscriber = safeSubscriber;\n    }\n    DoSubscriber.prototype._next = function (value) {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.next(value);\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.next(value);\n        }\n    };\n    DoSubscriber.prototype._error = function (err) {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.error(err);\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.error(err);\n        }\n    };\n    DoSubscriber.prototype._complete = function () {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.complete();\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.complete();\n        }\n    };\n    return DoSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=tap.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscription_1 = require('../Subscription');\n/**\n * A unit of work to be executed in a {@link Scheduler}. An action is typically\n * created from within a Scheduler and an RxJS user does not need to concern\n * themselves about creating and manipulating an Action.\n *\n * ```ts\n * class Action<T> extends Subscription {\n *   new (scheduler: Scheduler, work: (state?: T) => void);\n *   schedule(state?: T, delay: number = 0): Subscription;\n * }\n * ```\n *\n * @class Action<T>\n */\nvar Action = (function (_super) {\n    __extends(Action, _super);\n    function Action(scheduler, work) {\n        _super.call(this);\n    }\n    /**\n     * Schedules this action on its parent Scheduler for execution. May be passed\n     * some context object, `state`. May happen at some point in the future,\n     * according to the `delay` parameter, if specified.\n     * @param {T} [state] Some contextual data that the `work` function uses when\n     * called by the Scheduler.\n     * @param {number} [delay] Time to wait before executing the work, where the\n     * time unit is implicit and defined by the Scheduler.\n     * @return {void}\n     */\n    Action.prototype.schedule = function (state, delay) {\n        if (delay === void 0) { delay = 0; }\n        return this;\n    };\n    return Action;\n}(Subscription_1.Subscription));\nexports.Action = Action;\n//# sourceMappingURL=Action.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../util/root');\nvar Action_1 = require('./Action');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar AsyncAction = (function (_super) {\n    __extends(AsyncAction, _super);\n    function AsyncAction(scheduler, work) {\n        _super.call(this, scheduler, work);\n        this.scheduler = scheduler;\n        this.pending = false;\n        this.work = work;\n    }\n    AsyncAction.prototype.schedule = function (state, delay) {\n        if (delay === void 0) { delay = 0; }\n        if (this.closed) {\n            return this;\n        }\n        // Always replace the current state with the new state.\n        this.state = state;\n        // Set the pending flag indicating that this action has been scheduled, or\n        // has recursively rescheduled itself.\n        this.pending = true;\n        var id = this.id;\n        var scheduler = this.scheduler;\n        //\n        // Important implementation note:\n        //\n        // Actions only execute once by default, unless rescheduled from within the\n        // scheduled callback. This allows us to implement single and repeat\n        // actions via the same code path, without adding API surface area, as well\n        // as mimic traditional recursion but across asynchronous boundaries.\n        //\n        // However, JS runtimes and timers distinguish between intervals achieved by\n        // serial `setTimeout` calls vs. a single `setInterval` call. An interval of\n        // serial `setTimeout` calls can be individually delayed, which delays\n        // scheduling the next `setTimeout`, and so on. `setInterval` attempts to\n        // guarantee the interval callback will be invoked more precisely to the\n        // interval period, regardless of load.\n        //\n        // Therefore, we use `setInterval` to schedule single and repeat actions.\n        // If the action reschedules itself with the same delay, the interval is not\n        // canceled. If the action doesn't reschedule, or reschedules with a\n        // different delay, the interval will be canceled after scheduled callback\n        // execution.\n        //\n        if (id != null) {\n            this.id = this.recycleAsyncId(scheduler, id, delay);\n        }\n        this.delay = delay;\n        // If this action has already an async Id, don't request a new one.\n        this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);\n        return this;\n    };\n    AsyncAction.prototype.requestAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        return root_1.root.setInterval(scheduler.flush.bind(scheduler, this), delay);\n    };\n    AsyncAction.prototype.recycleAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If this action is rescheduled with the same delay time, don't clear the interval id.\n        if (delay !== null && this.delay === delay && this.pending === false) {\n            return id;\n        }\n        // Otherwise, if the action's delay time is different from the current delay,\n        // or the action has been rescheduled before it's executed, clear the interval id\n        return root_1.root.clearInterval(id) && undefined || undefined;\n    };\n    /**\n     * Immediately executes this action and the `work` it contains.\n     * @return {any}\n     */\n    AsyncAction.prototype.execute = function (state, delay) {\n        if (this.closed) {\n            return new Error('executing a cancelled action');\n        }\n        this.pending = false;\n        var error = this._execute(state, delay);\n        if (error) {\n            return error;\n        }\n        else if (this.pending === false && this.id != null) {\n            // Dequeue if the action didn't reschedule itself. Don't call\n            // unsubscribe(), because the action could reschedule later.\n            // For example:\n            // ```\n            // scheduler.schedule(function doWork(counter) {\n            //   /* ... I'm a busy worker bee ... */\n            //   var originalAction = this;\n            //   /* wait 100ms before rescheduling the action */\n            //   setTimeout(function () {\n            //     originalAction.schedule(counter + 1);\n            //   }, 100);\n            // }, 1000);\n            // ```\n            this.id = this.recycleAsyncId(this.scheduler, this.id, null);\n        }\n    };\n    AsyncAction.prototype._execute = function (state, delay) {\n        var errored = false;\n        var errorValue = undefined;\n        try {\n            this.work(state);\n        }\n        catch (e) {\n            errored = true;\n            errorValue = !!e && e || new Error(e);\n        }\n        if (errored) {\n            this.unsubscribe();\n            return errorValue;\n        }\n    };\n    /** @deprecated internal use only */ AsyncAction.prototype._unsubscribe = function () {\n        var id = this.id;\n        var scheduler = this.scheduler;\n        var actions = scheduler.actions;\n        var index = actions.indexOf(this);\n        this.work = null;\n        this.state = null;\n        this.pending = false;\n        this.scheduler = null;\n        if (index !== -1) {\n            actions.splice(index, 1);\n        }\n        if (id != null) {\n            this.id = this.recycleAsyncId(scheduler, id, null);\n        }\n        this.delay = null;\n    };\n    return AsyncAction;\n}(Action_1.Action));\nexports.AsyncAction = AsyncAction;\n//# sourceMappingURL=AsyncAction.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Scheduler_1 = require('../Scheduler');\nvar AsyncScheduler = (function (_super) {\n    __extends(AsyncScheduler, _super);\n    function AsyncScheduler() {\n        _super.apply(this, arguments);\n        this.actions = [];\n        /**\n         * A flag to indicate whether the Scheduler is currently executing a batch of\n         * queued actions.\n         * @type {boolean}\n         */\n        this.active = false;\n        /**\n         * An internal ID used to track the latest asynchronous task such as those\n         * coming from `setTimeout`, `setInterval`, `requestAnimationFrame`, and\n         * others.\n         * @type {any}\n         */\n        this.scheduled = undefined;\n    }\n    AsyncScheduler.prototype.flush = function (action) {\n        var actions = this.actions;\n        if (this.active) {\n            actions.push(action);\n            return;\n        }\n        var error;\n        this.active = true;\n        do {\n            if (error = action.execute(action.state, action.delay)) {\n                break;\n            }\n        } while (action = actions.shift()); // exhaust the scheduler queue\n        this.active = false;\n        if (error) {\n            while (action = actions.shift()) {\n                action.unsubscribe();\n            }\n            throw error;\n        }\n    };\n    return AsyncScheduler;\n}(Scheduler_1.Scheduler));\nexports.AsyncScheduler = AsyncScheduler;\n//# sourceMappingURL=AsyncScheduler.js.map","\"use strict\";\nvar AsyncAction_1 = require('./AsyncAction');\nvar AsyncScheduler_1 = require('./AsyncScheduler');\n/**\n *\n * Async Scheduler\n *\n * <span class=\"informal\">Schedule task as if you used setTimeout(task, duration)</span>\n *\n * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript\n * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating\n * in intervals.\n *\n * If you just want to \"defer\" task, that is to perform it right after currently\n * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`),\n * better choice will be the {@link asap} scheduler.\n *\n * @example <caption>Use async scheduler to delay task</caption>\n * const task = () => console.log('it works!');\n *\n * Rx.Scheduler.async.schedule(task, 2000);\n *\n * // After 2 seconds logs:\n * // \"it works!\"\n *\n *\n * @example <caption>Use async scheduler to repeat task in intervals</caption>\n * function task(state) {\n *   console.log(state);\n *   this.schedule(state + 1, 1000); // `this` references currently executing Action,\n *                                   // which we reschedule with new state and delay\n * }\n *\n * Rx.Scheduler.async.schedule(task, 3000, 0);\n *\n * // Logs:\n * // 0 after 3s\n * // 1 after 4s\n * // 2 after 5s\n * // 3 after 6s\n *\n * @static true\n * @name async\n * @owner Scheduler\n */\nexports.async = new AsyncScheduler_1.AsyncScheduler(AsyncAction_1.AsyncAction);\n//# sourceMappingURL=async.js.map","\"use strict\";\nvar root_1 = require('../util/root');\nfunction symbolIteratorPonyfill(root) {\n    var Symbol = root.Symbol;\n    if (typeof Symbol === 'function') {\n        if (!Symbol.iterator) {\n            Symbol.iterator = Symbol('iterator polyfill');\n        }\n        return Symbol.iterator;\n    }\n    else {\n        // [for Mozilla Gecko 27-35:](https://mzl.la/2ewE1zC)\n        var Set_1 = root.Set;\n        if (Set_1 && typeof new Set_1()['@@iterator'] === 'function') {\n            return '@@iterator';\n        }\n        var Map_1 = root.Map;\n        // required for compatability with es6-shim\n        if (Map_1) {\n            var keys = Object.getOwnPropertyNames(Map_1.prototype);\n            for (var i = 0; i < keys.length; ++i) {\n                var key = keys[i];\n                // according to spec, Map.prototype[@@iterator] and Map.orototype.entries must be equal.\n                if (key !== 'entries' && key !== 'size' && Map_1.prototype[key] === Map_1.prototype['entries']) {\n                    return key;\n                }\n            }\n        }\n        return '@@iterator';\n    }\n}\nexports.symbolIteratorPonyfill = symbolIteratorPonyfill;\nexports.iterator = symbolIteratorPonyfill(root_1.root);\n/**\n * @deprecated use iterator instead\n */\nexports.$$iterator = exports.iterator;\n//# sourceMappingURL=iterator.js.map","\"use strict\";\nvar root_1 = require('../util/root');\nfunction getSymbolObservable(context) {\n    var $$observable;\n    var Symbol = context.Symbol;\n    if (typeof Symbol === 'function') {\n        if (Symbol.observable) {\n            $$observable = Symbol.observable;\n        }\n        else {\n            $$observable = Symbol('observable');\n            Symbol.observable = $$observable;\n        }\n    }\n    else {\n        $$observable = '@@observable';\n    }\n    return $$observable;\n}\nexports.getSymbolObservable = getSymbolObservable;\nexports.observable = getSymbolObservable(root_1.root);\n/**\n * @deprecated use observable instead\n */\nexports.$$observable = exports.observable;\n//# sourceMappingURL=observable.js.map","\"use strict\";\nvar root_1 = require('../util/root');\nvar Symbol = root_1.root.Symbol;\nexports.rxSubscriber = (typeof Symbol === 'function' && typeof Symbol.for === 'function') ?\n    Symbol.for('rxSubscriber') : '@@rxSubscriber';\n/**\n * @deprecated use rxSubscriber instead\n */\nexports.$$rxSubscriber = exports.rxSubscriber;\n//# sourceMappingURL=rxSubscriber.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when an element was queried at a certain index of an\n * Observable, but no such index or position exists in that sequence.\n *\n * @see {@link elementAt}\n * @see {@link take}\n * @see {@link takeLast}\n *\n * @class ArgumentOutOfRangeError\n */\nvar ArgumentOutOfRangeError = (function (_super) {\n    __extends(ArgumentOutOfRangeError, _super);\n    function ArgumentOutOfRangeError() {\n        var err = _super.call(this, 'argument out of range');\n        this.name = err.name = 'ArgumentOutOfRangeError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return ArgumentOutOfRangeError;\n}(Error));\nexports.ArgumentOutOfRangeError = ArgumentOutOfRangeError;\n//# sourceMappingURL=ArgumentOutOfRangeError.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when an action is invalid because the object has been\n * unsubscribed.\n *\n * @see {@link Subject}\n * @see {@link BehaviorSubject}\n *\n * @class ObjectUnsubscribedError\n */\nvar ObjectUnsubscribedError = (function (_super) {\n    __extends(ObjectUnsubscribedError, _super);\n    function ObjectUnsubscribedError() {\n        var err = _super.call(this, 'object unsubscribed');\n        this.name = err.name = 'ObjectUnsubscribedError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return ObjectUnsubscribedError;\n}(Error));\nexports.ObjectUnsubscribedError = ObjectUnsubscribedError;\n//# sourceMappingURL=ObjectUnsubscribedError.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when one or more errors have occurred during the\n * `unsubscribe` of a {@link Subscription}.\n */\nvar UnsubscriptionError = (function (_super) {\n    __extends(UnsubscriptionError, _super);\n    function UnsubscriptionError(errors) {\n        _super.call(this);\n        this.errors = errors;\n        var err = Error.call(this, errors ?\n            errors.length + \" errors occurred during unsubscription:\\n  \" + errors.map(function (err, i) { return ((i + 1) + \") \" + err.toString()); }).join('\\n  ') : '');\n        this.name = err.name = 'UnsubscriptionError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return UnsubscriptionError;\n}(Error));\nexports.UnsubscriptionError = UnsubscriptionError;\n//# sourceMappingURL=UnsubscriptionError.js.map","\"use strict\";\n// typeof any so that it we don't have to cast when comparing a result to the error object\nexports.errorObject = { e: {} };\n//# sourceMappingURL=errorObject.js.map","\"use strict\";\nexports.isArray = Array.isArray || (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArray.js.map","\"use strict\";\nexports.isArrayLike = (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArrayLike.js.map","\"use strict\";\nfunction isDate(value) {\n    return value instanceof Date && !isNaN(+value);\n}\nexports.isDate = isDate;\n//# sourceMappingURL=isDate.js.map","\"use strict\";\nfunction isFunction(x) {\n    return typeof x === 'function';\n}\nexports.isFunction = isFunction;\n//# sourceMappingURL=isFunction.js.map","\"use strict\";\nvar isArray_1 = require('../util/isArray');\nfunction isNumeric(val) {\n    // parseFloat NaNs numeric-cast false positives (null|true|false|\"\")\n    // ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n    // subtraction forces infinities to NaN\n    // adding 1 corrects loss of precision from parseFloat (#15100)\n    return !isArray_1.isArray(val) && (val - parseFloat(val) + 1) >= 0;\n}\nexports.isNumeric = isNumeric;\n;\n//# sourceMappingURL=isNumeric.js.map","\"use strict\";\nfunction isObject(x) {\n    return x != null && typeof x === 'object';\n}\nexports.isObject = isObject;\n//# sourceMappingURL=isObject.js.map","\"use strict\";\nfunction isPromise(value) {\n    return value && typeof value.subscribe !== 'function' && typeof value.then === 'function';\n}\nexports.isPromise = isPromise;\n//# sourceMappingURL=isPromise.js.map","\"use strict\";\nfunction isScheduler(value) {\n    return value && typeof value.schedule === 'function';\n}\nexports.isScheduler = isScheduler;\n//# sourceMappingURL=isScheduler.js.map","\"use strict\";\n/* tslint:disable:no-empty */\nfunction noop() { }\nexports.noop = noop;\n//# sourceMappingURL=noop.js.map","\"use strict\";\nvar noop_1 = require('./noop');\n/* tslint:enable:max-line-length */\nfunction pipe() {\n    var fns = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        fns[_i - 0] = arguments[_i];\n    }\n    return pipeFromArray(fns);\n}\nexports.pipe = pipe;\n/* @internal */\nfunction pipeFromArray(fns) {\n    if (!fns) {\n        return noop_1.noop;\n    }\n    if (fns.length === 1) {\n        return fns[0];\n    }\n    return function piped(input) {\n        return fns.reduce(function (prev, fn) { return fn(prev); }, input);\n    };\n}\nexports.pipeFromArray = pipeFromArray;\n//# sourceMappingURL=pipe.js.map","\"use strict\";\n// CommonJS / Node have global context exposed as \"global\" variable.\n// We don't want to include the whole node.d.ts this this compilation unit so we'll just fake\n// the global \"global\" var for now.\nvar __window = typeof window !== 'undefined' && window;\nvar __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n    self instanceof WorkerGlobalScope && self;\nvar __global = typeof global !== 'undefined' && global;\nvar _root = __window || __global || __self;\nexports.root = _root;\n// Workaround Closure Compiler restriction: The body of a goog.module cannot use throw.\n// This is needed when used with angular/tsickle which inserts a goog.module statement.\n// Wrap in IIFE\n(function () {\n    if (!_root) {\n        throw new Error('RxJS could not find any global context (window, self, global)');\n    }\n})();\n//# sourceMappingURL=root.js.map","\"use strict\";\nvar root_1 = require('./root');\nvar isArrayLike_1 = require('./isArrayLike');\nvar isPromise_1 = require('./isPromise');\nvar isObject_1 = require('./isObject');\nvar Observable_1 = require('../Observable');\nvar iterator_1 = require('../symbol/iterator');\nvar InnerSubscriber_1 = require('../InnerSubscriber');\nvar observable_1 = require('../symbol/observable');\nfunction subscribeToResult(outerSubscriber, result, outerValue, outerIndex) {\n    var destination = new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex);\n    if (destination.closed) {\n        return null;\n    }\n    if (result instanceof Observable_1.Observable) {\n        if (result._isScalar) {\n            destination.next(result.value);\n            destination.complete();\n            return null;\n        }\n        else {\n            destination.syncErrorThrowable = true;\n            return result.subscribe(destination);\n        }\n    }\n    else if (isArrayLike_1.isArrayLike(result)) {\n        for (var i = 0, len = result.length; i < len && !destination.closed; i++) {\n            destination.next(result[i]);\n        }\n        if (!destination.closed) {\n            destination.complete();\n        }\n    }\n    else if (isPromise_1.isPromise(result)) {\n        result.then(function (value) {\n            if (!destination.closed) {\n                destination.next(value);\n                destination.complete();\n            }\n        }, function (err) { return destination.error(err); })\n            .then(null, function (err) {\n            // Escaping the Promise trap: globally throw unhandled errors\n            root_1.root.setTimeout(function () { throw err; });\n        });\n        return destination;\n    }\n    else if (result && typeof result[iterator_1.iterator] === 'function') {\n        var iterator = result[iterator_1.iterator]();\n        do {\n            var item = iterator.next();\n            if (item.done) {\n                destination.complete();\n                break;\n            }\n            destination.next(item.value);\n            if (destination.closed) {\n                break;\n            }\n        } while (true);\n    }\n    else if (result && typeof result[observable_1.observable] === 'function') {\n        var obs = result[observable_1.observable]();\n        if (typeof obs.subscribe !== 'function') {\n            destination.error(new TypeError('Provided object does not correctly implement Symbol.observable'));\n        }\n        else {\n            return obs.subscribe(new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex));\n        }\n    }\n    else {\n        var value = isObject_1.isObject(result) ? 'an invalid object' : \"'\" + result + \"'\";\n        var msg = (\"You provided \" + value + \" where a stream was expected.\")\n            + ' You can provide an Observable, Promise, Array, or Iterable.';\n        destination.error(new TypeError(msg));\n    }\n    return null;\n}\nexports.subscribeToResult = subscribeToResult;\n//# sourceMappingURL=subscribeToResult.js.map","\"use strict\";\nvar Subscriber_1 = require('../Subscriber');\nvar rxSubscriber_1 = require('../symbol/rxSubscriber');\nvar Observer_1 = require('../Observer');\nfunction toSubscriber(nextOrObserver, error, complete) {\n    if (nextOrObserver) {\n        if (nextOrObserver instanceof Subscriber_1.Subscriber) {\n            return nextOrObserver;\n        }\n        if (nextOrObserver[rxSubscriber_1.rxSubscriber]) {\n            return nextOrObserver[rxSubscriber_1.rxSubscriber]();\n        }\n    }\n    if (!nextOrObserver && !error && !complete) {\n        return new Subscriber_1.Subscriber(Observer_1.empty);\n    }\n    return new Subscriber_1.Subscriber(nextOrObserver, error, complete);\n}\nexports.toSubscriber = toSubscriber;\n//# sourceMappingURL=toSubscriber.js.map","\"use strict\";\nvar errorObject_1 = require('./errorObject');\nvar tryCatchTarget;\nfunction tryCatcher() {\n    try {\n        return tryCatchTarget.apply(this, arguments);\n    }\n    catch (e) {\n        errorObject_1.errorObject.e = e;\n        return errorObject_1.errorObject;\n    }\n}\nfunction tryCatch(fn) {\n    tryCatchTarget = fn;\n    return tryCatcher;\n}\nexports.tryCatch = tryCatch;\n;\n//# sourceMappingURL=tryCatch.js.map","'use strict';\n\nvar callBound = require('call-bound');\nvar isRegex = require('is-regex');\n\nvar $exec = callBound('RegExp.prototype.exec');\nvar $TypeError = require('es-errors/type');\n\n/** @type {import('.')} */\nmodule.exports = function regexTester(regex) {\n\tif (!isRegex(regex)) {\n\t\tthrow new $TypeError('`regex` must be a RegExp');\n\t}\n\treturn function test(s) {\n\t\treturn $exec(regex, s) !== null;\n\t};\n};\n","/**\n * @license React\n * scheduler.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,w=e>>>1;d<w;){var m=2*(d+1)-1,C=a[m],n=m+1,x=a[n];if(0>g(C,c))n<e&&0>g(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(n<e&&0>g(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}\nfunction g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D=\"function\"===typeof setTimeout?setTimeout:null,E=\"function\"===typeof clearTimeout?clearTimeout:null,F=\"undefined\"!==typeof setImmediate?setImmediate:null;\n\"undefined\"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t)}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else{var b=h(t);null!==b&&K(H,b.startTime-a)}}\nfunction J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if(\"function\"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?v.callback=e:v===h(r)&&k(r);G(b)}else k(r);v=h(r)}if(null!==v)var w=!0;else{var m=h(t);null!==m&&K(H,m.startTime-b);w=!1}return w}finally{v=null,y=c,z=!1}}var N=!1,O=null,L=-1,P=5,Q=-1;\nfunction M(){return exports.unstable_now()-Q<P?!1:!0}function R(){if(null!==O){var a=exports.unstable_now();Q=a;var b=!0;try{b=O(!0,a)}finally{b?S():(N=!1,O=null)}}else N=!1}var S;if(\"function\"===typeof F)S=function(){F(R)};else if(\"undefined\"!==typeof MessageChannel){var T=new MessageChannel,U=T.port2;T.port1.onmessage=R;S=function(){U.postMessage(null)}}else S=function(){D(R,0)};function I(a){O=a;N||(N=!0,S())}function K(a,b){L=D(function(){a(exports.unstable_now())},b)}\nexports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){A||z||(A=!0,I(J))};\nexports.unstable_forceFrameRate=function(a){0>a||125<a?console.error(\"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported\"):P=0<a?Math.floor(1E3/a):5};exports.unstable_getCurrentPriorityLevel=function(){return y};exports.unstable_getFirstCallbackNode=function(){return h(r)};exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var b=3;break;default:b=y}var c=y;y=b;try{return a()}finally{y=c}};exports.unstable_pauseExecution=function(){};\nexports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=y;y=a;try{return b()}finally{y=c}};\nexports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();\"object\"===typeof c&&null!==c?(c=c.delay,c=\"number\"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:u++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};\nexports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c}}};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/scheduler.production.min.js');\n} else {\n  module.exports = require('./cjs/scheduler.development.js');\n}\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\nvar define = require('define-data-property');\nvar hasDescriptors = require('has-property-descriptors')();\nvar gOPD = require('gopd');\n\nvar $TypeError = require('es-errors/type');\nvar $floor = GetIntrinsic('%Math.floor%');\n\n/** @type {import('.')} */\nmodule.exports = function setFunctionLength(fn, length) {\n\tif (typeof fn !== 'function') {\n\t\tthrow new $TypeError('`fn` is not a function');\n\t}\n\tif (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) {\n\t\tthrow new $TypeError('`length` must be a positive 32-bit integer');\n\t}\n\n\tvar loose = arguments.length > 2 && !!arguments[2];\n\n\tvar functionLengthIsConfigurable = true;\n\tvar functionLengthIsWritable = true;\n\tif ('length' in fn && gOPD) {\n\t\tvar desc = gOPD(fn, 'length');\n\t\tif (desc && !desc.configurable) {\n\t\t\tfunctionLengthIsConfigurable = false;\n\t\t}\n\t\tif (desc && !desc.writable) {\n\t\t\tfunctionLengthIsWritable = false;\n\t\t}\n\t}\n\n\tif (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {\n\t\tif (hasDescriptors) {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true);\n\t\t} else {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length);\n\t\t}\n\t}\n\treturn fn;\n};\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nexports.__esModule = true;\nvar style_to_object_1 = __importDefault(require(\"style-to-object\"));\nvar utilities_1 = require(\"./utilities\");\nfunction StyleToJS(style, options) {\n    var output = {};\n    if (!style || typeof style !== 'string') {\n        return output;\n    }\n    (0, style_to_object_1[\"default\"])(style, function (property, value) {\n        if (property && value) {\n            output[(0, utilities_1.camelCase)(property, options)] = value;\n        }\n    });\n    return output;\n}\nexports[\"default\"] = StyleToJS;\n","\"use strict\";\nexports.__esModule = true;\nexports.camelCase = void 0;\nvar CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9-]+$/;\nvar HYPHEN_REGEX = /-([a-z])/g;\nvar NO_HYPHEN_REGEX = /^[^-]+$/;\nvar VENDOR_PREFIX_REGEX = /^-(webkit|moz|ms|o|khtml)-/;\nvar MS_VENDOR_PREFIX_REGEX = /^-(ms)-/;\nvar skipCamelCase = function (property) {\n    return !property ||\n        NO_HYPHEN_REGEX.test(property) ||\n        CUSTOM_PROPERTY_REGEX.test(property);\n};\nvar capitalize = function (match, character) {\n    return character.toUpperCase();\n};\nvar trimHyphen = function (match, prefix) { return \"\".concat(prefix, \"-\"); };\nvar camelCase = function (property, options) {\n    if (options === void 0) { options = {}; }\n    if (skipCamelCase(property)) {\n        return property;\n    }\n    property = property.toLowerCase();\n    if (options.reactCompat) {\n        property = property.replace(MS_VENDOR_PREFIX_REGEX, trimHyphen);\n    }\n    else {\n        property = property.replace(VENDOR_PREFIX_REGEX, trimHyphen);\n    }\n    return property.replace(HYPHEN_REGEX, capitalize);\n};\nexports.camelCase = camelCase;\n","var parse = require('inline-style-parser');\n\n/**\n * Parses inline style to object.\n *\n * @example\n * // returns { 'line-height': '42' }\n * StyleToObject('line-height: 42;');\n *\n * @param  {String}      style      - The inline style.\n * @param  {Function}    [iterator] - The iterator function.\n * @return {null|Object}\n */\nfunction StyleToObject(style, iterator) {\n  var output = null;\n  if (!style || typeof style !== 'string') {\n    return output;\n  }\n\n  var declaration;\n  var declarations = parse(style);\n  var hasIterator = typeof iterator === 'function';\n  var property;\n  var value;\n\n  for (var i = 0, len = declarations.length; i < len; i++) {\n    declaration = declarations[i];\n    property = declaration.property;\n    value = declaration.value;\n\n    if (hasIterator) {\n      iterator(property, value, declaration);\n    } else if (value) {\n      output || (output = {});\n      output[property] = value;\n    }\n  }\n\n  return output;\n}\n\nmodule.exports = StyleToObject;\nmodule.exports.default = StyleToObject; // ESM support\n","export var MS = '-ms-'\nexport var MOZ = '-moz-'\nexport var WEBKIT = '-webkit-'\n\nexport var COMMENT = 'comm'\nexport var RULESET = 'rule'\nexport var DECLARATION = 'decl'\n\nexport var PAGE = '@page'\nexport var MEDIA = '@media'\nexport var IMPORT = '@import'\nexport var CHARSET = '@charset'\nexport var VIEWPORT = '@viewport'\nexport var SUPPORTS = '@supports'\nexport var DOCUMENT = '@document'\nexport var NAMESPACE = '@namespace'\nexport var KEYFRAMES = '@keyframes'\nexport var FONT_FACE = '@font-face'\nexport var COUNTER_STYLE = '@counter-style'\nexport var FONT_FEATURE_VALUES = '@font-feature-values'\nexport var LAYER = '@layer'\n","import {MS, MOZ, WEBKIT, RULESET, KEYFRAMES, DECLARATION} from './Enum.js'\nimport {match, charat, substr, strlen, sizeof, replace, combine} from './Utility.js'\nimport {copy, tokenize} from './Tokenizer.js'\nimport {serialize} from './Serializer.js'\nimport {prefix} from './Prefixer.js'\n\n/**\n * @param {function[]} collection\n * @return {function}\n */\nexport function middleware (collection) {\n\tvar length = sizeof(collection)\n\n\treturn function (element, index, children, callback) {\n\t\tvar output = ''\n\n\t\tfor (var i = 0; i < length; i++)\n\t\t\toutput += collection[i](element, index, children, callback) || ''\n\n\t\treturn output\n\t}\n}\n\n/**\n * @param {function} callback\n * @return {function}\n */\nexport function rulesheet (callback) {\n\treturn function (element) {\n\t\tif (!element.root)\n\t\t\tif (element = element.return)\n\t\t\t\tcallback(element)\n\t}\n}\n\n/**\n * @param {object} element\n * @param {number} index\n * @param {object[]} children\n * @param {function} callback\n */\nexport function prefixer (element, index, children, callback) {\n\tif (element.length > -1)\n\t\tif (!element.return)\n\t\t\tswitch (element.type) {\n\t\t\t\tcase DECLARATION: element.return = prefix(element.value, element.length, children)\n\t\t\t\t\treturn\n\t\t\t\tcase KEYFRAMES:\n\t\t\t\t\treturn serialize([copy(element, {value: replace(element.value, '@', '@' + WEBKIT)})], callback)\n\t\t\t\tcase RULESET:\n\t\t\t\t\tif (element.length)\n\t\t\t\t\t\treturn combine(element.props, function (value) {\n\t\t\t\t\t\t\tswitch (match(value, /(::plac\\w+|:read-\\w+)/)) {\n\t\t\t\t\t\t\t\t// :read-(only|write)\n\t\t\t\t\t\t\t\tcase ':read-only': case ':read-write':\n\t\t\t\t\t\t\t\t\treturn serialize([copy(element, {props: [replace(value, /:(read-\\w+)/, ':' + MOZ + '$1')]})], callback)\n\t\t\t\t\t\t\t\t// :placeholder\n\t\t\t\t\t\t\t\tcase '::placeholder':\n\t\t\t\t\t\t\t\t\treturn serialize([\n\t\t\t\t\t\t\t\t\t\tcopy(element, {props: [replace(value, /:(plac\\w+)/, ':' + WEBKIT + 'input-$1')]}),\n\t\t\t\t\t\t\t\t\t\tcopy(element, {props: [replace(value, /:(plac\\w+)/, ':' + MOZ + '$1')]}),\n\t\t\t\t\t\t\t\t\t\tcopy(element, {props: [replace(value, /:(plac\\w+)/, MS + 'input-$1')]})\n\t\t\t\t\t\t\t\t\t], callback)\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\treturn ''\n\t\t\t\t\t\t})\n\t\t\t}\n}\n\n/**\n * @param {object} element\n * @param {number} index\n * @param {object[]} children\n */\nexport function namespace (element) {\n\tswitch (element.type) {\n\t\tcase RULESET:\n\t\t\telement.props = element.props.map(function (value) {\n\t\t\t\treturn combine(tokenize(value), function (value, index, children) {\n\t\t\t\t\tswitch (charat(value, 0)) {\n\t\t\t\t\t\t// \\f\n\t\t\t\t\t\tcase 12:\n\t\t\t\t\t\t\treturn substr(value, 1, strlen(value))\n\t\t\t\t\t\t// \\0 ( + > ~\n\t\t\t\t\t\tcase 0: case 40: case 43: case 62: case 126:\n\t\t\t\t\t\t\treturn value\n\t\t\t\t\t\t// :\n\t\t\t\t\t\tcase 58:\n\t\t\t\t\t\t\tif (children[++index] === 'global')\n\t\t\t\t\t\t\t\tchildren[index] = '', children[++index] = '\\f' + substr(children[index], index = 1, -1)\n\t\t\t\t\t\t// \\s\n\t\t\t\t\t\tcase 32:\n\t\t\t\t\t\t\treturn index === 1 ? '' : value\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\tswitch (index) {\n\t\t\t\t\t\t\t\tcase 0: element = value\n\t\t\t\t\t\t\t\t\treturn sizeof(children) > 1 ? '' : value\n\t\t\t\t\t\t\t\tcase index = sizeof(children) - 1: case 2:\n\t\t\t\t\t\t\t\t\treturn index === 2 ? value + element + element : value + element\n\t\t\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t\t\treturn value\n\t\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t})\n\t\t\t})\n\t}\n}\n","import {COMMENT, RULESET, DECLARATION} from './Enum.js'\nimport {abs, charat, trim, from, sizeof, strlen, substr, append, replace, indexof} from './Utility.js'\nimport {node, char, prev, next, peek, caret, alloc, dealloc, delimit, whitespace, escaping, identifier, commenter} from './Tokenizer.js'\n\n/**\n * @param {string} value\n * @return {object[]}\n */\nexport function compile (value) {\n\treturn dealloc(parse('', null, null, null, [''], value = alloc(value), 0, [0], value))\n}\n\n/**\n * @param {string} value\n * @param {object} root\n * @param {object?} parent\n * @param {string[]} rule\n * @param {string[]} rules\n * @param {string[]} rulesets\n * @param {number[]} pseudo\n * @param {number[]} points\n * @param {string[]} declarations\n * @return {object}\n */\nexport function parse (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {\n\tvar index = 0\n\tvar offset = 0\n\tvar length = pseudo\n\tvar atrule = 0\n\tvar property = 0\n\tvar previous = 0\n\tvar variable = 1\n\tvar scanning = 1\n\tvar ampersand = 1\n\tvar character = 0\n\tvar type = ''\n\tvar props = rules\n\tvar children = rulesets\n\tvar reference = rule\n\tvar characters = type\n\n\twhile (scanning)\n\t\tswitch (previous = character, character = next()) {\n\t\t\t// (\n\t\t\tcase 40:\n\t\t\t\tif (previous != 108 && charat(characters, length - 1) == 58) {\n\t\t\t\t\tif (indexof(characters += replace(delimit(character), '&', '&\\f'), '&\\f') != -1)\n\t\t\t\t\t\tampersand = -1\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t// \" ' [\n\t\t\tcase 34: case 39: case 91:\n\t\t\t\tcharacters += delimit(character)\n\t\t\t\tbreak\n\t\t\t// \\t \\n \\r \\s\n\t\t\tcase 9: case 10: case 13: case 32:\n\t\t\t\tcharacters += whitespace(previous)\n\t\t\t\tbreak\n\t\t\t// \\\n\t\t\tcase 92:\n\t\t\t\tcharacters += escaping(caret() - 1, 7)\n\t\t\t\tcontinue\n\t\t\t// /\n\t\t\tcase 47:\n\t\t\t\tswitch (peek()) {\n\t\t\t\t\tcase 42: case 47:\n\t\t\t\t\t\tappend(comment(commenter(next(), caret()), root, parent), declarations)\n\t\t\t\t\t\tbreak\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tcharacters += '/'\n\t\t\t\t}\n\t\t\t\tbreak\n\t\t\t// {\n\t\t\tcase 123 * variable:\n\t\t\t\tpoints[index++] = strlen(characters) * ampersand\n\t\t\t// } ; \\0\n\t\t\tcase 125 * variable: case 59: case 0:\n\t\t\t\tswitch (character) {\n\t\t\t\t\t// \\0 }\n\t\t\t\t\tcase 0: case 125: scanning = 0\n\t\t\t\t\t// ;\n\t\t\t\t\tcase 59 + offset: if (ampersand == -1) characters = replace(characters, /\\f/g, '')\n\t\t\t\t\t\tif (property > 0 && (strlen(characters) - length))\n\t\t\t\t\t\t\tappend(property > 32 ? declaration(characters + ';', rule, parent, length - 1) : declaration(replace(characters, ' ', '') + ';', rule, parent, length - 2), declarations)\n\t\t\t\t\t\tbreak\n\t\t\t\t\t// @ ;\n\t\t\t\t\tcase 59: characters += ';'\n\t\t\t\t\t// { rule/at-rule\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tappend(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length), rulesets)\n\n\t\t\t\t\t\tif (character === 123)\n\t\t\t\t\t\t\tif (offset === 0)\n\t\t\t\t\t\t\t\tparse(characters, root, reference, reference, props, rulesets, length, points, children)\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\tswitch (atrule === 99 && charat(characters, 3) === 110 ? 100 : atrule) {\n\t\t\t\t\t\t\t\t\t// d l m s\n\t\t\t\t\t\t\t\t\tcase 100: case 108: case 109: case 115:\n\t\t\t\t\t\t\t\t\t\tparse(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children)\n\t\t\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t\t\t\tparse(characters, reference, reference, reference, [''], children, 0, points, children)\n\t\t\t\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tindex = offset = property = 0, variable = ampersand = 1, type = characters = '', length = pseudo\n\t\t\t\tbreak\n\t\t\t// :\n\t\t\tcase 58:\n\t\t\t\tlength = 1 + strlen(characters), property = previous\n\t\t\tdefault:\n\t\t\t\tif (variable < 1)\n\t\t\t\t\tif (character == 123)\n\t\t\t\t\t\t--variable\n\t\t\t\t\telse if (character == 125 && variable++ == 0 && prev() == 125)\n\t\t\t\t\t\tcontinue\n\n\t\t\t\tswitch (characters += from(character), character * variable) {\n\t\t\t\t\t// &\n\t\t\t\t\tcase 38:\n\t\t\t\t\t\tampersand = offset > 0 ? 1 : (characters += '\\f', -1)\n\t\t\t\t\t\tbreak\n\t\t\t\t\t// ,\n\t\t\t\t\tcase 44:\n\t\t\t\t\t\tpoints[index++] = (strlen(characters) - 1) * ampersand, ampersand = 1\n\t\t\t\t\t\tbreak\n\t\t\t\t\t// @\n\t\t\t\t\tcase 64:\n\t\t\t\t\t\t// -\n\t\t\t\t\t\tif (peek() === 45)\n\t\t\t\t\t\t\tcharacters += delimit(next())\n\n\t\t\t\t\t\tatrule = peek(), offset = length = strlen(type = characters += identifier(caret())), character++\n\t\t\t\t\t\tbreak\n\t\t\t\t\t// -\n\t\t\t\t\tcase 45:\n\t\t\t\t\t\tif (previous === 45 && strlen(characters) == 2)\n\t\t\t\t\t\t\tvariable = 0\n\t\t\t\t}\n\t\t}\n\n\treturn rulesets\n}\n\n/**\n * @param {string} value\n * @param {object} root\n * @param {object?} parent\n * @param {number} index\n * @param {number} offset\n * @param {string[]} rules\n * @param {number[]} points\n * @param {string} type\n * @param {string[]} props\n * @param {string[]} children\n * @param {number} length\n * @return {object}\n */\nexport function ruleset (value, root, parent, index, offset, rules, points, type, props, children, length) {\n\tvar post = offset - 1\n\tvar rule = offset === 0 ? rules : ['']\n\tvar size = sizeof(rule)\n\n\tfor (var i = 0, j = 0, k = 0; i < index; ++i)\n\t\tfor (var x = 0, y = substr(value, post + 1, post = abs(j = points[i])), z = value; x < size; ++x)\n\t\t\tif (z = trim(j > 0 ? rule[x] + ' ' + y : replace(y, /&\\f/g, rule[x])))\n\t\t\t\tprops[k++] = z\n\n\treturn node(value, root, parent, offset === 0 ? RULESET : type, props, children, length)\n}\n\n/**\n * @param {number} value\n * @param {object} root\n * @param {object?} parent\n * @return {object}\n */\nexport function comment (value, root, parent) {\n\treturn node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0)\n}\n\n/**\n * @param {string} value\n * @param {object} root\n * @param {object?} parent\n * @param {number} length\n * @return {object}\n */\nexport function declaration (value, root, parent, length) {\n\treturn node(value, root, parent, DECLARATION, substr(value, 0, length), substr(value, length + 1, -1), length)\n}\n","import {IMPORT, LAYER, COMMENT, RULESET, DECLARATION, KEYFRAMES} from './Enum.js'\nimport {strlen, sizeof} from './Utility.js'\n\n/**\n * @param {object[]} children\n * @param {function} callback\n * @return {string}\n */\nexport function serialize (children, callback) {\n\tvar output = ''\n\tvar length = sizeof(children)\n\n\tfor (var i = 0; i < length; i++)\n\t\toutput += callback(children[i], i, children, callback) || ''\n\n\treturn output\n}\n\n/**\n * @param {object} element\n * @param {number} index\n * @param {object[]} children\n * @param {function} callback\n * @return {string}\n */\nexport function stringify (element, index, children, callback) {\n\tswitch (element.type) {\n\t\tcase LAYER: if (element.children.length) break\n\t\tcase IMPORT: case DECLARATION: return element.return = element.return || element.value\n\t\tcase COMMENT: return ''\n\t\tcase KEYFRAMES: return element.return = element.value + '{' + serialize(element.children, callback) + '}'\n\t\tcase RULESET: element.value = element.props.join(',')\n\t}\n\n\treturn strlen(children = serialize(element.children, callback)) ? element.return = element.value + '{' + children + '}' : ''\n}\n","import {from, trim, charat, strlen, substr, append, assign} from './Utility.js'\n\nexport var line = 1\nexport var column = 1\nexport var length = 0\nexport var position = 0\nexport var character = 0\nexport var characters = ''\n\n/**\n * @param {string} value\n * @param {object | null} root\n * @param {object | null} parent\n * @param {string} type\n * @param {string[] | string} props\n * @param {object[] | string} children\n * @param {number} length\n */\nexport function node (value, root, parent, type, props, children, length) {\n\treturn {value: value, root: root, parent: parent, type: type, props: props, children: children, line: line, column: column, length: length, return: ''}\n}\n\n/**\n * @param {object} root\n * @param {object} props\n * @return {object}\n */\nexport function copy (root, props) {\n\treturn assign(node('', null, null, '', null, null, 0), root, {length: -root.length}, props)\n}\n\n/**\n * @return {number}\n */\nexport function char () {\n\treturn character\n}\n\n/**\n * @return {number}\n */\nexport function prev () {\n\tcharacter = position > 0 ? charat(characters, --position) : 0\n\n\tif (column--, character === 10)\n\t\tcolumn = 1, line--\n\n\treturn character\n}\n\n/**\n * @return {number}\n */\nexport function next () {\n\tcharacter = position < length ? charat(characters, position++) : 0\n\n\tif (column++, character === 10)\n\t\tcolumn = 1, line++\n\n\treturn character\n}\n\n/**\n * @return {number}\n */\nexport function peek () {\n\treturn charat(characters, position)\n}\n\n/**\n * @return {number}\n */\nexport function caret () {\n\treturn position\n}\n\n/**\n * @param {number} begin\n * @param {number} end\n * @return {string}\n */\nexport function slice (begin, end) {\n\treturn substr(characters, begin, end)\n}\n\n/**\n * @param {number} type\n * @return {number}\n */\nexport function token (type) {\n\tswitch (type) {\n\t\t// \\0 \\t \\n \\r \\s whitespace token\n\t\tcase 0: case 9: case 10: case 13: case 32:\n\t\t\treturn 5\n\t\t// ! + , / > @ ~ isolate token\n\t\tcase 33: case 43: case 44: case 47: case 62: case 64: case 126:\n\t\t// ; { } breakpoint token\n\t\tcase 59: case 123: case 125:\n\t\t\treturn 4\n\t\t// : accompanied token\n\t\tcase 58:\n\t\t\treturn 3\n\t\t// \" ' ( [ opening delimit token\n\t\tcase 34: case 39: case 40: case 91:\n\t\t\treturn 2\n\t\t// ) ] closing delimit token\n\t\tcase 41: case 93:\n\t\t\treturn 1\n\t}\n\n\treturn 0\n}\n\n/**\n * @param {string} value\n * @return {any[]}\n */\nexport function alloc (value) {\n\treturn line = column = 1, length = strlen(characters = value), position = 0, []\n}\n\n/**\n * @param {any} value\n * @return {any}\n */\nexport function dealloc (value) {\n\treturn characters = '', value\n}\n\n/**\n * @param {number} type\n * @return {string}\n */\nexport function delimit (type) {\n\treturn trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)))\n}\n\n/**\n * @param {string} value\n * @return {string[]}\n */\nexport function tokenize (value) {\n\treturn dealloc(tokenizer(alloc(value)))\n}\n\n/**\n * @param {number} type\n * @return {string}\n */\nexport function whitespace (type) {\n\twhile (character = peek())\n\t\tif (character < 33)\n\t\t\tnext()\n\t\telse\n\t\t\tbreak\n\n\treturn token(type) > 2 || token(character) > 3 ? '' : ' '\n}\n\n/**\n * @param {string[]} children\n * @return {string[]}\n */\nexport function tokenizer (children) {\n\twhile (next())\n\t\tswitch (token(character)) {\n\t\t\tcase 0: append(identifier(position - 1), children)\n\t\t\t\tbreak\n\t\t\tcase 2: append(delimit(character), children)\n\t\t\t\tbreak\n\t\t\tdefault: append(from(character), children)\n\t\t}\n\n\treturn children\n}\n\n/**\n * @param {number} index\n * @param {number} count\n * @return {string}\n */\nexport function escaping (index, count) {\n\twhile (--count && next())\n\t\t// not 0-9 A-F a-f\n\t\tif (character < 48 || character > 102 || (character > 57 && character < 65) || (character > 70 && character < 97))\n\t\t\tbreak\n\n\treturn slice(index, caret() + (count < 6 && peek() == 32 && next() == 32))\n}\n\n/**\n * @param {number} type\n * @return {number}\n */\nexport function delimiter (type) {\n\twhile (next())\n\t\tswitch (character) {\n\t\t\t// ] ) \" '\n\t\t\tcase type:\n\t\t\t\treturn position\n\t\t\t// \" '\n\t\t\tcase 34: case 39:\n\t\t\t\tif (type !== 34 && type !== 39)\n\t\t\t\t\tdelimiter(character)\n\t\t\t\tbreak\n\t\t\t// (\n\t\t\tcase 40:\n\t\t\t\tif (type === 41)\n\t\t\t\t\tdelimiter(type)\n\t\t\t\tbreak\n\t\t\t// \\\n\t\t\tcase 92:\n\t\t\t\tnext()\n\t\t\t\tbreak\n\t\t}\n\n\treturn position\n}\n\n/**\n * @param {number} type\n * @param {number} index\n * @return {number}\n */\nexport function commenter (type, index) {\n\twhile (next())\n\t\t// //\n\t\tif (type + character === 47 + 10)\n\t\t\tbreak\n\t\t// /*\n\t\telse if (type + character === 42 + 42 && peek() === 47)\n\t\t\tbreak\n\n\treturn '/*' + slice(index, position - 1) + '*' + from(type === 47 ? type : next())\n}\n\n/**\n * @param {number} index\n * @return {string}\n */\nexport function identifier (index) {\n\twhile (!token(peek()))\n\t\tnext()\n\n\treturn slice(index, position)\n}\n","/**\n * @param {number}\n * @return {number}\n */\nexport var abs = Math.abs\n\n/**\n * @param {number}\n * @return {string}\n */\nexport var from = String.fromCharCode\n\n/**\n * @param {object}\n * @return {object}\n */\nexport var assign = Object.assign\n\n/**\n * @param {string} value\n * @param {number} length\n * @return {number}\n */\nexport function hash (value, length) {\n\treturn charat(value, 0) ^ 45 ? (((((((length << 2) ^ charat(value, 0)) << 2) ^ charat(value, 1)) << 2) ^ charat(value, 2)) << 2) ^ charat(value, 3) : 0\n}\n\n/**\n * @param {string} value\n * @return {string}\n */\nexport function trim (value) {\n\treturn value.trim()\n}\n\n/**\n * @param {string} value\n * @param {RegExp} pattern\n * @return {string?}\n */\nexport function match (value, pattern) {\n\treturn (value = pattern.exec(value)) ? value[0] : value\n}\n\n/**\n * @param {string} value\n * @param {(string|RegExp)} pattern\n * @param {string} replacement\n * @return {string}\n */\nexport function replace (value, pattern, replacement) {\n\treturn value.replace(pattern, replacement)\n}\n\n/**\n * @param {string} value\n * @param {string} search\n * @return {number}\n */\nexport function indexof (value, search) {\n\treturn value.indexOf(search)\n}\n\n/**\n * @param {string} value\n * @param {number} index\n * @return {number}\n */\nexport function charat (value, index) {\n\treturn value.charCodeAt(index) | 0\n}\n\n/**\n * @param {string} value\n * @param {number} begin\n * @param {number} end\n * @return {string}\n */\nexport function substr (value, begin, end) {\n\treturn value.slice(begin, end)\n}\n\n/**\n * @param {string} value\n * @return {number}\n */\nexport function strlen (value) {\n\treturn value.length\n}\n\n/**\n * @param {any[]} value\n * @return {number}\n */\nexport function sizeof (value) {\n\treturn value.length\n}\n\n/**\n * @param {any} value\n * @param {any[]} array\n * @return {any}\n */\nexport function append (value, array) {\n\treturn array.push(value), value\n}\n\n/**\n * @param {string[]} array\n * @param {function} callback\n * @return {string}\n */\nexport function combine (array, callback) {\n\treturn array.map(callback).join('')\n}\n","/**\n * SSR Window 4.0.2\n * Better handling for window object in SSR environment\n * https://github.com/nolimits4web/ssr-window\n *\n * Copyright 2021, Vladimir Kharlampidi\n *\n * Licensed under MIT\n *\n * Released on: December 13, 2021\n */\n/* eslint-disable no-param-reassign */\nfunction isObject(obj) {\n    return (obj !== null &&\n        typeof obj === 'object' &&\n        'constructor' in obj &&\n        obj.constructor === Object);\n}\nfunction extend(target = {}, src = {}) {\n    Object.keys(src).forEach((key) => {\n        if (typeof target[key] === 'undefined')\n            target[key] = src[key];\n        else if (isObject(src[key]) &&\n            isObject(target[key]) &&\n            Object.keys(src[key]).length > 0) {\n            extend(target[key], src[key]);\n        }\n    });\n}\n\nconst ssrDocument = {\n    body: {},\n    addEventListener() { },\n    removeEventListener() { },\n    activeElement: {\n        blur() { },\n        nodeName: '',\n    },\n    querySelector() {\n        return null;\n    },\n    querySelectorAll() {\n        return [];\n    },\n    getElementById() {\n        return null;\n    },\n    createEvent() {\n        return {\n            initEvent() { },\n        };\n    },\n    createElement() {\n        return {\n            children: [],\n            childNodes: [],\n            style: {},\n            setAttribute() { },\n            getElementsByTagName() {\n                return [];\n            },\n        };\n    },\n    createElementNS() {\n        return {};\n    },\n    importNode() {\n        return null;\n    },\n    location: {\n        hash: '',\n        host: '',\n        hostname: '',\n        href: '',\n        origin: '',\n        pathname: '',\n        protocol: '',\n        search: '',\n    },\n};\nfunction getDocument() {\n    const doc = typeof document !== 'undefined' ? document : {};\n    extend(doc, ssrDocument);\n    return doc;\n}\n\nconst ssrWindow = {\n    document: ssrDocument,\n    navigator: {\n        userAgent: '',\n    },\n    location: {\n        hash: '',\n        host: '',\n        hostname: '',\n        href: '',\n        origin: '',\n        pathname: '',\n        protocol: '',\n        search: '',\n    },\n    history: {\n        replaceState() { },\n        pushState() { },\n        go() { },\n        back() { },\n    },\n    CustomEvent: function CustomEvent() {\n        return this;\n    },\n    addEventListener() { },\n    removeEventListener() { },\n    getComputedStyle() {\n        return {\n            getPropertyValue() {\n                return '';\n            },\n        };\n    },\n    Image() { },\n    Date() { },\n    screen: {},\n    setTimeout() { },\n    clearTimeout() { },\n    matchMedia() {\n        return {};\n    },\n    requestAnimationFrame(callback) {\n        if (typeof setTimeout === 'undefined') {\n            callback();\n            return null;\n        }\n        return setTimeout(callback, 0);\n    },\n    cancelAnimationFrame(id) {\n        if (typeof setTimeout === 'undefined') {\n            return;\n        }\n        clearTimeout(id);\n    },\n};\nfunction getWindow() {\n    const win = typeof window !== 'undefined' ? window : {};\n    extend(win, ssrWindow);\n    return win;\n}\n\nexport { extend, getDocument, getWindow, ssrDocument, ssrWindow };\n","import { getWindow, getDocument } from 'ssr-window';\nfunction deleteProps(obj) {\n  const object = obj;\n  Object.keys(object).forEach(key => {\n    try {\n      object[key] = null;\n    } catch (e) {\n      // no getter for object\n    }\n    try {\n      delete object[key];\n    } catch (e) {\n      // something got wrong\n    }\n  });\n}\nfunction nextTick(callback, delay = 0) {\n  return setTimeout(callback, delay);\n}\nfunction now() {\n  return Date.now();\n}\nfunction getComputedStyle(el) {\n  const window = getWindow();\n  let style;\n  if (window.getComputedStyle) {\n    style = window.getComputedStyle(el, null);\n  }\n  if (!style && el.currentStyle) {\n    style = el.currentStyle;\n  }\n  if (!style) {\n    style = el.style;\n  }\n  return style;\n}\nfunction getTranslate(el, axis = 'x') {\n  const window = getWindow();\n  let matrix;\n  let curTransform;\n  let transformMatrix;\n  const curStyle = getComputedStyle(el, null);\n  if (window.WebKitCSSMatrix) {\n    curTransform = curStyle.transform || curStyle.webkitTransform;\n    if (curTransform.split(',').length > 6) {\n      curTransform = curTransform.split(', ').map(a => a.replace(',', '.')).join(', ');\n    }\n    // Some old versions of Webkit choke when 'none' is passed; pass\n    // empty string instead in this case\n    transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);\n  } else {\n    transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');\n    matrix = transformMatrix.toString().split(',');\n  }\n  if (axis === 'x') {\n    // Latest Chrome and webkits Fix\n    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41;\n    // Crazy IE10 Matrix\n    else if (matrix.length === 16) curTransform = parseFloat(matrix[12]);\n    // Normal Browsers\n    else curTransform = parseFloat(matrix[4]);\n  }\n  if (axis === 'y') {\n    // Latest Chrome and webkits Fix\n    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42;\n    // Crazy IE10 Matrix\n    else if (matrix.length === 16) curTransform = parseFloat(matrix[13]);\n    // Normal Browsers\n    else curTransform = parseFloat(matrix[5]);\n  }\n  return curTransform || 0;\n}\nfunction isObject(o) {\n  return typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object';\n}\nfunction isNode(node) {\n  // eslint-disable-next-line\n  if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {\n    return node instanceof HTMLElement;\n  }\n  return node && (node.nodeType === 1 || node.nodeType === 11);\n}\nfunction extend(...args) {\n  const to = Object(args[0]);\n  const noExtend = ['__proto__', 'constructor', 'prototype'];\n  for (let i = 1; i < args.length; i += 1) {\n    const nextSource = args[i];\n    if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {\n      const keysArray = Object.keys(Object(nextSource)).filter(key => noExtend.indexOf(key) < 0);\n      for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {\n        const nextKey = keysArray[nextIndex];\n        const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);\n        if (desc !== undefined && desc.enumerable) {\n          if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {\n            if (nextSource[nextKey].__swiper__) {\n              to[nextKey] = nextSource[nextKey];\n            } else {\n              extend(to[nextKey], nextSource[nextKey]);\n            }\n          } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {\n            to[nextKey] = {};\n            if (nextSource[nextKey].__swiper__) {\n              to[nextKey] = nextSource[nextKey];\n            } else {\n              extend(to[nextKey], nextSource[nextKey]);\n            }\n          } else {\n            to[nextKey] = nextSource[nextKey];\n          }\n        }\n      }\n    }\n  }\n  return to;\n}\nfunction setCSSProperty(el, varName, varValue) {\n  el.style.setProperty(varName, varValue);\n}\nfunction animateCSSModeScroll({\n  swiper,\n  targetPosition,\n  side\n}) {\n  const window = getWindow();\n  const startPosition = -swiper.translate;\n  let startTime = null;\n  let time;\n  const duration = swiper.params.speed;\n  swiper.wrapperEl.style.scrollSnapType = 'none';\n  window.cancelAnimationFrame(swiper.cssModeFrameID);\n  const dir = targetPosition > startPosition ? 'next' : 'prev';\n  const isOutOfBound = (current, target) => {\n    return dir === 'next' && current >= target || dir === 'prev' && current <= target;\n  };\n  const animate = () => {\n    time = new Date().getTime();\n    if (startTime === null) {\n      startTime = time;\n    }\n    const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);\n    const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;\n    let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);\n    if (isOutOfBound(currentPosition, targetPosition)) {\n      currentPosition = targetPosition;\n    }\n    swiper.wrapperEl.scrollTo({\n      [side]: currentPosition\n    });\n    if (isOutOfBound(currentPosition, targetPosition)) {\n      swiper.wrapperEl.style.overflow = 'hidden';\n      swiper.wrapperEl.style.scrollSnapType = '';\n      setTimeout(() => {\n        swiper.wrapperEl.style.overflow = '';\n        swiper.wrapperEl.scrollTo({\n          [side]: currentPosition\n        });\n      });\n      window.cancelAnimationFrame(swiper.cssModeFrameID);\n      return;\n    }\n    swiper.cssModeFrameID = window.requestAnimationFrame(animate);\n  };\n  animate();\n}\nfunction getSlideTransformEl(slideEl) {\n  return slideEl.querySelector('.swiper-slide-transform') || slideEl.shadowEl && slideEl.shadowEl.querySelector('.swiper-slide-transform') || slideEl;\n}\nfunction findElementsInElements(elements = [], selector = '') {\n  const found = [];\n  elements.forEach(el => {\n    found.push(...el.querySelectorAll(selector));\n  });\n  return found;\n}\nfunction elementChildren(element, selector = '') {\n  return [...element.children].filter(el => el.matches(selector));\n}\nfunction createElement(tag, classes = []) {\n  const el = document.createElement(tag);\n  el.classList.add(...(Array.isArray(classes) ? classes : [classes]));\n  return el;\n}\nfunction elementOffset(el) {\n  const window = getWindow();\n  const document = getDocument();\n  const box = el.getBoundingClientRect();\n  const body = document.body;\n  const clientTop = el.clientTop || body.clientTop || 0;\n  const clientLeft = el.clientLeft || body.clientLeft || 0;\n  const scrollTop = el === window ? window.scrollY : el.scrollTop;\n  const scrollLeft = el === window ? window.scrollX : el.scrollLeft;\n  return {\n    top: box.top + scrollTop - clientTop,\n    left: box.left + scrollLeft - clientLeft\n  };\n}\nfunction elementPrevAll(el, selector) {\n  const prevEls = [];\n  while (el.previousElementSibling) {\n    const prev = el.previousElementSibling; // eslint-disable-line\n    if (selector) {\n      if (prev.matches(selector)) prevEls.push(prev);\n    } else prevEls.push(prev);\n    el = prev;\n  }\n  return prevEls;\n}\nfunction elementNextAll(el, selector) {\n  const nextEls = [];\n  while (el.nextElementSibling) {\n    const next = el.nextElementSibling; // eslint-disable-line\n    if (selector) {\n      if (next.matches(selector)) nextEls.push(next);\n    } else nextEls.push(next);\n    el = next;\n  }\n  return nextEls;\n}\nfunction elementStyle(el, prop) {\n  const window = getWindow();\n  return window.getComputedStyle(el, null).getPropertyValue(prop);\n}\nfunction elementIndex(el) {\n  let child = el;\n  let i;\n  if (child) {\n    i = 0;\n    // eslint-disable-next-line\n    while ((child = child.previousSibling) !== null) {\n      if (child.nodeType === 1) i += 1;\n    }\n    return i;\n  }\n  return undefined;\n}\nfunction elementParents(el, selector) {\n  const parents = []; // eslint-disable-line\n  let parent = el.parentElement; // eslint-disable-line\n  while (parent) {\n    if (selector) {\n      if (parent.matches(selector)) parents.push(parent);\n    } else {\n      parents.push(parent);\n    }\n    parent = parent.parentElement;\n  }\n  return parents;\n}\nfunction elementTransitionEnd(el, callback) {\n  function fireCallBack(e) {\n    if (e.target !== el) return;\n    callback.call(el, e);\n    el.removeEventListener('transitionend', fireCallBack);\n  }\n  if (callback) {\n    el.addEventListener('transitionend', fireCallBack);\n  }\n}\nfunction elementOuterSize(el, size, includeMargins) {\n  const window = getWindow();\n  if (includeMargins) {\n    return el[size === 'width' ? 'offsetWidth' : 'offsetHeight'] + parseFloat(window.getComputedStyle(el, null).getPropertyValue(size === 'width' ? 'margin-right' : 'margin-top')) + parseFloat(window.getComputedStyle(el, null).getPropertyValue(size === 'width' ? 'margin-left' : 'margin-bottom'));\n  }\n  return el.offsetWidth;\n}\nexport { animateCSSModeScroll, deleteProps, nextTick, now, getTranslate, isObject, extend, getComputedStyle, setCSSProperty, getSlideTransformEl,\n// dom\nfindElementsInElements, createElement, elementChildren, elementOffset, elementPrevAll, elementNextAll, elementStyle, elementIndex, elementParents, elementTransitionEnd, elementOuterSize };","import { getWindow, getDocument } from 'ssr-window';\nlet support;\nfunction calcSupport() {\n  const window = getWindow();\n  const document = getDocument();\n  return {\n    smoothScroll: document.documentElement && document.documentElement.style && 'scrollBehavior' in document.documentElement.style,\n    touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch)\n  };\n}\nfunction getSupport() {\n  if (!support) {\n    support = calcSupport();\n  }\n  return support;\n}\nexport { getSupport };","import { getWindow } from 'ssr-window';\nimport { getSupport } from './get-support.js';\nlet deviceCached;\nfunction calcDevice({\n  userAgent\n} = {}) {\n  const support = getSupport();\n  const window = getWindow();\n  const platform = window.navigator.platform;\n  const ua = userAgent || window.navigator.userAgent;\n  const device = {\n    ios: false,\n    android: false\n  };\n  const screenWidth = window.screen.width;\n  const screenHeight = window.screen.height;\n  const android = ua.match(/(Android);?[\\s\\/]+([\\d.]+)?/); // eslint-disable-line\n  let ipad = ua.match(/(iPad).*OS\\s([\\d_]+)/);\n  const ipod = ua.match(/(iPod)(.*OS\\s([\\d_]+))?/);\n  const iphone = !ipad && ua.match(/(iPhone\\sOS|iOS)\\s([\\d_]+)/);\n  const windows = platform === 'Win32';\n  let macos = platform === 'MacIntel';\n\n  // iPadOs 13 fix\n  const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];\n  if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {\n    ipad = ua.match(/(Version)\\/([\\d.]+)/);\n    if (!ipad) ipad = [0, 1, '13_0_0'];\n    macos = false;\n  }\n\n  // Android\n  if (android && !windows) {\n    device.os = 'android';\n    device.android = true;\n  }\n  if (ipad || iphone || ipod) {\n    device.os = 'ios';\n    device.ios = true;\n  }\n\n  // Export object\n  return device;\n}\nfunction getDevice(overrides = {}) {\n  if (!deviceCached) {\n    deviceCached = calcDevice(overrides);\n  }\n  return deviceCached;\n}\nexport { getDevice };","import { getWindow } from 'ssr-window';\nlet browser;\nfunction calcBrowser() {\n  const window = getWindow();\n  let needPerspectiveFix = false;\n  function isSafari() {\n    const ua = window.navigator.userAgent.toLowerCase();\n    return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;\n  }\n  if (isSafari()) {\n    const ua = String(window.navigator.userAgent);\n    if (ua.includes('Version/')) {\n      const [major, minor] = ua.split('Version/')[1].split(' ')[0].split('.').map(num => Number(num));\n      needPerspectiveFix = major < 16 || major === 16 && minor < 2;\n    }\n  }\n  return {\n    isSafari: needPerspectiveFix || isSafari(),\n    needPerspectiveFix,\n    isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent)\n  };\n}\nfunction getBrowser() {\n  if (!browser) {\n    browser = calcBrowser();\n  }\n  return browser;\n}\nexport { getBrowser };","/* eslint-disable no-underscore-dangle */\n\nexport default {\n  on(events, handler, priority) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (typeof handler !== 'function') return self;\n    const method = priority ? 'unshift' : 'push';\n    events.split(' ').forEach(event => {\n      if (!self.eventsListeners[event]) self.eventsListeners[event] = [];\n      self.eventsListeners[event][method](handler);\n    });\n    return self;\n  },\n  once(events, handler, priority) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (typeof handler !== 'function') return self;\n    function onceHandler(...args) {\n      self.off(events, onceHandler);\n      if (onceHandler.__emitterProxy) {\n        delete onceHandler.__emitterProxy;\n      }\n      handler.apply(self, args);\n    }\n    onceHandler.__emitterProxy = handler;\n    return self.on(events, onceHandler, priority);\n  },\n  onAny(handler, priority) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (typeof handler !== 'function') return self;\n    const method = priority ? 'unshift' : 'push';\n    if (self.eventsAnyListeners.indexOf(handler) < 0) {\n      self.eventsAnyListeners[method](handler);\n    }\n    return self;\n  },\n  offAny(handler) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (!self.eventsAnyListeners) return self;\n    const index = self.eventsAnyListeners.indexOf(handler);\n    if (index >= 0) {\n      self.eventsAnyListeners.splice(index, 1);\n    }\n    return self;\n  },\n  off(events, handler) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (!self.eventsListeners) return self;\n    events.split(' ').forEach(event => {\n      if (typeof handler === 'undefined') {\n        self.eventsListeners[event] = [];\n      } else if (self.eventsListeners[event]) {\n        self.eventsListeners[event].forEach((eventHandler, index) => {\n          if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {\n            self.eventsListeners[event].splice(index, 1);\n          }\n        });\n      }\n    });\n    return self;\n  },\n  emit(...args) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (!self.eventsListeners) return self;\n    let events;\n    let data;\n    let context;\n    if (typeof args[0] === 'string' || Array.isArray(args[0])) {\n      events = args[0];\n      data = args.slice(1, args.length);\n      context = self;\n    } else {\n      events = args[0].events;\n      data = args[0].data;\n      context = args[0].context || self;\n    }\n    data.unshift(context);\n    const eventsArray = Array.isArray(events) ? events : events.split(' ');\n    eventsArray.forEach(event => {\n      if (self.eventsAnyListeners && self.eventsAnyListeners.length) {\n        self.eventsAnyListeners.forEach(eventHandler => {\n          eventHandler.apply(context, [event, ...data]);\n        });\n      }\n      if (self.eventsListeners && self.eventsListeners[event]) {\n        self.eventsListeners[event].forEach(eventHandler => {\n          eventHandler.apply(context, data);\n        });\n      }\n    });\n    return self;\n  }\n};","export const processLazyPreloader = (swiper, imageEl) => {\n  if (!swiper || swiper.destroyed || !swiper.params) return;\n  const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;\n  const slideEl = imageEl.closest(slideSelector());\n  if (slideEl) {\n    const lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);\n    if (lazyEl) lazyEl.remove();\n  }\n};\nconst unlazy = (swiper, index) => {\n  if (!swiper.slides[index]) return;\n  const imageEl = swiper.slides[index].querySelector('[loading=\"lazy\"]');\n  if (imageEl) imageEl.removeAttribute('loading');\n};\nexport const preload = swiper => {\n  if (!swiper || swiper.destroyed || !swiper.params) return;\n  let amount = swiper.params.lazyPreloadPrevNext;\n  const len = swiper.slides.length;\n  if (!len || !amount || amount < 0) return;\n  amount = Math.min(amount, len);\n  const slidesPerView = swiper.params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);\n  const activeIndex = swiper.activeIndex;\n  if (swiper.params.grid && swiper.params.grid.rows > 1) {\n    const activeColumn = activeIndex;\n    const preloadColumns = [activeColumn - amount];\n    preloadColumns.push(...Array.from({\n      length: amount\n    }).map((_, i) => {\n      return activeColumn + slidesPerView + i;\n    }));\n    swiper.slides.forEach((slideEl, i) => {\n      if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);\n    });\n    return;\n  }\n  const slideIndexLastInView = activeIndex + slidesPerView - 1;\n  if (swiper.params.rewind || swiper.params.loop) {\n    for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {\n      const realIndex = (i % len + len) % len;\n      if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);\n    }\n  } else {\n    for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) {\n      if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) {\n        unlazy(swiper, i);\n      }\n    }\n  }\n};","import updateSize from './updateSize.js';\nimport updateSlides from './updateSlides.js';\nimport updateAutoHeight from './updateAutoHeight.js';\nimport updateSlidesOffset from './updateSlidesOffset.js';\nimport updateSlidesProgress from './updateSlidesProgress.js';\nimport updateProgress from './updateProgress.js';\nimport updateSlidesClasses from './updateSlidesClasses.js';\nimport updateActiveIndex from './updateActiveIndex.js';\nimport updateClickedSlide from './updateClickedSlide.js';\nexport default {\n  updateSize,\n  updateSlides,\n  updateAutoHeight,\n  updateSlidesOffset,\n  updateSlidesProgress,\n  updateProgress,\n  updateSlidesClasses,\n  updateActiveIndex,\n  updateClickedSlide\n};","import { elementStyle } from '../../shared/utils.js';\nexport default function updateSize() {\n  const swiper = this;\n  let width;\n  let height;\n  const el = swiper.el;\n  if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {\n    width = swiper.params.width;\n  } else {\n    width = el.clientWidth;\n  }\n  if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {\n    height = swiper.params.height;\n  } else {\n    height = el.clientHeight;\n  }\n  if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {\n    return;\n  }\n\n  // Subtract paddings\n  width = width - parseInt(elementStyle(el, 'padding-left') || 0, 10) - parseInt(elementStyle(el, 'padding-right') || 0, 10);\n  height = height - parseInt(elementStyle(el, 'padding-top') || 0, 10) - parseInt(elementStyle(el, 'padding-bottom') || 0, 10);\n  if (Number.isNaN(width)) width = 0;\n  if (Number.isNaN(height)) height = 0;\n  Object.assign(swiper, {\n    width,\n    height,\n    size: swiper.isHorizontal() ? width : height\n  });\n}","import { elementChildren, elementOuterSize, elementStyle, setCSSProperty } from '../../shared/utils.js';\nexport default function updateSlides() {\n  const swiper = this;\n  function getDirectionLabel(property) {\n    if (swiper.isHorizontal()) {\n      return property;\n    }\n    // prettier-ignore\n    return {\n      'width': 'height',\n      'margin-top': 'margin-left',\n      'margin-bottom ': 'margin-right',\n      'margin-left': 'margin-top',\n      'margin-right': 'margin-bottom',\n      'padding-left': 'padding-top',\n      'padding-right': 'padding-bottom',\n      'marginRight': 'marginBottom'\n    }[property];\n  }\n  function getDirectionPropertyValue(node, label) {\n    return parseFloat(node.getPropertyValue(getDirectionLabel(label)) || 0);\n  }\n  const params = swiper.params;\n  const {\n    wrapperEl,\n    slidesEl,\n    size: swiperSize,\n    rtlTranslate: rtl,\n    wrongRTL\n  } = swiper;\n  const isVirtual = swiper.virtual && params.virtual.enabled;\n  const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;\n  const slides = elementChildren(slidesEl, `.${swiper.params.slideClass}, swiper-slide`);\n  const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;\n  let snapGrid = [];\n  const slidesGrid = [];\n  const slidesSizesGrid = [];\n  let offsetBefore = params.slidesOffsetBefore;\n  if (typeof offsetBefore === 'function') {\n    offsetBefore = params.slidesOffsetBefore.call(swiper);\n  }\n  let offsetAfter = params.slidesOffsetAfter;\n  if (typeof offsetAfter === 'function') {\n    offsetAfter = params.slidesOffsetAfter.call(swiper);\n  }\n  const previousSnapGridLength = swiper.snapGrid.length;\n  const previousSlidesGridLength = swiper.slidesGrid.length;\n  let spaceBetween = params.spaceBetween;\n  let slidePosition = -offsetBefore;\n  let prevSlideSize = 0;\n  let index = 0;\n  if (typeof swiperSize === 'undefined') {\n    return;\n  }\n  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {\n    spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;\n  } else if (typeof spaceBetween === 'string') {\n    spaceBetween = parseFloat(spaceBetween);\n  }\n  swiper.virtualSize = -spaceBetween;\n\n  // reset margins\n  slides.forEach(slideEl => {\n    if (rtl) {\n      slideEl.style.marginLeft = '';\n    } else {\n      slideEl.style.marginRight = '';\n    }\n    slideEl.style.marginBottom = '';\n    slideEl.style.marginTop = '';\n  });\n\n  // reset cssMode offsets\n  if (params.centeredSlides && params.cssMode) {\n    setCSSProperty(wrapperEl, '--swiper-centered-offset-before', '');\n    setCSSProperty(wrapperEl, '--swiper-centered-offset-after', '');\n  }\n  const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;\n  if (gridEnabled) {\n    swiper.grid.initSlides(slidesLength);\n  }\n\n  // Calc slides\n  let slideSize;\n  const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {\n    return typeof params.breakpoints[key].slidesPerView !== 'undefined';\n  }).length > 0;\n  for (let i = 0; i < slidesLength; i += 1) {\n    slideSize = 0;\n    let slide;\n    if (slides[i]) slide = slides[i];\n    if (gridEnabled) {\n      swiper.grid.updateSlide(i, slide, slidesLength, getDirectionLabel);\n    }\n    if (slides[i] && elementStyle(slide, 'display') === 'none') continue; // eslint-disable-line\n\n    if (params.slidesPerView === 'auto') {\n      if (shouldResetSlideSize) {\n        slides[i].style[getDirectionLabel('width')] = ``;\n      }\n      const slideStyles = getComputedStyle(slide);\n      const currentTransform = slide.style.transform;\n      const currentWebKitTransform = slide.style.webkitTransform;\n      if (currentTransform) {\n        slide.style.transform = 'none';\n      }\n      if (currentWebKitTransform) {\n        slide.style.webkitTransform = 'none';\n      }\n      if (params.roundLengths) {\n        slideSize = swiper.isHorizontal() ? elementOuterSize(slide, 'width', true) : elementOuterSize(slide, 'height', true);\n      } else {\n        // eslint-disable-next-line\n        const width = getDirectionPropertyValue(slideStyles, 'width');\n        const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');\n        const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');\n        const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');\n        const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');\n        const boxSizing = slideStyles.getPropertyValue('box-sizing');\n        if (boxSizing && boxSizing === 'border-box') {\n          slideSize = width + marginLeft + marginRight;\n        } else {\n          const {\n            clientWidth,\n            offsetWidth\n          } = slide;\n          slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);\n        }\n      }\n      if (currentTransform) {\n        slide.style.transform = currentTransform;\n      }\n      if (currentWebKitTransform) {\n        slide.style.webkitTransform = currentWebKitTransform;\n      }\n      if (params.roundLengths) slideSize = Math.floor(slideSize);\n    } else {\n      slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;\n      if (params.roundLengths) slideSize = Math.floor(slideSize);\n      if (slides[i]) {\n        slides[i].style[getDirectionLabel('width')] = `${slideSize}px`;\n      }\n    }\n    if (slides[i]) {\n      slides[i].swiperSlideSize = slideSize;\n    }\n    slidesSizesGrid.push(slideSize);\n    if (params.centeredSlides) {\n      slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;\n      if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;\n      if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;\n      if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;\n      if (params.roundLengths) slidePosition = Math.floor(slidePosition);\n      if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);\n      slidesGrid.push(slidePosition);\n    } else {\n      if (params.roundLengths) slidePosition = Math.floor(slidePosition);\n      if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);\n      slidesGrid.push(slidePosition);\n      slidePosition = slidePosition + slideSize + spaceBetween;\n    }\n    swiper.virtualSize += slideSize + spaceBetween;\n    prevSlideSize = slideSize;\n    index += 1;\n  }\n  swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;\n  if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {\n    wrapperEl.style.width = `${swiper.virtualSize + spaceBetween}px`;\n  }\n  if (params.setWrapperSize) {\n    wrapperEl.style[getDirectionLabel('width')] = `${swiper.virtualSize + spaceBetween}px`;\n  }\n  if (gridEnabled) {\n    swiper.grid.updateWrapperSize(slideSize, snapGrid, getDirectionLabel);\n  }\n\n  // Remove last grid elements depending on width\n  if (!params.centeredSlides) {\n    const newSlidesGrid = [];\n    for (let i = 0; i < snapGrid.length; i += 1) {\n      let slidesGridItem = snapGrid[i];\n      if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);\n      if (snapGrid[i] <= swiper.virtualSize - swiperSize) {\n        newSlidesGrid.push(slidesGridItem);\n      }\n    }\n    snapGrid = newSlidesGrid;\n    if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {\n      snapGrid.push(swiper.virtualSize - swiperSize);\n    }\n  }\n  if (isVirtual && params.loop) {\n    const size = slidesSizesGrid[0] + spaceBetween;\n    if (params.slidesPerGroup > 1) {\n      const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);\n      const groupSize = size * params.slidesPerGroup;\n      for (let i = 0; i < groups; i += 1) {\n        snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);\n      }\n    }\n    for (let i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {\n      if (params.slidesPerGroup === 1) {\n        snapGrid.push(snapGrid[snapGrid.length - 1] + size);\n      }\n      slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);\n      swiper.virtualSize += size;\n    }\n  }\n  if (snapGrid.length === 0) snapGrid = [0];\n  if (spaceBetween !== 0) {\n    const key = swiper.isHorizontal() && rtl ? 'marginLeft' : getDirectionLabel('marginRight');\n    slides.filter((_, slideIndex) => {\n      if (!params.cssMode || params.loop) return true;\n      if (slideIndex === slides.length - 1) {\n        return false;\n      }\n      return true;\n    }).forEach(slideEl => {\n      slideEl.style[key] = `${spaceBetween}px`;\n    });\n  }\n  if (params.centeredSlides && params.centeredSlidesBounds) {\n    let allSlidesSize = 0;\n    slidesSizesGrid.forEach(slideSizeValue => {\n      allSlidesSize += slideSizeValue + (spaceBetween || 0);\n    });\n    allSlidesSize -= spaceBetween;\n    const maxSnap = allSlidesSize - swiperSize;\n    snapGrid = snapGrid.map(snap => {\n      if (snap <= 0) return -offsetBefore;\n      if (snap > maxSnap) return maxSnap + offsetAfter;\n      return snap;\n    });\n  }\n  if (params.centerInsufficientSlides) {\n    let allSlidesSize = 0;\n    slidesSizesGrid.forEach(slideSizeValue => {\n      allSlidesSize += slideSizeValue + (spaceBetween || 0);\n    });\n    allSlidesSize -= spaceBetween;\n    if (allSlidesSize < swiperSize) {\n      const allSlidesOffset = (swiperSize - allSlidesSize) / 2;\n      snapGrid.forEach((snap, snapIndex) => {\n        snapGrid[snapIndex] = snap - allSlidesOffset;\n      });\n      slidesGrid.forEach((snap, snapIndex) => {\n        slidesGrid[snapIndex] = snap + allSlidesOffset;\n      });\n    }\n  }\n  Object.assign(swiper, {\n    slides,\n    snapGrid,\n    slidesGrid,\n    slidesSizesGrid\n  });\n  if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {\n    setCSSProperty(wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);\n    setCSSProperty(wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);\n    const addToSnapGrid = -swiper.snapGrid[0];\n    const addToSlidesGrid = -swiper.slidesGrid[0];\n    swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);\n    swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);\n  }\n  if (slidesLength !== previousSlidesLength) {\n    swiper.emit('slidesLengthChange');\n  }\n  if (snapGrid.length !== previousSnapGridLength) {\n    if (swiper.params.watchOverflow) swiper.checkOverflow();\n    swiper.emit('snapGridLengthChange');\n  }\n  if (slidesGrid.length !== previousSlidesGridLength) {\n    swiper.emit('slidesGridLengthChange');\n  }\n  if (params.watchSlidesProgress) {\n    swiper.updateSlidesOffset();\n  }\n  if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {\n    const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;\n    const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);\n    if (slidesLength <= params.maxBackfaceHiddenSlides) {\n      if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);\n    } else if (hasClassBackfaceClassAdded) {\n      swiper.el.classList.remove(backFaceHiddenClass);\n    }\n  }\n}","export default function updateAutoHeight(speed) {\n  const swiper = this;\n  const activeSlides = [];\n  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;\n  let newHeight = 0;\n  let i;\n  if (typeof speed === 'number') {\n    swiper.setTransition(speed);\n  } else if (speed === true) {\n    swiper.setTransition(swiper.params.speed);\n  }\n  const getSlideByIndex = index => {\n    if (isVirtual) {\n      return swiper.slides[swiper.getSlideIndexByData(index)];\n    }\n    return swiper.slides[index];\n  };\n  // Find slides currently in view\n  if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {\n    if (swiper.params.centeredSlides) {\n      (swiper.visibleSlides || []).forEach(slide => {\n        activeSlides.push(slide);\n      });\n    } else {\n      for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {\n        const index = swiper.activeIndex + i;\n        if (index > swiper.slides.length && !isVirtual) break;\n        activeSlides.push(getSlideByIndex(index));\n      }\n    }\n  } else {\n    activeSlides.push(getSlideByIndex(swiper.activeIndex));\n  }\n\n  // Find new height from highest slide in view\n  for (i = 0; i < activeSlides.length; i += 1) {\n    if (typeof activeSlides[i] !== 'undefined') {\n      const height = activeSlides[i].offsetHeight;\n      newHeight = height > newHeight ? height : newHeight;\n    }\n  }\n\n  // Update Height\n  if (newHeight || newHeight === 0) swiper.wrapperEl.style.height = `${newHeight}px`;\n}","export default function updateSlidesOffset() {\n  const swiper = this;\n  const slides = swiper.slides;\n  // eslint-disable-next-line\n  const minusOffset = swiper.isElement ? swiper.isHorizontal() ? swiper.wrapperEl.offsetLeft : swiper.wrapperEl.offsetTop : 0;\n  for (let i = 0; i < slides.length; i += 1) {\n    slides[i].swiperSlideOffset = (swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop) - minusOffset - swiper.cssOverflowAdjustment();\n  }\n}","export default function updateSlidesProgress(translate = this && this.translate || 0) {\n  const swiper = this;\n  const params = swiper.params;\n  const {\n    slides,\n    rtlTranslate: rtl,\n    snapGrid\n  } = swiper;\n  if (slides.length === 0) return;\n  if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();\n  let offsetCenter = -translate;\n  if (rtl) offsetCenter = translate;\n\n  // Visible Slides\n  slides.forEach(slideEl => {\n    slideEl.classList.remove(params.slideVisibleClass);\n  });\n  swiper.visibleSlidesIndexes = [];\n  swiper.visibleSlides = [];\n  let spaceBetween = params.spaceBetween;\n  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {\n    spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiper.size;\n  } else if (typeof spaceBetween === 'string') {\n    spaceBetween = parseFloat(spaceBetween);\n  }\n  for (let i = 0; i < slides.length; i += 1) {\n    const slide = slides[i];\n    let slideOffset = slide.swiperSlideOffset;\n    if (params.cssMode && params.centeredSlides) {\n      slideOffset -= slides[0].swiperSlideOffset;\n    }\n    const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);\n    const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);\n    const slideBefore = -(offsetCenter - slideOffset);\n    const slideAfter = slideBefore + swiper.slidesSizesGrid[i];\n    const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;\n    if (isVisible) {\n      swiper.visibleSlides.push(slide);\n      swiper.visibleSlidesIndexes.push(i);\n      slides[i].classList.add(params.slideVisibleClass);\n    }\n    slide.progress = rtl ? -slideProgress : slideProgress;\n    slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;\n  }\n}","export default function updateProgress(translate) {\n  const swiper = this;\n  if (typeof translate === 'undefined') {\n    const multiplier = swiper.rtlTranslate ? -1 : 1;\n    // eslint-disable-next-line\n    translate = swiper && swiper.translate && swiper.translate * multiplier || 0;\n  }\n  const params = swiper.params;\n  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();\n  let {\n    progress,\n    isBeginning,\n    isEnd,\n    progressLoop\n  } = swiper;\n  const wasBeginning = isBeginning;\n  const wasEnd = isEnd;\n  if (translatesDiff === 0) {\n    progress = 0;\n    isBeginning = true;\n    isEnd = true;\n  } else {\n    progress = (translate - swiper.minTranslate()) / translatesDiff;\n    const isBeginningRounded = Math.abs(translate - swiper.minTranslate()) < 1;\n    const isEndRounded = Math.abs(translate - swiper.maxTranslate()) < 1;\n    isBeginning = isBeginningRounded || progress <= 0;\n    isEnd = isEndRounded || progress >= 1;\n    if (isBeginningRounded) progress = 0;\n    if (isEndRounded) progress = 1;\n  }\n  if (params.loop) {\n    const firstSlideIndex = swiper.getSlideIndexByData(0);\n    const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);\n    const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];\n    const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];\n    const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];\n    const translateAbs = Math.abs(translate);\n    if (translateAbs >= firstSlideTranslate) {\n      progressLoop = (translateAbs - firstSlideTranslate) / translateMax;\n    } else {\n      progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;\n    }\n    if (progressLoop > 1) progressLoop -= 1;\n  }\n  Object.assign(swiper, {\n    progress,\n    progressLoop,\n    isBeginning,\n    isEnd\n  });\n  if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);\n  if (isBeginning && !wasBeginning) {\n    swiper.emit('reachBeginning toEdge');\n  }\n  if (isEnd && !wasEnd) {\n    swiper.emit('reachEnd toEdge');\n  }\n  if (wasBeginning && !isBeginning || wasEnd && !isEnd) {\n    swiper.emit('fromEdge');\n  }\n  swiper.emit('progress', progress);\n}","import { elementChildren, elementNextAll, elementPrevAll } from '../../shared/utils.js';\nexport default function updateSlidesClasses() {\n  const swiper = this;\n  const {\n    slides,\n    params,\n    slidesEl,\n    activeIndex\n  } = swiper;\n  const isVirtual = swiper.virtual && params.virtual.enabled;\n  const getFilteredSlide = selector => {\n    return elementChildren(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];\n  };\n  slides.forEach(slideEl => {\n    slideEl.classList.remove(params.slideActiveClass, params.slideNextClass, params.slidePrevClass);\n  });\n  let activeSlide;\n  if (isVirtual) {\n    if (params.loop) {\n      let slideIndex = activeIndex - swiper.virtual.slidesBefore;\n      if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;\n      if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;\n      activeSlide = getFilteredSlide(`[data-swiper-slide-index=\"${slideIndex}\"]`);\n    } else {\n      activeSlide = getFilteredSlide(`[data-swiper-slide-index=\"${activeIndex}\"]`);\n    }\n  } else {\n    activeSlide = slides[activeIndex];\n  }\n  if (activeSlide) {\n    // Active classes\n    activeSlide.classList.add(params.slideActiveClass);\n\n    // Next Slide\n    let nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];\n    if (params.loop && !nextSlide) {\n      nextSlide = slides[0];\n    }\n    if (nextSlide) {\n      nextSlide.classList.add(params.slideNextClass);\n    }\n    // Prev Slide\n    let prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];\n    if (params.loop && !prevSlide === 0) {\n      prevSlide = slides[slides.length - 1];\n    }\n    if (prevSlide) {\n      prevSlide.classList.add(params.slidePrevClass);\n    }\n  }\n  swiper.emitSlidesClasses();\n}","import { preload } from '../../shared/process-lazy-preloader.js';\nexport function getActiveIndexByTranslate(swiper) {\n  const {\n    slidesGrid,\n    params\n  } = swiper;\n  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;\n  let activeIndex;\n  for (let i = 0; i < slidesGrid.length; i += 1) {\n    if (typeof slidesGrid[i + 1] !== 'undefined') {\n      if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {\n        activeIndex = i;\n      } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {\n        activeIndex = i + 1;\n      }\n    } else if (translate >= slidesGrid[i]) {\n      activeIndex = i;\n    }\n  }\n  // Normalize slideIndex\n  if (params.normalizeSlideIndex) {\n    if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;\n  }\n  return activeIndex;\n}\nexport default function updateActiveIndex(newActiveIndex) {\n  const swiper = this;\n  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;\n  const {\n    snapGrid,\n    params,\n    activeIndex: previousIndex,\n    realIndex: previousRealIndex,\n    snapIndex: previousSnapIndex\n  } = swiper;\n  let activeIndex = newActiveIndex;\n  let snapIndex;\n  const getVirtualRealIndex = aIndex => {\n    let realIndex = aIndex - swiper.virtual.slidesBefore;\n    if (realIndex < 0) {\n      realIndex = swiper.virtual.slides.length + realIndex;\n    }\n    if (realIndex >= swiper.virtual.slides.length) {\n      realIndex -= swiper.virtual.slides.length;\n    }\n    return realIndex;\n  };\n  if (typeof activeIndex === 'undefined') {\n    activeIndex = getActiveIndexByTranslate(swiper);\n  }\n  if (snapGrid.indexOf(translate) >= 0) {\n    snapIndex = snapGrid.indexOf(translate);\n  } else {\n    const skip = Math.min(params.slidesPerGroupSkip, activeIndex);\n    snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);\n  }\n  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;\n  if (activeIndex === previousIndex) {\n    if (snapIndex !== previousSnapIndex) {\n      swiper.snapIndex = snapIndex;\n      swiper.emit('snapIndexChange');\n    }\n    if (swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {\n      swiper.realIndex = getVirtualRealIndex(activeIndex);\n    }\n    return;\n  }\n  // Get real index\n  let realIndex;\n  if (swiper.virtual && params.virtual.enabled && params.loop) {\n    realIndex = getVirtualRealIndex(activeIndex);\n  } else if (swiper.slides[activeIndex]) {\n    realIndex = parseInt(swiper.slides[activeIndex].getAttribute('data-swiper-slide-index') || activeIndex, 10);\n  } else {\n    realIndex = activeIndex;\n  }\n  Object.assign(swiper, {\n    previousSnapIndex,\n    snapIndex,\n    previousRealIndex,\n    realIndex,\n    previousIndex,\n    activeIndex\n  });\n  if (swiper.initialized) {\n    preload(swiper);\n  }\n  swiper.emit('activeIndexChange');\n  swiper.emit('snapIndexChange');\n  if (previousRealIndex !== realIndex) {\n    swiper.emit('realIndexChange');\n  }\n  if (swiper.initialized || swiper.params.runCallbacksOnInit) {\n    swiper.emit('slideChange');\n  }\n}","export default function updateClickedSlide(e) {\n  const swiper = this;\n  const params = swiper.params;\n  const slide = e.closest(`.${params.slideClass}, swiper-slide`);\n  let slideFound = false;\n  let slideIndex;\n  if (slide) {\n    for (let i = 0; i < swiper.slides.length; i += 1) {\n      if (swiper.slides[i] === slide) {\n        slideFound = true;\n        slideIndex = i;\n        break;\n      }\n    }\n  }\n  if (slide && slideFound) {\n    swiper.clickedSlide = slide;\n    if (swiper.virtual && swiper.params.virtual.enabled) {\n      swiper.clickedIndex = parseInt(slide.getAttribute('data-swiper-slide-index'), 10);\n    } else {\n      swiper.clickedIndex = slideIndex;\n    }\n  } else {\n    swiper.clickedSlide = undefined;\n    swiper.clickedIndex = undefined;\n    return;\n  }\n  if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {\n    swiper.slideToClickedSlide();\n  }\n}","import getTranslate from './getTranslate.js';\nimport setTranslate from './setTranslate.js';\nimport minTranslate from './minTranslate.js';\nimport maxTranslate from './maxTranslate.js';\nimport translateTo from './translateTo.js';\nexport default {\n  getTranslate,\n  setTranslate,\n  minTranslate,\n  maxTranslate,\n  translateTo\n};","import { getTranslate } from '../../shared/utils.js';\nexport default function getSwiperTranslate(axis = this.isHorizontal() ? 'x' : 'y') {\n  const swiper = this;\n  const {\n    params,\n    rtlTranslate: rtl,\n    translate,\n    wrapperEl\n  } = swiper;\n  if (params.virtualTranslate) {\n    return rtl ? -translate : translate;\n  }\n  if (params.cssMode) {\n    return translate;\n  }\n  let currentTranslate = getTranslate(wrapperEl, axis);\n  currentTranslate += swiper.cssOverflowAdjustment();\n  if (rtl) currentTranslate = -currentTranslate;\n  return currentTranslate || 0;\n}","export default function setTranslate(translate, byController) {\n  const swiper = this;\n  const {\n    rtlTranslate: rtl,\n    params,\n    wrapperEl,\n    progress\n  } = swiper;\n  let x = 0;\n  let y = 0;\n  const z = 0;\n  if (swiper.isHorizontal()) {\n    x = rtl ? -translate : translate;\n  } else {\n    y = translate;\n  }\n  if (params.roundLengths) {\n    x = Math.floor(x);\n    y = Math.floor(y);\n  }\n  swiper.previousTranslate = swiper.translate;\n  swiper.translate = swiper.isHorizontal() ? x : y;\n  if (params.cssMode) {\n    wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;\n  } else if (!params.virtualTranslate) {\n    if (swiper.isHorizontal()) {\n      x -= swiper.cssOverflowAdjustment();\n    } else {\n      y -= swiper.cssOverflowAdjustment();\n    }\n    wrapperEl.style.transform = `translate3d(${x}px, ${y}px, ${z}px)`;\n  }\n\n  // Check if we need to update progress\n  let newProgress;\n  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();\n  if (translatesDiff === 0) {\n    newProgress = 0;\n  } else {\n    newProgress = (translate - swiper.minTranslate()) / translatesDiff;\n  }\n  if (newProgress !== progress) {\n    swiper.updateProgress(translate);\n  }\n  swiper.emit('setTranslate', swiper.translate, byController);\n}","export default function minTranslate() {\n  return -this.snapGrid[0];\n}","export default function maxTranslate() {\n  return -this.snapGrid[this.snapGrid.length - 1];\n}","import { animateCSSModeScroll } from '../../shared/utils.js';\nexport default function translateTo(translate = 0, speed = this.params.speed, runCallbacks = true, translateBounds = true, internal) {\n  const swiper = this;\n  const {\n    params,\n    wrapperEl\n  } = swiper;\n  if (swiper.animating && params.preventInteractionOnTransition) {\n    return false;\n  }\n  const minTranslate = swiper.minTranslate();\n  const maxTranslate = swiper.maxTranslate();\n  let newTranslate;\n  if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate;\n\n  // Update progress\n  swiper.updateProgress(newTranslate);\n  if (params.cssMode) {\n    const isH = swiper.isHorizontal();\n    if (speed === 0) {\n      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;\n    } else {\n      if (!swiper.support.smoothScroll) {\n        animateCSSModeScroll({\n          swiper,\n          targetPosition: -newTranslate,\n          side: isH ? 'left' : 'top'\n        });\n        return true;\n      }\n      wrapperEl.scrollTo({\n        [isH ? 'left' : 'top']: -newTranslate,\n        behavior: 'smooth'\n      });\n    }\n    return true;\n  }\n  if (speed === 0) {\n    swiper.setTransition(0);\n    swiper.setTranslate(newTranslate);\n    if (runCallbacks) {\n      swiper.emit('beforeTransitionStart', speed, internal);\n      swiper.emit('transitionEnd');\n    }\n  } else {\n    swiper.setTransition(speed);\n    swiper.setTranslate(newTranslate);\n    if (runCallbacks) {\n      swiper.emit('beforeTransitionStart', speed, internal);\n      swiper.emit('transitionStart');\n    }\n    if (!swiper.animating) {\n      swiper.animating = true;\n      if (!swiper.onTranslateToWrapperTransitionEnd) {\n        swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {\n          if (!swiper || swiper.destroyed) return;\n          if (e.target !== this) return;\n          swiper.wrapperEl.removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);\n          swiper.onTranslateToWrapperTransitionEnd = null;\n          delete swiper.onTranslateToWrapperTransitionEnd;\n          if (runCallbacks) {\n            swiper.emit('transitionEnd');\n          }\n        };\n      }\n      swiper.wrapperEl.addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);\n    }\n  }\n  return true;\n}","export default function transitionEmit({\n  swiper,\n  runCallbacks,\n  direction,\n  step\n}) {\n  const {\n    activeIndex,\n    previousIndex\n  } = swiper;\n  let dir = direction;\n  if (!dir) {\n    if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';\n  }\n  swiper.emit(`transition${step}`);\n  if (runCallbacks && activeIndex !== previousIndex) {\n    if (dir === 'reset') {\n      swiper.emit(`slideResetTransition${step}`);\n      return;\n    }\n    swiper.emit(`slideChangeTransition${step}`);\n    if (dir === 'next') {\n      swiper.emit(`slideNextTransition${step}`);\n    } else {\n      swiper.emit(`slidePrevTransition${step}`);\n    }\n  }\n}","import slideTo from './slideTo.js';\nimport slideToLoop from './slideToLoop.js';\nimport slideNext from './slideNext.js';\nimport slidePrev from './slidePrev.js';\nimport slideReset from './slideReset.js';\nimport slideToClosest from './slideToClosest.js';\nimport slideToClickedSlide from './slideToClickedSlide.js';\nexport default {\n  slideTo,\n  slideToLoop,\n  slideNext,\n  slidePrev,\n  slideReset,\n  slideToClosest,\n  slideToClickedSlide\n};","import { animateCSSModeScroll } from '../../shared/utils.js';\nexport default function slideTo(index = 0, speed = this.params.speed, runCallbacks = true, internal, initial) {\n  if (typeof index === 'string') {\n    index = parseInt(index, 10);\n  }\n  const swiper = this;\n  let slideIndex = index;\n  if (slideIndex < 0) slideIndex = 0;\n  const {\n    params,\n    snapGrid,\n    slidesGrid,\n    previousIndex,\n    activeIndex,\n    rtlTranslate: rtl,\n    wrapperEl,\n    enabled\n  } = swiper;\n  if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {\n    return false;\n  }\n  const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);\n  let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);\n  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;\n  const translate = -snapGrid[snapIndex];\n  // Normalize slideIndex\n  if (params.normalizeSlideIndex) {\n    for (let i = 0; i < slidesGrid.length; i += 1) {\n      const normalizedTranslate = -Math.floor(translate * 100);\n      const normalizedGrid = Math.floor(slidesGrid[i] * 100);\n      const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);\n      if (typeof slidesGrid[i + 1] !== 'undefined') {\n        if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {\n          slideIndex = i;\n        } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {\n          slideIndex = i + 1;\n        }\n      } else if (normalizedTranslate >= normalizedGrid) {\n        slideIndex = i;\n      }\n    }\n  }\n  // Directions locks\n  if (swiper.initialized && slideIndex !== activeIndex) {\n    if (!swiper.allowSlideNext && (rtl ? translate > swiper.translate && translate > swiper.minTranslate() : translate < swiper.translate && translate < swiper.minTranslate())) {\n      return false;\n    }\n    if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {\n      if ((activeIndex || 0) !== slideIndex) {\n        return false;\n      }\n    }\n  }\n  if (slideIndex !== (previousIndex || 0) && runCallbacks) {\n    swiper.emit('beforeSlideChangeStart');\n  }\n\n  // Update progress\n  swiper.updateProgress(translate);\n  let direction;\n  if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset';\n\n  // Update Index\n  if (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate) {\n    swiper.updateActiveIndex(slideIndex);\n    // Update Height\n    if (params.autoHeight) {\n      swiper.updateAutoHeight();\n    }\n    swiper.updateSlidesClasses();\n    if (params.effect !== 'slide') {\n      swiper.setTranslate(translate);\n    }\n    if (direction !== 'reset') {\n      swiper.transitionStart(runCallbacks, direction);\n      swiper.transitionEnd(runCallbacks, direction);\n    }\n    return false;\n  }\n  if (params.cssMode) {\n    const isH = swiper.isHorizontal();\n    const t = rtl ? translate : -translate;\n    if (speed === 0) {\n      const isVirtual = swiper.virtual && swiper.params.virtual.enabled;\n      if (isVirtual) {\n        swiper.wrapperEl.style.scrollSnapType = 'none';\n        swiper._immediateVirtual = true;\n      }\n      if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {\n        swiper._cssModeVirtualInitialSet = true;\n        requestAnimationFrame(() => {\n          wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;\n        });\n      } else {\n        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;\n      }\n      if (isVirtual) {\n        requestAnimationFrame(() => {\n          swiper.wrapperEl.style.scrollSnapType = '';\n          swiper._immediateVirtual = false;\n        });\n      }\n    } else {\n      if (!swiper.support.smoothScroll) {\n        animateCSSModeScroll({\n          swiper,\n          targetPosition: t,\n          side: isH ? 'left' : 'top'\n        });\n        return true;\n      }\n      wrapperEl.scrollTo({\n        [isH ? 'left' : 'top']: t,\n        behavior: 'smooth'\n      });\n    }\n    return true;\n  }\n  swiper.setTransition(speed);\n  swiper.setTranslate(translate);\n  swiper.updateActiveIndex(slideIndex);\n  swiper.updateSlidesClasses();\n  swiper.emit('beforeTransitionStart', speed, internal);\n  swiper.transitionStart(runCallbacks, direction);\n  if (speed === 0) {\n    swiper.transitionEnd(runCallbacks, direction);\n  } else if (!swiper.animating) {\n    swiper.animating = true;\n    if (!swiper.onSlideToWrapperTransitionEnd) {\n      swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {\n        if (!swiper || swiper.destroyed) return;\n        if (e.target !== this) return;\n        swiper.wrapperEl.removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);\n        swiper.onSlideToWrapperTransitionEnd = null;\n        delete swiper.onSlideToWrapperTransitionEnd;\n        swiper.transitionEnd(runCallbacks, direction);\n      };\n    }\n    swiper.wrapperEl.addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);\n  }\n  return true;\n}","export default function slideToLoop(index = 0, speed = this.params.speed, runCallbacks = true, internal) {\n  if (typeof index === 'string') {\n    const indexAsNumber = parseInt(index, 10);\n    index = indexAsNumber;\n  }\n  const swiper = this;\n  let newIndex = index;\n  if (swiper.params.loop) {\n    if (swiper.virtual && swiper.params.virtual.enabled) {\n      // eslint-disable-next-line\n      newIndex = newIndex + swiper.virtual.slidesBefore;\n    } else {\n      newIndex = swiper.getSlideIndexByData(newIndex);\n    }\n  }\n  return swiper.slideTo(newIndex, speed, runCallbacks, internal);\n}","/* eslint no-unused-vars: \"off\" */\nexport default function slideNext(speed = this.params.speed, runCallbacks = true, internal) {\n  const swiper = this;\n  const {\n    enabled,\n    params,\n    animating\n  } = swiper;\n  if (!enabled) return swiper;\n  let perGroup = params.slidesPerGroup;\n  if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {\n    perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);\n  }\n  const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;\n  const isVirtual = swiper.virtual && params.virtual.enabled;\n  if (params.loop) {\n    if (animating && !isVirtual && params.loopPreventsSliding) return false;\n    swiper.loopFix({\n      direction: 'next'\n    });\n    // eslint-disable-next-line\n    swiper._clientLeft = swiper.wrapperEl.clientLeft;\n  }\n  if (params.rewind && swiper.isEnd) {\n    return swiper.slideTo(0, speed, runCallbacks, internal);\n  }\n  return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);\n}","/* eslint no-unused-vars: \"off\" */\nexport default function slidePrev(speed = this.params.speed, runCallbacks = true, internal) {\n  const swiper = this;\n  const {\n    params,\n    snapGrid,\n    slidesGrid,\n    rtlTranslate,\n    enabled,\n    animating\n  } = swiper;\n  if (!enabled) return swiper;\n  const isVirtual = swiper.virtual && params.virtual.enabled;\n  if (params.loop) {\n    if (animating && !isVirtual && params.loopPreventsSliding) return false;\n    swiper.loopFix({\n      direction: 'prev'\n    });\n    // eslint-disable-next-line\n    swiper._clientLeft = swiper.wrapperEl.clientLeft;\n  }\n  const translate = rtlTranslate ? swiper.translate : -swiper.translate;\n  function normalize(val) {\n    if (val < 0) return -Math.floor(Math.abs(val));\n    return Math.floor(val);\n  }\n  const normalizedTranslate = normalize(translate);\n  const normalizedSnapGrid = snapGrid.map(val => normalize(val));\n  let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];\n  if (typeof prevSnap === 'undefined' && params.cssMode) {\n    let prevSnapIndex;\n    snapGrid.forEach((snap, snapIndex) => {\n      if (normalizedTranslate >= snap) {\n        // prevSnap = snap;\n        prevSnapIndex = snapIndex;\n      }\n    });\n    if (typeof prevSnapIndex !== 'undefined') {\n      prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];\n    }\n  }\n  let prevIndex = 0;\n  if (typeof prevSnap !== 'undefined') {\n    prevIndex = slidesGrid.indexOf(prevSnap);\n    if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;\n    if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {\n      prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;\n      prevIndex = Math.max(prevIndex, 0);\n    }\n  }\n  if (params.rewind && swiper.isBeginning) {\n    const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;\n    return swiper.slideTo(lastIndex, speed, runCallbacks, internal);\n  }\n  return swiper.slideTo(prevIndex, speed, runCallbacks, internal);\n}","/* eslint no-unused-vars: \"off\" */\nexport default function slideReset(speed = this.params.speed, runCallbacks = true, internal) {\n  const swiper = this;\n  return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);\n}","/* eslint no-unused-vars: \"off\" */\nexport default function slideToClosest(speed = this.params.speed, runCallbacks = true, internal, threshold = 0.5) {\n  const swiper = this;\n  let index = swiper.activeIndex;\n  const skip = Math.min(swiper.params.slidesPerGroupSkip, index);\n  const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);\n  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;\n  if (translate >= swiper.snapGrid[snapIndex]) {\n    // The current translate is on or after the current snap index, so the choice\n    // is between the current index and the one after it.\n    const currentSnap = swiper.snapGrid[snapIndex];\n    const nextSnap = swiper.snapGrid[snapIndex + 1];\n    if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {\n      index += swiper.params.slidesPerGroup;\n    }\n  } else {\n    // The current translate is before the current snap index, so the choice\n    // is between the current index and the one before it.\n    const prevSnap = swiper.snapGrid[snapIndex - 1];\n    const currentSnap = swiper.snapGrid[snapIndex];\n    if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {\n      index -= swiper.params.slidesPerGroup;\n    }\n  }\n  index = Math.max(index, 0);\n  index = Math.min(index, swiper.slidesGrid.length - 1);\n  return swiper.slideTo(index, speed, runCallbacks, internal);\n}","import { elementChildren, nextTick } from '../../shared/utils.js';\nexport default function slideToClickedSlide() {\n  const swiper = this;\n  const {\n    params,\n    slidesEl\n  } = swiper;\n  const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;\n  let slideToIndex = swiper.clickedIndex;\n  let realIndex;\n  const slideSelector = swiper.isElement ? `swiper-slide` : `.${params.slideClass}`;\n  if (params.loop) {\n    if (swiper.animating) return;\n    realIndex = parseInt(swiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);\n    if (params.centeredSlides) {\n      if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {\n        swiper.loopFix();\n        slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index=\"${realIndex}\"]`)[0]);\n        nextTick(() => {\n          swiper.slideTo(slideToIndex);\n        });\n      } else {\n        swiper.slideTo(slideToIndex);\n      }\n    } else if (slideToIndex > swiper.slides.length - slidesPerView) {\n      swiper.loopFix();\n      slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index=\"${realIndex}\"]`)[0]);\n      nextTick(() => {\n        swiper.slideTo(slideToIndex);\n      });\n    } else {\n      swiper.slideTo(slideToIndex);\n    }\n  } else {\n    swiper.slideTo(slideToIndex);\n  }\n}","import loopCreate from './loopCreate.js';\nimport loopFix from './loopFix.js';\nimport loopDestroy from './loopDestroy.js';\nexport default {\n  loopCreate,\n  loopFix,\n  loopDestroy\n};","import { elementChildren } from '../../shared/utils.js';\nexport default function loopCreate(slideRealIndex) {\n  const swiper = this;\n  const {\n    params,\n    slidesEl\n  } = swiper;\n  if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;\n  const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);\n  slides.forEach((el, index) => {\n    el.setAttribute('data-swiper-slide-index', index);\n  });\n  swiper.loopFix({\n    slideRealIndex,\n    direction: params.centeredSlides ? undefined : 'next'\n  });\n}","export default function loopFix({\n  slideRealIndex,\n  slideTo = true,\n  direction,\n  setTranslate,\n  activeSlideIndex,\n  byController,\n  byMousewheel\n} = {}) {\n  const swiper = this;\n  if (!swiper.params.loop) return;\n  swiper.emit('beforeLoopFix');\n  const {\n    slides,\n    allowSlidePrev,\n    allowSlideNext,\n    slidesEl,\n    params\n  } = swiper;\n  swiper.allowSlidePrev = true;\n  swiper.allowSlideNext = true;\n  if (swiper.virtual && params.virtual.enabled) {\n    if (slideTo) {\n      if (!params.centeredSlides && swiper.snapIndex === 0) {\n        swiper.slideTo(swiper.virtual.slides.length, 0, false, true);\n      } else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) {\n        swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true);\n      } else if (swiper.snapIndex === swiper.snapGrid.length - 1) {\n        swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);\n      }\n    }\n    swiper.allowSlidePrev = allowSlidePrev;\n    swiper.allowSlideNext = allowSlideNext;\n    swiper.emit('loopFix');\n    return;\n  }\n  const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(parseFloat(params.slidesPerView, 10));\n  let loopedSlides = params.loopedSlides || slidesPerView;\n  if (loopedSlides % params.slidesPerGroup !== 0) {\n    loopedSlides += params.slidesPerGroup - loopedSlides % params.slidesPerGroup;\n  }\n  swiper.loopedSlides = loopedSlides;\n  const prependSlidesIndexes = [];\n  const appendSlidesIndexes = [];\n  let activeIndex = swiper.activeIndex;\n  if (typeof activeSlideIndex === 'undefined') {\n    activeSlideIndex = swiper.getSlideIndex(swiper.slides.filter(el => el.classList.contains(params.slideActiveClass))[0]);\n  } else {\n    activeIndex = activeSlideIndex;\n  }\n  const isNext = direction === 'next' || !direction;\n  const isPrev = direction === 'prev' || !direction;\n  let slidesPrepended = 0;\n  let slidesAppended = 0;\n  // prepend last slides before start\n  if (activeSlideIndex < loopedSlides) {\n    slidesPrepended = Math.max(loopedSlides - activeSlideIndex, params.slidesPerGroup);\n    for (let i = 0; i < loopedSlides - activeSlideIndex; i += 1) {\n      const index = i - Math.floor(i / slides.length) * slides.length;\n      prependSlidesIndexes.push(slides.length - index - 1);\n    }\n  } else if (activeSlideIndex /* + slidesPerView */ > swiper.slides.length - loopedSlides * 2) {\n    slidesAppended = Math.max(activeSlideIndex - (swiper.slides.length - loopedSlides * 2), params.slidesPerGroup);\n    for (let i = 0; i < slidesAppended; i += 1) {\n      const index = i - Math.floor(i / slides.length) * slides.length;\n      appendSlidesIndexes.push(index);\n    }\n  }\n  if (isPrev) {\n    prependSlidesIndexes.forEach(index => {\n      swiper.slides[index].swiperLoopMoveDOM = true;\n      slidesEl.prepend(swiper.slides[index]);\n      swiper.slides[index].swiperLoopMoveDOM = false;\n    });\n  }\n  if (isNext) {\n    appendSlidesIndexes.forEach(index => {\n      swiper.slides[index].swiperLoopMoveDOM = true;\n      slidesEl.append(swiper.slides[index]);\n      swiper.slides[index].swiperLoopMoveDOM = false;\n    });\n  }\n  swiper.recalcSlides();\n  if (params.slidesPerView === 'auto') {\n    swiper.updateSlides();\n  }\n  if (params.watchSlidesProgress) {\n    swiper.updateSlidesOffset();\n  }\n  if (slideTo) {\n    if (prependSlidesIndexes.length > 0 && isPrev) {\n      if (typeof slideRealIndex === 'undefined') {\n        const currentSlideTranslate = swiper.slidesGrid[activeIndex];\n        const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];\n        const diff = newSlideTranslate - currentSlideTranslate;\n        if (byMousewheel) {\n          swiper.setTranslate(swiper.translate - diff);\n        } else {\n          swiper.slideTo(activeIndex + slidesPrepended, 0, false, true);\n          if (setTranslate) {\n            swiper.touches[swiper.isHorizontal() ? 'startX' : 'startY'] += diff;\n          }\n        }\n      } else {\n        if (setTranslate) {\n          swiper.slideToLoop(slideRealIndex, 0, false, true);\n        }\n      }\n    } else if (appendSlidesIndexes.length > 0 && isNext) {\n      if (typeof slideRealIndex === 'undefined') {\n        const currentSlideTranslate = swiper.slidesGrid[activeIndex];\n        const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];\n        const diff = newSlideTranslate - currentSlideTranslate;\n        if (byMousewheel) {\n          swiper.setTranslate(swiper.translate - diff);\n        } else {\n          swiper.slideTo(activeIndex - slidesAppended, 0, false, true);\n          if (setTranslate) {\n            swiper.touches[swiper.isHorizontal() ? 'startX' : 'startY'] += diff;\n          }\n        }\n      } else {\n        swiper.slideToLoop(slideRealIndex, 0, false, true);\n      }\n    }\n  }\n  swiper.allowSlidePrev = allowSlidePrev;\n  swiper.allowSlideNext = allowSlideNext;\n  if (swiper.controller && swiper.controller.control && !byController) {\n    const loopParams = {\n      slideRealIndex,\n      slideTo: false,\n      direction,\n      setTranslate,\n      activeSlideIndex,\n      byController: true\n    };\n    if (Array.isArray(swiper.controller.control)) {\n      swiper.controller.control.forEach(c => {\n        if (!c.destroyed && c.params.loop) c.loopFix(loopParams);\n      });\n    } else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) {\n      swiper.controller.control.loopFix(loopParams);\n    }\n  }\n  swiper.emit('loopFix');\n}","export default function loopDestroy() {\n  const swiper = this;\n  const {\n    params,\n    slidesEl\n  } = swiper;\n  if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;\n  swiper.recalcSlides();\n  const newSlidesOrder = [];\n  swiper.slides.forEach(slideEl => {\n    const index = typeof slideEl.swiperSlideIndex === 'undefined' ? slideEl.getAttribute('data-swiper-slide-index') * 1 : slideEl.swiperSlideIndex;\n    newSlidesOrder[index] = slideEl;\n  });\n  swiper.slides.forEach(slideEl => {\n    slideEl.removeAttribute('data-swiper-slide-index');\n  });\n  newSlidesOrder.forEach(slideEl => {\n    slidesEl.append(slideEl);\n  });\n  swiper.recalcSlides();\n  swiper.slideTo(swiper.realIndex, 0);\n}","import { getWindow, getDocument } from 'ssr-window';\nimport { now } from '../../shared/utils.js';\n\n// Modified from https://stackoverflow.com/questions/54520554/custom-element-getrootnode-closest-function-crossing-multiple-parent-shadowd\nfunction closestElement(selector, base = this) {\n  function __closestFrom(el) {\n    if (!el || el === getDocument() || el === getWindow()) return null;\n    if (el.assignedSlot) el = el.assignedSlot;\n    const found = el.closest(selector);\n    if (!found && !el.getRootNode) {\n      return null;\n    }\n    return found || __closestFrom(el.getRootNode().host);\n  }\n  return __closestFrom(base);\n}\nexport default function onTouchStart(event) {\n  const swiper = this;\n  const document = getDocument();\n  const window = getWindow();\n  const data = swiper.touchEventsData;\n  data.evCache.push(event);\n  const {\n    params,\n    touches,\n    enabled\n  } = swiper;\n  if (!enabled) return;\n  if (!params.simulateTouch && event.pointerType === 'mouse') return;\n  if (swiper.animating && params.preventInteractionOnTransition) {\n    return;\n  }\n  if (!swiper.animating && params.cssMode && params.loop) {\n    swiper.loopFix();\n  }\n  let e = event;\n  if (e.originalEvent) e = e.originalEvent;\n  let targetEl = e.target;\n  if (params.touchEventsTarget === 'wrapper') {\n    if (!swiper.wrapperEl.contains(targetEl)) return;\n  }\n  if ('which' in e && e.which === 3) return;\n  if ('button' in e && e.button > 0) return;\n  if (data.isTouched && data.isMoved) return;\n\n  // change target el for shadow root component\n  const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== '';\n  // eslint-disable-next-line\n  const eventPath = event.composedPath ? event.composedPath() : event.path;\n  if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {\n    targetEl = eventPath[0];\n  }\n  const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;\n  const isTargetShadow = !!(e.target && e.target.shadowRoot);\n\n  // use closestElement for shadow root element to get the actual closest for nested shadow root element\n  if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, targetEl) : targetEl.closest(noSwipingSelector))) {\n    swiper.allowClick = true;\n    return;\n  }\n  if (params.swipeHandler) {\n    if (!targetEl.closest(params.swipeHandler)) return;\n  }\n  touches.currentX = e.pageX;\n  touches.currentY = e.pageY;\n  const startX = touches.currentX;\n  const startY = touches.currentY;\n\n  // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore\n\n  const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;\n  const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;\n  if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {\n    if (edgeSwipeDetection === 'prevent') {\n      event.preventDefault();\n    } else {\n      return;\n    }\n  }\n  Object.assign(data, {\n    isTouched: true,\n    isMoved: false,\n    allowTouchCallbacks: true,\n    isScrolling: undefined,\n    startMoving: undefined\n  });\n  touches.startX = startX;\n  touches.startY = startY;\n  data.touchStartTime = now();\n  swiper.allowClick = true;\n  swiper.updateSize();\n  swiper.swipeDirection = undefined;\n  if (params.threshold > 0) data.allowThresholdMove = false;\n  let preventDefault = true;\n  if (targetEl.matches(data.focusableElements)) {\n    preventDefault = false;\n    if (targetEl.nodeName === 'SELECT') {\n      data.isTouched = false;\n    }\n  }\n  if (document.activeElement && document.activeElement.matches(data.focusableElements) && document.activeElement !== targetEl) {\n    document.activeElement.blur();\n  }\n  const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;\n  if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !targetEl.isContentEditable) {\n    e.preventDefault();\n  }\n  if (params.freeMode && params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {\n    swiper.freeMode.onTouchStart();\n  }\n  swiper.emit('touchStart', e);\n}","import { getDocument } from 'ssr-window';\nimport { now } from '../../shared/utils.js';\nexport default function onTouchMove(event) {\n  const document = getDocument();\n  const swiper = this;\n  const data = swiper.touchEventsData;\n  const {\n    params,\n    touches,\n    rtlTranslate: rtl,\n    enabled\n  } = swiper;\n  if (!enabled) return;\n  if (!params.simulateTouch && event.pointerType === 'mouse') return;\n  let e = event;\n  if (e.originalEvent) e = e.originalEvent;\n  if (!data.isTouched) {\n    if (data.startMoving && data.isScrolling) {\n      swiper.emit('touchMoveOpposite', e);\n    }\n    return;\n  }\n  const pointerIndex = data.evCache.findIndex(cachedEv => cachedEv.pointerId === e.pointerId);\n  if (pointerIndex >= 0) data.evCache[pointerIndex] = e;\n  const targetTouch = data.evCache.length > 1 ? data.evCache[0] : e;\n  const pageX = targetTouch.pageX;\n  const pageY = targetTouch.pageY;\n  if (e.preventedByNestedSwiper) {\n    touches.startX = pageX;\n    touches.startY = pageY;\n    return;\n  }\n  if (!swiper.allowTouchMove) {\n    if (!e.target.matches(data.focusableElements)) {\n      swiper.allowClick = false;\n    }\n    if (data.isTouched) {\n      Object.assign(touches, {\n        startX: pageX,\n        startY: pageY,\n        prevX: swiper.touches.currentX,\n        prevY: swiper.touches.currentY,\n        currentX: pageX,\n        currentY: pageY\n      });\n      data.touchStartTime = now();\n    }\n    return;\n  }\n  if (params.touchReleaseOnEdges && !params.loop) {\n    if (swiper.isVertical()) {\n      // Vertical\n      if (pageY < touches.startY && swiper.translate <= swiper.maxTranslate() || pageY > touches.startY && swiper.translate >= swiper.minTranslate()) {\n        data.isTouched = false;\n        data.isMoved = false;\n        return;\n      }\n    } else if (pageX < touches.startX && swiper.translate <= swiper.maxTranslate() || pageX > touches.startX && swiper.translate >= swiper.minTranslate()) {\n      return;\n    }\n  }\n  if (document.activeElement) {\n    if (e.target === document.activeElement && e.target.matches(data.focusableElements)) {\n      data.isMoved = true;\n      swiper.allowClick = false;\n      return;\n    }\n  }\n  if (data.allowTouchCallbacks) {\n    swiper.emit('touchMove', e);\n  }\n  if (e.targetTouches && e.targetTouches.length > 1) return;\n  touches.currentX = pageX;\n  touches.currentY = pageY;\n  const diffX = touches.currentX - touches.startX;\n  const diffY = touches.currentY - touches.startY;\n  if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) < swiper.params.threshold) return;\n  if (typeof data.isScrolling === 'undefined') {\n    let touchAngle;\n    if (swiper.isHorizontal() && touches.currentY === touches.startY || swiper.isVertical() && touches.currentX === touches.startX) {\n      data.isScrolling = false;\n    } else {\n      // eslint-disable-next-line\n      if (diffX * diffX + diffY * diffY >= 25) {\n        touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;\n        data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;\n      }\n    }\n  }\n  if (data.isScrolling) {\n    swiper.emit('touchMoveOpposite', e);\n  }\n  if (typeof data.startMoving === 'undefined') {\n    if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {\n      data.startMoving = true;\n    }\n  }\n  if (data.isScrolling || swiper.zoom && swiper.params.zoom && swiper.params.zoom.enabled && data.evCache.length > 1) {\n    data.isTouched = false;\n    return;\n  }\n  if (!data.startMoving) {\n    return;\n  }\n  swiper.allowClick = false;\n  if (!params.cssMode && e.cancelable) {\n    e.preventDefault();\n  }\n  if (params.touchMoveStopPropagation && !params.nested) {\n    e.stopPropagation();\n  }\n  let diff = swiper.isHorizontal() ? diffX : diffY;\n  let touchesDiff = swiper.isHorizontal() ? touches.currentX - touches.previousX : touches.currentY - touches.previousY;\n  if (params.oneWayMovement) {\n    diff = Math.abs(diff) * (rtl ? 1 : -1);\n    touchesDiff = Math.abs(touchesDiff) * (rtl ? 1 : -1);\n  }\n  touches.diff = diff;\n  diff *= params.touchRatio;\n  if (rtl) {\n    diff = -diff;\n    touchesDiff = -touchesDiff;\n  }\n  const prevTouchesDirection = swiper.touchesDirection;\n  swiper.swipeDirection = diff > 0 ? 'prev' : 'next';\n  swiper.touchesDirection = touchesDiff > 0 ? 'prev' : 'next';\n  const isLoop = swiper.params.loop && !params.cssMode;\n  if (!data.isMoved) {\n    if (isLoop) {\n      swiper.loopFix({\n        direction: swiper.swipeDirection\n      });\n    }\n    data.startTranslate = swiper.getTranslate();\n    swiper.setTransition(0);\n    if (swiper.animating) {\n      const evt = new window.CustomEvent('transitionend', {\n        bubbles: true,\n        cancelable: true\n      });\n      swiper.wrapperEl.dispatchEvent(evt);\n    }\n    data.allowMomentumBounce = false;\n    // Grab Cursor\n    if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {\n      swiper.setGrabCursor(true);\n    }\n    swiper.emit('sliderFirstMove', e);\n  }\n  let loopFixed;\n  if (data.isMoved && prevTouchesDirection !== swiper.touchesDirection && isLoop && Math.abs(diff) >= 1) {\n    // need another loop fix\n    swiper.loopFix({\n      direction: swiper.swipeDirection,\n      setTranslate: true\n    });\n    loopFixed = true;\n  }\n  swiper.emit('sliderMove', e);\n  data.isMoved = true;\n  data.currentTranslate = diff + data.startTranslate;\n  let disableParentSwiper = true;\n  let resistanceRatio = params.resistanceRatio;\n  if (params.touchReleaseOnEdges) {\n    resistanceRatio = 0;\n  }\n  if (diff > 0) {\n    if (isLoop && !loopFixed && data.currentTranslate > (params.centeredSlides ? swiper.minTranslate() - swiper.size / 2 : swiper.minTranslate())) {\n      swiper.loopFix({\n        direction: 'prev',\n        setTranslate: true,\n        activeSlideIndex: 0\n      });\n    }\n    if (data.currentTranslate > swiper.minTranslate()) {\n      disableParentSwiper = false;\n      if (params.resistance) {\n        data.currentTranslate = swiper.minTranslate() - 1 + (-swiper.minTranslate() + data.startTranslate + diff) ** resistanceRatio;\n      }\n    }\n  } else if (diff < 0) {\n    if (isLoop && !loopFixed && data.currentTranslate < (params.centeredSlides ? swiper.maxTranslate() + swiper.size / 2 : swiper.maxTranslate())) {\n      swiper.loopFix({\n        direction: 'next',\n        setTranslate: true,\n        activeSlideIndex: swiper.slides.length - (params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(parseFloat(params.slidesPerView, 10)))\n      });\n    }\n    if (data.currentTranslate < swiper.maxTranslate()) {\n      disableParentSwiper = false;\n      if (params.resistance) {\n        data.currentTranslate = swiper.maxTranslate() + 1 - (swiper.maxTranslate() - data.startTranslate - diff) ** resistanceRatio;\n      }\n    }\n  }\n  if (disableParentSwiper) {\n    e.preventedByNestedSwiper = true;\n  }\n\n  // Directions locks\n  if (!swiper.allowSlideNext && swiper.swipeDirection === 'next' && data.currentTranslate < data.startTranslate) {\n    data.currentTranslate = data.startTranslate;\n  }\n  if (!swiper.allowSlidePrev && swiper.swipeDirection === 'prev' && data.currentTranslate > data.startTranslate) {\n    data.currentTranslate = data.startTranslate;\n  }\n  if (!swiper.allowSlidePrev && !swiper.allowSlideNext) {\n    data.currentTranslate = data.startTranslate;\n  }\n\n  // Threshold\n  if (params.threshold > 0) {\n    if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {\n      if (!data.allowThresholdMove) {\n        data.allowThresholdMove = true;\n        touches.startX = touches.currentX;\n        touches.startY = touches.currentY;\n        data.currentTranslate = data.startTranslate;\n        touches.diff = swiper.isHorizontal() ? touches.currentX - touches.startX : touches.currentY - touches.startY;\n        return;\n      }\n    } else {\n      data.currentTranslate = data.startTranslate;\n      return;\n    }\n  }\n  if (!params.followFinger || params.cssMode) return;\n\n  // Update active index in free mode\n  if (params.freeMode && params.freeMode.enabled && swiper.freeMode || params.watchSlidesProgress) {\n    swiper.updateActiveIndex();\n    swiper.updateSlidesClasses();\n  }\n  if (params.freeMode && params.freeMode.enabled && swiper.freeMode) {\n    swiper.freeMode.onTouchMove();\n  }\n  // Update progress\n  swiper.updateProgress(data.currentTranslate);\n  // Update translate\n  swiper.setTranslate(data.currentTranslate);\n}","import { now, nextTick } from '../../shared/utils.js';\nexport default function onTouchEnd(event) {\n  const swiper = this;\n  const data = swiper.touchEventsData;\n  const pointerIndex = data.evCache.findIndex(cachedEv => cachedEv.pointerId === event.pointerId);\n  if (pointerIndex >= 0) {\n    data.evCache.splice(pointerIndex, 1);\n  }\n  if (['pointercancel', 'pointerout', 'pointerleave'].includes(event.type)) {\n    const proceed = event.type === 'pointercancel' && (swiper.browser.isSafari || swiper.browser.isWebView);\n    if (!proceed) {\n      return;\n    }\n  }\n  const {\n    params,\n    touches,\n    rtlTranslate: rtl,\n    slidesGrid,\n    enabled\n  } = swiper;\n  if (!enabled) return;\n  if (!params.simulateTouch && event.pointerType === 'mouse') return;\n  let e = event;\n  if (e.originalEvent) e = e.originalEvent;\n  if (data.allowTouchCallbacks) {\n    swiper.emit('touchEnd', e);\n  }\n  data.allowTouchCallbacks = false;\n  if (!data.isTouched) {\n    if (data.isMoved && params.grabCursor) {\n      swiper.setGrabCursor(false);\n    }\n    data.isMoved = false;\n    data.startMoving = false;\n    return;\n  }\n  // Return Grab Cursor\n  if (params.grabCursor && data.isMoved && data.isTouched && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {\n    swiper.setGrabCursor(false);\n  }\n\n  // Time diff\n  const touchEndTime = now();\n  const timeDiff = touchEndTime - data.touchStartTime;\n\n  // Tap, doubleTap, Click\n  if (swiper.allowClick) {\n    const pathTree = e.path || e.composedPath && e.composedPath();\n    swiper.updateClickedSlide(pathTree && pathTree[0] || e.target);\n    swiper.emit('tap click', e);\n    if (timeDiff < 300 && touchEndTime - data.lastClickTime < 300) {\n      swiper.emit('doubleTap doubleClick', e);\n    }\n  }\n  data.lastClickTime = now();\n  nextTick(() => {\n    if (!swiper.destroyed) swiper.allowClick = true;\n  });\n  if (!data.isTouched || !data.isMoved || !swiper.swipeDirection || touches.diff === 0 || data.currentTranslate === data.startTranslate) {\n    data.isTouched = false;\n    data.isMoved = false;\n    data.startMoving = false;\n    return;\n  }\n  data.isTouched = false;\n  data.isMoved = false;\n  data.startMoving = false;\n  let currentPos;\n  if (params.followFinger) {\n    currentPos = rtl ? swiper.translate : -swiper.translate;\n  } else {\n    currentPos = -data.currentTranslate;\n  }\n  if (params.cssMode) {\n    return;\n  }\n  if (params.freeMode && params.freeMode.enabled) {\n    swiper.freeMode.onTouchEnd({\n      currentPos\n    });\n    return;\n  }\n\n  // Find current slide\n  let stopIndex = 0;\n  let groupSize = swiper.slidesSizesGrid[0];\n  for (let i = 0; i < slidesGrid.length; i += i < params.slidesPerGroupSkip ? 1 : params.slidesPerGroup) {\n    const increment = i < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;\n    if (typeof slidesGrid[i + increment] !== 'undefined') {\n      if (currentPos >= slidesGrid[i] && currentPos < slidesGrid[i + increment]) {\n        stopIndex = i;\n        groupSize = slidesGrid[i + increment] - slidesGrid[i];\n      }\n    } else if (currentPos >= slidesGrid[i]) {\n      stopIndex = i;\n      groupSize = slidesGrid[slidesGrid.length - 1] - slidesGrid[slidesGrid.length - 2];\n    }\n  }\n  let rewindFirstIndex = null;\n  let rewindLastIndex = null;\n  if (params.rewind) {\n    if (swiper.isBeginning) {\n      rewindLastIndex = params.virtual && params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;\n    } else if (swiper.isEnd) {\n      rewindFirstIndex = 0;\n    }\n  }\n  // Find current slide size\n  const ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;\n  const increment = stopIndex < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;\n  if (timeDiff > params.longSwipesMs) {\n    // Long touches\n    if (!params.longSwipes) {\n      swiper.slideTo(swiper.activeIndex);\n      return;\n    }\n    if (swiper.swipeDirection === 'next') {\n      if (ratio >= params.longSwipesRatio) swiper.slideTo(params.rewind && swiper.isEnd ? rewindFirstIndex : stopIndex + increment);else swiper.slideTo(stopIndex);\n    }\n    if (swiper.swipeDirection === 'prev') {\n      if (ratio > 1 - params.longSwipesRatio) {\n        swiper.slideTo(stopIndex + increment);\n      } else if (rewindLastIndex !== null && ratio < 0 && Math.abs(ratio) > params.longSwipesRatio) {\n        swiper.slideTo(rewindLastIndex);\n      } else {\n        swiper.slideTo(stopIndex);\n      }\n    }\n  } else {\n    // Short swipes\n    if (!params.shortSwipes) {\n      swiper.slideTo(swiper.activeIndex);\n      return;\n    }\n    const isNavButtonTarget = swiper.navigation && (e.target === swiper.navigation.nextEl || e.target === swiper.navigation.prevEl);\n    if (!isNavButtonTarget) {\n      if (swiper.swipeDirection === 'next') {\n        swiper.slideTo(rewindFirstIndex !== null ? rewindFirstIndex : stopIndex + increment);\n      }\n      if (swiper.swipeDirection === 'prev') {\n        swiper.slideTo(rewindLastIndex !== null ? rewindLastIndex : stopIndex);\n      }\n    } else if (e.target === swiper.navigation.nextEl) {\n      swiper.slideTo(stopIndex + increment);\n    } else {\n      swiper.slideTo(stopIndex);\n    }\n  }\n}","export default function onResize() {\n  const swiper = this;\n  const {\n    params,\n    el\n  } = swiper;\n  if (el && el.offsetWidth === 0) return;\n\n  // Breakpoints\n  if (params.breakpoints) {\n    swiper.setBreakpoint();\n  }\n\n  // Save locks\n  const {\n    allowSlideNext,\n    allowSlidePrev,\n    snapGrid\n  } = swiper;\n  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;\n\n  // Disable locks on resize\n  swiper.allowSlideNext = true;\n  swiper.allowSlidePrev = true;\n  swiper.updateSize();\n  swiper.updateSlides();\n  swiper.updateSlidesClasses();\n  const isVirtualLoop = isVirtual && params.loop;\n  if ((params.slidesPerView === 'auto' || params.slidesPerView > 1) && swiper.isEnd && !swiper.isBeginning && !swiper.params.centeredSlides && !isVirtualLoop) {\n    swiper.slideTo(swiper.slides.length - 1, 0, false, true);\n  } else {\n    if (swiper.params.loop && !isVirtual) {\n      swiper.slideToLoop(swiper.realIndex, 0, false, true);\n    } else {\n      swiper.slideTo(swiper.activeIndex, 0, false, true);\n    }\n  }\n  if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {\n    clearTimeout(swiper.autoplay.resizeTimeout);\n    swiper.autoplay.resizeTimeout = setTimeout(() => {\n      if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {\n        swiper.autoplay.resume();\n      }\n    }, 500);\n  }\n  // Return locks after resize\n  swiper.allowSlidePrev = allowSlidePrev;\n  swiper.allowSlideNext = allowSlideNext;\n  if (swiper.params.watchOverflow && snapGrid !== swiper.snapGrid) {\n    swiper.checkOverflow();\n  }\n}","export default function onClick(e) {\n  const swiper = this;\n  if (!swiper.enabled) return;\n  if (!swiper.allowClick) {\n    if (swiper.params.preventClicks) e.preventDefault();\n    if (swiper.params.preventClicksPropagation && swiper.animating) {\n      e.stopPropagation();\n      e.stopImmediatePropagation();\n    }\n  }\n}","export default function onScroll() {\n  const swiper = this;\n  const {\n    wrapperEl,\n    rtlTranslate,\n    enabled\n  } = swiper;\n  if (!enabled) return;\n  swiper.previousTranslate = swiper.translate;\n  if (swiper.isHorizontal()) {\n    swiper.translate = -wrapperEl.scrollLeft;\n  } else {\n    swiper.translate = -wrapperEl.scrollTop;\n  }\n  // eslint-disable-next-line\n  if (swiper.translate === 0) swiper.translate = 0;\n  swiper.updateActiveIndex();\n  swiper.updateSlidesClasses();\n  let newProgress;\n  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();\n  if (translatesDiff === 0) {\n    newProgress = 0;\n  } else {\n    newProgress = (swiper.translate - swiper.minTranslate()) / translatesDiff;\n  }\n  if (newProgress !== swiper.progress) {\n    swiper.updateProgress(rtlTranslate ? -swiper.translate : swiper.translate);\n  }\n  swiper.emit('setTranslate', swiper.translate, false);\n}","import { processLazyPreloader } from '../../shared/process-lazy-preloader.js';\nexport default function onLoad(e) {\n  const swiper = this;\n  processLazyPreloader(swiper, e.target);\n  if (swiper.params.cssMode || swiper.params.slidesPerView !== 'auto' && !swiper.params.autoHeight) {\n    return;\n  }\n  swiper.update();\n}","import { getDocument } from 'ssr-window';\nimport onTouchStart from './onTouchStart.js';\nimport onTouchMove from './onTouchMove.js';\nimport onTouchEnd from './onTouchEnd.js';\nimport onResize from './onResize.js';\nimport onClick from './onClick.js';\nimport onScroll from './onScroll.js';\nimport onLoad from './onLoad.js';\nlet dummyEventAttached = false;\nfunction dummyEventListener() {}\nconst events = (swiper, method) => {\n  const document = getDocument();\n  const {\n    params,\n    el,\n    wrapperEl,\n    device\n  } = swiper;\n  const capture = !!params.nested;\n  const domMethod = method === 'on' ? 'addEventListener' : 'removeEventListener';\n  const swiperMethod = method;\n\n  // Touch Events\n  el[domMethod]('pointerdown', swiper.onTouchStart, {\n    passive: false\n  });\n  document[domMethod]('pointermove', swiper.onTouchMove, {\n    passive: false,\n    capture\n  });\n  document[domMethod]('pointerup', swiper.onTouchEnd, {\n    passive: true\n  });\n  document[domMethod]('pointercancel', swiper.onTouchEnd, {\n    passive: true\n  });\n  document[domMethod]('pointerout', swiper.onTouchEnd, {\n    passive: true\n  });\n  document[domMethod]('pointerleave', swiper.onTouchEnd, {\n    passive: true\n  });\n\n  // Prevent Links Clicks\n  if (params.preventClicks || params.preventClicksPropagation) {\n    el[domMethod]('click', swiper.onClick, true);\n  }\n  if (params.cssMode) {\n    wrapperEl[domMethod]('scroll', swiper.onScroll);\n  }\n\n  // Resize handler\n  if (params.updateOnWindowResize) {\n    swiper[swiperMethod](device.ios || device.android ? 'resize orientationchange observerUpdate' : 'resize observerUpdate', onResize, true);\n  } else {\n    swiper[swiperMethod]('observerUpdate', onResize, true);\n  }\n\n  // Images loader\n  el[domMethod]('load', swiper.onLoad, {\n    capture: true\n  });\n};\nfunction attachEvents() {\n  const swiper = this;\n  const document = getDocument();\n  const {\n    params\n  } = swiper;\n  swiper.onTouchStart = onTouchStart.bind(swiper);\n  swiper.onTouchMove = onTouchMove.bind(swiper);\n  swiper.onTouchEnd = onTouchEnd.bind(swiper);\n  if (params.cssMode) {\n    swiper.onScroll = onScroll.bind(swiper);\n  }\n  swiper.onClick = onClick.bind(swiper);\n  swiper.onLoad = onLoad.bind(swiper);\n  if (!dummyEventAttached) {\n    document.addEventListener('touchstart', dummyEventListener);\n    dummyEventAttached = true;\n  }\n  events(swiper, 'on');\n}\nfunction detachEvents() {\n  const swiper = this;\n  events(swiper, 'off');\n}\nexport default {\n  attachEvents,\n  detachEvents\n};","import { extend } from '../../shared/utils.js';\nconst isGridEnabled = (swiper, params) => {\n  return swiper.grid && params.grid && params.grid.rows > 1;\n};\nexport default function setBreakpoint() {\n  const swiper = this;\n  const {\n    realIndex,\n    initialized,\n    params,\n    el\n  } = swiper;\n  const breakpoints = params.breakpoints;\n  if (!breakpoints || breakpoints && Object.keys(breakpoints).length === 0) return;\n\n  // Get breakpoint for window width and update parameters\n  const breakpoint = swiper.getBreakpoint(breakpoints, swiper.params.breakpointsBase, swiper.el);\n  if (!breakpoint || swiper.currentBreakpoint === breakpoint) return;\n  const breakpointOnlyParams = breakpoint in breakpoints ? breakpoints[breakpoint] : undefined;\n  const breakpointParams = breakpointOnlyParams || swiper.originalParams;\n  const wasMultiRow = isGridEnabled(swiper, params);\n  const isMultiRow = isGridEnabled(swiper, breakpointParams);\n  const wasEnabled = params.enabled;\n  if (wasMultiRow && !isMultiRow) {\n    el.classList.remove(`${params.containerModifierClass}grid`, `${params.containerModifierClass}grid-column`);\n    swiper.emitContainerClasses();\n  } else if (!wasMultiRow && isMultiRow) {\n    el.classList.add(`${params.containerModifierClass}grid`);\n    if (breakpointParams.grid.fill && breakpointParams.grid.fill === 'column' || !breakpointParams.grid.fill && params.grid.fill === 'column') {\n      el.classList.add(`${params.containerModifierClass}grid-column`);\n    }\n    swiper.emitContainerClasses();\n  }\n\n  // Toggle navigation, pagination, scrollbar\n  ['navigation', 'pagination', 'scrollbar'].forEach(prop => {\n    if (typeof breakpointParams[prop] === 'undefined') return;\n    const wasModuleEnabled = params[prop] && params[prop].enabled;\n    const isModuleEnabled = breakpointParams[prop] && breakpointParams[prop].enabled;\n    if (wasModuleEnabled && !isModuleEnabled) {\n      swiper[prop].disable();\n    }\n    if (!wasModuleEnabled && isModuleEnabled) {\n      swiper[prop].enable();\n    }\n  });\n  const directionChanged = breakpointParams.direction && breakpointParams.direction !== params.direction;\n  const needsReLoop = params.loop && (breakpointParams.slidesPerView !== params.slidesPerView || directionChanged);\n  if (directionChanged && initialized) {\n    swiper.changeDirection();\n  }\n  extend(swiper.params, breakpointParams);\n  const isEnabled = swiper.params.enabled;\n  Object.assign(swiper, {\n    allowTouchMove: swiper.params.allowTouchMove,\n    allowSlideNext: swiper.params.allowSlideNext,\n    allowSlidePrev: swiper.params.allowSlidePrev\n  });\n  if (wasEnabled && !isEnabled) {\n    swiper.disable();\n  } else if (!wasEnabled && isEnabled) {\n    swiper.enable();\n  }\n  swiper.currentBreakpoint = breakpoint;\n  swiper.emit('_beforeBreakpoint', breakpointParams);\n  if (needsReLoop && initialized) {\n    swiper.loopDestroy();\n    swiper.loopCreate(realIndex);\n    swiper.updateSlides();\n  }\n  swiper.emit('breakpoint', breakpointParams);\n}","function checkOverflow() {\n  const swiper = this;\n  const {\n    isLocked: wasLocked,\n    params\n  } = swiper;\n  const {\n    slidesOffsetBefore\n  } = params;\n  if (slidesOffsetBefore) {\n    const lastSlideIndex = swiper.slides.length - 1;\n    const lastSlideRightEdge = swiper.slidesGrid[lastSlideIndex] + swiper.slidesSizesGrid[lastSlideIndex] + slidesOffsetBefore * 2;\n    swiper.isLocked = swiper.size > lastSlideRightEdge;\n  } else {\n    swiper.isLocked = swiper.snapGrid.length === 1;\n  }\n  if (params.allowSlideNext === true) {\n    swiper.allowSlideNext = !swiper.isLocked;\n  }\n  if (params.allowSlidePrev === true) {\n    swiper.allowSlidePrev = !swiper.isLocked;\n  }\n  if (wasLocked && wasLocked !== swiper.isLocked) {\n    swiper.isEnd = false;\n  }\n  if (wasLocked !== swiper.isLocked) {\n    swiper.emit(swiper.isLocked ? 'lock' : 'unlock');\n  }\n}\nexport default {\n  checkOverflow\n};","export default {\n  init: true,\n  direction: 'horizontal',\n  oneWayMovement: false,\n  touchEventsTarget: 'wrapper',\n  initialSlide: 0,\n  speed: 300,\n  cssMode: false,\n  updateOnWindowResize: true,\n  resizeObserver: true,\n  nested: false,\n  createElements: false,\n  enabled: true,\n  focusableElements: 'input, select, option, textarea, button, video, label',\n  // Overrides\n  width: null,\n  height: null,\n  //\n  preventInteractionOnTransition: false,\n  // ssr\n  userAgent: null,\n  url: null,\n  // To support iOS's swipe-to-go-back gesture (when being used in-app).\n  edgeSwipeDetection: false,\n  edgeSwipeThreshold: 20,\n  // Autoheight\n  autoHeight: false,\n  // Set wrapper width\n  setWrapperSize: false,\n  // Virtual Translate\n  virtualTranslate: false,\n  // Effects\n  effect: 'slide',\n  // 'slide' or 'fade' or 'cube' or 'coverflow' or 'flip'\n\n  // Breakpoints\n  breakpoints: undefined,\n  breakpointsBase: 'window',\n  // Slides grid\n  spaceBetween: 0,\n  slidesPerView: 1,\n  slidesPerGroup: 1,\n  slidesPerGroupSkip: 0,\n  slidesPerGroupAuto: false,\n  centeredSlides: false,\n  centeredSlidesBounds: false,\n  slidesOffsetBefore: 0,\n  // in px\n  slidesOffsetAfter: 0,\n  // in px\n  normalizeSlideIndex: true,\n  centerInsufficientSlides: false,\n  // Disable swiper and hide navigation when container not overflow\n  watchOverflow: true,\n  // Round length\n  roundLengths: false,\n  // Touches\n  touchRatio: 1,\n  touchAngle: 45,\n  simulateTouch: true,\n  shortSwipes: true,\n  longSwipes: true,\n  longSwipesRatio: 0.5,\n  longSwipesMs: 300,\n  followFinger: true,\n  allowTouchMove: true,\n  threshold: 5,\n  touchMoveStopPropagation: false,\n  touchStartPreventDefault: true,\n  touchStartForcePreventDefault: false,\n  touchReleaseOnEdges: false,\n  // Unique Navigation Elements\n  uniqueNavElements: true,\n  // Resistance\n  resistance: true,\n  resistanceRatio: 0.85,\n  // Progress\n  watchSlidesProgress: false,\n  // Cursor\n  grabCursor: false,\n  // Clicks\n  preventClicks: true,\n  preventClicksPropagation: true,\n  slideToClickedSlide: false,\n  // loop\n  loop: false,\n  loopedSlides: null,\n  loopPreventsSliding: true,\n  // rewind\n  rewind: false,\n  // Swiping/no swiping\n  allowSlidePrev: true,\n  allowSlideNext: true,\n  swipeHandler: null,\n  // '.swipe-handler',\n  noSwiping: true,\n  noSwipingClass: 'swiper-no-swiping',\n  noSwipingSelector: null,\n  // Passive Listeners\n  passiveListeners: true,\n  maxBackfaceHiddenSlides: 10,\n  // NS\n  containerModifierClass: 'swiper-',\n  // NEW\n  slideClass: 'swiper-slide',\n  slideActiveClass: 'swiper-slide-active',\n  slideVisibleClass: 'swiper-slide-visible',\n  slideNextClass: 'swiper-slide-next',\n  slidePrevClass: 'swiper-slide-prev',\n  wrapperClass: 'swiper-wrapper',\n  lazyPreloaderClass: 'swiper-lazy-preloader',\n  lazyPreloadPrevNext: 0,\n  // Callbacks\n  runCallbacksOnInit: true,\n  // Internals\n  _emitClasses: false\n};","import { extend } from '../shared/utils.js';\nexport default function moduleExtendParams(params, allModulesParams) {\n  return function extendParams(obj = {}) {\n    const moduleParamName = Object.keys(obj)[0];\n    const moduleParams = obj[moduleParamName];\n    if (typeof moduleParams !== 'object' || moduleParams === null) {\n      extend(allModulesParams, obj);\n      return;\n    }\n    if (['navigation', 'pagination', 'scrollbar'].indexOf(moduleParamName) >= 0 && params[moduleParamName] === true) {\n      params[moduleParamName] = {\n        auto: true\n      };\n    }\n    if (!(moduleParamName in params && 'enabled' in moduleParams)) {\n      extend(allModulesParams, obj);\n      return;\n    }\n    if (params[moduleParamName] === true) {\n      params[moduleParamName] = {\n        enabled: true\n      };\n    }\n    if (typeof params[moduleParamName] === 'object' && !('enabled' in params[moduleParamName])) {\n      params[moduleParamName].enabled = true;\n    }\n    if (!params[moduleParamName]) params[moduleParamName] = {\n      enabled: false\n    };\n    extend(allModulesParams, obj);\n  };\n}","/* eslint no-param-reassign: \"off\" */\nimport { getDocument } from 'ssr-window';\nimport { extend, deleteProps, createElement, elementChildren, elementStyle, elementIndex } from '../shared/utils.js';\nimport { getSupport } from '../shared/get-support.js';\nimport { getDevice } from '../shared/get-device.js';\nimport { getBrowser } from '../shared/get-browser.js';\nimport Resize from './modules/resize/resize.js';\nimport Observer from './modules/observer/observer.js';\nimport eventsEmitter from './events-emitter.js';\nimport update from './update/index.js';\nimport translate from './translate/index.js';\nimport transition from './transition/index.js';\nimport slide from './slide/index.js';\nimport loop from './loop/index.js';\nimport grabCursor from './grab-cursor/index.js';\nimport events from './events/index.js';\nimport breakpoints from './breakpoints/index.js';\nimport classes from './classes/index.js';\nimport checkOverflow from './check-overflow/index.js';\nimport defaults from './defaults.js';\nimport moduleExtendParams from './moduleExtendParams.js';\nimport { processLazyPreloader, preload } from '../shared/process-lazy-preloader.js';\nconst prototypes = {\n  eventsEmitter,\n  update,\n  translate,\n  transition,\n  slide,\n  loop,\n  grabCursor,\n  events,\n  breakpoints,\n  checkOverflow,\n  classes\n};\nconst extendedDefaults = {};\nclass Swiper {\n  constructor(...args) {\n    let el;\n    let params;\n    if (args.length === 1 && args[0].constructor && Object.prototype.toString.call(args[0]).slice(8, -1) === 'Object') {\n      params = args[0];\n    } else {\n      [el, params] = args;\n    }\n    if (!params) params = {};\n    params = extend({}, params);\n    if (el && !params.el) params.el = el;\n    const document = getDocument();\n    if (params.el && typeof params.el === 'string' && document.querySelectorAll(params.el).length > 1) {\n      const swipers = [];\n      document.querySelectorAll(params.el).forEach(containerEl => {\n        const newParams = extend({}, params, {\n          el: containerEl\n        });\n        swipers.push(new Swiper(newParams));\n      });\n      // eslint-disable-next-line no-constructor-return\n      return swipers;\n    }\n\n    // Swiper Instance\n    const swiper = this;\n    swiper.__swiper__ = true;\n    swiper.support = getSupport();\n    swiper.device = getDevice({\n      userAgent: params.userAgent\n    });\n    swiper.browser = getBrowser();\n    swiper.eventsListeners = {};\n    swiper.eventsAnyListeners = [];\n    swiper.modules = [...swiper.__modules__];\n    if (params.modules && Array.isArray(params.modules)) {\n      swiper.modules.push(...params.modules);\n    }\n    const allModulesParams = {};\n    swiper.modules.forEach(mod => {\n      mod({\n        params,\n        swiper,\n        extendParams: moduleExtendParams(params, allModulesParams),\n        on: swiper.on.bind(swiper),\n        once: swiper.once.bind(swiper),\n        off: swiper.off.bind(swiper),\n        emit: swiper.emit.bind(swiper)\n      });\n    });\n\n    // Extend defaults with modules params\n    const swiperParams = extend({}, defaults, allModulesParams);\n\n    // Extend defaults with passed params\n    swiper.params = extend({}, swiperParams, extendedDefaults, params);\n    swiper.originalParams = extend({}, swiper.params);\n    swiper.passedParams = extend({}, params);\n\n    // add event listeners\n    if (swiper.params && swiper.params.on) {\n      Object.keys(swiper.params.on).forEach(eventName => {\n        swiper.on(eventName, swiper.params.on[eventName]);\n      });\n    }\n    if (swiper.params && swiper.params.onAny) {\n      swiper.onAny(swiper.params.onAny);\n    }\n\n    // Extend Swiper\n    Object.assign(swiper, {\n      enabled: swiper.params.enabled,\n      el,\n      // Classes\n      classNames: [],\n      // Slides\n      slides: [],\n      slidesGrid: [],\n      snapGrid: [],\n      slidesSizesGrid: [],\n      // isDirection\n      isHorizontal() {\n        return swiper.params.direction === 'horizontal';\n      },\n      isVertical() {\n        return swiper.params.direction === 'vertical';\n      },\n      // Indexes\n      activeIndex: 0,\n      realIndex: 0,\n      //\n      isBeginning: true,\n      isEnd: false,\n      // Props\n      translate: 0,\n      previousTranslate: 0,\n      progress: 0,\n      velocity: 0,\n      animating: false,\n      cssOverflowAdjustment() {\n        // Returns 0 unless `translate` is > 2**23\n        // Should be subtracted from css values to prevent overflow\n        return Math.trunc(this.translate / 2 ** 23) * 2 ** 23;\n      },\n      // Locks\n      allowSlideNext: swiper.params.allowSlideNext,\n      allowSlidePrev: swiper.params.allowSlidePrev,\n      // Touch Events\n      touchEventsData: {\n        isTouched: undefined,\n        isMoved: undefined,\n        allowTouchCallbacks: undefined,\n        touchStartTime: undefined,\n        isScrolling: undefined,\n        currentTranslate: undefined,\n        startTranslate: undefined,\n        allowThresholdMove: undefined,\n        // Form elements to match\n        focusableElements: swiper.params.focusableElements,\n        // Last click time\n        lastClickTime: 0,\n        clickTimeout: undefined,\n        // Velocities\n        velocities: [],\n        allowMomentumBounce: undefined,\n        startMoving: undefined,\n        evCache: []\n      },\n      // Clicks\n      allowClick: true,\n      // Touches\n      allowTouchMove: swiper.params.allowTouchMove,\n      touches: {\n        startX: 0,\n        startY: 0,\n        currentX: 0,\n        currentY: 0,\n        diff: 0\n      },\n      // Images\n      imagesToLoad: [],\n      imagesLoaded: 0\n    });\n    swiper.emit('_swiper');\n\n    // Init\n    if (swiper.params.init) {\n      swiper.init();\n    }\n\n    // Return app instance\n    // eslint-disable-next-line no-constructor-return\n    return swiper;\n  }\n  getSlideIndex(slideEl) {\n    const {\n      slidesEl,\n      params\n    } = this;\n    const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);\n    const firstSlideIndex = elementIndex(slides[0]);\n    return elementIndex(slideEl) - firstSlideIndex;\n  }\n  getSlideIndexByData(index) {\n    return this.getSlideIndex(this.slides.filter(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === index)[0]);\n  }\n  recalcSlides() {\n    const swiper = this;\n    const {\n      slidesEl,\n      params\n    } = swiper;\n    swiper.slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);\n  }\n  enable() {\n    const swiper = this;\n    if (swiper.enabled) return;\n    swiper.enabled = true;\n    if (swiper.params.grabCursor) {\n      swiper.setGrabCursor();\n    }\n    swiper.emit('enable');\n  }\n  disable() {\n    const swiper = this;\n    if (!swiper.enabled) return;\n    swiper.enabled = false;\n    if (swiper.params.grabCursor) {\n      swiper.unsetGrabCursor();\n    }\n    swiper.emit('disable');\n  }\n  setProgress(progress, speed) {\n    const swiper = this;\n    progress = Math.min(Math.max(progress, 0), 1);\n    const min = swiper.minTranslate();\n    const max = swiper.maxTranslate();\n    const current = (max - min) * progress + min;\n    swiper.translateTo(current, typeof speed === 'undefined' ? 0 : speed);\n    swiper.updateActiveIndex();\n    swiper.updateSlidesClasses();\n  }\n  emitContainerClasses() {\n    const swiper = this;\n    if (!swiper.params._emitClasses || !swiper.el) return;\n    const cls = swiper.el.className.split(' ').filter(className => {\n      return className.indexOf('swiper') === 0 || className.indexOf(swiper.params.containerModifierClass) === 0;\n    });\n    swiper.emit('_containerClasses', cls.join(' '));\n  }\n  getSlideClasses(slideEl) {\n    const swiper = this;\n    if (swiper.destroyed) return '';\n    return slideEl.className.split(' ').filter(className => {\n      return className.indexOf('swiper-slide') === 0 || className.indexOf(swiper.params.slideClass) === 0;\n    }).join(' ');\n  }\n  emitSlidesClasses() {\n    const swiper = this;\n    if (!swiper.params._emitClasses || !swiper.el) return;\n    const updates = [];\n    swiper.slides.forEach(slideEl => {\n      const classNames = swiper.getSlideClasses(slideEl);\n      updates.push({\n        slideEl,\n        classNames\n      });\n      swiper.emit('_slideClass', slideEl, classNames);\n    });\n    swiper.emit('_slideClasses', updates);\n  }\n  slidesPerViewDynamic(view = 'current', exact = false) {\n    const swiper = this;\n    const {\n      params,\n      slides,\n      slidesGrid,\n      slidesSizesGrid,\n      size: swiperSize,\n      activeIndex\n    } = swiper;\n    let spv = 1;\n    if (params.centeredSlides) {\n      let slideSize = slides[activeIndex] ? slides[activeIndex].swiperSlideSize : 0;\n      let breakLoop;\n      for (let i = activeIndex + 1; i < slides.length; i += 1) {\n        if (slides[i] && !breakLoop) {\n          slideSize += slides[i].swiperSlideSize;\n          spv += 1;\n          if (slideSize > swiperSize) breakLoop = true;\n        }\n      }\n      for (let i = activeIndex - 1; i >= 0; i -= 1) {\n        if (slides[i] && !breakLoop) {\n          slideSize += slides[i].swiperSlideSize;\n          spv += 1;\n          if (slideSize > swiperSize) breakLoop = true;\n        }\n      }\n    } else {\n      // eslint-disable-next-line\n      if (view === 'current') {\n        for (let i = activeIndex + 1; i < slides.length; i += 1) {\n          const slideInView = exact ? slidesGrid[i] + slidesSizesGrid[i] - slidesGrid[activeIndex] < swiperSize : slidesGrid[i] - slidesGrid[activeIndex] < swiperSize;\n          if (slideInView) {\n            spv += 1;\n          }\n        }\n      } else {\n        // previous\n        for (let i = activeIndex - 1; i >= 0; i -= 1) {\n          const slideInView = slidesGrid[activeIndex] - slidesGrid[i] < swiperSize;\n          if (slideInView) {\n            spv += 1;\n          }\n        }\n      }\n    }\n    return spv;\n  }\n  update() {\n    const swiper = this;\n    if (!swiper || swiper.destroyed) return;\n    const {\n      snapGrid,\n      params\n    } = swiper;\n    // Breakpoints\n    if (params.breakpoints) {\n      swiper.setBreakpoint();\n    }\n    [...swiper.el.querySelectorAll('[loading=\"lazy\"]')].forEach(imageEl => {\n      if (imageEl.complete) {\n        processLazyPreloader(swiper, imageEl);\n      }\n    });\n    swiper.updateSize();\n    swiper.updateSlides();\n    swiper.updateProgress();\n    swiper.updateSlidesClasses();\n    function setTranslate() {\n      const translateValue = swiper.rtlTranslate ? swiper.translate * -1 : swiper.translate;\n      const newTranslate = Math.min(Math.max(translateValue, swiper.maxTranslate()), swiper.minTranslate());\n      swiper.setTranslate(newTranslate);\n      swiper.updateActiveIndex();\n      swiper.updateSlidesClasses();\n    }\n    let translated;\n    if (params.freeMode && params.freeMode.enabled && !params.cssMode) {\n      setTranslate();\n      if (params.autoHeight) {\n        swiper.updateAutoHeight();\n      }\n    } else {\n      if ((params.slidesPerView === 'auto' || params.slidesPerView > 1) && swiper.isEnd && !params.centeredSlides) {\n        const slides = swiper.virtual && params.virtual.enabled ? swiper.virtual.slides : swiper.slides;\n        translated = swiper.slideTo(slides.length - 1, 0, false, true);\n      } else {\n        translated = swiper.slideTo(swiper.activeIndex, 0, false, true);\n      }\n      if (!translated) {\n        setTranslate();\n      }\n    }\n    if (params.watchOverflow && snapGrid !== swiper.snapGrid) {\n      swiper.checkOverflow();\n    }\n    swiper.emit('update');\n  }\n  changeDirection(newDirection, needUpdate = true) {\n    const swiper = this;\n    const currentDirection = swiper.params.direction;\n    if (!newDirection) {\n      // eslint-disable-next-line\n      newDirection = currentDirection === 'horizontal' ? 'vertical' : 'horizontal';\n    }\n    if (newDirection === currentDirection || newDirection !== 'horizontal' && newDirection !== 'vertical') {\n      return swiper;\n    }\n    swiper.el.classList.remove(`${swiper.params.containerModifierClass}${currentDirection}`);\n    swiper.el.classList.add(`${swiper.params.containerModifierClass}${newDirection}`);\n    swiper.emitContainerClasses();\n    swiper.params.direction = newDirection;\n    swiper.slides.forEach(slideEl => {\n      if (newDirection === 'vertical') {\n        slideEl.style.width = '';\n      } else {\n        slideEl.style.height = '';\n      }\n    });\n    swiper.emit('changeDirection');\n    if (needUpdate) swiper.update();\n    return swiper;\n  }\n  changeLanguageDirection(direction) {\n    const swiper = this;\n    if (swiper.rtl && direction === 'rtl' || !swiper.rtl && direction === 'ltr') return;\n    swiper.rtl = direction === 'rtl';\n    swiper.rtlTranslate = swiper.params.direction === 'horizontal' && swiper.rtl;\n    if (swiper.rtl) {\n      swiper.el.classList.add(`${swiper.params.containerModifierClass}rtl`);\n      swiper.el.dir = 'rtl';\n    } else {\n      swiper.el.classList.remove(`${swiper.params.containerModifierClass}rtl`);\n      swiper.el.dir = 'ltr';\n    }\n    swiper.update();\n  }\n  mount(element) {\n    const swiper = this;\n    if (swiper.mounted) return true;\n\n    // Find el\n    let el = element || swiper.params.el;\n    if (typeof el === 'string') {\n      el = document.querySelector(el);\n    }\n    if (!el) {\n      return false;\n    }\n    el.swiper = swiper;\n    if (el.shadowEl) {\n      swiper.isElement = true;\n    }\n    const getWrapperSelector = () => {\n      return `.${(swiper.params.wrapperClass || '').trim().split(' ').join('.')}`;\n    };\n    const getWrapper = () => {\n      if (el && el.shadowRoot && el.shadowRoot.querySelector) {\n        const res = el.shadowRoot.querySelector(getWrapperSelector());\n        // Children needs to return slot items\n        return res;\n      }\n      return elementChildren(el, getWrapperSelector())[0];\n    };\n    // Find Wrapper\n    let wrapperEl = getWrapper();\n    if (!wrapperEl && swiper.params.createElements) {\n      wrapperEl = createElement('div', swiper.params.wrapperClass);\n      el.append(wrapperEl);\n      elementChildren(el, `.${swiper.params.slideClass}`).forEach(slideEl => {\n        wrapperEl.append(slideEl);\n      });\n    }\n    Object.assign(swiper, {\n      el,\n      wrapperEl,\n      slidesEl: swiper.isElement ? el : wrapperEl,\n      mounted: true,\n      // RTL\n      rtl: el.dir.toLowerCase() === 'rtl' || elementStyle(el, 'direction') === 'rtl',\n      rtlTranslate: swiper.params.direction === 'horizontal' && (el.dir.toLowerCase() === 'rtl' || elementStyle(el, 'direction') === 'rtl'),\n      wrongRTL: elementStyle(wrapperEl, 'display') === '-webkit-box'\n    });\n    return true;\n  }\n  init(el) {\n    const swiper = this;\n    if (swiper.initialized) return swiper;\n    const mounted = swiper.mount(el);\n    if (mounted === false) return swiper;\n    swiper.emit('beforeInit');\n\n    // Set breakpoint\n    if (swiper.params.breakpoints) {\n      swiper.setBreakpoint();\n    }\n\n    // Add Classes\n    swiper.addClasses();\n\n    // Update size\n    swiper.updateSize();\n\n    // Update slides\n    swiper.updateSlides();\n    if (swiper.params.watchOverflow) {\n      swiper.checkOverflow();\n    }\n\n    // Set Grab Cursor\n    if (swiper.params.grabCursor && swiper.enabled) {\n      swiper.setGrabCursor();\n    }\n\n    // Slide To Initial Slide\n    if (swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {\n      swiper.slideTo(swiper.params.initialSlide + swiper.virtual.slidesBefore, 0, swiper.params.runCallbacksOnInit, false, true);\n    } else {\n      swiper.slideTo(swiper.params.initialSlide, 0, swiper.params.runCallbacksOnInit, false, true);\n    }\n\n    // Create loop\n    if (swiper.params.loop) {\n      swiper.loopCreate();\n    }\n\n    // Attach events\n    swiper.attachEvents();\n    [...swiper.el.querySelectorAll('[loading=\"lazy\"]')].forEach(imageEl => {\n      if (imageEl.complete) {\n        processLazyPreloader(swiper, imageEl);\n      } else {\n        imageEl.addEventListener('load', e => {\n          processLazyPreloader(swiper, e.target);\n        });\n      }\n    });\n    preload(swiper);\n\n    // Init Flag\n    swiper.initialized = true;\n    preload(swiper);\n\n    // Emit\n    swiper.emit('init');\n    swiper.emit('afterInit');\n    return swiper;\n  }\n  destroy(deleteInstance = true, cleanStyles = true) {\n    const swiper = this;\n    const {\n      params,\n      el,\n      wrapperEl,\n      slides\n    } = swiper;\n    if (typeof swiper.params === 'undefined' || swiper.destroyed) {\n      return null;\n    }\n    swiper.emit('beforeDestroy');\n\n    // Init Flag\n    swiper.initialized = false;\n\n    // Detach events\n    swiper.detachEvents();\n\n    // Destroy loop\n    if (params.loop) {\n      swiper.loopDestroy();\n    }\n\n    // Cleanup styles\n    if (cleanStyles) {\n      swiper.removeClasses();\n      el.removeAttribute('style');\n      wrapperEl.removeAttribute('style');\n      if (slides && slides.length) {\n        slides.forEach(slideEl => {\n          slideEl.classList.remove(params.slideVisibleClass, params.slideActiveClass, params.slideNextClass, params.slidePrevClass);\n          slideEl.removeAttribute('style');\n          slideEl.removeAttribute('data-swiper-slide-index');\n        });\n      }\n    }\n    swiper.emit('destroy');\n\n    // Detach emitter events\n    Object.keys(swiper.eventsListeners).forEach(eventName => {\n      swiper.off(eventName);\n    });\n    if (deleteInstance !== false) {\n      swiper.el.swiper = null;\n      deleteProps(swiper);\n    }\n    swiper.destroyed = true;\n    return null;\n  }\n  static extendDefaults(newDefaults) {\n    extend(extendedDefaults, newDefaults);\n  }\n  static get extendedDefaults() {\n    return extendedDefaults;\n  }\n  static get defaults() {\n    return defaults;\n  }\n  static installModule(mod) {\n    if (!Swiper.prototype.__modules__) Swiper.prototype.__modules__ = [];\n    const modules = Swiper.prototype.__modules__;\n    if (typeof mod === 'function' && modules.indexOf(mod) < 0) {\n      modules.push(mod);\n    }\n  }\n  static use(module) {\n    if (Array.isArray(module)) {\n      module.forEach(m => Swiper.installModule(m));\n      return Swiper;\n    }\n    Swiper.installModule(module);\n    return Swiper;\n  }\n}\nObject.keys(prototypes).forEach(prototypeGroup => {\n  Object.keys(prototypes[prototypeGroup]).forEach(protoMethod => {\n    Swiper.prototype[protoMethod] = prototypes[prototypeGroup][protoMethod];\n  });\n});\nSwiper.use([Resize, Observer]);\nexport default Swiper;","import setTransition from './setTransition.js';\nimport transitionStart from './transitionStart.js';\nimport transitionEnd from './transitionEnd.js';\nexport default {\n  setTransition,\n  transitionStart,\n  transitionEnd\n};","export default function setTransition(duration, byController) {\n  const swiper = this;\n  if (!swiper.params.cssMode) {\n    swiper.wrapperEl.style.transitionDuration = `${duration}ms`;\n  }\n  swiper.emit('setTransition', duration, byController);\n}","import transitionEmit from './transitionEmit.js';\nexport default function transitionStart(runCallbacks = true, direction) {\n  const swiper = this;\n  const {\n    params\n  } = swiper;\n  if (params.cssMode) return;\n  if (params.autoHeight) {\n    swiper.updateAutoHeight();\n  }\n  transitionEmit({\n    swiper,\n    runCallbacks,\n    direction,\n    step: 'Start'\n  });\n}","import transitionEmit from './transitionEmit.js';\nexport default function transitionEnd(runCallbacks = true, direction) {\n  const swiper = this;\n  const {\n    params\n  } = swiper;\n  swiper.animating = false;\n  if (params.cssMode) return;\n  swiper.setTransition(0);\n  transitionEmit({\n    swiper,\n    runCallbacks,\n    direction,\n    step: 'End'\n  });\n}","import setGrabCursor from './setGrabCursor.js';\nimport unsetGrabCursor from './unsetGrabCursor.js';\nexport default {\n  setGrabCursor,\n  unsetGrabCursor\n};","export default function setGrabCursor(moving) {\n  const swiper = this;\n  if (!swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;\n  const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;\n  if (swiper.isElement) {\n    swiper.__preventObserver__ = true;\n  }\n  el.style.cursor = 'move';\n  el.style.cursor = moving ? 'grabbing' : 'grab';\n  if (swiper.isElement) {\n    requestAnimationFrame(() => {\n      swiper.__preventObserver__ = false;\n    });\n  }\n}","export default function unsetGrabCursor() {\n  const swiper = this;\n  if (swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {\n    return;\n  }\n  if (swiper.isElement) {\n    swiper.__preventObserver__ = true;\n  }\n  swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';\n  if (swiper.isElement) {\n    requestAnimationFrame(() => {\n      swiper.__preventObserver__ = false;\n    });\n  }\n}","import setBreakpoint from './setBreakpoint.js';\nimport getBreakpoint from './getBreakpoint.js';\nexport default {\n  setBreakpoint,\n  getBreakpoint\n};","import { getWindow } from 'ssr-window';\nexport default function getBreakpoint(breakpoints, base = 'window', containerEl) {\n  if (!breakpoints || base === 'container' && !containerEl) return undefined;\n  let breakpoint = false;\n  const window = getWindow();\n  const currentHeight = base === 'window' ? window.innerHeight : containerEl.clientHeight;\n  const points = Object.keys(breakpoints).map(point => {\n    if (typeof point === 'string' && point.indexOf('@') === 0) {\n      const minRatio = parseFloat(point.substr(1));\n      const value = currentHeight * minRatio;\n      return {\n        value,\n        point\n      };\n    }\n    return {\n      value: point,\n      point\n    };\n  });\n  points.sort((a, b) => parseInt(a.value, 10) - parseInt(b.value, 10));\n  for (let i = 0; i < points.length; i += 1) {\n    const {\n      point,\n      value\n    } = points[i];\n    if (base === 'window') {\n      if (window.matchMedia(`(min-width: ${value}px)`).matches) {\n        breakpoint = point;\n      }\n    } else if (value <= containerEl.clientWidth) {\n      breakpoint = point;\n    }\n  }\n  return breakpoint || 'max';\n}","import addClasses from './addClasses.js';\nimport removeClasses from './removeClasses.js';\nexport default {\n  addClasses,\n  removeClasses\n};","function prepareClasses(entries, prefix) {\n  const resultClasses = [];\n  entries.forEach(item => {\n    if (typeof item === 'object') {\n      Object.keys(item).forEach(classNames => {\n        if (item[classNames]) {\n          resultClasses.push(prefix + classNames);\n        }\n      });\n    } else if (typeof item === 'string') {\n      resultClasses.push(prefix + item);\n    }\n  });\n  return resultClasses;\n}\nexport default function addClasses() {\n  const swiper = this;\n  const {\n    classNames,\n    params,\n    rtl,\n    el,\n    device\n  } = swiper;\n  // prettier-ignore\n  const suffixes = prepareClasses(['initialized', params.direction, {\n    'free-mode': swiper.params.freeMode && params.freeMode.enabled\n  }, {\n    'autoheight': params.autoHeight\n  }, {\n    'rtl': rtl\n  }, {\n    'grid': params.grid && params.grid.rows > 1\n  }, {\n    'grid-column': params.grid && params.grid.rows > 1 && params.grid.fill === 'column'\n  }, {\n    'android': device.android\n  }, {\n    'ios': device.ios\n  }, {\n    'css-mode': params.cssMode\n  }, {\n    'centered': params.cssMode && params.centeredSlides\n  }, {\n    'watch-progress': params.watchSlidesProgress\n  }], params.containerModifierClass);\n  classNames.push(...suffixes);\n  el.classList.add(...classNames);\n  swiper.emitContainerClasses();\n}","export default function removeClasses() {\n  const swiper = this;\n  const {\n    el,\n    classNames\n  } = swiper;\n  el.classList.remove(...classNames);\n  swiper.emitContainerClasses();\n}","import { getWindow } from 'ssr-window';\nexport default function Resize({\n  swiper,\n  on,\n  emit\n}) {\n  const window = getWindow();\n  let observer = null;\n  let animationFrame = null;\n  const resizeHandler = () => {\n    if (!swiper || swiper.destroyed || !swiper.initialized) return;\n    emit('beforeResize');\n    emit('resize');\n  };\n  const createObserver = () => {\n    if (!swiper || swiper.destroyed || !swiper.initialized) return;\n    observer = new ResizeObserver(entries => {\n      animationFrame = window.requestAnimationFrame(() => {\n        const {\n          width,\n          height\n        } = swiper;\n        let newWidth = width;\n        let newHeight = height;\n        entries.forEach(({\n          contentBoxSize,\n          contentRect,\n          target\n        }) => {\n          if (target && target !== swiper.el) return;\n          newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;\n          newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;\n        });\n        if (newWidth !== width || newHeight !== height) {\n          resizeHandler();\n        }\n      });\n    });\n    observer.observe(swiper.el);\n  };\n  const removeObserver = () => {\n    if (animationFrame) {\n      window.cancelAnimationFrame(animationFrame);\n    }\n    if (observer && observer.unobserve && swiper.el) {\n      observer.unobserve(swiper.el);\n      observer = null;\n    }\n  };\n  const orientationChangeHandler = () => {\n    if (!swiper || swiper.destroyed || !swiper.initialized) return;\n    emit('orientationchange');\n  };\n  on('init', () => {\n    if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {\n      createObserver();\n      return;\n    }\n    window.addEventListener('resize', resizeHandler);\n    window.addEventListener('orientationchange', orientationChangeHandler);\n  });\n  on('destroy', () => {\n    removeObserver();\n    window.removeEventListener('resize', resizeHandler);\n    window.removeEventListener('orientationchange', orientationChangeHandler);\n  });\n}","import { getWindow } from 'ssr-window';\nimport { elementParents } from '../../../shared/utils.js';\nexport default function Observer({\n  swiper,\n  extendParams,\n  on,\n  emit\n}) {\n  const observers = [];\n  const window = getWindow();\n  const attach = (target, options = {}) => {\n    const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;\n    const observer = new ObserverFunc(mutations => {\n      // The observerUpdate event should only be triggered\n      // once despite the number of mutations.  Additional\n      // triggers are redundant and are very costly\n      if (swiper.__preventObserver__) return;\n      if (mutations.length === 1) {\n        emit('observerUpdate', mutations[0]);\n        return;\n      }\n      const observerUpdate = function observerUpdate() {\n        emit('observerUpdate', mutations[0]);\n      };\n      if (window.requestAnimationFrame) {\n        window.requestAnimationFrame(observerUpdate);\n      } else {\n        window.setTimeout(observerUpdate, 0);\n      }\n    });\n    observer.observe(target, {\n      attributes: typeof options.attributes === 'undefined' ? true : options.attributes,\n      childList: typeof options.childList === 'undefined' ? true : options.childList,\n      characterData: typeof options.characterData === 'undefined' ? true : options.characterData\n    });\n    observers.push(observer);\n  };\n  const init = () => {\n    if (!swiper.params.observer) return;\n    if (swiper.params.observeParents) {\n      const containerParents = elementParents(swiper.el);\n      for (let i = 0; i < containerParents.length; i += 1) {\n        attach(containerParents[i]);\n      }\n    }\n    // Observe container\n    attach(swiper.el, {\n      childList: swiper.params.observeSlideChildren\n    });\n\n    // Observe wrapper\n    attach(swiper.wrapperEl, {\n      attributes: false\n    });\n  };\n  const destroy = () => {\n    observers.forEach(observer => {\n      observer.disconnect();\n    });\n    observers.splice(0, observers.length);\n  };\n  extendParams({\n    observer: false,\n    observeParents: false,\n    observeSlideChildren: false\n  });\n  on('init', init);\n  on('destroy', destroy);\n}","import { getDocument } from 'ssr-window';\nimport { createElement, elementChildren, setCSSProperty } from '../../shared/utils.js';\nexport default function Virtual({\n  swiper,\n  extendParams,\n  on,\n  emit\n}) {\n  extendParams({\n    virtual: {\n      enabled: false,\n      slides: [],\n      cache: true,\n      renderSlide: null,\n      renderExternal: null,\n      renderExternalUpdate: true,\n      addSlidesBefore: 0,\n      addSlidesAfter: 0\n    }\n  });\n  let cssModeTimeout;\n  const document = getDocument();\n  swiper.virtual = {\n    cache: {},\n    from: undefined,\n    to: undefined,\n    slides: [],\n    offset: 0,\n    slidesGrid: []\n  };\n  const tempDOM = document.createElement('div');\n  function renderSlide(slide, index) {\n    const params = swiper.params.virtual;\n    if (params.cache && swiper.virtual.cache[index]) {\n      return swiper.virtual.cache[index];\n    }\n    // eslint-disable-next-line\n    let slideEl;\n    if (params.renderSlide) {\n      slideEl = params.renderSlide.call(swiper, slide, index);\n      if (typeof slideEl === 'string') {\n        tempDOM.innerHTML = slideEl;\n        slideEl = tempDOM.children[0];\n      }\n    } else if (swiper.isElement) {\n      slideEl = createElement('swiper-slide');\n    } else {\n      slideEl = createElement('div', swiper.params.slideClass);\n    }\n    slideEl.setAttribute('data-swiper-slide-index', index);\n    if (!params.renderSlide) {\n      slideEl.innerHTML = slide;\n    }\n    if (params.cache) swiper.virtual.cache[index] = slideEl;\n    return slideEl;\n  }\n  function update(force) {\n    const {\n      slidesPerView,\n      slidesPerGroup,\n      centeredSlides,\n      loop: isLoop\n    } = swiper.params;\n    const {\n      addSlidesBefore,\n      addSlidesAfter\n    } = swiper.params.virtual;\n    const {\n      from: previousFrom,\n      to: previousTo,\n      slides,\n      slidesGrid: previousSlidesGrid,\n      offset: previousOffset\n    } = swiper.virtual;\n    if (!swiper.params.cssMode) {\n      swiper.updateActiveIndex();\n    }\n    const activeIndex = swiper.activeIndex || 0;\n    let offsetProp;\n    if (swiper.rtlTranslate) offsetProp = 'right';else offsetProp = swiper.isHorizontal() ? 'left' : 'top';\n    let slidesAfter;\n    let slidesBefore;\n    if (centeredSlides) {\n      slidesAfter = Math.floor(slidesPerView / 2) + slidesPerGroup + addSlidesAfter;\n      slidesBefore = Math.floor(slidesPerView / 2) + slidesPerGroup + addSlidesBefore;\n    } else {\n      slidesAfter = slidesPerView + (slidesPerGroup - 1) + addSlidesAfter;\n      slidesBefore = (isLoop ? slidesPerView : slidesPerGroup) + addSlidesBefore;\n    }\n    let from = activeIndex - slidesBefore;\n    let to = activeIndex + slidesAfter;\n    if (!isLoop) {\n      from = Math.max(from, 0);\n      to = Math.min(to, slides.length - 1);\n    }\n    let offset = (swiper.slidesGrid[from] || 0) - (swiper.slidesGrid[0] || 0);\n    if (isLoop && activeIndex >= slidesBefore) {\n      from -= slidesBefore;\n      if (!centeredSlides) offset += swiper.slidesGrid[0];\n    } else if (isLoop && activeIndex < slidesBefore) {\n      from = -slidesBefore;\n      if (centeredSlides) offset += swiper.slidesGrid[0];\n    }\n    Object.assign(swiper.virtual, {\n      from,\n      to,\n      offset,\n      slidesGrid: swiper.slidesGrid,\n      slidesBefore,\n      slidesAfter\n    });\n    function onRendered() {\n      swiper.updateSlides();\n      swiper.updateProgress();\n      swiper.updateSlidesClasses();\n      emit('virtualUpdate');\n    }\n    if (previousFrom === from && previousTo === to && !force) {\n      if (swiper.slidesGrid !== previousSlidesGrid && offset !== previousOffset) {\n        swiper.slides.forEach(slideEl => {\n          slideEl.style[offsetProp] = `${offset - Math.abs(swiper.cssOverflowAdjustment())}px`;\n        });\n      }\n      swiper.updateProgress();\n      emit('virtualUpdate');\n      return;\n    }\n    if (swiper.params.virtual.renderExternal) {\n      swiper.params.virtual.renderExternal.call(swiper, {\n        offset,\n        from,\n        to,\n        slides: function getSlides() {\n          const slidesToRender = [];\n          for (let i = from; i <= to; i += 1) {\n            slidesToRender.push(slides[i]);\n          }\n          return slidesToRender;\n        }()\n      });\n      if (swiper.params.virtual.renderExternalUpdate) {\n        onRendered();\n      } else {\n        emit('virtualUpdate');\n      }\n      return;\n    }\n    const prependIndexes = [];\n    const appendIndexes = [];\n    const getSlideIndex = index => {\n      let slideIndex = index;\n      if (index < 0) {\n        slideIndex = slides.length + index;\n      } else if (slideIndex >= slides.length) {\n        // eslint-disable-next-line\n        slideIndex = slideIndex - slides.length;\n      }\n      return slideIndex;\n    };\n    if (force) {\n      swiper.slidesEl.querySelectorAll(`.${swiper.params.slideClass}, swiper-slide`).forEach(slideEl => {\n        slideEl.remove();\n      });\n    } else {\n      for (let i = previousFrom; i <= previousTo; i += 1) {\n        if (i < from || i > to) {\n          const slideIndex = getSlideIndex(i);\n          swiper.slidesEl.querySelectorAll(`.${swiper.params.slideClass}[data-swiper-slide-index=\"${slideIndex}\"], swiper-slide[data-swiper-slide-index=\"${slideIndex}\"]`).forEach(slideEl => {\n            slideEl.remove();\n          });\n        }\n      }\n    }\n    const loopFrom = isLoop ? -slides.length : 0;\n    const loopTo = isLoop ? slides.length * 2 : slides.length;\n    for (let i = loopFrom; i < loopTo; i += 1) {\n      if (i >= from && i <= to) {\n        const slideIndex = getSlideIndex(i);\n        if (typeof previousTo === 'undefined' || force) {\n          appendIndexes.push(slideIndex);\n        } else {\n          if (i > previousTo) appendIndexes.push(slideIndex);\n          if (i < previousFrom) prependIndexes.push(slideIndex);\n        }\n      }\n    }\n    appendIndexes.forEach(index => {\n      swiper.slidesEl.append(renderSlide(slides[index], index));\n    });\n    if (isLoop) {\n      for (let i = prependIndexes.length - 1; i >= 0; i -= 1) {\n        const index = prependIndexes[i];\n        swiper.slidesEl.prepend(renderSlide(slides[index], index));\n      }\n    } else {\n      prependIndexes.sort((a, b) => b - a);\n      prependIndexes.forEach(index => {\n        swiper.slidesEl.prepend(renderSlide(slides[index], index));\n      });\n    }\n    elementChildren(swiper.slidesEl, '.swiper-slide, swiper-slide').forEach(slideEl => {\n      slideEl.style[offsetProp] = `${offset - Math.abs(swiper.cssOverflowAdjustment())}px`;\n    });\n    onRendered();\n  }\n  function appendSlide(slides) {\n    if (typeof slides === 'object' && 'length' in slides) {\n      for (let i = 0; i < slides.length; i += 1) {\n        if (slides[i]) swiper.virtual.slides.push(slides[i]);\n      }\n    } else {\n      swiper.virtual.slides.push(slides);\n    }\n    update(true);\n  }\n  function prependSlide(slides) {\n    const activeIndex = swiper.activeIndex;\n    let newActiveIndex = activeIndex + 1;\n    let numberOfNewSlides = 1;\n    if (Array.isArray(slides)) {\n      for (let i = 0; i < slides.length; i += 1) {\n        if (slides[i]) swiper.virtual.slides.unshift(slides[i]);\n      }\n      newActiveIndex = activeIndex + slides.length;\n      numberOfNewSlides = slides.length;\n    } else {\n      swiper.virtual.slides.unshift(slides);\n    }\n    if (swiper.params.virtual.cache) {\n      const cache = swiper.virtual.cache;\n      const newCache = {};\n      Object.keys(cache).forEach(cachedIndex => {\n        const cachedEl = cache[cachedIndex];\n        const cachedElIndex = cachedEl.getAttribute('data-swiper-slide-index');\n        if (cachedElIndex) {\n          cachedEl.setAttribute('data-swiper-slide-index', parseInt(cachedElIndex, 10) + numberOfNewSlides);\n        }\n        newCache[parseInt(cachedIndex, 10) + numberOfNewSlides] = cachedEl;\n      });\n      swiper.virtual.cache = newCache;\n    }\n    update(true);\n    swiper.slideTo(newActiveIndex, 0);\n  }\n  function removeSlide(slidesIndexes) {\n    if (typeof slidesIndexes === 'undefined' || slidesIndexes === null) return;\n    let activeIndex = swiper.activeIndex;\n    if (Array.isArray(slidesIndexes)) {\n      for (let i = slidesIndexes.length - 1; i >= 0; i -= 1) {\n        swiper.virtual.slides.splice(slidesIndexes[i], 1);\n        if (swiper.params.virtual.cache) {\n          delete swiper.virtual.cache[slidesIndexes[i]];\n        }\n        if (slidesIndexes[i] < activeIndex) activeIndex -= 1;\n        activeIndex = Math.max(activeIndex, 0);\n      }\n    } else {\n      swiper.virtual.slides.splice(slidesIndexes, 1);\n      if (swiper.params.virtual.cache) {\n        delete swiper.virtual.cache[slidesIndexes];\n      }\n      if (slidesIndexes < activeIndex) activeIndex -= 1;\n      activeIndex = Math.max(activeIndex, 0);\n    }\n    update(true);\n    swiper.slideTo(activeIndex, 0);\n  }\n  function removeAllSlides() {\n    swiper.virtual.slides = [];\n    if (swiper.params.virtual.cache) {\n      swiper.virtual.cache = {};\n    }\n    update(true);\n    swiper.slideTo(0, 0);\n  }\n  on('beforeInit', () => {\n    if (!swiper.params.virtual.enabled) return;\n    let domSlidesAssigned;\n    if (typeof swiper.passedParams.virtual.slides === 'undefined') {\n      const slides = [...swiper.slidesEl.children].filter(el => el.matches(`.${swiper.params.slideClass}, swiper-slide`));\n      if (slides && slides.length) {\n        swiper.virtual.slides = [...slides];\n        domSlidesAssigned = true;\n        slides.forEach((slideEl, slideIndex) => {\n          slideEl.setAttribute('data-swiper-slide-index', slideIndex);\n          swiper.virtual.cache[slideIndex] = slideEl;\n          slideEl.remove();\n        });\n      }\n    }\n    if (!domSlidesAssigned) {\n      swiper.virtual.slides = swiper.params.virtual.slides;\n    }\n    swiper.classNames.push(`${swiper.params.containerModifierClass}virtual`);\n    swiper.params.watchSlidesProgress = true;\n    swiper.originalParams.watchSlidesProgress = true;\n    if (!swiper.params.initialSlide) {\n      update();\n    }\n  });\n  on('setTranslate', () => {\n    if (!swiper.params.virtual.enabled) return;\n    if (swiper.params.cssMode && !swiper._immediateVirtual) {\n      clearTimeout(cssModeTimeout);\n      cssModeTimeout = setTimeout(() => {\n        update();\n      }, 100);\n    } else {\n      update();\n    }\n  });\n  on('init update resize', () => {\n    if (!swiper.params.virtual.enabled) return;\n    if (swiper.params.cssMode) {\n      setCSSProperty(swiper.wrapperEl, '--swiper-virtual-size', `${swiper.virtualSize}px`);\n    }\n  });\n  Object.assign(swiper.virtual, {\n    appendSlide,\n    prependSlide,\n    removeSlide,\n    removeAllSlides,\n    update\n  });\n}","/* eslint-disable consistent-return */\nimport { getWindow, getDocument } from 'ssr-window';\nimport { elementOffset, elementParents } from '../../shared/utils.js';\nexport default function Keyboard({\n  swiper,\n  extendParams,\n  on,\n  emit\n}) {\n  const document = getDocument();\n  const window = getWindow();\n  swiper.keyboard = {\n    enabled: false\n  };\n  extendParams({\n    keyboard: {\n      enabled: false,\n      onlyInViewport: true,\n      pageUpDown: true\n    }\n  });\n  function handle(event) {\n    if (!swiper.enabled) return;\n    const {\n      rtlTranslate: rtl\n    } = swiper;\n    let e = event;\n    if (e.originalEvent) e = e.originalEvent; // jquery fix\n    const kc = e.keyCode || e.charCode;\n    const pageUpDown = swiper.params.keyboard.pageUpDown;\n    const isPageUp = pageUpDown && kc === 33;\n    const isPageDown = pageUpDown && kc === 34;\n    const isArrowLeft = kc === 37;\n    const isArrowRight = kc === 39;\n    const isArrowUp = kc === 38;\n    const isArrowDown = kc === 40;\n    // Directions locks\n    if (!swiper.allowSlideNext && (swiper.isHorizontal() && isArrowRight || swiper.isVertical() && isArrowDown || isPageDown)) {\n      return false;\n    }\n    if (!swiper.allowSlidePrev && (swiper.isHorizontal() && isArrowLeft || swiper.isVertical() && isArrowUp || isPageUp)) {\n      return false;\n    }\n    if (e.shiftKey || e.altKey || e.ctrlKey || e.metaKey) {\n      return undefined;\n    }\n    if (document.activeElement && document.activeElement.nodeName && (document.activeElement.nodeName.toLowerCase() === 'input' || document.activeElement.nodeName.toLowerCase() === 'textarea')) {\n      return undefined;\n    }\n    if (swiper.params.keyboard.onlyInViewport && (isPageUp || isPageDown || isArrowLeft || isArrowRight || isArrowUp || isArrowDown)) {\n      let inView = false;\n      // Check that swiper should be inside of visible area of window\n      if (elementParents(swiper.el, `.${swiper.params.slideClass}, swiper-slide`).length > 0 && elementParents(swiper.el, `.${swiper.params.slideActiveClass}`).length === 0) {\n        return undefined;\n      }\n      const el = swiper.el;\n      const swiperWidth = el.clientWidth;\n      const swiperHeight = el.clientHeight;\n      const windowWidth = window.innerWidth;\n      const windowHeight = window.innerHeight;\n      const swiperOffset = elementOffset(el);\n      if (rtl) swiperOffset.left -= el.scrollLeft;\n      const swiperCoord = [[swiperOffset.left, swiperOffset.top], [swiperOffset.left + swiperWidth, swiperOffset.top], [swiperOffset.left, swiperOffset.top + swiperHeight], [swiperOffset.left + swiperWidth, swiperOffset.top + swiperHeight]];\n      for (let i = 0; i < swiperCoord.length; i += 1) {\n        const point = swiperCoord[i];\n        if (point[0] >= 0 && point[0] <= windowWidth && point[1] >= 0 && point[1] <= windowHeight) {\n          if (point[0] === 0 && point[1] === 0) continue; // eslint-disable-line\n          inView = true;\n        }\n      }\n      if (!inView) return undefined;\n    }\n    if (swiper.isHorizontal()) {\n      if (isPageUp || isPageDown || isArrowLeft || isArrowRight) {\n        if (e.preventDefault) e.preventDefault();else e.returnValue = false;\n      }\n      if ((isPageDown || isArrowRight) && !rtl || (isPageUp || isArrowLeft) && rtl) swiper.slideNext();\n      if ((isPageUp || isArrowLeft) && !rtl || (isPageDown || isArrowRight) && rtl) swiper.slidePrev();\n    } else {\n      if (isPageUp || isPageDown || isArrowUp || isArrowDown) {\n        if (e.preventDefault) e.preventDefault();else e.returnValue = false;\n      }\n      if (isPageDown || isArrowDown) swiper.slideNext();\n      if (isPageUp || isArrowUp) swiper.slidePrev();\n    }\n    emit('keyPress', kc);\n    return undefined;\n  }\n  function enable() {\n    if (swiper.keyboard.enabled) return;\n    document.addEventListener('keydown', handle);\n    swiper.keyboard.enabled = true;\n  }\n  function disable() {\n    if (!swiper.keyboard.enabled) return;\n    document.removeEventListener('keydown', handle);\n    swiper.keyboard.enabled = false;\n  }\n  on('init', () => {\n    if (swiper.params.keyboard.enabled) {\n      enable();\n    }\n  });\n  on('destroy', () => {\n    if (swiper.keyboard.enabled) {\n      disable();\n    }\n  });\n  Object.assign(swiper.keyboard, {\n    enable,\n    disable\n  });\n}","/* eslint-disable consistent-return */\nimport { getWindow } from 'ssr-window';\nimport { now, nextTick } from '../../shared/utils.js';\nexport default function Mousewheel({\n  swiper,\n  extendParams,\n  on,\n  emit\n}) {\n  const window = getWindow();\n  extendParams({\n    mousewheel: {\n      enabled: false,\n      releaseOnEdges: false,\n      invert: false,\n      forceToAxis: false,\n      sensitivity: 1,\n      eventsTarget: 'container',\n      thresholdDelta: null,\n      thresholdTime: null,\n      noMousewheelClass: 'swiper-no-mousewheel'\n    }\n  });\n  swiper.mousewheel = {\n    enabled: false\n  };\n  let timeout;\n  let lastScrollTime = now();\n  let lastEventBeforeSnap;\n  const recentWheelEvents = [];\n  function normalize(e) {\n    // Reasonable defaults\n    const PIXEL_STEP = 10;\n    const LINE_HEIGHT = 40;\n    const PAGE_HEIGHT = 800;\n    let sX = 0;\n    let sY = 0; // spinX, spinY\n    let pX = 0;\n    let pY = 0; // pixelX, pixelY\n\n    // Legacy\n    if ('detail' in e) {\n      sY = e.detail;\n    }\n    if ('wheelDelta' in e) {\n      sY = -e.wheelDelta / 120;\n    }\n    if ('wheelDeltaY' in e) {\n      sY = -e.wheelDeltaY / 120;\n    }\n    if ('wheelDeltaX' in e) {\n      sX = -e.wheelDeltaX / 120;\n    }\n\n    // side scrolling on FF with DOMMouseScroll\n    if ('axis' in e && e.axis === e.HORIZONTAL_AXIS) {\n      sX = sY;\n      sY = 0;\n    }\n    pX = sX * PIXEL_STEP;\n    pY = sY * PIXEL_STEP;\n    if ('deltaY' in e) {\n      pY = e.deltaY;\n    }\n    if ('deltaX' in e) {\n      pX = e.deltaX;\n    }\n    if (e.shiftKey && !pX) {\n      // if user scrolls with shift he wants horizontal scroll\n      pX = pY;\n      pY = 0;\n    }\n    if ((pX || pY) && e.deltaMode) {\n      if (e.deltaMode === 1) {\n        // delta in LINE units\n        pX *= LINE_HEIGHT;\n        pY *= LINE_HEIGHT;\n      } else {\n        // delta in PAGE units\n        pX *= PAGE_HEIGHT;\n        pY *= PAGE_HEIGHT;\n      }\n    }\n\n    // Fall-back if spin cannot be determined\n    if (pX && !sX) {\n      sX = pX < 1 ? -1 : 1;\n    }\n    if (pY && !sY) {\n      sY = pY < 1 ? -1 : 1;\n    }\n    return {\n      spinX: sX,\n      spinY: sY,\n      pixelX: pX,\n      pixelY: pY\n    };\n  }\n  function handleMouseEnter() {\n    if (!swiper.enabled) return;\n    swiper.mouseEntered = true;\n  }\n  function handleMouseLeave() {\n    if (!swiper.enabled) return;\n    swiper.mouseEntered = false;\n  }\n  function animateSlider(newEvent) {\n    if (swiper.params.mousewheel.thresholdDelta && newEvent.delta < swiper.params.mousewheel.thresholdDelta) {\n      // Prevent if delta of wheel scroll delta is below configured threshold\n      return false;\n    }\n    if (swiper.params.mousewheel.thresholdTime && now() - lastScrollTime < swiper.params.mousewheel.thresholdTime) {\n      // Prevent if time between scrolls is below configured threshold\n      return false;\n    }\n\n    // If the movement is NOT big enough and\n    // if the last time the user scrolled was too close to the current one (avoid continuously triggering the slider):\n    //   Don't go any further (avoid insignificant scroll movement).\n    if (newEvent.delta >= 6 && now() - lastScrollTime < 60) {\n      // Return false as a default\n      return true;\n    }\n    // If user is scrolling towards the end:\n    //   If the slider hasn't hit the latest slide or\n    //   if the slider is a loop and\n    //   if the slider isn't moving right now:\n    //     Go to next slide and\n    //     emit a scroll event.\n    // Else (the user is scrolling towards the beginning) and\n    // if the slider hasn't hit the first slide or\n    // if the slider is a loop and\n    // if the slider isn't moving right now:\n    //   Go to prev slide and\n    //   emit a scroll event.\n    if (newEvent.direction < 0) {\n      if ((!swiper.isEnd || swiper.params.loop) && !swiper.animating) {\n        swiper.slideNext();\n        emit('scroll', newEvent.raw);\n      }\n    } else if ((!swiper.isBeginning || swiper.params.loop) && !swiper.animating) {\n      swiper.slidePrev();\n      emit('scroll', newEvent.raw);\n    }\n    // If you got here is because an animation has been triggered so store the current time\n    lastScrollTime = new window.Date().getTime();\n    // Return false as a default\n    return false;\n  }\n  function releaseScroll(newEvent) {\n    const params = swiper.params.mousewheel;\n    if (newEvent.direction < 0) {\n      if (swiper.isEnd && !swiper.params.loop && params.releaseOnEdges) {\n        // Return true to animate scroll on edges\n        return true;\n      }\n    } else if (swiper.isBeginning && !swiper.params.loop && params.releaseOnEdges) {\n      // Return true to animate scroll on edges\n      return true;\n    }\n    return false;\n  }\n  function handle(event) {\n    let e = event;\n    let disableParentSwiper = true;\n    if (!swiper.enabled) return;\n\n    // Ignore event if the target or its parents have the swiper-no-mousewheel class\n    if (event.target.closest(`.${swiper.params.mousewheel.noMousewheelClass}`)) return;\n    const params = swiper.params.mousewheel;\n    if (swiper.params.cssMode) {\n      e.preventDefault();\n    }\n    let targetEl = swiper.el;\n    if (swiper.params.mousewheel.eventsTarget !== 'container') {\n      targetEl = document.querySelector(swiper.params.mousewheel.eventsTarget);\n    }\n    const targetElContainsTarget = targetEl && targetEl.contains(e.target);\n    if (!swiper.mouseEntered && !targetElContainsTarget && !params.releaseOnEdges) return true;\n    if (e.originalEvent) e = e.originalEvent; // jquery fix\n    let delta = 0;\n    const rtlFactor = swiper.rtlTranslate ? -1 : 1;\n    const data = normalize(e);\n    if (params.forceToAxis) {\n      if (swiper.isHorizontal()) {\n        if (Math.abs(data.pixelX) > Math.abs(data.pixelY)) delta = -data.pixelX * rtlFactor;else return true;\n      } else if (Math.abs(data.pixelY) > Math.abs(data.pixelX)) delta = -data.pixelY;else return true;\n    } else {\n      delta = Math.abs(data.pixelX) > Math.abs(data.pixelY) ? -data.pixelX * rtlFactor : -data.pixelY;\n    }\n    if (delta === 0) return true;\n    if (params.invert) delta = -delta;\n\n    // Get the scroll positions\n    let positions = swiper.getTranslate() + delta * params.sensitivity;\n    if (positions >= swiper.minTranslate()) positions = swiper.minTranslate();\n    if (positions <= swiper.maxTranslate()) positions = swiper.maxTranslate();\n\n    // When loop is true:\n    //     the disableParentSwiper will be true.\n    // When loop is false:\n    //     if the scroll positions is not on edge,\n    //     then the disableParentSwiper will be true.\n    //     if the scroll on edge positions,\n    //     then the disableParentSwiper will be false.\n    disableParentSwiper = swiper.params.loop ? true : !(positions === swiper.minTranslate() || positions === swiper.maxTranslate());\n    if (disableParentSwiper && swiper.params.nested) e.stopPropagation();\n    if (!swiper.params.freeMode || !swiper.params.freeMode.enabled) {\n      // Register the new event in a variable which stores the relevant data\n      const newEvent = {\n        time: now(),\n        delta: Math.abs(delta),\n        direction: Math.sign(delta),\n        raw: event\n      };\n\n      // Keep the most recent events\n      if (recentWheelEvents.length >= 2) {\n        recentWheelEvents.shift(); // only store the last N events\n      }\n\n      const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : undefined;\n      recentWheelEvents.push(newEvent);\n\n      // If there is at least one previous recorded event:\n      //   If direction has changed or\n      //   if the scroll is quicker than the previous one:\n      //     Animate the slider.\n      // Else (this is the first time the wheel is moved):\n      //     Animate the slider.\n      if (prevEvent) {\n        if (newEvent.direction !== prevEvent.direction || newEvent.delta > prevEvent.delta || newEvent.time > prevEvent.time + 150) {\n          animateSlider(newEvent);\n        }\n      } else {\n        animateSlider(newEvent);\n      }\n\n      // If it's time to release the scroll:\n      //   Return now so you don't hit the preventDefault.\n      if (releaseScroll(newEvent)) {\n        return true;\n      }\n    } else {\n      // Freemode or scrollContainer:\n\n      // If we recently snapped after a momentum scroll, then ignore wheel events\n      // to give time for the deceleration to finish. Stop ignoring after 500 msecs\n      // or if it's a new scroll (larger delta or inverse sign as last event before\n      // an end-of-momentum snap).\n      const newEvent = {\n        time: now(),\n        delta: Math.abs(delta),\n        direction: Math.sign(delta)\n      };\n      const ignoreWheelEvents = lastEventBeforeSnap && newEvent.time < lastEventBeforeSnap.time + 500 && newEvent.delta <= lastEventBeforeSnap.delta && newEvent.direction === lastEventBeforeSnap.direction;\n      if (!ignoreWheelEvents) {\n        lastEventBeforeSnap = undefined;\n        let position = swiper.getTranslate() + delta * params.sensitivity;\n        const wasBeginning = swiper.isBeginning;\n        const wasEnd = swiper.isEnd;\n        if (position >= swiper.minTranslate()) position = swiper.minTranslate();\n        if (position <= swiper.maxTranslate()) position = swiper.maxTranslate();\n        swiper.setTransition(0);\n        swiper.setTranslate(position);\n        swiper.updateProgress();\n        swiper.updateActiveIndex();\n        swiper.updateSlidesClasses();\n        if (!wasBeginning && swiper.isBeginning || !wasEnd && swiper.isEnd) {\n          swiper.updateSlidesClasses();\n        }\n        if (swiper.params.loop) {\n          swiper.loopFix({\n            direction: newEvent.direction < 0 ? 'next' : 'prev',\n            byMousewheel: true\n          });\n        }\n        if (swiper.params.freeMode.sticky) {\n          // When wheel scrolling starts with sticky (aka snap) enabled, then detect\n          // the end of a momentum scroll by storing recent (N=15?) wheel events.\n          // 1. do all N events have decreasing or same (absolute value) delta?\n          // 2. did all N events arrive in the last M (M=500?) msecs?\n          // 3. does the earliest event have an (absolute value) delta that's\n          //    at least P (P=1?) larger than the most recent event's delta?\n          // 4. does the latest event have a delta that's smaller than Q (Q=6?) pixels?\n          // If 1-4 are \"yes\" then we're near the end of a momentum scroll deceleration.\n          // Snap immediately and ignore remaining wheel events in this scroll.\n          // See comment above for \"remaining wheel events in this scroll\" determination.\n          // If 1-4 aren't satisfied, then wait to snap until 500ms after the last event.\n          clearTimeout(timeout);\n          timeout = undefined;\n          if (recentWheelEvents.length >= 15) {\n            recentWheelEvents.shift(); // only store the last N events\n          }\n\n          const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : undefined;\n          const firstEvent = recentWheelEvents[0];\n          recentWheelEvents.push(newEvent);\n          if (prevEvent && (newEvent.delta > prevEvent.delta || newEvent.direction !== prevEvent.direction)) {\n            // Increasing or reverse-sign delta means the user started scrolling again. Clear the wheel event log.\n            recentWheelEvents.splice(0);\n          } else if (recentWheelEvents.length >= 15 && newEvent.time - firstEvent.time < 500 && firstEvent.delta - newEvent.delta >= 1 && newEvent.delta <= 6) {\n            // We're at the end of the deceleration of a momentum scroll, so there's no need\n            // to wait for more events. Snap ASAP on the next tick.\n            // Also, because there's some remaining momentum we'll bias the snap in the\n            // direction of the ongoing scroll because it's better UX for the scroll to snap\n            // in the same direction as the scroll instead of reversing to snap.  Therefore,\n            // if it's already scrolled more than 20% in the current direction, keep going.\n            const snapToThreshold = delta > 0 ? 0.8 : 0.2;\n            lastEventBeforeSnap = newEvent;\n            recentWheelEvents.splice(0);\n            timeout = nextTick(() => {\n              swiper.slideToClosest(swiper.params.speed, true, undefined, snapToThreshold);\n            }, 0); // no delay; move on next tick\n          }\n\n          if (!timeout) {\n            // if we get here, then we haven't detected the end of a momentum scroll, so\n            // we'll consider a scroll \"complete\" when there haven't been any wheel events\n            // for 500ms.\n            timeout = nextTick(() => {\n              const snapToThreshold = 0.5;\n              lastEventBeforeSnap = newEvent;\n              recentWheelEvents.splice(0);\n              swiper.slideToClosest(swiper.params.speed, true, undefined, snapToThreshold);\n            }, 500);\n          }\n        }\n\n        // Emit event\n        if (!ignoreWheelEvents) emit('scroll', e);\n\n        // Stop autoplay\n        if (swiper.params.autoplay && swiper.params.autoplayDisableOnInteraction) swiper.autoplay.stop();\n        // Return page scroll on edge positions\n        if (position === swiper.minTranslate() || position === swiper.maxTranslate()) return true;\n      }\n    }\n    if (e.preventDefault) e.preventDefault();else e.returnValue = false;\n    return false;\n  }\n  function events(method) {\n    let targetEl = swiper.el;\n    if (swiper.params.mousewheel.eventsTarget !== 'container') {\n      targetEl = document.querySelector(swiper.params.mousewheel.eventsTarget);\n    }\n    targetEl[method]('mouseenter', handleMouseEnter);\n    targetEl[method]('mouseleave', handleMouseLeave);\n    targetEl[method]('wheel', handle);\n  }\n  function enable() {\n    if (swiper.params.cssMode) {\n      swiper.wrapperEl.removeEventListener('wheel', handle);\n      return true;\n    }\n    if (swiper.mousewheel.enabled) return false;\n    events('addEventListener');\n    swiper.mousewheel.enabled = true;\n    return true;\n  }\n  function disable() {\n    if (swiper.params.cssMode) {\n      swiper.wrapperEl.addEventListener(event, handle);\n      return true;\n    }\n    if (!swiper.mousewheel.enabled) return false;\n    events('removeEventListener');\n    swiper.mousewheel.enabled = false;\n    return true;\n  }\n  on('init', () => {\n    if (!swiper.params.mousewheel.enabled && swiper.params.cssMode) {\n      disable();\n    }\n    if (swiper.params.mousewheel.enabled) enable();\n  });\n  on('destroy', () => {\n    if (swiper.params.cssMode) {\n      enable();\n    }\n    if (swiper.mousewheel.enabled) disable();\n  });\n  Object.assign(swiper.mousewheel, {\n    enable,\n    disable\n  });\n}","import { createElement, elementChildren } from './utils.js';\nexport default function createElementIfNotDefined(swiper, originalParams, params, checkProps) {\n  if (swiper.params.createElements) {\n    Object.keys(checkProps).forEach(key => {\n      if (!params[key] && params.auto === true) {\n        let element = elementChildren(swiper.el, `.${checkProps[key]}`)[0];\n        if (!element) {\n          element = createElement('div', checkProps[key]);\n          element.className = checkProps[key];\n          swiper.el.append(element);\n        }\n        params[key] = element;\n        originalParams[key] = element;\n      }\n    });\n  }\n  return params;\n}","import createElementIfNotDefined from '../../shared/create-element-if-not-defined.js';\nexport default function Navigation({\n  swiper,\n  extendParams,\n  on,\n  emit\n}) {\n  extendParams({\n    navigation: {\n      nextEl: null,\n      prevEl: null,\n      hideOnClick: false,\n      disabledClass: 'swiper-button-disabled',\n      hiddenClass: 'swiper-button-hidden',\n      lockClass: 'swiper-button-lock',\n      navigationDisabledClass: 'swiper-navigation-disabled'\n    }\n  });\n  swiper.navigation = {\n    nextEl: null,\n    prevEl: null\n  };\n  const makeElementsArray = el => {\n    if (!Array.isArray(el)) el = [el].filter(e => !!e);\n    return el;\n  };\n  function getEl(el) {\n    let res;\n    if (el && typeof el === 'string' && swiper.isElement) {\n      res = swiper.el.shadowRoot.querySelector(el);\n      if (res) return res;\n    }\n    if (el) {\n      if (typeof el === 'string') res = [...document.querySelectorAll(el)];\n      if (swiper.params.uniqueNavElements && typeof el === 'string' && res.length > 1 && swiper.el.querySelectorAll(el).length === 1) {\n        res = swiper.el.querySelector(el);\n      }\n    }\n    if (el && !res) return el;\n    // if (Array.isArray(res) && res.length === 1) res = res[0];\n    return res;\n  }\n  function toggleEl(el, disabled) {\n    const params = swiper.params.navigation;\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      if (subEl) {\n        subEl.classList[disabled ? 'add' : 'remove'](...params.disabledClass.split(' '));\n        if (subEl.tagName === 'BUTTON') subEl.disabled = disabled;\n        if (swiper.params.watchOverflow && swiper.enabled) {\n          subEl.classList[swiper.isLocked ? 'add' : 'remove'](params.lockClass);\n        }\n      }\n    });\n  }\n  function update() {\n    // Update Navigation Buttons\n    const {\n      nextEl,\n      prevEl\n    } = swiper.navigation;\n    if (swiper.params.loop) {\n      toggleEl(prevEl, false);\n      toggleEl(nextEl, false);\n      return;\n    }\n    toggleEl(prevEl, swiper.isBeginning && !swiper.params.rewind);\n    toggleEl(nextEl, swiper.isEnd && !swiper.params.rewind);\n  }\n  function onPrevClick(e) {\n    e.preventDefault();\n    if (swiper.isBeginning && !swiper.params.loop && !swiper.params.rewind) return;\n    swiper.slidePrev();\n    emit('navigationPrev');\n  }\n  function onNextClick(e) {\n    e.preventDefault();\n    if (swiper.isEnd && !swiper.params.loop && !swiper.params.rewind) return;\n    swiper.slideNext();\n    emit('navigationNext');\n  }\n  function init() {\n    const params = swiper.params.navigation;\n    swiper.params.navigation = createElementIfNotDefined(swiper, swiper.originalParams.navigation, swiper.params.navigation, {\n      nextEl: 'swiper-button-next',\n      prevEl: 'swiper-button-prev'\n    });\n    if (!(params.nextEl || params.prevEl)) return;\n    let nextEl = getEl(params.nextEl);\n    let prevEl = getEl(params.prevEl);\n    Object.assign(swiper.navigation, {\n      nextEl,\n      prevEl\n    });\n    nextEl = makeElementsArray(nextEl);\n    prevEl = makeElementsArray(prevEl);\n    const initButton = (el, dir) => {\n      if (el) {\n        el.addEventListener('click', dir === 'next' ? onNextClick : onPrevClick);\n      }\n      if (!swiper.enabled && el) {\n        el.classList.add(...params.lockClass.split(' '));\n      }\n    };\n    nextEl.forEach(el => initButton(el, 'next'));\n    prevEl.forEach(el => initButton(el, 'prev'));\n  }\n  function destroy() {\n    let {\n      nextEl,\n      prevEl\n    } = swiper.navigation;\n    nextEl = makeElementsArray(nextEl);\n    prevEl = makeElementsArray(prevEl);\n    const destroyButton = (el, dir) => {\n      el.removeEventListener('click', dir === 'next' ? onNextClick : onPrevClick);\n      el.classList.remove(...swiper.params.navigation.disabledClass.split(' '));\n    };\n    nextEl.forEach(el => destroyButton(el, 'next'));\n    prevEl.forEach(el => destroyButton(el, 'prev'));\n  }\n  on('init', () => {\n    if (swiper.params.navigation.enabled === false) {\n      // eslint-disable-next-line\n      disable();\n    } else {\n      init();\n      update();\n    }\n  });\n  on('toEdge fromEdge lock unlock', () => {\n    update();\n  });\n  on('destroy', () => {\n    destroy();\n  });\n  on('enable disable', () => {\n    let {\n      nextEl,\n      prevEl\n    } = swiper.navigation;\n    nextEl = makeElementsArray(nextEl);\n    prevEl = makeElementsArray(prevEl);\n    [...nextEl, ...prevEl].filter(el => !!el).forEach(el => el.classList[swiper.enabled ? 'remove' : 'add'](swiper.params.navigation.lockClass));\n  });\n  on('click', (_s, e) => {\n    let {\n      nextEl,\n      prevEl\n    } = swiper.navigation;\n    nextEl = makeElementsArray(nextEl);\n    prevEl = makeElementsArray(prevEl);\n    const targetEl = e.target;\n    if (swiper.params.navigation.hideOnClick && !prevEl.includes(targetEl) && !nextEl.includes(targetEl)) {\n      if (swiper.pagination && swiper.params.pagination && swiper.params.pagination.clickable && (swiper.pagination.el === targetEl || swiper.pagination.el.contains(targetEl))) return;\n      let isHidden;\n      if (nextEl.length) {\n        isHidden = nextEl[0].classList.contains(swiper.params.navigation.hiddenClass);\n      } else if (prevEl.length) {\n        isHidden = prevEl[0].classList.contains(swiper.params.navigation.hiddenClass);\n      }\n      if (isHidden === true) {\n        emit('navigationShow');\n      } else {\n        emit('navigationHide');\n      }\n      [...nextEl, ...prevEl].filter(el => !!el).forEach(el => el.classList.toggle(swiper.params.navigation.hiddenClass));\n    }\n  });\n  const enable = () => {\n    swiper.el.classList.remove(...swiper.params.navigation.navigationDisabledClass.split(' '));\n    init();\n    update();\n  };\n  const disable = () => {\n    swiper.el.classList.add(...swiper.params.navigation.navigationDisabledClass.split(' '));\n    destroy();\n  };\n  Object.assign(swiper.navigation, {\n    enable,\n    disable,\n    update,\n    init,\n    destroy\n  });\n}","export default function classesToSelector(classes = '') {\n  return `.${classes.trim().replace(/([\\.:!+\\/])/g, '\\\\$1') // eslint-disable-line\n  .replace(/ /g, '.')}`;\n}","import classesToSelector from '../../shared/classes-to-selector.js';\nimport createElementIfNotDefined from '../../shared/create-element-if-not-defined.js';\nimport { elementIndex, elementOuterSize, elementParents } from '../../shared/utils.js';\nexport default function Pagination({\n  swiper,\n  extendParams,\n  on,\n  emit\n}) {\n  const pfx = 'swiper-pagination';\n  extendParams({\n    pagination: {\n      el: null,\n      bulletElement: 'span',\n      clickable: false,\n      hideOnClick: false,\n      renderBullet: null,\n      renderProgressbar: null,\n      renderFraction: null,\n      renderCustom: null,\n      progressbarOpposite: false,\n      type: 'bullets',\n      // 'bullets' or 'progressbar' or 'fraction' or 'custom'\n      dynamicBullets: false,\n      dynamicMainBullets: 1,\n      formatFractionCurrent: number => number,\n      formatFractionTotal: number => number,\n      bulletClass: `${pfx}-bullet`,\n      bulletActiveClass: `${pfx}-bullet-active`,\n      modifierClass: `${pfx}-`,\n      currentClass: `${pfx}-current`,\n      totalClass: `${pfx}-total`,\n      hiddenClass: `${pfx}-hidden`,\n      progressbarFillClass: `${pfx}-progressbar-fill`,\n      progressbarOppositeClass: `${pfx}-progressbar-opposite`,\n      clickableClass: `${pfx}-clickable`,\n      lockClass: `${pfx}-lock`,\n      horizontalClass: `${pfx}-horizontal`,\n      verticalClass: `${pfx}-vertical`,\n      paginationDisabledClass: `${pfx}-disabled`\n    }\n  });\n  swiper.pagination = {\n    el: null,\n    bullets: []\n  };\n  let bulletSize;\n  let dynamicBulletIndex = 0;\n  const makeElementsArray = el => {\n    if (!Array.isArray(el)) el = [el].filter(e => !!e);\n    return el;\n  };\n  function isPaginationDisabled() {\n    return !swiper.params.pagination.el || !swiper.pagination.el || Array.isArray(swiper.pagination.el) && swiper.pagination.el.length === 0;\n  }\n  function setSideBullets(bulletEl, position) {\n    const {\n      bulletActiveClass\n    } = swiper.params.pagination;\n    if (!bulletEl) return;\n    bulletEl = bulletEl[`${position === 'prev' ? 'previous' : 'next'}ElementSibling`];\n    if (bulletEl) {\n      bulletEl.classList.add(`${bulletActiveClass}-${position}`);\n      bulletEl = bulletEl[`${position === 'prev' ? 'previous' : 'next'}ElementSibling`];\n      if (bulletEl) {\n        bulletEl.classList.add(`${bulletActiveClass}-${position}-${position}`);\n      }\n    }\n  }\n  function onBulletClick(e) {\n    const bulletEl = e.target.closest(classesToSelector(swiper.params.pagination.bulletClass));\n    if (!bulletEl) {\n      return;\n    }\n    e.preventDefault();\n    const index = elementIndex(bulletEl) * swiper.params.slidesPerGroup;\n    if (swiper.params.loop) {\n      if (swiper.realIndex === index) return;\n      const newSlideIndex = swiper.getSlideIndexByData(index);\n      const currentSlideIndex = swiper.getSlideIndexByData(swiper.realIndex);\n      if (newSlideIndex > swiper.slides.length - swiper.loopedSlides) {\n        swiper.loopFix({\n          direction: newSlideIndex > currentSlideIndex ? 'next' : 'prev',\n          activeSlideIndex: newSlideIndex,\n          slideTo: false\n        });\n      }\n      swiper.slideToLoop(index);\n    } else {\n      swiper.slideTo(index);\n    }\n  }\n  function update() {\n    // Render || Update Pagination bullets/items\n    const rtl = swiper.rtl;\n    const params = swiper.params.pagination;\n    if (isPaginationDisabled()) return;\n    let el = swiper.pagination.el;\n    el = makeElementsArray(el);\n    // Current/Total\n    let current;\n    let previousIndex;\n    const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.slides.length;\n    const total = swiper.params.loop ? Math.ceil(slidesLength / swiper.params.slidesPerGroup) : swiper.snapGrid.length;\n    if (swiper.params.loop) {\n      previousIndex = swiper.previousRealIndex || 0;\n      current = swiper.params.slidesPerGroup > 1 ? Math.floor(swiper.realIndex / swiper.params.slidesPerGroup) : swiper.realIndex;\n    } else if (typeof swiper.snapIndex !== 'undefined') {\n      current = swiper.snapIndex;\n      previousIndex = swiper.previousSnapIndex;\n    } else {\n      previousIndex = swiper.previousIndex || 0;\n      current = swiper.activeIndex || 0;\n    }\n    // Types\n    if (params.type === 'bullets' && swiper.pagination.bullets && swiper.pagination.bullets.length > 0) {\n      const bullets = swiper.pagination.bullets;\n      let firstIndex;\n      let lastIndex;\n      let midIndex;\n      if (params.dynamicBullets) {\n        bulletSize = elementOuterSize(bullets[0], swiper.isHorizontal() ? 'width' : 'height', true);\n        el.forEach(subEl => {\n          subEl.style[swiper.isHorizontal() ? 'width' : 'height'] = `${bulletSize * (params.dynamicMainBullets + 4)}px`;\n        });\n        if (params.dynamicMainBullets > 1 && previousIndex !== undefined) {\n          dynamicBulletIndex += current - (previousIndex || 0);\n          if (dynamicBulletIndex > params.dynamicMainBullets - 1) {\n            dynamicBulletIndex = params.dynamicMainBullets - 1;\n          } else if (dynamicBulletIndex < 0) {\n            dynamicBulletIndex = 0;\n          }\n        }\n        firstIndex = Math.max(current - dynamicBulletIndex, 0);\n        lastIndex = firstIndex + (Math.min(bullets.length, params.dynamicMainBullets) - 1);\n        midIndex = (lastIndex + firstIndex) / 2;\n      }\n      bullets.forEach(bulletEl => {\n        const classesToRemove = [...['', '-next', '-next-next', '-prev', '-prev-prev', '-main'].map(suffix => `${params.bulletActiveClass}${suffix}`)].map(s => typeof s === 'string' && s.includes(' ') ? s.split(' ') : s).flat();\n        bulletEl.classList.remove(...classesToRemove);\n      });\n      if (el.length > 1) {\n        bullets.forEach(bullet => {\n          const bulletIndex = elementIndex(bullet);\n          if (bulletIndex === current) {\n            bullet.classList.add(...params.bulletActiveClass.split(' '));\n          } else if (swiper.isElement) {\n            bullet.setAttribute('part', 'bullet');\n          }\n          if (params.dynamicBullets) {\n            if (bulletIndex >= firstIndex && bulletIndex <= lastIndex) {\n              bullet.classList.add(...`${params.bulletActiveClass}-main`.split(' '));\n            }\n            if (bulletIndex === firstIndex) {\n              setSideBullets(bullet, 'prev');\n            }\n            if (bulletIndex === lastIndex) {\n              setSideBullets(bullet, 'next');\n            }\n          }\n        });\n      } else {\n        const bullet = bullets[current];\n        if (bullet) {\n          bullet.classList.add(...params.bulletActiveClass.split(' '));\n        }\n        if (swiper.isElement) {\n          bullets.forEach((bulletEl, bulletIndex) => {\n            bulletEl.setAttribute('part', bulletIndex === current ? 'bullet-active' : 'bullet');\n          });\n        }\n        if (params.dynamicBullets) {\n          const firstDisplayedBullet = bullets[firstIndex];\n          const lastDisplayedBullet = bullets[lastIndex];\n          for (let i = firstIndex; i <= lastIndex; i += 1) {\n            if (bullets[i]) {\n              bullets[i].classList.add(...`${params.bulletActiveClass}-main`.split(' '));\n            }\n          }\n          setSideBullets(firstDisplayedBullet, 'prev');\n          setSideBullets(lastDisplayedBullet, 'next');\n        }\n      }\n      if (params.dynamicBullets) {\n        const dynamicBulletsLength = Math.min(bullets.length, params.dynamicMainBullets + 4);\n        const bulletsOffset = (bulletSize * dynamicBulletsLength - bulletSize) / 2 - midIndex * bulletSize;\n        const offsetProp = rtl ? 'right' : 'left';\n        bullets.forEach(bullet => {\n          bullet.style[swiper.isHorizontal() ? offsetProp : 'top'] = `${bulletsOffset}px`;\n        });\n      }\n    }\n    el.forEach((subEl, subElIndex) => {\n      if (params.type === 'fraction') {\n        subEl.querySelectorAll(classesToSelector(params.currentClass)).forEach(fractionEl => {\n          fractionEl.textContent = params.formatFractionCurrent(current + 1);\n        });\n        subEl.querySelectorAll(classesToSelector(params.totalClass)).forEach(totalEl => {\n          totalEl.textContent = params.formatFractionTotal(total);\n        });\n      }\n      if (params.type === 'progressbar') {\n        let progressbarDirection;\n        if (params.progressbarOpposite) {\n          progressbarDirection = swiper.isHorizontal() ? 'vertical' : 'horizontal';\n        } else {\n          progressbarDirection = swiper.isHorizontal() ? 'horizontal' : 'vertical';\n        }\n        const scale = (current + 1) / total;\n        let scaleX = 1;\n        let scaleY = 1;\n        if (progressbarDirection === 'horizontal') {\n          scaleX = scale;\n        } else {\n          scaleY = scale;\n        }\n        subEl.querySelectorAll(classesToSelector(params.progressbarFillClass)).forEach(progressEl => {\n          progressEl.style.transform = `translate3d(0,0,0) scaleX(${scaleX}) scaleY(${scaleY})`;\n          progressEl.style.transitionDuration = `${swiper.params.speed}ms`;\n        });\n      }\n      if (params.type === 'custom' && params.renderCustom) {\n        subEl.innerHTML = params.renderCustom(swiper, current + 1, total);\n        if (subElIndex === 0) emit('paginationRender', subEl);\n      } else {\n        if (subElIndex === 0) emit('paginationRender', subEl);\n        emit('paginationUpdate', subEl);\n      }\n      if (swiper.params.watchOverflow && swiper.enabled) {\n        subEl.classList[swiper.isLocked ? 'add' : 'remove'](params.lockClass);\n      }\n    });\n  }\n  function render() {\n    // Render Container\n    const params = swiper.params.pagination;\n    if (isPaginationDisabled()) return;\n    const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.slides.length;\n    let el = swiper.pagination.el;\n    el = makeElementsArray(el);\n    let paginationHTML = '';\n    if (params.type === 'bullets') {\n      let numberOfBullets = swiper.params.loop ? Math.ceil(slidesLength / swiper.params.slidesPerGroup) : swiper.snapGrid.length;\n      if (swiper.params.freeMode && swiper.params.freeMode.enabled && numberOfBullets > slidesLength) {\n        numberOfBullets = slidesLength;\n      }\n      for (let i = 0; i < numberOfBullets; i += 1) {\n        if (params.renderBullet) {\n          paginationHTML += params.renderBullet.call(swiper, i, params.bulletClass);\n        } else {\n          // prettier-ignore\n          paginationHTML += `<${params.bulletElement} ${swiper.isElement ? 'part=\"bullet\"' : ''} class=\"${params.bulletClass}\"></${params.bulletElement}>`;\n        }\n      }\n    }\n    if (params.type === 'fraction') {\n      if (params.renderFraction) {\n        paginationHTML = params.renderFraction.call(swiper, params.currentClass, params.totalClass);\n      } else {\n        paginationHTML = `<span class=\"${params.currentClass}\"></span>` + ' / ' + `<span class=\"${params.totalClass}\"></span>`;\n      }\n    }\n    if (params.type === 'progressbar') {\n      if (params.renderProgressbar) {\n        paginationHTML = params.renderProgressbar.call(swiper, params.progressbarFillClass);\n      } else {\n        paginationHTML = `<span class=\"${params.progressbarFillClass}\"></span>`;\n      }\n    }\n    swiper.pagination.bullets = [];\n    el.forEach(subEl => {\n      if (params.type !== 'custom') {\n        subEl.innerHTML = paginationHTML || '';\n      }\n      if (params.type === 'bullets') {\n        swiper.pagination.bullets.push(...subEl.querySelectorAll(classesToSelector(params.bulletClass)));\n      }\n    });\n    if (params.type !== 'custom') {\n      emit('paginationRender', el[0]);\n    }\n  }\n  function init() {\n    swiper.params.pagination = createElementIfNotDefined(swiper, swiper.originalParams.pagination, swiper.params.pagination, {\n      el: 'swiper-pagination'\n    });\n    const params = swiper.params.pagination;\n    if (!params.el) return;\n    let el;\n    if (typeof params.el === 'string' && swiper.isElement) {\n      el = swiper.el.shadowRoot.querySelector(params.el);\n    }\n    if (!el && typeof params.el === 'string') {\n      el = [...document.querySelectorAll(params.el)];\n    }\n    if (!el) {\n      el = params.el;\n    }\n    if (!el || el.length === 0) return;\n    if (swiper.params.uniqueNavElements && typeof params.el === 'string' && Array.isArray(el) && el.length > 1) {\n      el = [...swiper.el.querySelectorAll(params.el)];\n      // check if it belongs to another nested Swiper\n      if (el.length > 1) {\n        el = el.filter(subEl => {\n          if (elementParents(subEl, '.swiper')[0] !== swiper.el) return false;\n          return true;\n        })[0];\n      }\n    }\n    if (Array.isArray(el) && el.length === 1) el = el[0];\n    Object.assign(swiper.pagination, {\n      el\n    });\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      if (params.type === 'bullets' && params.clickable) {\n        subEl.classList.add(params.clickableClass);\n      }\n      subEl.classList.add(params.modifierClass + params.type);\n      subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);\n      if (params.type === 'bullets' && params.dynamicBullets) {\n        subEl.classList.add(`${params.modifierClass}${params.type}-dynamic`);\n        dynamicBulletIndex = 0;\n        if (params.dynamicMainBullets < 1) {\n          params.dynamicMainBullets = 1;\n        }\n      }\n      if (params.type === 'progressbar' && params.progressbarOpposite) {\n        subEl.classList.add(params.progressbarOppositeClass);\n      }\n      if (params.clickable) {\n        subEl.addEventListener('click', onBulletClick);\n      }\n      if (!swiper.enabled) {\n        subEl.classList.add(params.lockClass);\n      }\n    });\n  }\n  function destroy() {\n    const params = swiper.params.pagination;\n    if (isPaginationDisabled()) return;\n    let el = swiper.pagination.el;\n    if (el) {\n      el = makeElementsArray(el);\n      el.forEach(subEl => {\n        subEl.classList.remove(params.hiddenClass);\n        subEl.classList.remove(params.modifierClass + params.type);\n        subEl.classList.remove(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);\n        if (params.clickable) {\n          subEl.removeEventListener('click', onBulletClick);\n        }\n      });\n    }\n    if (swiper.pagination.bullets) swiper.pagination.bullets.forEach(subEl => subEl.classList.remove(...params.bulletActiveClass.split(' ')));\n  }\n  on('changeDirection', () => {\n    if (!swiper.pagination || !swiper.pagination.el) return;\n    const params = swiper.params.pagination;\n    let {\n      el\n    } = swiper.pagination;\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.classList.remove(params.horizontalClass, params.verticalClass);\n      subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);\n    });\n  });\n  on('init', () => {\n    if (swiper.params.pagination.enabled === false) {\n      // eslint-disable-next-line\n      disable();\n    } else {\n      init();\n      render();\n      update();\n    }\n  });\n  on('activeIndexChange', () => {\n    if (typeof swiper.snapIndex === 'undefined') {\n      update();\n    }\n  });\n  on('snapIndexChange', () => {\n    update();\n  });\n  on('snapGridLengthChange', () => {\n    render();\n    update();\n  });\n  on('destroy', () => {\n    destroy();\n  });\n  on('enable disable', () => {\n    let {\n      el\n    } = swiper.pagination;\n    if (el) {\n      el = makeElementsArray(el);\n      el.forEach(subEl => subEl.classList[swiper.enabled ? 'remove' : 'add'](swiper.params.pagination.lockClass));\n    }\n  });\n  on('lock unlock', () => {\n    update();\n  });\n  on('click', (_s, e) => {\n    const targetEl = e.target;\n    let {\n      el\n    } = swiper.pagination;\n    if (!Array.isArray(el)) el = [el].filter(element => !!element);\n    if (swiper.params.pagination.el && swiper.params.pagination.hideOnClick && el && el.length > 0 && !targetEl.classList.contains(swiper.params.pagination.bulletClass)) {\n      if (swiper.navigation && (swiper.navigation.nextEl && targetEl === swiper.navigation.nextEl || swiper.navigation.prevEl && targetEl === swiper.navigation.prevEl)) return;\n      const isHidden = el[0].classList.contains(swiper.params.pagination.hiddenClass);\n      if (isHidden === true) {\n        emit('paginationShow');\n      } else {\n        emit('paginationHide');\n      }\n      el.forEach(subEl => subEl.classList.toggle(swiper.params.pagination.hiddenClass));\n    }\n  });\n  const enable = () => {\n    swiper.el.classList.remove(swiper.params.pagination.paginationDisabledClass);\n    let {\n      el\n    } = swiper.pagination;\n    if (el) {\n      el = makeElementsArray(el);\n      el.forEach(subEl => subEl.classList.remove(swiper.params.pagination.paginationDisabledClass));\n    }\n    init();\n    render();\n    update();\n  };\n  const disable = () => {\n    swiper.el.classList.add(swiper.params.pagination.paginationDisabledClass);\n    let {\n      el\n    } = swiper.pagination;\n    if (el) {\n      el = makeElementsArray(el);\n      el.forEach(subEl => subEl.classList.add(swiper.params.pagination.paginationDisabledClass));\n    }\n    destroy();\n  };\n  Object.assign(swiper.pagination, {\n    enable,\n    disable,\n    render,\n    update,\n    init,\n    destroy\n  });\n}","import { getDocument } from 'ssr-window';\nimport { createElement, elementOffset, nextTick } from '../../shared/utils.js';\nimport createElementIfNotDefined from '../../shared/create-element-if-not-defined.js';\nexport default function Scrollbar({\n  swiper,\n  extendParams,\n  on,\n  emit\n}) {\n  const document = getDocument();\n  let isTouched = false;\n  let timeout = null;\n  let dragTimeout = null;\n  let dragStartPos;\n  let dragSize;\n  let trackSize;\n  let divider;\n  extendParams({\n    scrollbar: {\n      el: null,\n      dragSize: 'auto',\n      hide: false,\n      draggable: false,\n      snapOnRelease: true,\n      lockClass: 'swiper-scrollbar-lock',\n      dragClass: 'swiper-scrollbar-drag',\n      scrollbarDisabledClass: 'swiper-scrollbar-disabled',\n      horizontalClass: `swiper-scrollbar-horizontal`,\n      verticalClass: `swiper-scrollbar-vertical`\n    }\n  });\n  swiper.scrollbar = {\n    el: null,\n    dragEl: null\n  };\n  function setTranslate() {\n    if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;\n    const {\n      scrollbar,\n      rtlTranslate: rtl\n    } = swiper;\n    const {\n      dragEl,\n      el\n    } = scrollbar;\n    const params = swiper.params.scrollbar;\n    const progress = swiper.params.loop ? swiper.progressLoop : swiper.progress;\n    let newSize = dragSize;\n    let newPos = (trackSize - dragSize) * progress;\n    if (rtl) {\n      newPos = -newPos;\n      if (newPos > 0) {\n        newSize = dragSize - newPos;\n        newPos = 0;\n      } else if (-newPos + dragSize > trackSize) {\n        newSize = trackSize + newPos;\n      }\n    } else if (newPos < 0) {\n      newSize = dragSize + newPos;\n      newPos = 0;\n    } else if (newPos + dragSize > trackSize) {\n      newSize = trackSize - newPos;\n    }\n    if (swiper.isHorizontal()) {\n      dragEl.style.transform = `translate3d(${newPos}px, 0, 0)`;\n      dragEl.style.width = `${newSize}px`;\n    } else {\n      dragEl.style.transform = `translate3d(0px, ${newPos}px, 0)`;\n      dragEl.style.height = `${newSize}px`;\n    }\n    if (params.hide) {\n      clearTimeout(timeout);\n      el.style.opacity = 1;\n      timeout = setTimeout(() => {\n        el.style.opacity = 0;\n        el.style.transitionDuration = '400ms';\n      }, 1000);\n    }\n  }\n  function setTransition(duration) {\n    if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;\n    swiper.scrollbar.dragEl.style.transitionDuration = `${duration}ms`;\n  }\n  function updateSize() {\n    if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;\n    const {\n      scrollbar\n    } = swiper;\n    const {\n      dragEl,\n      el\n    } = scrollbar;\n    dragEl.style.width = '';\n    dragEl.style.height = '';\n    trackSize = swiper.isHorizontal() ? el.offsetWidth : el.offsetHeight;\n    divider = swiper.size / (swiper.virtualSize + swiper.params.slidesOffsetBefore - (swiper.params.centeredSlides ? swiper.snapGrid[0] : 0));\n    if (swiper.params.scrollbar.dragSize === 'auto') {\n      dragSize = trackSize * divider;\n    } else {\n      dragSize = parseInt(swiper.params.scrollbar.dragSize, 10);\n    }\n    if (swiper.isHorizontal()) {\n      dragEl.style.width = `${dragSize}px`;\n    } else {\n      dragEl.style.height = `${dragSize}px`;\n    }\n    if (divider >= 1) {\n      el.style.display = 'none';\n    } else {\n      el.style.display = '';\n    }\n    if (swiper.params.scrollbar.hide) {\n      el.style.opacity = 0;\n    }\n    if (swiper.params.watchOverflow && swiper.enabled) {\n      scrollbar.el.classList[swiper.isLocked ? 'add' : 'remove'](swiper.params.scrollbar.lockClass);\n    }\n  }\n  function getPointerPosition(e) {\n    return swiper.isHorizontal() ? e.clientX : e.clientY;\n  }\n  function setDragPosition(e) {\n    const {\n      scrollbar,\n      rtlTranslate: rtl\n    } = swiper;\n    const {\n      el\n    } = scrollbar;\n    let positionRatio;\n    positionRatio = (getPointerPosition(e) - elementOffset(el)[swiper.isHorizontal() ? 'left' : 'top'] - (dragStartPos !== null ? dragStartPos : dragSize / 2)) / (trackSize - dragSize);\n    positionRatio = Math.max(Math.min(positionRatio, 1), 0);\n    if (rtl) {\n      positionRatio = 1 - positionRatio;\n    }\n    const position = swiper.minTranslate() + (swiper.maxTranslate() - swiper.minTranslate()) * positionRatio;\n    swiper.updateProgress(position);\n    swiper.setTranslate(position);\n    swiper.updateActiveIndex();\n    swiper.updateSlidesClasses();\n  }\n  function onDragStart(e) {\n    const params = swiper.params.scrollbar;\n    const {\n      scrollbar,\n      wrapperEl\n    } = swiper;\n    const {\n      el,\n      dragEl\n    } = scrollbar;\n    isTouched = true;\n    dragStartPos = e.target === dragEl ? getPointerPosition(e) - e.target.getBoundingClientRect()[swiper.isHorizontal() ? 'left' : 'top'] : null;\n    e.preventDefault();\n    e.stopPropagation();\n    wrapperEl.style.transitionDuration = '100ms';\n    dragEl.style.transitionDuration = '100ms';\n    setDragPosition(e);\n    clearTimeout(dragTimeout);\n    el.style.transitionDuration = '0ms';\n    if (params.hide) {\n      el.style.opacity = 1;\n    }\n    if (swiper.params.cssMode) {\n      swiper.wrapperEl.style['scroll-snap-type'] = 'none';\n    }\n    emit('scrollbarDragStart', e);\n  }\n  function onDragMove(e) {\n    const {\n      scrollbar,\n      wrapperEl\n    } = swiper;\n    const {\n      el,\n      dragEl\n    } = scrollbar;\n    if (!isTouched) return;\n    if (e.preventDefault) e.preventDefault();else e.returnValue = false;\n    setDragPosition(e);\n    wrapperEl.style.transitionDuration = '0ms';\n    el.style.transitionDuration = '0ms';\n    dragEl.style.transitionDuration = '0ms';\n    emit('scrollbarDragMove', e);\n  }\n  function onDragEnd(e) {\n    const params = swiper.params.scrollbar;\n    const {\n      scrollbar,\n      wrapperEl\n    } = swiper;\n    const {\n      el\n    } = scrollbar;\n    if (!isTouched) return;\n    isTouched = false;\n    if (swiper.params.cssMode) {\n      swiper.wrapperEl.style['scroll-snap-type'] = '';\n      wrapperEl.style.transitionDuration = '';\n    }\n    if (params.hide) {\n      clearTimeout(dragTimeout);\n      dragTimeout = nextTick(() => {\n        el.style.opacity = 0;\n        el.style.transitionDuration = '400ms';\n      }, 1000);\n    }\n    emit('scrollbarDragEnd', e);\n    if (params.snapOnRelease) {\n      swiper.slideToClosest();\n    }\n  }\n  function events(method) {\n    const {\n      scrollbar,\n      params\n    } = swiper;\n    const el = scrollbar.el;\n    if (!el) return;\n    const target = el;\n    const activeListener = params.passiveListeners ? {\n      passive: false,\n      capture: false\n    } : false;\n    const passiveListener = params.passiveListeners ? {\n      passive: true,\n      capture: false\n    } : false;\n    if (!target) return;\n    const eventMethod = method === 'on' ? 'addEventListener' : 'removeEventListener';\n    target[eventMethod]('pointerdown', onDragStart, activeListener);\n    document[eventMethod]('pointermove', onDragMove, activeListener);\n    document[eventMethod]('pointerup', onDragEnd, passiveListener);\n  }\n  function enableDraggable() {\n    if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;\n    events('on');\n  }\n  function disableDraggable() {\n    if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;\n    events('off');\n  }\n  function init() {\n    const {\n      scrollbar,\n      el: swiperEl\n    } = swiper;\n    swiper.params.scrollbar = createElementIfNotDefined(swiper, swiper.originalParams.scrollbar, swiper.params.scrollbar, {\n      el: 'swiper-scrollbar'\n    });\n    const params = swiper.params.scrollbar;\n    if (!params.el) return;\n    let el;\n    if (typeof params.el === 'string' && swiper.isElement) {\n      el = swiper.el.shadowRoot.querySelector(params.el);\n    }\n    if (!el && typeof params.el === 'string') {\n      el = document.querySelectorAll(params.el);\n    } else if (!el) {\n      el = params.el;\n    }\n    if (swiper.params.uniqueNavElements && typeof params.el === 'string' && el.length > 1 && swiperEl.querySelectorAll(params.el).length === 1) {\n      el = swiperEl.querySelector(params.el);\n    }\n    if (el.length > 0) el = el[0];\n    el.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);\n    let dragEl;\n    if (el) {\n      dragEl = el.querySelector(`.${swiper.params.scrollbar.dragClass}`);\n      if (!dragEl) {\n        dragEl = createElement('div', swiper.params.scrollbar.dragClass);\n        el.append(dragEl);\n      }\n    }\n    Object.assign(scrollbar, {\n      el,\n      dragEl\n    });\n    if (params.draggable) {\n      enableDraggable();\n    }\n    if (el) {\n      el.classList[swiper.enabled ? 'remove' : 'add'](swiper.params.scrollbar.lockClass);\n    }\n  }\n  function destroy() {\n    const params = swiper.params.scrollbar;\n    const el = swiper.scrollbar.el;\n    if (el) {\n      el.classList.remove(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);\n    }\n    disableDraggable();\n  }\n  on('init', () => {\n    if (swiper.params.scrollbar.enabled === false) {\n      // eslint-disable-next-line\n      disable();\n    } else {\n      init();\n      updateSize();\n      setTranslate();\n    }\n  });\n  on('update resize observerUpdate lock unlock', () => {\n    updateSize();\n  });\n  on('setTranslate', () => {\n    setTranslate();\n  });\n  on('setTransition', (_s, duration) => {\n    setTransition(duration);\n  });\n  on('enable disable', () => {\n    const {\n      el\n    } = swiper.scrollbar;\n    if (el) {\n      el.classList[swiper.enabled ? 'remove' : 'add'](swiper.params.scrollbar.lockClass);\n    }\n  });\n  on('destroy', () => {\n    destroy();\n  });\n  const enable = () => {\n    swiper.el.classList.remove(swiper.params.scrollbar.scrollbarDisabledClass);\n    if (swiper.scrollbar.el) {\n      swiper.scrollbar.el.classList.remove(swiper.params.scrollbar.scrollbarDisabledClass);\n    }\n    init();\n    updateSize();\n    setTranslate();\n  };\n  const disable = () => {\n    swiper.el.classList.add(swiper.params.scrollbar.scrollbarDisabledClass);\n    if (swiper.scrollbar.el) {\n      swiper.scrollbar.el.classList.add(swiper.params.scrollbar.scrollbarDisabledClass);\n    }\n    destroy();\n  };\n  Object.assign(swiper.scrollbar, {\n    enable,\n    disable,\n    updateSize,\n    setTranslate,\n    init,\n    destroy\n  });\n}","import { elementChildren } from '../../shared/utils.js';\nexport default function Parallax({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    parallax: {\n      enabled: false\n    }\n  });\n  const setTransform = (el, progress) => {\n    const {\n      rtl\n    } = swiper;\n    const rtlFactor = rtl ? -1 : 1;\n    const p = el.getAttribute('data-swiper-parallax') || '0';\n    let x = el.getAttribute('data-swiper-parallax-x');\n    let y = el.getAttribute('data-swiper-parallax-y');\n    const scale = el.getAttribute('data-swiper-parallax-scale');\n    const opacity = el.getAttribute('data-swiper-parallax-opacity');\n    const rotate = el.getAttribute('data-swiper-parallax-rotate');\n    if (x || y) {\n      x = x || '0';\n      y = y || '0';\n    } else if (swiper.isHorizontal()) {\n      x = p;\n      y = '0';\n    } else {\n      y = p;\n      x = '0';\n    }\n    if (x.indexOf('%') >= 0) {\n      x = `${parseInt(x, 10) * progress * rtlFactor}%`;\n    } else {\n      x = `${x * progress * rtlFactor}px`;\n    }\n    if (y.indexOf('%') >= 0) {\n      y = `${parseInt(y, 10) * progress}%`;\n    } else {\n      y = `${y * progress}px`;\n    }\n    if (typeof opacity !== 'undefined' && opacity !== null) {\n      const currentOpacity = opacity - (opacity - 1) * (1 - Math.abs(progress));\n      el.style.opacity = currentOpacity;\n    }\n    let transform = `translate3d(${x}, ${y}, 0px)`;\n    if (typeof scale !== 'undefined' && scale !== null) {\n      const currentScale = scale - (scale - 1) * (1 - Math.abs(progress));\n      transform += ` scale(${currentScale})`;\n    }\n    if (rotate && typeof rotate !== 'undefined' && rotate !== null) {\n      const currentRotate = rotate * progress * -1;\n      transform += ` rotate(${currentRotate}deg)`;\n    }\n    el.style.transform = transform;\n  };\n  const setTranslate = () => {\n    const {\n      el,\n      slides,\n      progress,\n      snapGrid\n    } = swiper;\n    elementChildren(el, '[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]').forEach(subEl => {\n      setTransform(subEl, progress);\n    });\n    slides.forEach((slideEl, slideIndex) => {\n      let slideProgress = slideEl.progress;\n      if (swiper.params.slidesPerGroup > 1 && swiper.params.slidesPerView !== 'auto') {\n        slideProgress += Math.ceil(slideIndex / 2) - progress * (snapGrid.length - 1);\n      }\n      slideProgress = Math.min(Math.max(slideProgress, -1), 1);\n      slideEl.querySelectorAll('[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale], [data-swiper-parallax-rotate]').forEach(subEl => {\n        setTransform(subEl, slideProgress);\n      });\n    });\n  };\n  const setTransition = (duration = swiper.params.speed) => {\n    const {\n      el\n    } = swiper;\n    el.querySelectorAll('[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]').forEach(parallaxEl => {\n      let parallaxDuration = parseInt(parallaxEl.getAttribute('data-swiper-parallax-duration'), 10) || duration;\n      if (duration === 0) parallaxDuration = 0;\n      parallaxEl.style.transitionDuration = `${parallaxDuration}ms`;\n    });\n  };\n  on('beforeInit', () => {\n    if (!swiper.params.parallax.enabled) return;\n    swiper.params.watchSlidesProgress = true;\n    swiper.originalParams.watchSlidesProgress = true;\n  });\n  on('init', () => {\n    if (!swiper.params.parallax.enabled) return;\n    setTranslate();\n  });\n  on('setTranslate', () => {\n    if (!swiper.params.parallax.enabled) return;\n    setTranslate();\n  });\n  on('setTransition', (_swiper, duration) => {\n    if (!swiper.params.parallax.enabled) return;\n    setTransition(duration);\n  });\n}","import { getWindow } from 'ssr-window';\nimport { elementChildren, elementOffset, elementParents, getTranslate } from '../../shared/utils.js';\nexport default function Zoom({\n  swiper,\n  extendParams,\n  on,\n  emit\n}) {\n  const window = getWindow();\n  extendParams({\n    zoom: {\n      enabled: false,\n      maxRatio: 3,\n      minRatio: 1,\n      toggle: true,\n      containerClass: 'swiper-zoom-container',\n      zoomedSlideClass: 'swiper-slide-zoomed'\n    }\n  });\n  swiper.zoom = {\n    enabled: false\n  };\n  let currentScale = 1;\n  let isScaling = false;\n  let fakeGestureTouched;\n  let fakeGestureMoved;\n  const evCache = [];\n  const gesture = {\n    originX: 0,\n    originY: 0,\n    slideEl: undefined,\n    slideWidth: undefined,\n    slideHeight: undefined,\n    imageEl: undefined,\n    imageWrapEl: undefined,\n    maxRatio: 3\n  };\n  const image = {\n    isTouched: undefined,\n    isMoved: undefined,\n    currentX: undefined,\n    currentY: undefined,\n    minX: undefined,\n    minY: undefined,\n    maxX: undefined,\n    maxY: undefined,\n    width: undefined,\n    height: undefined,\n    startX: undefined,\n    startY: undefined,\n    touchesStart: {},\n    touchesCurrent: {}\n  };\n  const velocity = {\n    x: undefined,\n    y: undefined,\n    prevPositionX: undefined,\n    prevPositionY: undefined,\n    prevTime: undefined\n  };\n  let scale = 1;\n  Object.defineProperty(swiper.zoom, 'scale', {\n    get() {\n      return scale;\n    },\n    set(value) {\n      if (scale !== value) {\n        const imageEl = gesture.imageEl;\n        const slideEl = gesture.slideEl;\n        emit('zoomChange', value, imageEl, slideEl);\n      }\n      scale = value;\n    }\n  });\n  function getDistanceBetweenTouches() {\n    if (evCache.length < 2) return 1;\n    const x1 = evCache[0].pageX;\n    const y1 = evCache[0].pageY;\n    const x2 = evCache[1].pageX;\n    const y2 = evCache[1].pageY;\n    const distance = Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);\n    return distance;\n  }\n  function getScaleOrigin() {\n    if (evCache.length < 2) return {\n      x: null,\n      y: null\n    };\n    const box = gesture.imageEl.getBoundingClientRect();\n    return [(evCache[0].pageX + (evCache[1].pageX - evCache[0].pageX) / 2 - box.x) / currentScale, (evCache[0].pageY + (evCache[1].pageY - evCache[0].pageY) / 2 - box.y) / currentScale];\n  }\n  function getSlideSelector() {\n    return swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;\n  }\n  function eventWithinSlide(e) {\n    const slideSelector = getSlideSelector();\n    if (e.target.matches(slideSelector)) return true;\n    if (swiper.slides.filter(slideEl => slideEl.contains(e.target)).length > 0) return true;\n    return false;\n  }\n  function eventWithinZoomContainer(e) {\n    const selector = `.${swiper.params.zoom.containerClass}`;\n    if (e.target.matches(selector)) return true;\n    if ([...swiper.el.querySelectorAll(selector)].filter(containerEl => containerEl.contains(e.target)).length > 0) return true;\n    return false;\n  }\n\n  // Events\n  function onGestureStart(e) {\n    if (e.pointerType === 'mouse') {\n      evCache.splice(0, evCache.length);\n    }\n    if (!eventWithinSlide(e)) return;\n    const params = swiper.params.zoom;\n    fakeGestureTouched = false;\n    fakeGestureMoved = false;\n    evCache.push(e);\n    if (evCache.length < 2) {\n      return;\n    }\n    fakeGestureTouched = true;\n    gesture.scaleStart = getDistanceBetweenTouches();\n    if (!gesture.slideEl) {\n      gesture.slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);\n      if (!gesture.slideEl) gesture.slideEl = swiper.slides[swiper.activeIndex];\n      let imageEl = gesture.slideEl.querySelector(`.${params.containerClass}`);\n      if (imageEl) {\n        imageEl = imageEl.querySelectorAll('picture, img, svg, canvas, .swiper-zoom-target')[0];\n      }\n      gesture.imageEl = imageEl;\n      if (imageEl) {\n        gesture.imageWrapEl = elementParents(gesture.imageEl, `.${params.containerClass}`)[0];\n      } else {\n        gesture.imageWrapEl = undefined;\n      }\n      if (!gesture.imageWrapEl) {\n        gesture.imageEl = undefined;\n        return;\n      }\n      gesture.maxRatio = gesture.imageWrapEl.getAttribute('data-swiper-zoom') || params.maxRatio;\n    }\n    if (gesture.imageEl) {\n      const [originX, originY] = getScaleOrigin();\n      gesture.originX = originX;\n      gesture.originY = originY;\n      gesture.imageEl.style.transitionDuration = '0ms';\n    }\n    isScaling = true;\n  }\n  function onGestureChange(e) {\n    if (!eventWithinSlide(e)) return;\n    const params = swiper.params.zoom;\n    const zoom = swiper.zoom;\n    const pointerIndex = evCache.findIndex(cachedEv => cachedEv.pointerId === e.pointerId);\n    if (pointerIndex >= 0) evCache[pointerIndex] = e;\n    if (evCache.length < 2) {\n      return;\n    }\n    fakeGestureMoved = true;\n    gesture.scaleMove = getDistanceBetweenTouches();\n    if (!gesture.imageEl) {\n      return;\n    }\n    zoom.scale = gesture.scaleMove / gesture.scaleStart * currentScale;\n    if (zoom.scale > gesture.maxRatio) {\n      zoom.scale = gesture.maxRatio - 1 + (zoom.scale - gesture.maxRatio + 1) ** 0.5;\n    }\n    if (zoom.scale < params.minRatio) {\n      zoom.scale = params.minRatio + 1 - (params.minRatio - zoom.scale + 1) ** 0.5;\n    }\n    gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;\n  }\n  function onGestureEnd(e) {\n    if (!eventWithinSlide(e)) return;\n    if (e.pointerType === 'mouse' && e.type === 'pointerout') return;\n    const params = swiper.params.zoom;\n    const zoom = swiper.zoom;\n    const pointerIndex = evCache.findIndex(cachedEv => cachedEv.pointerId === e.pointerId);\n    if (pointerIndex >= 0) evCache.splice(pointerIndex, 1);\n    if (!fakeGestureTouched || !fakeGestureMoved) {\n      return;\n    }\n    fakeGestureTouched = false;\n    fakeGestureMoved = false;\n    if (!gesture.imageEl) return;\n    zoom.scale = Math.max(Math.min(zoom.scale, gesture.maxRatio), params.minRatio);\n    gesture.imageEl.style.transitionDuration = `${swiper.params.speed}ms`;\n    gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;\n    currentScale = zoom.scale;\n    isScaling = false;\n    if (zoom.scale > 1 && gesture.slideEl) {\n      gesture.slideEl.classList.add(`${params.zoomedSlideClass}`);\n    } else if (zoom.scale <= 1 && gesture.slideEl) {\n      gesture.slideEl.classList.remove(`${params.zoomedSlideClass}`);\n    }\n    if (zoom.scale === 1) {\n      gesture.originX = 0;\n      gesture.originY = 0;\n      gesture.slideEl = undefined;\n    }\n  }\n  function onTouchStart(e) {\n    const device = swiper.device;\n    if (!gesture.imageEl) return;\n    if (image.isTouched) return;\n    if (device.android && e.cancelable) e.preventDefault();\n    image.isTouched = true;\n    const event = evCache.length > 0 ? evCache[0] : e;\n    image.touchesStart.x = event.pageX;\n    image.touchesStart.y = event.pageY;\n  }\n  function onTouchMove(e) {\n    if (!eventWithinSlide(e) || !eventWithinZoomContainer(e)) return;\n    const zoom = swiper.zoom;\n    if (!gesture.imageEl) return;\n    if (!image.isTouched || !gesture.slideEl) return;\n    if (!image.isMoved) {\n      image.width = gesture.imageEl.offsetWidth;\n      image.height = gesture.imageEl.offsetHeight;\n      image.startX = getTranslate(gesture.imageWrapEl, 'x') || 0;\n      image.startY = getTranslate(gesture.imageWrapEl, 'y') || 0;\n      gesture.slideWidth = gesture.slideEl.offsetWidth;\n      gesture.slideHeight = gesture.slideEl.offsetHeight;\n      gesture.imageWrapEl.style.transitionDuration = '0ms';\n    }\n    // Define if we need image drag\n    const scaledWidth = image.width * zoom.scale;\n    const scaledHeight = image.height * zoom.scale;\n    if (scaledWidth < gesture.slideWidth && scaledHeight < gesture.slideHeight) return;\n    image.minX = Math.min(gesture.slideWidth / 2 - scaledWidth / 2, 0);\n    image.maxX = -image.minX;\n    image.minY = Math.min(gesture.slideHeight / 2 - scaledHeight / 2, 0);\n    image.maxY = -image.minY;\n    image.touchesCurrent.x = evCache.length > 0 ? evCache[0].pageX : e.pageX;\n    image.touchesCurrent.y = evCache.length > 0 ? evCache[0].pageY : e.pageY;\n    const touchesDiff = Math.max(Math.abs(image.touchesCurrent.x - image.touchesStart.x), Math.abs(image.touchesCurrent.y - image.touchesStart.y));\n    if (touchesDiff > 5) {\n      swiper.allowClick = false;\n    }\n    if (!image.isMoved && !isScaling) {\n      if (swiper.isHorizontal() && (Math.floor(image.minX) === Math.floor(image.startX) && image.touchesCurrent.x < image.touchesStart.x || Math.floor(image.maxX) === Math.floor(image.startX) && image.touchesCurrent.x > image.touchesStart.x)) {\n        image.isTouched = false;\n        return;\n      }\n      if (!swiper.isHorizontal() && (Math.floor(image.minY) === Math.floor(image.startY) && image.touchesCurrent.y < image.touchesStart.y || Math.floor(image.maxY) === Math.floor(image.startY) && image.touchesCurrent.y > image.touchesStart.y)) {\n        image.isTouched = false;\n        return;\n      }\n    }\n    if (e.cancelable) {\n      e.preventDefault();\n    }\n    e.stopPropagation();\n    image.isMoved = true;\n    const scaleRatio = (zoom.scale - currentScale) / (gesture.maxRatio - swiper.params.zoom.minRatio);\n    const {\n      originX,\n      originY\n    } = gesture;\n    image.currentX = image.touchesCurrent.x - image.touchesStart.x + image.startX + scaleRatio * (image.width - originX * 2);\n    image.currentY = image.touchesCurrent.y - image.touchesStart.y + image.startY + scaleRatio * (image.height - originY * 2);\n    if (image.currentX < image.minX) {\n      image.currentX = image.minX + 1 - (image.minX - image.currentX + 1) ** 0.8;\n    }\n    if (image.currentX > image.maxX) {\n      image.currentX = image.maxX - 1 + (image.currentX - image.maxX + 1) ** 0.8;\n    }\n    if (image.currentY < image.minY) {\n      image.currentY = image.minY + 1 - (image.minY - image.currentY + 1) ** 0.8;\n    }\n    if (image.currentY > image.maxY) {\n      image.currentY = image.maxY - 1 + (image.currentY - image.maxY + 1) ** 0.8;\n    }\n\n    // Velocity\n    if (!velocity.prevPositionX) velocity.prevPositionX = image.touchesCurrent.x;\n    if (!velocity.prevPositionY) velocity.prevPositionY = image.touchesCurrent.y;\n    if (!velocity.prevTime) velocity.prevTime = Date.now();\n    velocity.x = (image.touchesCurrent.x - velocity.prevPositionX) / (Date.now() - velocity.prevTime) / 2;\n    velocity.y = (image.touchesCurrent.y - velocity.prevPositionY) / (Date.now() - velocity.prevTime) / 2;\n    if (Math.abs(image.touchesCurrent.x - velocity.prevPositionX) < 2) velocity.x = 0;\n    if (Math.abs(image.touchesCurrent.y - velocity.prevPositionY) < 2) velocity.y = 0;\n    velocity.prevPositionX = image.touchesCurrent.x;\n    velocity.prevPositionY = image.touchesCurrent.y;\n    velocity.prevTime = Date.now();\n    gesture.imageWrapEl.style.transform = `translate3d(${image.currentX}px, ${image.currentY}px,0)`;\n  }\n  function onTouchEnd() {\n    const zoom = swiper.zoom;\n    if (!gesture.imageEl) return;\n    if (!image.isTouched || !image.isMoved) {\n      image.isTouched = false;\n      image.isMoved = false;\n      return;\n    }\n    image.isTouched = false;\n    image.isMoved = false;\n    let momentumDurationX = 300;\n    let momentumDurationY = 300;\n    const momentumDistanceX = velocity.x * momentumDurationX;\n    const newPositionX = image.currentX + momentumDistanceX;\n    const momentumDistanceY = velocity.y * momentumDurationY;\n    const newPositionY = image.currentY + momentumDistanceY;\n\n    // Fix duration\n    if (velocity.x !== 0) momentumDurationX = Math.abs((newPositionX - image.currentX) / velocity.x);\n    if (velocity.y !== 0) momentumDurationY = Math.abs((newPositionY - image.currentY) / velocity.y);\n    const momentumDuration = Math.max(momentumDurationX, momentumDurationY);\n    image.currentX = newPositionX;\n    image.currentY = newPositionY;\n    // Define if we need image drag\n    const scaledWidth = image.width * zoom.scale;\n    const scaledHeight = image.height * zoom.scale;\n    image.minX = Math.min(gesture.slideWidth / 2 - scaledWidth / 2, 0);\n    image.maxX = -image.minX;\n    image.minY = Math.min(gesture.slideHeight / 2 - scaledHeight / 2, 0);\n    image.maxY = -image.minY;\n    image.currentX = Math.max(Math.min(image.currentX, image.maxX), image.minX);\n    image.currentY = Math.max(Math.min(image.currentY, image.maxY), image.minY);\n    gesture.imageWrapEl.style.transitionDuration = `${momentumDuration}ms`;\n    gesture.imageWrapEl.style.transform = `translate3d(${image.currentX}px, ${image.currentY}px,0)`;\n  }\n  function onTransitionEnd() {\n    const zoom = swiper.zoom;\n    if (gesture.slideEl && swiper.activeIndex !== swiper.slides.indexOf(gesture.slideEl)) {\n      if (gesture.imageEl) {\n        gesture.imageEl.style.transform = 'translate3d(0,0,0) scale(1)';\n      }\n      if (gesture.imageWrapEl) {\n        gesture.imageWrapEl.style.transform = 'translate3d(0,0,0)';\n      }\n      gesture.slideEl.classList.remove(`${swiper.params.zoom.zoomedSlideClass}`);\n      zoom.scale = 1;\n      currentScale = 1;\n      gesture.slideEl = undefined;\n      gesture.imageEl = undefined;\n      gesture.imageWrapEl = undefined;\n      gesture.originX = 0;\n      gesture.originY = 0;\n    }\n  }\n  function zoomIn(e) {\n    const zoom = swiper.zoom;\n    const params = swiper.params.zoom;\n    if (!gesture.slideEl) {\n      if (e && e.target) {\n        gesture.slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);\n      }\n      if (!gesture.slideEl) {\n        if (swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual) {\n          gesture.slideEl = elementChildren(swiper.slidesEl, `.${swiper.params.slideActiveClass}`)[0];\n        } else {\n          gesture.slideEl = swiper.slides[swiper.activeIndex];\n        }\n      }\n      let imageEl = gesture.slideEl.querySelector(`.${params.containerClass}`);\n      if (imageEl) {\n        imageEl = imageEl.querySelectorAll('picture, img, svg, canvas, .swiper-zoom-target')[0];\n      }\n      gesture.imageEl = imageEl;\n      if (imageEl) {\n        gesture.imageWrapEl = elementParents(gesture.imageEl, `.${params.containerClass}`)[0];\n      } else {\n        gesture.imageWrapEl = undefined;\n      }\n    }\n    if (!gesture.imageEl || !gesture.imageWrapEl) return;\n    if (swiper.params.cssMode) {\n      swiper.wrapperEl.style.overflow = 'hidden';\n      swiper.wrapperEl.style.touchAction = 'none';\n    }\n    gesture.slideEl.classList.add(`${params.zoomedSlideClass}`);\n    let touchX;\n    let touchY;\n    let offsetX;\n    let offsetY;\n    let diffX;\n    let diffY;\n    let translateX;\n    let translateY;\n    let imageWidth;\n    let imageHeight;\n    let scaledWidth;\n    let scaledHeight;\n    let translateMinX;\n    let translateMinY;\n    let translateMaxX;\n    let translateMaxY;\n    let slideWidth;\n    let slideHeight;\n    if (typeof image.touchesStart.x === 'undefined' && e) {\n      touchX = e.pageX;\n      touchY = e.pageY;\n    } else {\n      touchX = image.touchesStart.x;\n      touchY = image.touchesStart.y;\n    }\n    const forceZoomRatio = typeof e === 'number' ? e : null;\n    if (currentScale === 1 && forceZoomRatio) {\n      touchX = undefined;\n      touchY = undefined;\n    }\n    zoom.scale = forceZoomRatio || gesture.imageWrapEl.getAttribute('data-swiper-zoom') || params.maxRatio;\n    currentScale = forceZoomRatio || gesture.imageWrapEl.getAttribute('data-swiper-zoom') || params.maxRatio;\n    if (e && !(currentScale === 1 && forceZoomRatio)) {\n      slideWidth = gesture.slideEl.offsetWidth;\n      slideHeight = gesture.slideEl.offsetHeight;\n      offsetX = elementOffset(gesture.slideEl).left + window.scrollX;\n      offsetY = elementOffset(gesture.slideEl).top + window.scrollY;\n      diffX = offsetX + slideWidth / 2 - touchX;\n      diffY = offsetY + slideHeight / 2 - touchY;\n      imageWidth = gesture.imageEl.offsetWidth;\n      imageHeight = gesture.imageEl.offsetHeight;\n      scaledWidth = imageWidth * zoom.scale;\n      scaledHeight = imageHeight * zoom.scale;\n      translateMinX = Math.min(slideWidth / 2 - scaledWidth / 2, 0);\n      translateMinY = Math.min(slideHeight / 2 - scaledHeight / 2, 0);\n      translateMaxX = -translateMinX;\n      translateMaxY = -translateMinY;\n      translateX = diffX * zoom.scale;\n      translateY = diffY * zoom.scale;\n      if (translateX < translateMinX) {\n        translateX = translateMinX;\n      }\n      if (translateX > translateMaxX) {\n        translateX = translateMaxX;\n      }\n      if (translateY < translateMinY) {\n        translateY = translateMinY;\n      }\n      if (translateY > translateMaxY) {\n        translateY = translateMaxY;\n      }\n    } else {\n      translateX = 0;\n      translateY = 0;\n    }\n    if (forceZoomRatio && zoom.scale === 1) {\n      gesture.originX = 0;\n      gesture.originY = 0;\n    }\n    gesture.imageWrapEl.style.transitionDuration = '300ms';\n    gesture.imageWrapEl.style.transform = `translate3d(${translateX}px, ${translateY}px,0)`;\n    gesture.imageEl.style.transitionDuration = '300ms';\n    gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;\n  }\n  function zoomOut() {\n    const zoom = swiper.zoom;\n    const params = swiper.params.zoom;\n    if (!gesture.slideEl) {\n      if (swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual) {\n        gesture.slideEl = elementChildren(swiper.slidesEl, `.${swiper.params.slideActiveClass}`)[0];\n      } else {\n        gesture.slideEl = swiper.slides[swiper.activeIndex];\n      }\n      let imageEl = gesture.slideEl.querySelector(`.${params.containerClass}`);\n      if (imageEl) {\n        imageEl = imageEl.querySelectorAll('picture, img, svg, canvas, .swiper-zoom-target')[0];\n      }\n      gesture.imageEl = imageEl;\n      if (imageEl) {\n        gesture.imageWrapEl = elementParents(gesture.imageEl, `.${params.containerClass}`)[0];\n      } else {\n        gesture.imageWrapEl = undefined;\n      }\n    }\n    if (!gesture.imageEl || !gesture.imageWrapEl) return;\n    if (swiper.params.cssMode) {\n      swiper.wrapperEl.style.overflow = '';\n      swiper.wrapperEl.style.touchAction = '';\n    }\n    zoom.scale = 1;\n    currentScale = 1;\n    gesture.imageWrapEl.style.transitionDuration = '300ms';\n    gesture.imageWrapEl.style.transform = 'translate3d(0,0,0)';\n    gesture.imageEl.style.transitionDuration = '300ms';\n    gesture.imageEl.style.transform = 'translate3d(0,0,0) scale(1)';\n    gesture.slideEl.classList.remove(`${params.zoomedSlideClass}`);\n    gesture.slideEl = undefined;\n    gesture.originX = 0;\n    gesture.originY = 0;\n  }\n\n  // Toggle Zoom\n  function zoomToggle(e) {\n    const zoom = swiper.zoom;\n    if (zoom.scale && zoom.scale !== 1) {\n      // Zoom Out\n      zoomOut();\n    } else {\n      // Zoom In\n      zoomIn(e);\n    }\n  }\n  function getListeners() {\n    const passiveListener = swiper.params.passiveListeners ? {\n      passive: true,\n      capture: false\n    } : false;\n    const activeListenerWithCapture = swiper.params.passiveListeners ? {\n      passive: false,\n      capture: true\n    } : true;\n    return {\n      passiveListener,\n      activeListenerWithCapture\n    };\n  }\n\n  // Attach/Detach Events\n  function enable() {\n    const zoom = swiper.zoom;\n    if (zoom.enabled) return;\n    zoom.enabled = true;\n    const {\n      passiveListener,\n      activeListenerWithCapture\n    } = getListeners();\n\n    // Scale image\n    swiper.wrapperEl.addEventListener('pointerdown', onGestureStart, passiveListener);\n    swiper.wrapperEl.addEventListener('pointermove', onGestureChange, activeListenerWithCapture);\n    ['pointerup', 'pointercancel', 'pointerout'].forEach(eventName => {\n      swiper.wrapperEl.addEventListener(eventName, onGestureEnd, passiveListener);\n    });\n\n    // Move image\n    swiper.wrapperEl.addEventListener('pointermove', onTouchMove, activeListenerWithCapture);\n  }\n  function disable() {\n    const zoom = swiper.zoom;\n    if (!zoom.enabled) return;\n    zoom.enabled = false;\n    const {\n      passiveListener,\n      activeListenerWithCapture\n    } = getListeners();\n\n    // Scale image\n    swiper.wrapperEl.removeEventListener('pointerdown', onGestureStart, passiveListener);\n    swiper.wrapperEl.removeEventListener('pointermove', onGestureChange, activeListenerWithCapture);\n    ['pointerup', 'pointercancel', 'pointerout'].forEach(eventName => {\n      swiper.wrapperEl.removeEventListener(eventName, onGestureEnd, passiveListener);\n    });\n\n    // Move image\n    swiper.wrapperEl.removeEventListener('pointermove', onTouchMove, activeListenerWithCapture);\n  }\n  on('init', () => {\n    if (swiper.params.zoom.enabled) {\n      enable();\n    }\n  });\n  on('destroy', () => {\n    disable();\n  });\n  on('touchStart', (_s, e) => {\n    if (!swiper.zoom.enabled) return;\n    onTouchStart(e);\n  });\n  on('touchEnd', (_s, e) => {\n    if (!swiper.zoom.enabled) return;\n    onTouchEnd(e);\n  });\n  on('doubleTap', (_s, e) => {\n    if (!swiper.animating && swiper.params.zoom.enabled && swiper.zoom.enabled && swiper.params.zoom.toggle) {\n      zoomToggle(e);\n    }\n  });\n  on('transitionEnd', () => {\n    if (swiper.zoom.enabled && swiper.params.zoom.enabled) {\n      onTransitionEnd();\n    }\n  });\n  on('slideChange', () => {\n    if (swiper.zoom.enabled && swiper.params.zoom.enabled && swiper.params.cssMode) {\n      onTransitionEnd();\n    }\n  });\n  Object.assign(swiper.zoom, {\n    enable,\n    disable,\n    in: zoomIn,\n    out: zoomOut,\n    toggle: zoomToggle\n  });\n}","/* eslint no-bitwise: [\"error\", { \"allow\": [\">>\"] }] */\nimport { elementTransitionEnd, nextTick } from '../../shared/utils.js';\nexport default function Controller({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    controller: {\n      control: undefined,\n      inverse: false,\n      by: 'slide' // or 'container'\n    }\n  });\n\n  swiper.controller = {\n    control: undefined\n  };\n  function LinearSpline(x, y) {\n    const binarySearch = function search() {\n      let maxIndex;\n      let minIndex;\n      let guess;\n      return (array, val) => {\n        minIndex = -1;\n        maxIndex = array.length;\n        while (maxIndex - minIndex > 1) {\n          guess = maxIndex + minIndex >> 1;\n          if (array[guess] <= val) {\n            minIndex = guess;\n          } else {\n            maxIndex = guess;\n          }\n        }\n        return maxIndex;\n      };\n    }();\n    this.x = x;\n    this.y = y;\n    this.lastIndex = x.length - 1;\n    // Given an x value (x2), return the expected y2 value:\n    // (x1,y1) is the known point before given value,\n    // (x3,y3) is the known point after given value.\n    let i1;\n    let i3;\n    this.interpolate = function interpolate(x2) {\n      if (!x2) return 0;\n\n      // Get the indexes of x1 and x3 (the array indexes before and after given x2):\n      i3 = binarySearch(this.x, x2);\n      i1 = i3 - 1;\n\n      // We have our indexes i1 & i3, so we can calculate already:\n      // y2 := ((x2−x1) × (y3−y1)) ÷ (x3−x1) + y1\n      return (x2 - this.x[i1]) * (this.y[i3] - this.y[i1]) / (this.x[i3] - this.x[i1]) + this.y[i1];\n    };\n    return this;\n  }\n  function getInterpolateFunction(c) {\n    swiper.controller.spline = swiper.params.loop ? new LinearSpline(swiper.slidesGrid, c.slidesGrid) : new LinearSpline(swiper.snapGrid, c.snapGrid);\n  }\n  function setTranslate(_t, byController) {\n    const controlled = swiper.controller.control;\n    let multiplier;\n    let controlledTranslate;\n    const Swiper = swiper.constructor;\n    function setControlledTranslate(c) {\n      if (c.destroyed) return;\n\n      // this will create an Interpolate function based on the snapGrids\n      // x is the Grid of the scrolled scroller and y will be the controlled scroller\n      // it makes sense to create this only once and recall it for the interpolation\n      // the function does a lot of value caching for performance\n      const translate = swiper.rtlTranslate ? -swiper.translate : swiper.translate;\n      if (swiper.params.controller.by === 'slide') {\n        getInterpolateFunction(c);\n        // i am not sure why the values have to be multiplicated this way, tried to invert the snapGrid\n        // but it did not work out\n        controlledTranslate = -swiper.controller.spline.interpolate(-translate);\n      }\n      if (!controlledTranslate || swiper.params.controller.by === 'container') {\n        multiplier = (c.maxTranslate() - c.minTranslate()) / (swiper.maxTranslate() - swiper.minTranslate());\n        if (Number.isNaN(multiplier) || !Number.isFinite(multiplier)) {\n          multiplier = 1;\n        }\n        controlledTranslate = (translate - swiper.minTranslate()) * multiplier + c.minTranslate();\n      }\n      if (swiper.params.controller.inverse) {\n        controlledTranslate = c.maxTranslate() - controlledTranslate;\n      }\n      c.updateProgress(controlledTranslate);\n      c.setTranslate(controlledTranslate, swiper);\n      c.updateActiveIndex();\n      c.updateSlidesClasses();\n    }\n    if (Array.isArray(controlled)) {\n      for (let i = 0; i < controlled.length; i += 1) {\n        if (controlled[i] !== byController && controlled[i] instanceof Swiper) {\n          setControlledTranslate(controlled[i]);\n        }\n      }\n    } else if (controlled instanceof Swiper && byController !== controlled) {\n      setControlledTranslate(controlled);\n    }\n  }\n  function setTransition(duration, byController) {\n    const Swiper = swiper.constructor;\n    const controlled = swiper.controller.control;\n    let i;\n    function setControlledTransition(c) {\n      if (c.destroyed) return;\n      c.setTransition(duration, swiper);\n      if (duration !== 0) {\n        c.transitionStart();\n        if (c.params.autoHeight) {\n          nextTick(() => {\n            c.updateAutoHeight();\n          });\n        }\n        elementTransitionEnd(c.wrapperEl, () => {\n          if (!controlled) return;\n          c.transitionEnd();\n        });\n      }\n    }\n    if (Array.isArray(controlled)) {\n      for (i = 0; i < controlled.length; i += 1) {\n        if (controlled[i] !== byController && controlled[i] instanceof Swiper) {\n          setControlledTransition(controlled[i]);\n        }\n      }\n    } else if (controlled instanceof Swiper && byController !== controlled) {\n      setControlledTransition(controlled);\n    }\n  }\n  function removeSpline() {\n    if (!swiper.controller.control) return;\n    if (swiper.controller.spline) {\n      swiper.controller.spline = undefined;\n      delete swiper.controller.spline;\n    }\n  }\n  on('beforeInit', () => {\n    if (typeof window !== 'undefined' && (\n    // eslint-disable-line\n    typeof swiper.params.controller.control === 'string' || swiper.params.controller.control instanceof HTMLElement)) {\n      const controlElement = document.querySelector(swiper.params.controller.control);\n      if (controlElement && controlElement.swiper) {\n        swiper.controller.control = controlElement.swiper;\n      } else if (controlElement) {\n        const onControllerSwiper = e => {\n          swiper.controller.control = e.detail[0];\n          swiper.update();\n          controlElement.removeEventListener('init', onControllerSwiper);\n        };\n        controlElement.addEventListener('init', onControllerSwiper);\n      }\n      return;\n    }\n    swiper.controller.control = swiper.params.controller.control;\n  });\n  on('update', () => {\n    removeSpline();\n  });\n  on('resize', () => {\n    removeSpline();\n  });\n  on('observerUpdate', () => {\n    removeSpline();\n  });\n  on('setTranslate', (_s, translate, byController) => {\n    if (!swiper.controller.control || swiper.controller.control.destroyed) return;\n    swiper.controller.setTranslate(translate, byController);\n  });\n  on('setTransition', (_s, duration, byController) => {\n    if (!swiper.controller.control || swiper.controller.control.destroyed) return;\n    swiper.controller.setTransition(duration, byController);\n  });\n  Object.assign(swiper.controller, {\n    setTranslate,\n    setTransition\n  });\n}","import classesToSelector from '../../shared/classes-to-selector.js';\nimport { createElement, elementIndex } from '../../shared/utils.js';\nexport default function A11y({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    a11y: {\n      enabled: true,\n      notificationClass: 'swiper-notification',\n      prevSlideMessage: 'Previous slide',\n      nextSlideMessage: 'Next slide',\n      firstSlideMessage: 'This is the first slide',\n      lastSlideMessage: 'This is the last slide',\n      paginationBulletMessage: 'Go to slide {{index}}',\n      slideLabelMessage: '{{index}} / {{slidesLength}}',\n      containerMessage: null,\n      containerRoleDescriptionMessage: null,\n      itemRoleDescriptionMessage: null,\n      slideRole: 'group',\n      id: null\n    }\n  });\n  swiper.a11y = {\n    clicked: false\n  };\n  let liveRegion = null;\n  function notify(message) {\n    const notification = liveRegion;\n    if (notification.length === 0) return;\n    notification.innerHTML = '';\n    notification.innerHTML = message;\n  }\n  const makeElementsArray = el => {\n    if (!Array.isArray(el)) el = [el].filter(e => !!e);\n    return el;\n  };\n  function getRandomNumber(size = 16) {\n    const randomChar = () => Math.round(16 * Math.random()).toString(16);\n    return 'x'.repeat(size).replace(/x/g, randomChar);\n  }\n  function makeElFocusable(el) {\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.setAttribute('tabIndex', '0');\n    });\n  }\n  function makeElNotFocusable(el) {\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.setAttribute('tabIndex', '-1');\n    });\n  }\n  function addElRole(el, role) {\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.setAttribute('role', role);\n    });\n  }\n  function addElRoleDescription(el, description) {\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.setAttribute('aria-roledescription', description);\n    });\n  }\n  function addElControls(el, controls) {\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.setAttribute('aria-controls', controls);\n    });\n  }\n  function addElLabel(el, label) {\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.setAttribute('aria-label', label);\n    });\n  }\n  function addElId(el, id) {\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.setAttribute('id', id);\n    });\n  }\n  function addElLive(el, live) {\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.setAttribute('aria-live', live);\n    });\n  }\n  function disableEl(el) {\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.setAttribute('aria-disabled', true);\n    });\n  }\n  function enableEl(el) {\n    el = makeElementsArray(el);\n    el.forEach(subEl => {\n      subEl.setAttribute('aria-disabled', false);\n    });\n  }\n  function onEnterOrSpaceKey(e) {\n    if (e.keyCode !== 13 && e.keyCode !== 32) return;\n    const params = swiper.params.a11y;\n    const targetEl = e.target;\n    if (swiper.pagination && swiper.pagination.el && (targetEl === swiper.pagination.el || swiper.pagination.el.contains(e.target))) {\n      if (!e.target.matches(classesToSelector(swiper.params.pagination.bulletClass))) return;\n    }\n    if (swiper.navigation && swiper.navigation.nextEl && targetEl === swiper.navigation.nextEl) {\n      if (!(swiper.isEnd && !swiper.params.loop)) {\n        swiper.slideNext();\n      }\n      if (swiper.isEnd) {\n        notify(params.lastSlideMessage);\n      } else {\n        notify(params.nextSlideMessage);\n      }\n    }\n    if (swiper.navigation && swiper.navigation.prevEl && targetEl === swiper.navigation.prevEl) {\n      if (!(swiper.isBeginning && !swiper.params.loop)) {\n        swiper.slidePrev();\n      }\n      if (swiper.isBeginning) {\n        notify(params.firstSlideMessage);\n      } else {\n        notify(params.prevSlideMessage);\n      }\n    }\n    if (swiper.pagination && targetEl.matches(classesToSelector(swiper.params.pagination.bulletClass))) {\n      targetEl.click();\n    }\n  }\n  function updateNavigation() {\n    if (swiper.params.loop || swiper.params.rewind || !swiper.navigation) return;\n    const {\n      nextEl,\n      prevEl\n    } = swiper.navigation;\n    if (prevEl) {\n      if (swiper.isBeginning) {\n        disableEl(prevEl);\n        makeElNotFocusable(prevEl);\n      } else {\n        enableEl(prevEl);\n        makeElFocusable(prevEl);\n      }\n    }\n    if (nextEl) {\n      if (swiper.isEnd) {\n        disableEl(nextEl);\n        makeElNotFocusable(nextEl);\n      } else {\n        enableEl(nextEl);\n        makeElFocusable(nextEl);\n      }\n    }\n  }\n  function hasPagination() {\n    return swiper.pagination && swiper.pagination.bullets && swiper.pagination.bullets.length;\n  }\n  function hasClickablePagination() {\n    return hasPagination() && swiper.params.pagination.clickable;\n  }\n  function updatePagination() {\n    const params = swiper.params.a11y;\n    if (!hasPagination()) return;\n    swiper.pagination.bullets.forEach(bulletEl => {\n      if (swiper.params.pagination.clickable) {\n        makeElFocusable(bulletEl);\n        if (!swiper.params.pagination.renderBullet) {\n          addElRole(bulletEl, 'button');\n          addElLabel(bulletEl, params.paginationBulletMessage.replace(/\\{\\{index\\}\\}/, elementIndex(bulletEl) + 1));\n        }\n      }\n      if (bulletEl.matches(classesToSelector(swiper.params.pagination.bulletActiveClass))) {\n        bulletEl.setAttribute('aria-current', 'true');\n      } else {\n        bulletEl.removeAttribute('aria-current');\n      }\n    });\n  }\n  const initNavEl = (el, wrapperId, message) => {\n    makeElFocusable(el);\n    if (el.tagName !== 'BUTTON') {\n      addElRole(el, 'button');\n      el.addEventListener('keydown', onEnterOrSpaceKey);\n    }\n    addElLabel(el, message);\n    addElControls(el, wrapperId);\n  };\n  const handlePointerDown = () => {\n    swiper.a11y.clicked = true;\n  };\n  const handlePointerUp = () => {\n    requestAnimationFrame(() => {\n      requestAnimationFrame(() => {\n        if (!swiper.destroyed) {\n          swiper.a11y.clicked = false;\n        }\n      });\n    });\n  };\n  const handleFocus = e => {\n    if (swiper.a11y.clicked) return;\n    const slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);\n    if (!slideEl || !swiper.slides.includes(slideEl)) return;\n    const isActive = swiper.slides.indexOf(slideEl) === swiper.activeIndex;\n    const isVisible = swiper.params.watchSlidesProgress && swiper.visibleSlides && swiper.visibleSlides.includes(slideEl);\n    if (isActive || isVisible) return;\n    if (e.sourceCapabilities && e.sourceCapabilities.firesTouchEvents) return;\n    if (swiper.isHorizontal()) {\n      swiper.el.scrollLeft = 0;\n    } else {\n      swiper.el.scrollTop = 0;\n    }\n    swiper.slideTo(swiper.slides.indexOf(slideEl), 0);\n  };\n  const initSlides = () => {\n    const params = swiper.params.a11y;\n    if (params.itemRoleDescriptionMessage) {\n      addElRoleDescription(swiper.slides, params.itemRoleDescriptionMessage);\n    }\n    if (params.slideRole) {\n      addElRole(swiper.slides, params.slideRole);\n    }\n    const slidesLength = swiper.slides.length;\n    if (params.slideLabelMessage) {\n      swiper.slides.forEach((slideEl, index) => {\n        const slideIndex = swiper.params.loop ? parseInt(slideEl.getAttribute('data-swiper-slide-index'), 10) : index;\n        const ariaLabelMessage = params.slideLabelMessage.replace(/\\{\\{index\\}\\}/, slideIndex + 1).replace(/\\{\\{slidesLength\\}\\}/, slidesLength);\n        addElLabel(slideEl, ariaLabelMessage);\n      });\n    }\n  };\n  const init = () => {\n    const params = swiper.params.a11y;\n    if (swiper.isElement) {\n      swiper.el.shadowEl.append(liveRegion);\n    } else {\n      swiper.el.append(liveRegion);\n    }\n\n    // Container\n    const containerEl = swiper.el;\n    if (params.containerRoleDescriptionMessage) {\n      addElRoleDescription(containerEl, params.containerRoleDescriptionMessage);\n    }\n    if (params.containerMessage) {\n      addElLabel(containerEl, params.containerMessage);\n    }\n\n    // Wrapper\n    const wrapperEl = swiper.wrapperEl;\n    const wrapperId = params.id || wrapperEl.getAttribute('id') || `swiper-wrapper-${getRandomNumber(16)}`;\n    const live = swiper.params.autoplay && swiper.params.autoplay.enabled ? 'off' : 'polite';\n    addElId(wrapperEl, wrapperId);\n    addElLive(wrapperEl, live);\n\n    // Slide\n    initSlides();\n\n    // Navigation\n    let {\n      nextEl,\n      prevEl\n    } = swiper.navigation ? swiper.navigation : {};\n    nextEl = makeElementsArray(nextEl);\n    prevEl = makeElementsArray(prevEl);\n    if (nextEl) {\n      nextEl.forEach(el => initNavEl(el, wrapperId, params.nextSlideMessage));\n    }\n    if (prevEl) {\n      prevEl.forEach(el => initNavEl(el, wrapperId, params.prevSlideMessage));\n    }\n\n    // Pagination\n    if (hasClickablePagination()) {\n      const paginationEl = Array.isArray(swiper.pagination.el) ? swiper.pagination.el : [swiper.pagination.el];\n      paginationEl.forEach(el => {\n        el.addEventListener('keydown', onEnterOrSpaceKey);\n      });\n    }\n\n    // Tab focus\n    swiper.el.addEventListener('focus', handleFocus, true);\n    swiper.el.addEventListener('pointerdown', handlePointerDown, true);\n    swiper.el.addEventListener('pointerup', handlePointerUp, true);\n  };\n  function destroy() {\n    if (liveRegion) liveRegion.remove();\n    let {\n      nextEl,\n      prevEl\n    } = swiper.navigation ? swiper.navigation : {};\n    nextEl = makeElementsArray(nextEl);\n    prevEl = makeElementsArray(prevEl);\n    if (nextEl) {\n      nextEl.forEach(el => el.removeEventListener('keydown', onEnterOrSpaceKey));\n    }\n    if (prevEl) {\n      prevEl.forEach(el => el.removeEventListener('keydown', onEnterOrSpaceKey));\n    }\n\n    // Pagination\n    if (hasClickablePagination()) {\n      const paginationEl = Array.isArray(swiper.pagination.el) ? swiper.pagination.el : [swiper.pagination.el];\n      paginationEl.forEach(el => {\n        el.removeEventListener('keydown', onEnterOrSpaceKey);\n      });\n    }\n\n    // Tab focus\n    swiper.el.removeEventListener('focus', handleFocus, true);\n    swiper.el.removeEventListener('pointerdown', handlePointerDown, true);\n    swiper.el.removeEventListener('pointerup', handlePointerUp, true);\n  }\n  on('beforeInit', () => {\n    liveRegion = createElement('span', swiper.params.a11y.notificationClass);\n    liveRegion.setAttribute('aria-live', 'assertive');\n    liveRegion.setAttribute('aria-atomic', 'true');\n  });\n  on('afterInit', () => {\n    if (!swiper.params.a11y.enabled) return;\n    init();\n  });\n  on('slidesLengthChange snapGridLengthChange slidesGridLengthChange', () => {\n    if (!swiper.params.a11y.enabled) return;\n    initSlides();\n  });\n  on('fromEdge toEdge afterInit lock unlock', () => {\n    if (!swiper.params.a11y.enabled) return;\n    updateNavigation();\n  });\n  on('paginationUpdate', () => {\n    if (!swiper.params.a11y.enabled) return;\n    updatePagination();\n  });\n  on('destroy', () => {\n    if (!swiper.params.a11y.enabled) return;\n    destroy();\n  });\n}","import { getWindow } from 'ssr-window';\nexport default function History({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    history: {\n      enabled: false,\n      root: '',\n      replaceState: false,\n      key: 'slides',\n      keepQuery: false\n    }\n  });\n  let initialized = false;\n  let paths = {};\n  const slugify = text => {\n    return text.toString().replace(/\\s+/g, '-').replace(/[^\\w-]+/g, '').replace(/--+/g, '-').replace(/^-+/, '').replace(/-+$/, '');\n  };\n  const getPathValues = urlOverride => {\n    const window = getWindow();\n    let location;\n    if (urlOverride) {\n      location = new URL(urlOverride);\n    } else {\n      location = window.location;\n    }\n    const pathArray = location.pathname.slice(1).split('/').filter(part => part !== '');\n    const total = pathArray.length;\n    const key = pathArray[total - 2];\n    const value = pathArray[total - 1];\n    return {\n      key,\n      value\n    };\n  };\n  const setHistory = (key, index) => {\n    const window = getWindow();\n    if (!initialized || !swiper.params.history.enabled) return;\n    let location;\n    if (swiper.params.url) {\n      location = new URL(swiper.params.url);\n    } else {\n      location = window.location;\n    }\n    const slide = swiper.slides[index];\n    let value = slugify(slide.getAttribute('data-history'));\n    if (swiper.params.history.root.length > 0) {\n      let root = swiper.params.history.root;\n      if (root[root.length - 1] === '/') root = root.slice(0, root.length - 1);\n      value = `${root}/${key ? `${key}/` : ''}${value}`;\n    } else if (!location.pathname.includes(key)) {\n      value = `${key ? `${key}/` : ''}${value}`;\n    }\n    if (swiper.params.history.keepQuery) {\n      value += location.search;\n    }\n    const currentState = window.history.state;\n    if (currentState && currentState.value === value) {\n      return;\n    }\n    if (swiper.params.history.replaceState) {\n      window.history.replaceState({\n        value\n      }, null, value);\n    } else {\n      window.history.pushState({\n        value\n      }, null, value);\n    }\n  };\n  const scrollToSlide = (speed, value, runCallbacks) => {\n    if (value) {\n      for (let i = 0, length = swiper.slides.length; i < length; i += 1) {\n        const slide = swiper.slides[i];\n        const slideHistory = slugify(slide.getAttribute('data-history'));\n        if (slideHistory === value) {\n          const index = swiper.getSlideIndex(slide);\n          swiper.slideTo(index, speed, runCallbacks);\n        }\n      }\n    } else {\n      swiper.slideTo(0, speed, runCallbacks);\n    }\n  };\n  const setHistoryPopState = () => {\n    paths = getPathValues(swiper.params.url);\n    scrollToSlide(swiper.params.speed, paths.value, false);\n  };\n  const init = () => {\n    const window = getWindow();\n    if (!swiper.params.history) return;\n    if (!window.history || !window.history.pushState) {\n      swiper.params.history.enabled = false;\n      swiper.params.hashNavigation.enabled = true;\n      return;\n    }\n    initialized = true;\n    paths = getPathValues(swiper.params.url);\n    if (!paths.key && !paths.value) {\n      if (!swiper.params.history.replaceState) {\n        window.addEventListener('popstate', setHistoryPopState);\n      }\n      return;\n    }\n    scrollToSlide(0, paths.value, swiper.params.runCallbacksOnInit);\n    if (!swiper.params.history.replaceState) {\n      window.addEventListener('popstate', setHistoryPopState);\n    }\n  };\n  const destroy = () => {\n    const window = getWindow();\n    if (!swiper.params.history.replaceState) {\n      window.removeEventListener('popstate', setHistoryPopState);\n    }\n  };\n  on('init', () => {\n    if (swiper.params.history.enabled) {\n      init();\n    }\n  });\n  on('destroy', () => {\n    if (swiper.params.history.enabled) {\n      destroy();\n    }\n  });\n  on('transitionEnd _freeModeNoMomentumRelease', () => {\n    if (initialized) {\n      setHistory(swiper.params.history.key, swiper.activeIndex);\n    }\n  });\n  on('slideChange', () => {\n    if (initialized && swiper.params.cssMode) {\n      setHistory(swiper.params.history.key, swiper.activeIndex);\n    }\n  });\n}","import { getWindow, getDocument } from 'ssr-window';\nimport { elementChildren } from '../../shared/utils.js';\nexport default function HashNavigation({\n  swiper,\n  extendParams,\n  emit,\n  on\n}) {\n  let initialized = false;\n  const document = getDocument();\n  const window = getWindow();\n  extendParams({\n    hashNavigation: {\n      enabled: false,\n      replaceState: false,\n      watchState: false,\n      getSlideIndex(_s, hash) {\n        if (swiper.virtual && swiper.params.virtual.enabled) {\n          const slideWithHash = swiper.slides.filter(slideEl => slideEl.getAttribute('data-hash') === hash)[0];\n          if (!slideWithHash) return 0;\n          const index = parseInt(slideWithHash.getAttribute('data-swiper-slide-index'), 10);\n          return index;\n        }\n        return swiper.getSlideIndex(elementChildren(swiper.slidesEl, `.${swiper.params.slideClass}[data-hash=\"${hash}\"], swiper-slide[data-hash=\"${hash}\"]`)[0]);\n      }\n    }\n  });\n  const onHashChange = () => {\n    emit('hashChange');\n    const newHash = document.location.hash.replace('#', '');\n    const activeSlideEl = swiper.virtual && swiper.params.virtual.enabled ? swiper.slidesEl.querySelector(`[data-swiper-slide-index=\"${swiper.activeIndex}\"]`) : swiper.slides[swiper.activeIndex];\n    const activeSlideHash = activeSlideEl ? activeSlideEl.getAttribute('data-hash') : '';\n    if (newHash !== activeSlideHash) {\n      const newIndex = swiper.params.hashNavigation.getSlideIndex(swiper, newHash);\n      if (typeof newIndex === 'undefined' || Number.isNaN(newIndex)) return;\n      swiper.slideTo(newIndex);\n    }\n  };\n  const setHash = () => {\n    if (!initialized || !swiper.params.hashNavigation.enabled) return;\n    const activeSlideEl = swiper.virtual && swiper.params.virtual.enabled ? swiper.slidesEl.querySelector(`[data-swiper-slide-index=\"${swiper.activeIndex}\"]`) : swiper.slides[swiper.activeIndex];\n    const activeSlideHash = activeSlideEl ? activeSlideEl.getAttribute('data-hash') || activeSlideEl.getAttribute('data-history') : '';\n    if (swiper.params.hashNavigation.replaceState && window.history && window.history.replaceState) {\n      window.history.replaceState(null, null, `#${activeSlideHash}` || '');\n      emit('hashSet');\n    } else {\n      document.location.hash = activeSlideHash || '';\n      emit('hashSet');\n    }\n  };\n  const init = () => {\n    if (!swiper.params.hashNavigation.enabled || swiper.params.history && swiper.params.history.enabled) return;\n    initialized = true;\n    const hash = document.location.hash.replace('#', '');\n    if (hash) {\n      const speed = 0;\n      const index = swiper.params.hashNavigation.getSlideIndex(swiper, hash);\n      swiper.slideTo(index || 0, speed, swiper.params.runCallbacksOnInit, true);\n    }\n    if (swiper.params.hashNavigation.watchState) {\n      window.addEventListener('hashchange', onHashChange);\n    }\n  };\n  const destroy = () => {\n    if (swiper.params.hashNavigation.watchState) {\n      window.removeEventListener('hashchange', onHashChange);\n    }\n  };\n  on('init', () => {\n    if (swiper.params.hashNavigation.enabled) {\n      init();\n    }\n  });\n  on('destroy', () => {\n    if (swiper.params.hashNavigation.enabled) {\n      destroy();\n    }\n  });\n  on('transitionEnd _freeModeNoMomentumRelease', () => {\n    if (initialized) {\n      setHash();\n    }\n  });\n  on('slideChange', () => {\n    if (initialized && swiper.params.cssMode) {\n      setHash();\n    }\n  });\n}","/* eslint no-underscore-dangle: \"off\" */\n/* eslint no-use-before-define: \"off\" */\nimport { getDocument } from 'ssr-window';\nexport default function Autoplay({\n  swiper,\n  extendParams,\n  on,\n  emit,\n  params\n}) {\n  swiper.autoplay = {\n    running: false,\n    paused: false,\n    timeLeft: 0\n  };\n  extendParams({\n    autoplay: {\n      enabled: false,\n      delay: 3000,\n      waitForTransition: true,\n      disableOnInteraction: true,\n      stopOnLastSlide: false,\n      reverseDirection: false,\n      pauseOnMouseEnter: false\n    }\n  });\n  let timeout;\n  let raf;\n  let autoplayDelayTotal = params && params.autoplay ? params.autoplay.delay : 3000;\n  let autoplayDelayCurrent = params && params.autoplay ? params.autoplay.delay : 3000;\n  let autoplayTimeLeft;\n  let autoplayStartTime = new Date().getTime;\n  let wasPaused;\n  let isTouched;\n  let pausedByTouch;\n  let touchStartTimeout;\n  let slideChanged;\n  let pausedByInteraction;\n  function onTransitionEnd(e) {\n    if (!swiper || swiper.destroyed || !swiper.wrapperEl) return;\n    if (e.target !== swiper.wrapperEl) return;\n    swiper.wrapperEl.removeEventListener('transitionend', onTransitionEnd);\n    resume();\n  }\n  const calcTimeLeft = () => {\n    if (swiper.destroyed || !swiper.autoplay.running) return;\n    if (swiper.autoplay.paused) {\n      wasPaused = true;\n    } else if (wasPaused) {\n      autoplayDelayCurrent = autoplayTimeLeft;\n      wasPaused = false;\n    }\n    const timeLeft = swiper.autoplay.paused ? autoplayTimeLeft : autoplayStartTime + autoplayDelayCurrent - new Date().getTime();\n    swiper.autoplay.timeLeft = timeLeft;\n    emit('autoplayTimeLeft', timeLeft, timeLeft / autoplayDelayTotal);\n    raf = requestAnimationFrame(() => {\n      calcTimeLeft();\n    });\n  };\n  const getSlideDelay = () => {\n    let activeSlideEl;\n    if (swiper.virtual && swiper.params.virtual.enabled) {\n      activeSlideEl = swiper.slides.filter(slideEl => slideEl.classList.contains('swiper-slide-active'))[0];\n    } else {\n      activeSlideEl = swiper.slides[swiper.activeIndex];\n    }\n    if (!activeSlideEl) return undefined;\n    const currentSlideDelay = parseInt(activeSlideEl.getAttribute('data-swiper-autoplay'), 10);\n    return currentSlideDelay;\n  };\n  const run = delayForce => {\n    if (swiper.destroyed || !swiper.autoplay.running) return;\n    cancelAnimationFrame(raf);\n    calcTimeLeft();\n    let delay = typeof delayForce === 'undefined' ? swiper.params.autoplay.delay : delayForce;\n    autoplayDelayTotal = swiper.params.autoplay.delay;\n    autoplayDelayCurrent = swiper.params.autoplay.delay;\n    const currentSlideDelay = getSlideDelay();\n    if (!Number.isNaN(currentSlideDelay) && currentSlideDelay > 0 && typeof delayForce === 'undefined') {\n      delay = currentSlideDelay;\n      autoplayDelayTotal = currentSlideDelay;\n      autoplayDelayCurrent = currentSlideDelay;\n    }\n    autoplayTimeLeft = delay;\n    const speed = swiper.params.speed;\n    const proceed = () => {\n      if (!swiper || swiper.destroyed) return;\n      if (swiper.params.autoplay.reverseDirection) {\n        if (!swiper.isBeginning || swiper.params.loop || swiper.params.rewind) {\n          swiper.slidePrev(speed, true, true);\n          emit('autoplay');\n        } else if (!swiper.params.autoplay.stopOnLastSlide) {\n          swiper.slideTo(swiper.slides.length - 1, speed, true, true);\n          emit('autoplay');\n        }\n      } else {\n        if (!swiper.isEnd || swiper.params.loop || swiper.params.rewind) {\n          swiper.slideNext(speed, true, true);\n          emit('autoplay');\n        } else if (!swiper.params.autoplay.stopOnLastSlide) {\n          swiper.slideTo(0, speed, true, true);\n          emit('autoplay');\n        }\n      }\n      if (swiper.params.cssMode) {\n        autoplayStartTime = new Date().getTime();\n        requestAnimationFrame(() => {\n          run();\n        });\n      }\n    };\n    if (delay > 0) {\n      clearTimeout(timeout);\n      timeout = setTimeout(() => {\n        proceed();\n      }, delay);\n    } else {\n      requestAnimationFrame(() => {\n        proceed();\n      });\n    }\n\n    // eslint-disable-next-line\n    return delay;\n  };\n  const start = () => {\n    swiper.autoplay.running = true;\n    run();\n    emit('autoplayStart');\n  };\n  const stop = () => {\n    swiper.autoplay.running = false;\n    clearTimeout(timeout);\n    cancelAnimationFrame(raf);\n    emit('autoplayStop');\n  };\n  const pause = (internal, reset) => {\n    if (swiper.destroyed || !swiper.autoplay.running) return;\n    clearTimeout(timeout);\n    if (!internal) {\n      pausedByInteraction = true;\n    }\n    const proceed = () => {\n      emit('autoplayPause');\n      if (swiper.params.autoplay.waitForTransition) {\n        swiper.wrapperEl.addEventListener('transitionend', onTransitionEnd);\n      } else {\n        resume();\n      }\n    };\n    swiper.autoplay.paused = true;\n    if (reset) {\n      if (slideChanged) {\n        autoplayTimeLeft = swiper.params.autoplay.delay;\n      }\n      slideChanged = false;\n      proceed();\n      return;\n    }\n    const delay = autoplayTimeLeft || swiper.params.autoplay.delay;\n    autoplayTimeLeft = delay - (new Date().getTime() - autoplayStartTime);\n    if (swiper.isEnd && autoplayTimeLeft < 0 && !swiper.params.loop) return;\n    if (autoplayTimeLeft < 0) autoplayTimeLeft = 0;\n    proceed();\n  };\n  const resume = () => {\n    if (swiper.isEnd && autoplayTimeLeft < 0 && !swiper.params.loop || swiper.destroyed || !swiper.autoplay.running) return;\n    autoplayStartTime = new Date().getTime();\n    if (pausedByInteraction) {\n      pausedByInteraction = false;\n      run(autoplayTimeLeft);\n    } else {\n      run();\n    }\n    swiper.autoplay.paused = false;\n    emit('autoplayResume');\n  };\n  const onVisibilityChange = () => {\n    if (swiper.destroyed || !swiper.autoplay.running) return;\n    const document = getDocument();\n    if (document.visibilityState === 'hidden') {\n      pausedByInteraction = true;\n      pause(true);\n    }\n    if (document.visibilityState === 'visible') {\n      resume();\n    }\n  };\n  const onPointerEnter = e => {\n    if (e.pointerType !== 'mouse') return;\n    pausedByInteraction = true;\n    pause(true);\n  };\n  const onPointerLeave = e => {\n    if (e.pointerType !== 'mouse') return;\n    if (swiper.autoplay.paused) {\n      resume();\n    }\n  };\n  const attachMouseEvents = () => {\n    if (swiper.params.autoplay.pauseOnMouseEnter) {\n      swiper.el.addEventListener('pointerenter', onPointerEnter);\n      swiper.el.addEventListener('pointerleave', onPointerLeave);\n    }\n  };\n  const detachMouseEvents = () => {\n    swiper.el.removeEventListener('pointerenter', onPointerEnter);\n    swiper.el.removeEventListener('pointerleave', onPointerLeave);\n  };\n  const attachDocumentEvents = () => {\n    const document = getDocument();\n    document.addEventListener('visibilitychange', onVisibilityChange);\n  };\n  const detachDocumentEvents = () => {\n    const document = getDocument();\n    document.removeEventListener('visibilitychange', onVisibilityChange);\n  };\n  on('init', () => {\n    if (swiper.params.autoplay.enabled) {\n      attachMouseEvents();\n      attachDocumentEvents();\n      autoplayStartTime = new Date().getTime();\n      start();\n    }\n  });\n  on('destroy', () => {\n    detachMouseEvents();\n    detachDocumentEvents();\n    if (swiper.autoplay.running) {\n      stop();\n    }\n  });\n  on('beforeTransitionStart', (_s, speed, internal) => {\n    if (swiper.destroyed || !swiper.autoplay.running) return;\n    if (internal || !swiper.params.autoplay.disableOnInteraction) {\n      pause(true, true);\n    } else {\n      stop();\n    }\n  });\n  on('sliderFirstMove', () => {\n    if (swiper.destroyed || !swiper.autoplay.running) return;\n    if (swiper.params.autoplay.disableOnInteraction) {\n      stop();\n      return;\n    }\n    isTouched = true;\n    pausedByTouch = false;\n    pausedByInteraction = false;\n    touchStartTimeout = setTimeout(() => {\n      pausedByInteraction = true;\n      pausedByTouch = true;\n      pause(true);\n    }, 200);\n  });\n  on('touchEnd', () => {\n    if (swiper.destroyed || !swiper.autoplay.running || !isTouched) return;\n    clearTimeout(touchStartTimeout);\n    clearTimeout(timeout);\n    if (swiper.params.autoplay.disableOnInteraction) {\n      pausedByTouch = false;\n      isTouched = false;\n      return;\n    }\n    if (pausedByTouch && swiper.params.cssMode) resume();\n    pausedByTouch = false;\n    isTouched = false;\n  });\n  on('slideChange', () => {\n    if (swiper.destroyed || !swiper.autoplay.running) return;\n    slideChanged = true;\n  });\n  Object.assign(swiper.autoplay, {\n    start,\n    stop,\n    pause,\n    resume\n  });\n}","import { getDocument } from 'ssr-window';\nimport { elementChildren, isObject } from '../../shared/utils.js';\nexport default function Thumb({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    thumbs: {\n      swiper: null,\n      multipleActiveThumbs: true,\n      autoScrollOffset: 0,\n      slideThumbActiveClass: 'swiper-slide-thumb-active',\n      thumbsContainerClass: 'swiper-thumbs'\n    }\n  });\n  let initialized = false;\n  let swiperCreated = false;\n  swiper.thumbs = {\n    swiper: null\n  };\n  function onThumbClick() {\n    const thumbsSwiper = swiper.thumbs.swiper;\n    if (!thumbsSwiper || thumbsSwiper.destroyed) return;\n    const clickedIndex = thumbsSwiper.clickedIndex;\n    const clickedSlide = thumbsSwiper.clickedSlide;\n    if (clickedSlide && clickedSlide.classList.contains(swiper.params.thumbs.slideThumbActiveClass)) return;\n    if (typeof clickedIndex === 'undefined' || clickedIndex === null) return;\n    let slideToIndex;\n    if (thumbsSwiper.params.loop) {\n      slideToIndex = parseInt(thumbsSwiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);\n    } else {\n      slideToIndex = clickedIndex;\n    }\n    if (swiper.params.loop) {\n      swiper.slideToLoop(slideToIndex);\n    } else {\n      swiper.slideTo(slideToIndex);\n    }\n  }\n  function init() {\n    const {\n      thumbs: thumbsParams\n    } = swiper.params;\n    if (initialized) return false;\n    initialized = true;\n    const SwiperClass = swiper.constructor;\n    if (thumbsParams.swiper instanceof SwiperClass) {\n      swiper.thumbs.swiper = thumbsParams.swiper;\n      Object.assign(swiper.thumbs.swiper.originalParams, {\n        watchSlidesProgress: true,\n        slideToClickedSlide: false\n      });\n      Object.assign(swiper.thumbs.swiper.params, {\n        watchSlidesProgress: true,\n        slideToClickedSlide: false\n      });\n      swiper.thumbs.swiper.update();\n    } else if (isObject(thumbsParams.swiper)) {\n      const thumbsSwiperParams = Object.assign({}, thumbsParams.swiper);\n      Object.assign(thumbsSwiperParams, {\n        watchSlidesProgress: true,\n        slideToClickedSlide: false\n      });\n      swiper.thumbs.swiper = new SwiperClass(thumbsSwiperParams);\n      swiperCreated = true;\n    }\n    swiper.thumbs.swiper.el.classList.add(swiper.params.thumbs.thumbsContainerClass);\n    swiper.thumbs.swiper.on('tap', onThumbClick);\n    return true;\n  }\n  function update(initial) {\n    const thumbsSwiper = swiper.thumbs.swiper;\n    if (!thumbsSwiper || thumbsSwiper.destroyed) return;\n    const slidesPerView = thumbsSwiper.params.slidesPerView === 'auto' ? thumbsSwiper.slidesPerViewDynamic() : thumbsSwiper.params.slidesPerView;\n\n    // Activate thumbs\n    let thumbsToActivate = 1;\n    const thumbActiveClass = swiper.params.thumbs.slideThumbActiveClass;\n    if (swiper.params.slidesPerView > 1 && !swiper.params.centeredSlides) {\n      thumbsToActivate = swiper.params.slidesPerView;\n    }\n    if (!swiper.params.thumbs.multipleActiveThumbs) {\n      thumbsToActivate = 1;\n    }\n    thumbsToActivate = Math.floor(thumbsToActivate);\n    thumbsSwiper.slides.forEach(slideEl => slideEl.classList.remove(thumbActiveClass));\n    if (thumbsSwiper.params.loop || thumbsSwiper.params.virtual && thumbsSwiper.params.virtual.enabled) {\n      for (let i = 0; i < thumbsToActivate; i += 1) {\n        elementChildren(thumbsSwiper.slidesEl, `[data-swiper-slide-index=\"${swiper.realIndex + i}\"]`).forEach(slideEl => {\n          slideEl.classList.add(thumbActiveClass);\n        });\n      }\n    } else {\n      for (let i = 0; i < thumbsToActivate; i += 1) {\n        if (thumbsSwiper.slides[swiper.realIndex + i]) {\n          thumbsSwiper.slides[swiper.realIndex + i].classList.add(thumbActiveClass);\n        }\n      }\n    }\n    const autoScrollOffset = swiper.params.thumbs.autoScrollOffset;\n    const useOffset = autoScrollOffset && !thumbsSwiper.params.loop;\n    if (swiper.realIndex !== thumbsSwiper.realIndex || useOffset) {\n      const currentThumbsIndex = thumbsSwiper.activeIndex;\n      let newThumbsIndex;\n      let direction;\n      if (thumbsSwiper.params.loop) {\n        const newThumbsSlide = thumbsSwiper.slides.filter(slideEl => slideEl.getAttribute('data-swiper-slide-index') === `${swiper.realIndex}`)[0];\n        newThumbsIndex = thumbsSwiper.slides.indexOf(newThumbsSlide);\n        direction = swiper.activeIndex > swiper.previousIndex ? 'next' : 'prev';\n      } else {\n        newThumbsIndex = swiper.realIndex;\n        direction = newThumbsIndex > swiper.previousIndex ? 'next' : 'prev';\n      }\n      if (useOffset) {\n        newThumbsIndex += direction === 'next' ? autoScrollOffset : -1 * autoScrollOffset;\n      }\n      if (thumbsSwiper.visibleSlidesIndexes && thumbsSwiper.visibleSlidesIndexes.indexOf(newThumbsIndex) < 0) {\n        if (thumbsSwiper.params.centeredSlides) {\n          if (newThumbsIndex > currentThumbsIndex) {\n            newThumbsIndex = newThumbsIndex - Math.floor(slidesPerView / 2) + 1;\n          } else {\n            newThumbsIndex = newThumbsIndex + Math.floor(slidesPerView / 2) - 1;\n          }\n        } else if (newThumbsIndex > currentThumbsIndex && thumbsSwiper.params.slidesPerGroup === 1) {\n          // newThumbsIndex = newThumbsIndex - slidesPerView + 1;\n        }\n        thumbsSwiper.slideTo(newThumbsIndex, initial ? 0 : undefined);\n      }\n    }\n  }\n  on('beforeInit', () => {\n    const {\n      thumbs\n    } = swiper.params;\n    if (!thumbs || !thumbs.swiper) return;\n    if (typeof thumbs.swiper === 'string' || thumbs.swiper instanceof HTMLElement) {\n      const document = getDocument();\n      const getThumbsElementAndInit = () => {\n        const thumbsElement = typeof thumbs.swiper === 'string' ? document.querySelector(thumbs.swiper) : thumbs.swiper;\n        if (thumbsElement && thumbsElement.swiper) {\n          thumbs.swiper = thumbsElement.swiper;\n          init();\n          update(true);\n        } else if (thumbsElement) {\n          const onThumbsSwiper = e => {\n            thumbs.swiper = e.detail[0];\n            thumbsElement.removeEventListener('init', onThumbsSwiper);\n            init();\n            update(true);\n            thumbs.swiper.update();\n            swiper.update();\n          };\n          thumbsElement.addEventListener('init', onThumbsSwiper);\n        }\n        return thumbsElement;\n      };\n      const watchForThumbsToAppear = () => {\n        if (swiper.destroyed) return;\n        const thumbsElement = getThumbsElementAndInit();\n        if (!thumbsElement) {\n          requestAnimationFrame(watchForThumbsToAppear);\n        }\n      };\n      requestAnimationFrame(watchForThumbsToAppear);\n    } else {\n      init();\n      update(true);\n    }\n  });\n  on('slideChange update resize observerUpdate', () => {\n    update();\n  });\n  on('setTransition', (_s, duration) => {\n    const thumbsSwiper = swiper.thumbs.swiper;\n    if (!thumbsSwiper || thumbsSwiper.destroyed) return;\n    thumbsSwiper.setTransition(duration);\n  });\n  on('beforeDestroy', () => {\n    const thumbsSwiper = swiper.thumbs.swiper;\n    if (!thumbsSwiper || thumbsSwiper.destroyed) return;\n    if (swiperCreated) {\n      thumbsSwiper.destroy();\n    }\n  });\n  Object.assign(swiper.thumbs, {\n    init,\n    update\n  });\n}","import { elementTransitionEnd, now } from '../../shared/utils.js';\nexport default function freeMode({\n  swiper,\n  extendParams,\n  emit,\n  once\n}) {\n  extendParams({\n    freeMode: {\n      enabled: false,\n      momentum: true,\n      momentumRatio: 1,\n      momentumBounce: true,\n      momentumBounceRatio: 1,\n      momentumVelocityRatio: 1,\n      sticky: false,\n      minimumVelocity: 0.02\n    }\n  });\n  function onTouchStart() {\n    if (swiper.params.cssMode) return;\n    const translate = swiper.getTranslate();\n    swiper.setTranslate(translate);\n    swiper.setTransition(0);\n    swiper.touchEventsData.velocities.length = 0;\n    swiper.freeMode.onTouchEnd({\n      currentPos: swiper.rtl ? swiper.translate : -swiper.translate\n    });\n  }\n  function onTouchMove() {\n    if (swiper.params.cssMode) return;\n    const {\n      touchEventsData: data,\n      touches\n    } = swiper;\n    // Velocity\n    if (data.velocities.length === 0) {\n      data.velocities.push({\n        position: touches[swiper.isHorizontal() ? 'startX' : 'startY'],\n        time: data.touchStartTime\n      });\n    }\n    data.velocities.push({\n      position: touches[swiper.isHorizontal() ? 'currentX' : 'currentY'],\n      time: now()\n    });\n  }\n  function onTouchEnd({\n    currentPos\n  }) {\n    if (swiper.params.cssMode) return;\n    const {\n      params,\n      wrapperEl,\n      rtlTranslate: rtl,\n      snapGrid,\n      touchEventsData: data\n    } = swiper;\n    // Time diff\n    const touchEndTime = now();\n    const timeDiff = touchEndTime - data.touchStartTime;\n    if (currentPos < -swiper.minTranslate()) {\n      swiper.slideTo(swiper.activeIndex);\n      return;\n    }\n    if (currentPos > -swiper.maxTranslate()) {\n      if (swiper.slides.length < snapGrid.length) {\n        swiper.slideTo(snapGrid.length - 1);\n      } else {\n        swiper.slideTo(swiper.slides.length - 1);\n      }\n      return;\n    }\n    if (params.freeMode.momentum) {\n      if (data.velocities.length > 1) {\n        const lastMoveEvent = data.velocities.pop();\n        const velocityEvent = data.velocities.pop();\n        const distance = lastMoveEvent.position - velocityEvent.position;\n        const time = lastMoveEvent.time - velocityEvent.time;\n        swiper.velocity = distance / time;\n        swiper.velocity /= 2;\n        if (Math.abs(swiper.velocity) < params.freeMode.minimumVelocity) {\n          swiper.velocity = 0;\n        }\n        // this implies that the user stopped moving a finger then released.\n        // There would be no events with distance zero, so the last event is stale.\n        if (time > 150 || now() - lastMoveEvent.time > 300) {\n          swiper.velocity = 0;\n        }\n      } else {\n        swiper.velocity = 0;\n      }\n      swiper.velocity *= params.freeMode.momentumVelocityRatio;\n      data.velocities.length = 0;\n      let momentumDuration = 1000 * params.freeMode.momentumRatio;\n      const momentumDistance = swiper.velocity * momentumDuration;\n      let newPosition = swiper.translate + momentumDistance;\n      if (rtl) newPosition = -newPosition;\n      let doBounce = false;\n      let afterBouncePosition;\n      const bounceAmount = Math.abs(swiper.velocity) * 20 * params.freeMode.momentumBounceRatio;\n      let needsLoopFix;\n      if (newPosition < swiper.maxTranslate()) {\n        if (params.freeMode.momentumBounce) {\n          if (newPosition + swiper.maxTranslate() < -bounceAmount) {\n            newPosition = swiper.maxTranslate() - bounceAmount;\n          }\n          afterBouncePosition = swiper.maxTranslate();\n          doBounce = true;\n          data.allowMomentumBounce = true;\n        } else {\n          newPosition = swiper.maxTranslate();\n        }\n        if (params.loop && params.centeredSlides) needsLoopFix = true;\n      } else if (newPosition > swiper.minTranslate()) {\n        if (params.freeMode.momentumBounce) {\n          if (newPosition - swiper.minTranslate() > bounceAmount) {\n            newPosition = swiper.minTranslate() + bounceAmount;\n          }\n          afterBouncePosition = swiper.minTranslate();\n          doBounce = true;\n          data.allowMomentumBounce = true;\n        } else {\n          newPosition = swiper.minTranslate();\n        }\n        if (params.loop && params.centeredSlides) needsLoopFix = true;\n      } else if (params.freeMode.sticky) {\n        let nextSlide;\n        for (let j = 0; j < snapGrid.length; j += 1) {\n          if (snapGrid[j] > -newPosition) {\n            nextSlide = j;\n            break;\n          }\n        }\n        if (Math.abs(snapGrid[nextSlide] - newPosition) < Math.abs(snapGrid[nextSlide - 1] - newPosition) || swiper.swipeDirection === 'next') {\n          newPosition = snapGrid[nextSlide];\n        } else {\n          newPosition = snapGrid[nextSlide - 1];\n        }\n        newPosition = -newPosition;\n      }\n      if (needsLoopFix) {\n        once('transitionEnd', () => {\n          swiper.loopFix();\n        });\n      }\n      // Fix duration\n      if (swiper.velocity !== 0) {\n        if (rtl) {\n          momentumDuration = Math.abs((-newPosition - swiper.translate) / swiper.velocity);\n        } else {\n          momentumDuration = Math.abs((newPosition - swiper.translate) / swiper.velocity);\n        }\n        if (params.freeMode.sticky) {\n          // If freeMode.sticky is active and the user ends a swipe with a slow-velocity\n          // event, then durations can be 20+ seconds to slide one (or zero!) slides.\n          // It's easy to see this when simulating touch with mouse events. To fix this,\n          // limit single-slide swipes to the default slide duration. This also has the\n          // nice side effect of matching slide speed if the user stopped moving before\n          // lifting finger or mouse vs. moving slowly before lifting the finger/mouse.\n          // For faster swipes, also apply limits (albeit higher ones).\n          const moveDistance = Math.abs((rtl ? -newPosition : newPosition) - swiper.translate);\n          const currentSlideSize = swiper.slidesSizesGrid[swiper.activeIndex];\n          if (moveDistance < currentSlideSize) {\n            momentumDuration = params.speed;\n          } else if (moveDistance < 2 * currentSlideSize) {\n            momentumDuration = params.speed * 1.5;\n          } else {\n            momentumDuration = params.speed * 2.5;\n          }\n        }\n      } else if (params.freeMode.sticky) {\n        swiper.slideToClosest();\n        return;\n      }\n      if (params.freeMode.momentumBounce && doBounce) {\n        swiper.updateProgress(afterBouncePosition);\n        swiper.setTransition(momentumDuration);\n        swiper.setTranslate(newPosition);\n        swiper.transitionStart(true, swiper.swipeDirection);\n        swiper.animating = true;\n        elementTransitionEnd(wrapperEl, () => {\n          if (!swiper || swiper.destroyed || !data.allowMomentumBounce) return;\n          emit('momentumBounce');\n          swiper.setTransition(params.speed);\n          setTimeout(() => {\n            swiper.setTranslate(afterBouncePosition);\n            elementTransitionEnd(wrapperEl, () => {\n              if (!swiper || swiper.destroyed) return;\n              swiper.transitionEnd();\n            });\n          }, 0);\n        });\n      } else if (swiper.velocity) {\n        emit('_freeModeNoMomentumRelease');\n        swiper.updateProgress(newPosition);\n        swiper.setTransition(momentumDuration);\n        swiper.setTranslate(newPosition);\n        swiper.transitionStart(true, swiper.swipeDirection);\n        if (!swiper.animating) {\n          swiper.animating = true;\n          elementTransitionEnd(wrapperEl, () => {\n            if (!swiper || swiper.destroyed) return;\n            swiper.transitionEnd();\n          });\n        }\n      } else {\n        swiper.updateProgress(newPosition);\n      }\n      swiper.updateActiveIndex();\n      swiper.updateSlidesClasses();\n    } else if (params.freeMode.sticky) {\n      swiper.slideToClosest();\n      return;\n    } else if (params.freeMode) {\n      emit('_freeModeNoMomentumRelease');\n    }\n    if (!params.freeMode.momentum || timeDiff >= params.longSwipesMs) {\n      swiper.updateProgress();\n      swiper.updateActiveIndex();\n      swiper.updateSlidesClasses();\n    }\n  }\n  Object.assign(swiper, {\n    freeMode: {\n      onTouchStart,\n      onTouchMove,\n      onTouchEnd\n    }\n  });\n}","export default function Grid({\n  swiper,\n  extendParams\n}) {\n  extendParams({\n    grid: {\n      rows: 1,\n      fill: 'column'\n    }\n  });\n  let slidesNumberEvenToRows;\n  let slidesPerRow;\n  let numFullColumns;\n  const getSpaceBetween = () => {\n    let spaceBetween = swiper.params.spaceBetween;\n    if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {\n      spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiper.size;\n    } else if (typeof spaceBetween === 'string') {\n      spaceBetween = parseFloat(spaceBetween);\n    }\n    return spaceBetween;\n  };\n  const initSlides = slidesLength => {\n    const {\n      slidesPerView\n    } = swiper.params;\n    const {\n      rows,\n      fill\n    } = swiper.params.grid;\n    numFullColumns = Math.floor(slidesLength / rows);\n    if (Math.floor(slidesLength / rows) === slidesLength / rows) {\n      slidesNumberEvenToRows = slidesLength;\n    } else {\n      slidesNumberEvenToRows = Math.ceil(slidesLength / rows) * rows;\n    }\n    if (slidesPerView !== 'auto' && fill === 'row') {\n      slidesNumberEvenToRows = Math.max(slidesNumberEvenToRows, slidesPerView * rows);\n    }\n    slidesPerRow = slidesNumberEvenToRows / rows;\n  };\n  const updateSlide = (i, slide, slidesLength, getDirectionLabel) => {\n    const {\n      slidesPerGroup\n    } = swiper.params;\n    const spaceBetween = getSpaceBetween();\n    const {\n      rows,\n      fill\n    } = swiper.params.grid;\n    // Set slides order\n    let newSlideOrderIndex;\n    let column;\n    let row;\n    if (fill === 'row' && slidesPerGroup > 1) {\n      const groupIndex = Math.floor(i / (slidesPerGroup * rows));\n      const slideIndexInGroup = i - rows * slidesPerGroup * groupIndex;\n      const columnsInGroup = groupIndex === 0 ? slidesPerGroup : Math.min(Math.ceil((slidesLength - groupIndex * rows * slidesPerGroup) / rows), slidesPerGroup);\n      row = Math.floor(slideIndexInGroup / columnsInGroup);\n      column = slideIndexInGroup - row * columnsInGroup + groupIndex * slidesPerGroup;\n      newSlideOrderIndex = column + row * slidesNumberEvenToRows / rows;\n      slide.style.order = newSlideOrderIndex;\n    } else if (fill === 'column') {\n      column = Math.floor(i / rows);\n      row = i - column * rows;\n      if (column > numFullColumns || column === numFullColumns && row === rows - 1) {\n        row += 1;\n        if (row >= rows) {\n          row = 0;\n          column += 1;\n        }\n      }\n    } else {\n      row = Math.floor(i / slidesPerRow);\n      column = i - row * slidesPerRow;\n    }\n    slide.row = row;\n    slide.column = column;\n    slide.style[getDirectionLabel('margin-top')] = row !== 0 ? spaceBetween && `${spaceBetween}px` : '';\n  };\n  const updateWrapperSize = (slideSize, snapGrid, getDirectionLabel) => {\n    const {\n      centeredSlides,\n      roundLengths\n    } = swiper.params;\n    const spaceBetween = getSpaceBetween();\n    const {\n      rows\n    } = swiper.params.grid;\n    swiper.virtualSize = (slideSize + spaceBetween) * slidesNumberEvenToRows;\n    swiper.virtualSize = Math.ceil(swiper.virtualSize / rows) - spaceBetween;\n    swiper.wrapperEl.style[getDirectionLabel('width')] = `${swiper.virtualSize + spaceBetween}px`;\n    if (centeredSlides) {\n      const newSlidesGrid = [];\n      for (let i = 0; i < snapGrid.length; i += 1) {\n        let slidesGridItem = snapGrid[i];\n        if (roundLengths) slidesGridItem = Math.floor(slidesGridItem);\n        if (snapGrid[i] < swiper.virtualSize + snapGrid[0]) newSlidesGrid.push(slidesGridItem);\n      }\n      snapGrid.splice(0, snapGrid.length);\n      snapGrid.push(...newSlidesGrid);\n    }\n  };\n  swiper.grid = {\n    initSlides,\n    updateSlide,\n    updateWrapperSize\n  };\n}","export default function appendSlide(slides) {\n  const swiper = this;\n  const {\n    params,\n    slidesEl\n  } = swiper;\n  if (params.loop) {\n    swiper.loopDestroy();\n  }\n  const appendElement = slideEl => {\n    if (typeof slideEl === 'string') {\n      const tempDOM = document.createElement('div');\n      tempDOM.innerHTML = slideEl;\n      slidesEl.append(tempDOM.children[0]);\n      tempDOM.innerHTML = '';\n    } else {\n      slidesEl.append(slideEl);\n    }\n  };\n  if (typeof slides === 'object' && 'length' in slides) {\n    for (let i = 0; i < slides.length; i += 1) {\n      if (slides[i]) appendElement(slides[i]);\n    }\n  } else {\n    appendElement(slides);\n  }\n  swiper.recalcSlides();\n  if (params.loop) {\n    swiper.loopCreate();\n  }\n  if (!params.observer || swiper.isElement) {\n    swiper.update();\n  }\n}","export default function prependSlide(slides) {\n  const swiper = this;\n  const {\n    params,\n    activeIndex,\n    slidesEl\n  } = swiper;\n  if (params.loop) {\n    swiper.loopDestroy();\n  }\n  let newActiveIndex = activeIndex + 1;\n  const prependElement = slideEl => {\n    if (typeof slideEl === 'string') {\n      const tempDOM = document.createElement('div');\n      tempDOM.innerHTML = slideEl;\n      slidesEl.prepend(tempDOM.children[0]);\n      tempDOM.innerHTML = '';\n    } else {\n      slidesEl.prepend(slideEl);\n    }\n  };\n  if (typeof slides === 'object' && 'length' in slides) {\n    for (let i = 0; i < slides.length; i += 1) {\n      if (slides[i]) prependElement(slides[i]);\n    }\n    newActiveIndex = activeIndex + slides.length;\n  } else {\n    prependElement(slides);\n  }\n  swiper.recalcSlides();\n  if (params.loop) {\n    swiper.loopCreate();\n  }\n  if (!params.observer || swiper.isElement) {\n    swiper.update();\n  }\n  swiper.slideTo(newActiveIndex, 0, false);\n}","export default function addSlide(index, slides) {\n  const swiper = this;\n  const {\n    params,\n    activeIndex,\n    slidesEl\n  } = swiper;\n  let activeIndexBuffer = activeIndex;\n  if (params.loop) {\n    activeIndexBuffer -= swiper.loopedSlides;\n    swiper.loopDestroy();\n    swiper.recalcSlides();\n  }\n  const baseLength = swiper.slides.length;\n  if (index <= 0) {\n    swiper.prependSlide(slides);\n    return;\n  }\n  if (index >= baseLength) {\n    swiper.appendSlide(slides);\n    return;\n  }\n  let newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + 1 : activeIndexBuffer;\n  const slidesBuffer = [];\n  for (let i = baseLength - 1; i >= index; i -= 1) {\n    const currentSlide = swiper.slides[i];\n    currentSlide.remove();\n    slidesBuffer.unshift(currentSlide);\n  }\n  if (typeof slides === 'object' && 'length' in slides) {\n    for (let i = 0; i < slides.length; i += 1) {\n      if (slides[i]) slidesEl.append(slides[i]);\n    }\n    newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + slides.length : activeIndexBuffer;\n  } else {\n    slidesEl.append(slides);\n  }\n  for (let i = 0; i < slidesBuffer.length; i += 1) {\n    slidesEl.append(slidesBuffer[i]);\n  }\n  swiper.recalcSlides();\n  if (params.loop) {\n    swiper.loopCreate();\n  }\n  if (!params.observer || swiper.isElement) {\n    swiper.update();\n  }\n  if (params.loop) {\n    swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);\n  } else {\n    swiper.slideTo(newActiveIndex, 0, false);\n  }\n}","export default function removeSlide(slidesIndexes) {\n  const swiper = this;\n  const {\n    params,\n    activeIndex\n  } = swiper;\n  let activeIndexBuffer = activeIndex;\n  if (params.loop) {\n    activeIndexBuffer -= swiper.loopedSlides;\n    swiper.loopDestroy();\n  }\n  let newActiveIndex = activeIndexBuffer;\n  let indexToRemove;\n  if (typeof slidesIndexes === 'object' && 'length' in slidesIndexes) {\n    for (let i = 0; i < slidesIndexes.length; i += 1) {\n      indexToRemove = slidesIndexes[i];\n      if (swiper.slides[indexToRemove]) swiper.slides[indexToRemove].remove();\n      if (indexToRemove < newActiveIndex) newActiveIndex -= 1;\n    }\n    newActiveIndex = Math.max(newActiveIndex, 0);\n  } else {\n    indexToRemove = slidesIndexes;\n    if (swiper.slides[indexToRemove]) swiper.slides[indexToRemove].remove();\n    if (indexToRemove < newActiveIndex) newActiveIndex -= 1;\n    newActiveIndex = Math.max(newActiveIndex, 0);\n  }\n  swiper.recalcSlides();\n  if (params.loop) {\n    swiper.loopCreate();\n  }\n  if (!params.observer || swiper.isElement) {\n    swiper.update();\n  }\n  if (params.loop) {\n    swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);\n  } else {\n    swiper.slideTo(newActiveIndex, 0, false);\n  }\n}","export default function removeAllSlides() {\n  const swiper = this;\n  const slidesIndexes = [];\n  for (let i = 0; i < swiper.slides.length; i += 1) {\n    slidesIndexes.push(i);\n  }\n  swiper.removeSlide(slidesIndexes);\n}","import appendSlide from './methods/appendSlide.js';\nimport prependSlide from './methods/prependSlide.js';\nimport addSlide from './methods/addSlide.js';\nimport removeSlide from './methods/removeSlide.js';\nimport removeAllSlides from './methods/removeAllSlides.js';\nexport default function Manipulation({\n  swiper\n}) {\n  Object.assign(swiper, {\n    appendSlide: appendSlide.bind(swiper),\n    prependSlide: prependSlide.bind(swiper),\n    addSlide: addSlide.bind(swiper),\n    removeSlide: removeSlide.bind(swiper),\n    removeAllSlides: removeAllSlides.bind(swiper)\n  });\n}","export default function effectInit(params) {\n  const {\n    effect,\n    swiper,\n    on,\n    setTranslate,\n    setTransition,\n    overwriteParams,\n    perspective,\n    recreateShadows,\n    getEffectParams\n  } = params;\n  on('beforeInit', () => {\n    if (swiper.params.effect !== effect) return;\n    swiper.classNames.push(`${swiper.params.containerModifierClass}${effect}`);\n    if (perspective && perspective()) {\n      swiper.classNames.push(`${swiper.params.containerModifierClass}3d`);\n    }\n    const overwriteParamsResult = overwriteParams ? overwriteParams() : {};\n    Object.assign(swiper.params, overwriteParamsResult);\n    Object.assign(swiper.originalParams, overwriteParamsResult);\n  });\n  on('setTranslate', () => {\n    if (swiper.params.effect !== effect) return;\n    setTranslate();\n  });\n  on('setTransition', (_s, duration) => {\n    if (swiper.params.effect !== effect) return;\n    setTransition(duration);\n  });\n  on('transitionEnd', () => {\n    if (swiper.params.effect !== effect) return;\n    if (recreateShadows) {\n      if (!getEffectParams || !getEffectParams().slideShadows) return;\n      // remove shadows\n      swiper.slides.forEach(slideEl => {\n        slideEl.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(shadowEl => shadowEl.remove());\n      });\n      // create new one\n      recreateShadows();\n    }\n  });\n  let requireUpdateOnVirtual;\n  on('virtualUpdate', () => {\n    if (swiper.params.effect !== effect) return;\n    if (!swiper.slides.length) {\n      requireUpdateOnVirtual = true;\n    }\n    requestAnimationFrame(() => {\n      if (requireUpdateOnVirtual && swiper.slides && swiper.slides.length) {\n        setTranslate();\n        requireUpdateOnVirtual = false;\n      }\n    });\n  });\n}","import { getSlideTransformEl } from './utils.js';\nexport default function effectTarget(effectParams, slideEl) {\n  const transformEl = getSlideTransformEl(slideEl);\n  if (transformEl !== slideEl) {\n    transformEl.style.backfaceVisibility = 'hidden';\n    transformEl.style['-webkit-backface-visibility'] = 'hidden';\n  }\n  return transformEl;\n}","import { elementTransitionEnd } from './utils.js';\nexport default function effectVirtualTransitionEnd({\n  swiper,\n  duration,\n  transformElements,\n  allSlides\n}) {\n  const {\n    activeIndex\n  } = swiper;\n  const getSlide = el => {\n    if (!el.parentElement) {\n      // assume shadow root\n      const slide = swiper.slides.filter(slideEl => slideEl.shadowEl && slideEl.shadowEl === el.parentNode)[0];\n      return slide;\n    }\n    return el.parentElement;\n  };\n  if (swiper.params.virtualTranslate && duration !== 0) {\n    let eventTriggered = false;\n    let transitionEndTarget;\n    if (allSlides) {\n      transitionEndTarget = transformElements;\n    } else {\n      transitionEndTarget = transformElements.filter(transformEl => {\n        const el = transformEl.classList.contains('swiper-slide-transform') ? getSlide(transformEl) : transformEl;\n        return swiper.getSlideIndex(el) === activeIndex;\n      });\n    }\n    transitionEndTarget.forEach(el => {\n      elementTransitionEnd(el, () => {\n        if (eventTriggered) return;\n        if (!swiper || swiper.destroyed) return;\n        eventTriggered = true;\n        swiper.animating = false;\n        const evt = new window.CustomEvent('transitionend', {\n          bubbles: true,\n          cancelable: true\n        });\n        swiper.wrapperEl.dispatchEvent(evt);\n      });\n    });\n  }\n}","import effectInit from '../../shared/effect-init.js';\nimport effectTarget from '../../shared/effect-target.js';\nimport effectVirtualTransitionEnd from '../../shared/effect-virtual-transition-end.js';\nimport { getSlideTransformEl } from '../../shared/utils.js';\nexport default function EffectFade({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    fadeEffect: {\n      crossFade: false\n    }\n  });\n  const setTranslate = () => {\n    const {\n      slides\n    } = swiper;\n    const params = swiper.params.fadeEffect;\n    for (let i = 0; i < slides.length; i += 1) {\n      const slideEl = swiper.slides[i];\n      const offset = slideEl.swiperSlideOffset;\n      let tx = -offset;\n      if (!swiper.params.virtualTranslate) tx -= swiper.translate;\n      let ty = 0;\n      if (!swiper.isHorizontal()) {\n        ty = tx;\n        tx = 0;\n      }\n      const slideOpacity = swiper.params.fadeEffect.crossFade ? Math.max(1 - Math.abs(slideEl.progress), 0) : 1 + Math.min(Math.max(slideEl.progress, -1), 0);\n      const targetEl = effectTarget(params, slideEl);\n      targetEl.style.opacity = slideOpacity;\n      targetEl.style.transform = `translate3d(${tx}px, ${ty}px, 0px)`;\n    }\n  };\n  const setTransition = duration => {\n    const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));\n    transformElements.forEach(el => {\n      el.style.transitionDuration = `${duration}ms`;\n    });\n    effectVirtualTransitionEnd({\n      swiper,\n      duration,\n      transformElements,\n      allSlides: true\n    });\n  };\n  effectInit({\n    effect: 'fade',\n    swiper,\n    on,\n    setTranslate,\n    setTransition,\n    overwriteParams: () => ({\n      slidesPerView: 1,\n      slidesPerGroup: 1,\n      watchSlidesProgress: true,\n      spaceBetween: 0,\n      virtualTranslate: !swiper.params.cssMode\n    })\n  });\n}","import effectInit from '../../shared/effect-init.js';\nimport { createElement } from '../../shared/utils.js';\nexport default function EffectCube({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    cubeEffect: {\n      slideShadows: true,\n      shadow: true,\n      shadowOffset: 20,\n      shadowScale: 0.94\n    }\n  });\n  const createSlideShadows = (slideEl, progress, isHorizontal) => {\n    let shadowBefore = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-left') : slideEl.querySelector('.swiper-slide-shadow-top');\n    let shadowAfter = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-right') : slideEl.querySelector('.swiper-slide-shadow-bottom');\n    if (!shadowBefore) {\n      shadowBefore = createElement('div', `swiper-slide-shadow-${isHorizontal ? 'left' : 'top'}`);\n      slideEl.append(shadowBefore);\n    }\n    if (!shadowAfter) {\n      shadowAfter = createElement('div', `swiper-slide-shadow-${isHorizontal ? 'right' : 'bottom'}`);\n      slideEl.append(shadowAfter);\n    }\n    if (shadowBefore) shadowBefore.style.opacity = Math.max(-progress, 0);\n    if (shadowAfter) shadowAfter.style.opacity = Math.max(progress, 0);\n  };\n  const recreateShadows = () => {\n    // create new ones\n    const isHorizontal = swiper.isHorizontal();\n    swiper.slides.forEach(slideEl => {\n      const progress = Math.max(Math.min(slideEl.progress, 1), -1);\n      createSlideShadows(slideEl, progress, isHorizontal);\n    });\n  };\n  const setTranslate = () => {\n    const {\n      el,\n      wrapperEl,\n      slides,\n      width: swiperWidth,\n      height: swiperHeight,\n      rtlTranslate: rtl,\n      size: swiperSize,\n      browser\n    } = swiper;\n    const params = swiper.params.cubeEffect;\n    const isHorizontal = swiper.isHorizontal();\n    const isVirtual = swiper.virtual && swiper.params.virtual.enabled;\n    let wrapperRotate = 0;\n    let cubeShadowEl;\n    if (params.shadow) {\n      if (isHorizontal) {\n        cubeShadowEl = swiper.slidesEl.querySelector('.swiper-cube-shadow');\n        if (!cubeShadowEl) {\n          cubeShadowEl = createElement('div', 'swiper-cube-shadow');\n          swiper.slidesEl.append(cubeShadowEl);\n        }\n        cubeShadowEl.style.height = `${swiperWidth}px`;\n      } else {\n        cubeShadowEl = el.querySelector('.swiper-cube-shadow');\n        if (!cubeShadowEl) {\n          cubeShadowEl = createElement('div', 'swiper-cube-shadow');\n          el.append(cubeShadowEl);\n        }\n      }\n    }\n    for (let i = 0; i < slides.length; i += 1) {\n      const slideEl = slides[i];\n      let slideIndex = i;\n      if (isVirtual) {\n        slideIndex = parseInt(slideEl.getAttribute('data-swiper-slide-index'), 10);\n      }\n      let slideAngle = slideIndex * 90;\n      let round = Math.floor(slideAngle / 360);\n      if (rtl) {\n        slideAngle = -slideAngle;\n        round = Math.floor(-slideAngle / 360);\n      }\n      const progress = Math.max(Math.min(slideEl.progress, 1), -1);\n      let tx = 0;\n      let ty = 0;\n      let tz = 0;\n      if (slideIndex % 4 === 0) {\n        tx = -round * 4 * swiperSize;\n        tz = 0;\n      } else if ((slideIndex - 1) % 4 === 0) {\n        tx = 0;\n        tz = -round * 4 * swiperSize;\n      } else if ((slideIndex - 2) % 4 === 0) {\n        tx = swiperSize + round * 4 * swiperSize;\n        tz = swiperSize;\n      } else if ((slideIndex - 3) % 4 === 0) {\n        tx = -swiperSize;\n        tz = 3 * swiperSize + swiperSize * 4 * round;\n      }\n      if (rtl) {\n        tx = -tx;\n      }\n      if (!isHorizontal) {\n        ty = tx;\n        tx = 0;\n      }\n      const transform = `rotateX(${isHorizontal ? 0 : -slideAngle}deg) rotateY(${isHorizontal ? slideAngle : 0}deg) translate3d(${tx}px, ${ty}px, ${tz}px)`;\n      if (progress <= 1 && progress > -1) {\n        wrapperRotate = slideIndex * 90 + progress * 90;\n        if (rtl) wrapperRotate = -slideIndex * 90 - progress * 90;\n      }\n      slideEl.style.transform = transform;\n      if (params.slideShadows) {\n        createSlideShadows(slideEl, progress, isHorizontal);\n      }\n    }\n    wrapperEl.style.transformOrigin = `50% 50% -${swiperSize / 2}px`;\n    wrapperEl.style['-webkit-transform-origin'] = `50% 50% -${swiperSize / 2}px`;\n    if (params.shadow) {\n      if (isHorizontal) {\n        cubeShadowEl.style.transform = `translate3d(0px, ${swiperWidth / 2 + params.shadowOffset}px, ${-swiperWidth / 2}px) rotateX(90deg) rotateZ(0deg) scale(${params.shadowScale})`;\n      } else {\n        const shadowAngle = Math.abs(wrapperRotate) - Math.floor(Math.abs(wrapperRotate) / 90) * 90;\n        const multiplier = 1.5 - (Math.sin(shadowAngle * 2 * Math.PI / 360) / 2 + Math.cos(shadowAngle * 2 * Math.PI / 360) / 2);\n        const scale1 = params.shadowScale;\n        const scale2 = params.shadowScale / multiplier;\n        const offset = params.shadowOffset;\n        cubeShadowEl.style.transform = `scale3d(${scale1}, 1, ${scale2}) translate3d(0px, ${swiperHeight / 2 + offset}px, ${-swiperHeight / 2 / scale2}px) rotateX(-90deg)`;\n      }\n    }\n    const zFactor = (browser.isSafari || browser.isWebView) && browser.needPerspectiveFix ? -swiperSize / 2 : 0;\n    wrapperEl.style.transform = `translate3d(0px,0,${zFactor}px) rotateX(${swiper.isHorizontal() ? 0 : wrapperRotate}deg) rotateY(${swiper.isHorizontal() ? -wrapperRotate : 0}deg)`;\n    wrapperEl.style.setProperty('--swiper-cube-translate-z', `${zFactor}px`);\n  };\n  const setTransition = duration => {\n    const {\n      el,\n      slides\n    } = swiper;\n    slides.forEach(slideEl => {\n      slideEl.style.transitionDuration = `${duration}ms`;\n      slideEl.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(subEl => {\n        subEl.style.transitionDuration = `${duration}ms`;\n      });\n    });\n    if (swiper.params.cubeEffect.shadow && !swiper.isHorizontal()) {\n      const shadowEl = el.querySelector('.swiper-cube-shadow');\n      if (shadowEl) shadowEl.style.transitionDuration = `${duration}ms`;\n    }\n  };\n  effectInit({\n    effect: 'cube',\n    swiper,\n    on,\n    setTranslate,\n    setTransition,\n    recreateShadows,\n    getEffectParams: () => swiper.params.cubeEffect,\n    perspective: () => true,\n    overwriteParams: () => ({\n      slidesPerView: 1,\n      slidesPerGroup: 1,\n      watchSlidesProgress: true,\n      resistanceRatio: 0,\n      spaceBetween: 0,\n      centeredSlides: false,\n      virtualTranslate: true\n    })\n  });\n}","import { createElement, getSlideTransformEl } from './utils.js';\nexport default function createShadow(params, slideEl, side) {\n  const shadowClass = `swiper-slide-shadow${side ? `-${side}` : ''}`;\n  const shadowContainer = getSlideTransformEl(slideEl);\n  let shadowEl = shadowContainer.querySelector(`.${shadowClass}`);\n  if (!shadowEl) {\n    shadowEl = createElement('div', `swiper-slide-shadow${side ? `-${side}` : ''}`);\n    shadowContainer.append(shadowEl);\n  }\n  return shadowEl;\n}","import createShadow from '../../shared/create-shadow.js';\nimport effectInit from '../../shared/effect-init.js';\nimport effectTarget from '../../shared/effect-target.js';\nimport effectVirtualTransitionEnd from '../../shared/effect-virtual-transition-end.js';\nimport { getSlideTransformEl } from '../../shared/utils.js';\nexport default function EffectFlip({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    flipEffect: {\n      slideShadows: true,\n      limitRotation: true\n    }\n  });\n  const createSlideShadows = (slideEl, progress, params) => {\n    let shadowBefore = swiper.isHorizontal() ? slideEl.querySelector('.swiper-slide-shadow-left') : slideEl.querySelector('.swiper-slide-shadow-top');\n    let shadowAfter = swiper.isHorizontal() ? slideEl.querySelector('.swiper-slide-shadow-right') : slideEl.querySelector('.swiper-slide-shadow-bottom');\n    if (!shadowBefore) {\n      shadowBefore = createShadow(params, slideEl, swiper.isHorizontal() ? 'left' : 'top');\n    }\n    if (!shadowAfter) {\n      shadowAfter = createShadow(params, slideEl, swiper.isHorizontal() ? 'right' : 'bottom');\n    }\n    if (shadowBefore) shadowBefore.style.opacity = Math.max(-progress, 0);\n    if (shadowAfter) shadowAfter.style.opacity = Math.max(progress, 0);\n  };\n  const recreateShadows = () => {\n    // Set shadows\n    const params = swiper.params.flipEffect;\n    swiper.slides.forEach(slideEl => {\n      let progress = slideEl.progress;\n      if (swiper.params.flipEffect.limitRotation) {\n        progress = Math.max(Math.min(slideEl.progress, 1), -1);\n      }\n      createSlideShadows(slideEl, progress, params);\n    });\n  };\n  const setTranslate = () => {\n    const {\n      slides,\n      rtlTranslate: rtl\n    } = swiper;\n    const params = swiper.params.flipEffect;\n    for (let i = 0; i < slides.length; i += 1) {\n      const slideEl = slides[i];\n      let progress = slideEl.progress;\n      if (swiper.params.flipEffect.limitRotation) {\n        progress = Math.max(Math.min(slideEl.progress, 1), -1);\n      }\n      const offset = slideEl.swiperSlideOffset;\n      const rotate = -180 * progress;\n      let rotateY = rotate;\n      let rotateX = 0;\n      let tx = swiper.params.cssMode ? -offset - swiper.translate : -offset;\n      let ty = 0;\n      if (!swiper.isHorizontal()) {\n        ty = tx;\n        tx = 0;\n        rotateX = -rotateY;\n        rotateY = 0;\n      } else if (rtl) {\n        rotateY = -rotateY;\n      }\n      slideEl.style.zIndex = -Math.abs(Math.round(progress)) + slides.length;\n      if (params.slideShadows) {\n        createSlideShadows(slideEl, progress, params);\n      }\n      const transform = `translate3d(${tx}px, ${ty}px, 0px) rotateX(${rotateX}deg) rotateY(${rotateY}deg)`;\n      const targetEl = effectTarget(params, slideEl);\n      targetEl.style.transform = transform;\n    }\n  };\n  const setTransition = duration => {\n    const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));\n    transformElements.forEach(el => {\n      el.style.transitionDuration = `${duration}ms`;\n      el.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(shadowEl => {\n        shadowEl.style.transitionDuration = `${duration}ms`;\n      });\n    });\n    effectVirtualTransitionEnd({\n      swiper,\n      duration,\n      transformElements\n    });\n  };\n  effectInit({\n    effect: 'flip',\n    swiper,\n    on,\n    setTranslate,\n    setTransition,\n    recreateShadows,\n    getEffectParams: () => swiper.params.flipEffect,\n    perspective: () => true,\n    overwriteParams: () => ({\n      slidesPerView: 1,\n      slidesPerGroup: 1,\n      watchSlidesProgress: true,\n      spaceBetween: 0,\n      virtualTranslate: !swiper.params.cssMode\n    })\n  });\n}","import createShadow from '../../shared/create-shadow.js';\nimport effectInit from '../../shared/effect-init.js';\nimport effectTarget from '../../shared/effect-target.js';\nimport { getSlideTransformEl } from '../../shared/utils.js';\nexport default function EffectCoverflow({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    coverflowEffect: {\n      rotate: 50,\n      stretch: 0,\n      depth: 100,\n      scale: 1,\n      modifier: 1,\n      slideShadows: true\n    }\n  });\n  const setTranslate = () => {\n    const {\n      width: swiperWidth,\n      height: swiperHeight,\n      slides,\n      slidesSizesGrid\n    } = swiper;\n    const params = swiper.params.coverflowEffect;\n    const isHorizontal = swiper.isHorizontal();\n    const transform = swiper.translate;\n    const center = isHorizontal ? -transform + swiperWidth / 2 : -transform + swiperHeight / 2;\n    const rotate = isHorizontal ? params.rotate : -params.rotate;\n    const translate = params.depth;\n    // Each slide offset from center\n    for (let i = 0, length = slides.length; i < length; i += 1) {\n      const slideEl = slides[i];\n      const slideSize = slidesSizesGrid[i];\n      const slideOffset = slideEl.swiperSlideOffset;\n      const centerOffset = (center - slideOffset - slideSize / 2) / slideSize;\n      const offsetMultiplier = typeof params.modifier === 'function' ? params.modifier(centerOffset) : centerOffset * params.modifier;\n      let rotateY = isHorizontal ? rotate * offsetMultiplier : 0;\n      let rotateX = isHorizontal ? 0 : rotate * offsetMultiplier;\n      // var rotateZ = 0\n      let translateZ = -translate * Math.abs(offsetMultiplier);\n      let stretch = params.stretch;\n      // Allow percentage to make a relative stretch for responsive sliders\n      if (typeof stretch === 'string' && stretch.indexOf('%') !== -1) {\n        stretch = parseFloat(params.stretch) / 100 * slideSize;\n      }\n      let translateY = isHorizontal ? 0 : stretch * offsetMultiplier;\n      let translateX = isHorizontal ? stretch * offsetMultiplier : 0;\n      let scale = 1 - (1 - params.scale) * Math.abs(offsetMultiplier);\n\n      // Fix for ultra small values\n      if (Math.abs(translateX) < 0.001) translateX = 0;\n      if (Math.abs(translateY) < 0.001) translateY = 0;\n      if (Math.abs(translateZ) < 0.001) translateZ = 0;\n      if (Math.abs(rotateY) < 0.001) rotateY = 0;\n      if (Math.abs(rotateX) < 0.001) rotateX = 0;\n      if (Math.abs(scale) < 0.001) scale = 0;\n      const slideTransform = `translate3d(${translateX}px,${translateY}px,${translateZ}px)  rotateX(${rotateX}deg) rotateY(${rotateY}deg) scale(${scale})`;\n      const targetEl = effectTarget(params, slideEl);\n      targetEl.style.transform = slideTransform;\n      slideEl.style.zIndex = -Math.abs(Math.round(offsetMultiplier)) + 1;\n      if (params.slideShadows) {\n        // Set shadows\n        let shadowBeforeEl = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-left') : slideEl.querySelector('.swiper-slide-shadow-top');\n        let shadowAfterEl = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-right') : slideEl.querySelector('.swiper-slide-shadow-bottom');\n        if (!shadowBeforeEl) {\n          shadowBeforeEl = createShadow(params, slideEl, isHorizontal ? 'left' : 'top');\n        }\n        if (!shadowAfterEl) {\n          shadowAfterEl = createShadow(params, slideEl, isHorizontal ? 'right' : 'bottom');\n        }\n        if (shadowBeforeEl) shadowBeforeEl.style.opacity = offsetMultiplier > 0 ? offsetMultiplier : 0;\n        if (shadowAfterEl) shadowAfterEl.style.opacity = -offsetMultiplier > 0 ? -offsetMultiplier : 0;\n      }\n    }\n  };\n  const setTransition = duration => {\n    const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));\n    transformElements.forEach(el => {\n      el.style.transitionDuration = `${duration}ms`;\n      el.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(shadowEl => {\n        shadowEl.style.transitionDuration = `${duration}ms`;\n      });\n    });\n  };\n  effectInit({\n    effect: 'coverflow',\n    swiper,\n    on,\n    setTranslate,\n    setTransition,\n    perspective: () => true,\n    overwriteParams: () => ({\n      watchSlidesProgress: true\n    })\n  });\n}","import createShadow from '../../shared/create-shadow.js';\nimport effectInit from '../../shared/effect-init.js';\nimport effectTarget from '../../shared/effect-target.js';\nimport effectVirtualTransitionEnd from '../../shared/effect-virtual-transition-end.js';\nimport { getSlideTransformEl } from '../../shared/utils.js';\nexport default function EffectCreative({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    creativeEffect: {\n      limitProgress: 1,\n      shadowPerProgress: false,\n      progressMultiplier: 1,\n      perspective: true,\n      prev: {\n        translate: [0, 0, 0],\n        rotate: [0, 0, 0],\n        opacity: 1,\n        scale: 1\n      },\n      next: {\n        translate: [0, 0, 0],\n        rotate: [0, 0, 0],\n        opacity: 1,\n        scale: 1\n      }\n    }\n  });\n  const getTranslateValue = value => {\n    if (typeof value === 'string') return value;\n    return `${value}px`;\n  };\n  const setTranslate = () => {\n    const {\n      slides,\n      wrapperEl,\n      slidesSizesGrid\n    } = swiper;\n    const params = swiper.params.creativeEffect;\n    const {\n      progressMultiplier: multiplier\n    } = params;\n    const isCenteredSlides = swiper.params.centeredSlides;\n    if (isCenteredSlides) {\n      const margin = slidesSizesGrid[0] / 2 - swiper.params.slidesOffsetBefore || 0;\n      wrapperEl.style.transform = `translateX(calc(50% - ${margin}px))`;\n    }\n    for (let i = 0; i < slides.length; i += 1) {\n      const slideEl = slides[i];\n      const slideProgress = slideEl.progress;\n      const progress = Math.min(Math.max(slideEl.progress, -params.limitProgress), params.limitProgress);\n      let originalProgress = progress;\n      if (!isCenteredSlides) {\n        originalProgress = Math.min(Math.max(slideEl.originalProgress, -params.limitProgress), params.limitProgress);\n      }\n      const offset = slideEl.swiperSlideOffset;\n      const t = [swiper.params.cssMode ? -offset - swiper.translate : -offset, 0, 0];\n      const r = [0, 0, 0];\n      let custom = false;\n      if (!swiper.isHorizontal()) {\n        t[1] = t[0];\n        t[0] = 0;\n      }\n      let data = {\n        translate: [0, 0, 0],\n        rotate: [0, 0, 0],\n        scale: 1,\n        opacity: 1\n      };\n      if (progress < 0) {\n        data = params.next;\n        custom = true;\n      } else if (progress > 0) {\n        data = params.prev;\n        custom = true;\n      }\n      // set translate\n      t.forEach((value, index) => {\n        t[index] = `calc(${value}px + (${getTranslateValue(data.translate[index])} * ${Math.abs(progress * multiplier)}))`;\n      });\n      // set rotates\n      r.forEach((value, index) => {\n        r[index] = data.rotate[index] * Math.abs(progress * multiplier);\n      });\n      slideEl.style.zIndex = -Math.abs(Math.round(slideProgress)) + slides.length;\n      const translateString = t.join(', ');\n      const rotateString = `rotateX(${r[0]}deg) rotateY(${r[1]}deg) rotateZ(${r[2]}deg)`;\n      const scaleString = originalProgress < 0 ? `scale(${1 + (1 - data.scale) * originalProgress * multiplier})` : `scale(${1 - (1 - data.scale) * originalProgress * multiplier})`;\n      const opacityString = originalProgress < 0 ? 1 + (1 - data.opacity) * originalProgress * multiplier : 1 - (1 - data.opacity) * originalProgress * multiplier;\n      const transform = `translate3d(${translateString}) ${rotateString} ${scaleString}`;\n\n      // Set shadows\n      if (custom && data.shadow || !custom) {\n        let shadowEl = slideEl.querySelector('.swiper-slide-shadow');\n        if (!shadowEl && data.shadow) {\n          shadowEl = createShadow(params, slideEl);\n        }\n        if (shadowEl) {\n          const shadowOpacity = params.shadowPerProgress ? progress * (1 / params.limitProgress) : progress;\n          shadowEl.style.opacity = Math.min(Math.max(Math.abs(shadowOpacity), 0), 1);\n        }\n      }\n      const targetEl = effectTarget(params, slideEl);\n      targetEl.style.transform = transform;\n      targetEl.style.opacity = opacityString;\n      if (data.origin) {\n        targetEl.style.transformOrigin = data.origin;\n      }\n    }\n  };\n  const setTransition = duration => {\n    const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));\n    transformElements.forEach(el => {\n      el.style.transitionDuration = `${duration}ms`;\n      el.querySelectorAll('.swiper-slide-shadow').forEach(shadowEl => {\n        shadowEl.style.transitionDuration = `${duration}ms`;\n      });\n    });\n    effectVirtualTransitionEnd({\n      swiper,\n      duration,\n      transformElements,\n      allSlides: true\n    });\n  };\n  effectInit({\n    effect: 'creative',\n    swiper,\n    on,\n    setTranslate,\n    setTransition,\n    perspective: () => swiper.params.creativeEffect.perspective,\n    overwriteParams: () => ({\n      watchSlidesProgress: true,\n      virtualTranslate: !swiper.params.cssMode\n    })\n  });\n}","import createShadow from '../../shared/create-shadow.js';\nimport effectInit from '../../shared/effect-init.js';\nimport effectTarget from '../../shared/effect-target.js';\nimport effectVirtualTransitionEnd from '../../shared/effect-virtual-transition-end.js';\nimport { getSlideTransformEl } from '../../shared/utils.js';\nexport default function EffectCards({\n  swiper,\n  extendParams,\n  on\n}) {\n  extendParams({\n    cardsEffect: {\n      slideShadows: true,\n      rotate: true,\n      perSlideRotate: 2,\n      perSlideOffset: 8\n    }\n  });\n  const setTranslate = () => {\n    const {\n      slides,\n      activeIndex,\n      rtlTranslate: rtl\n    } = swiper;\n    const params = swiper.params.cardsEffect;\n    const {\n      startTranslate,\n      isTouched\n    } = swiper.touchEventsData;\n    const currentTranslate = rtl ? -swiper.translate : swiper.translate;\n    for (let i = 0; i < slides.length; i += 1) {\n      const slideEl = slides[i];\n      const slideProgress = slideEl.progress;\n      const progress = Math.min(Math.max(slideProgress, -4), 4);\n      let offset = slideEl.swiperSlideOffset;\n      if (swiper.params.centeredSlides && !swiper.params.cssMode) {\n        swiper.wrapperEl.style.transform = `translateX(${swiper.minTranslate()}px)`;\n      }\n      if (swiper.params.centeredSlides && swiper.params.cssMode) {\n        offset -= slides[0].swiperSlideOffset;\n      }\n      let tX = swiper.params.cssMode ? -offset - swiper.translate : -offset;\n      let tY = 0;\n      const tZ = -100 * Math.abs(progress);\n      let scale = 1;\n      let rotate = -params.perSlideRotate * progress;\n      let tXAdd = params.perSlideOffset - Math.abs(progress) * 0.75;\n      const slideIndex = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.from + i : i;\n      const isSwipeToNext = (slideIndex === activeIndex || slideIndex === activeIndex - 1) && progress > 0 && progress < 1 && (isTouched || swiper.params.cssMode) && currentTranslate < startTranslate;\n      const isSwipeToPrev = (slideIndex === activeIndex || slideIndex === activeIndex + 1) && progress < 0 && progress > -1 && (isTouched || swiper.params.cssMode) && currentTranslate > startTranslate;\n      if (isSwipeToNext || isSwipeToPrev) {\n        const subProgress = (1 - Math.abs((Math.abs(progress) - 0.5) / 0.5)) ** 0.5;\n        rotate += -28 * progress * subProgress;\n        scale += -0.5 * subProgress;\n        tXAdd += 96 * subProgress;\n        tY = `${-25 * subProgress * Math.abs(progress)}%`;\n      }\n      if (progress < 0) {\n        // next\n        tX = `calc(${tX}px ${rtl ? '-' : '+'} (${tXAdd * Math.abs(progress)}%))`;\n      } else if (progress > 0) {\n        // prev\n        tX = `calc(${tX}px ${rtl ? '-' : '+'} (-${tXAdd * Math.abs(progress)}%))`;\n      } else {\n        tX = `${tX}px`;\n      }\n      if (!swiper.isHorizontal()) {\n        const prevY = tY;\n        tY = tX;\n        tX = prevY;\n      }\n      const scaleString = progress < 0 ? `${1 + (1 - scale) * progress}` : `${1 - (1 - scale) * progress}`;\n\n      /* eslint-disable */\n      const transform = `\n        translate3d(${tX}, ${tY}, ${tZ}px)\n        rotateZ(${params.rotate ? rtl ? -rotate : rotate : 0}deg)\n        scale(${scaleString})\n      `;\n      /* eslint-enable */\n\n      if (params.slideShadows) {\n        // Set shadows\n        let shadowEl = slideEl.querySelector('.swiper-slide-shadow');\n        if (!shadowEl) {\n          shadowEl = createShadow(params, slideEl);\n        }\n        if (shadowEl) shadowEl.style.opacity = Math.min(Math.max((Math.abs(progress) - 0.5) / 0.5, 0), 1);\n      }\n      slideEl.style.zIndex = -Math.abs(Math.round(slideProgress)) + slides.length;\n      const targetEl = effectTarget(params, slideEl);\n      targetEl.style.transform = transform;\n    }\n  };\n  const setTransition = duration => {\n    const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));\n    transformElements.forEach(el => {\n      el.style.transitionDuration = `${duration}ms`;\n      el.querySelectorAll('.swiper-slide-shadow').forEach(shadowEl => {\n        shadowEl.style.transitionDuration = `${duration}ms`;\n      });\n    });\n    effectVirtualTransitionEnd({\n      swiper,\n      duration,\n      transformElements\n    });\n  };\n  effectInit({\n    effect: 'cards',\n    swiper,\n    on,\n    setTranslate,\n    setTransition,\n    perspective: () => true,\n    overwriteParams: () => ({\n      watchSlidesProgress: true,\n      virtualTranslate: !swiper.params.cssMode\n    })\n  });\n}"],"names":["__spreadArray","to","from","i","il","length","j","__defProp","Object","defineProperty","__defProps","defineProperties","__getOwnPropDescs","getOwnPropertyDescriptors","__getOwnPropSymbols","getOwnPropertySymbols","__hasOwnProp","prototype","hasOwnProperty","__propIsEnum","propertyIsEnumerable","__defNormalProp","obj","key","value","enumerable","configurable","writable","__spreadValues","a","b","prop","call","_i","_c","__spreadProps","useStableQueryArgs","queryArgs","serialize","endpointDefinition","endpointName","incoming","useMemo","serialized","cache2","useRef","useEffect","current","UNINITIALIZED_VALUE","Symbol","useShallowStableValue","shallowEqual","DefinitionType","DefinitionType2","cache","WeakMap","defaultSerializeQueryArgs","cached","get","stringified","JSON","stringify","isPlainObject","keys","sort","reduce","acc","key2","set","useIsomorphicLayoutEffect","window","document","createElement","useLayoutEffect","defaultMutationStateSelector","x","noPendingQueryStateSelector","selected","isUninitialized","isFetching","isLoading","data","status","pending","capitalize","str","replace","toUpperCase","safeAssign","target","args","arguments","assign","apply","reactHooksModuleName","reactHooksModule","_d","_e","batch","_f","useDispatch","_g","useSelector","_h","useStore","_j","unstable__sideEffectsInRender","name","init","api","context","serializeQueryArgs","anyApi","moduleOptions","usePossiblyImmediateEffect","cb","buildQueryHooks","useQuerySubscription","arg","refetchOnReconnect","refetchOnFocus","refetchOnMountOrArgChange","skip","pollingInterval","initiate","endpoints","dispatch","stableArg","endpointDefinitions","stableSubscriptionOptions","lastRenderHadSubscription","promiseRef","queryCacheKey","requestId","currentRenderHasSubscription","returnedValue","internalActions","internal_probeSubscription","subscriptionRemoved","_a","lastPromise","unsubscribe","lastSubscriptionOptions","subscriptionOptions","updateSubscriptionOptions","promise","forceRefetch","refetch","Error","useLazyQuerySubscription","useState","setArg","_b","subscriptionOptionsRef","trigger","useCallback","arg2","preferCacheValue","useQueryState","selectFromResult","select","lastValue","selectDefaultResult","_","lastResult","queryStatePreSelector","querySelector","currentState","state","store","newLastValue","getState","useLazyQuery","options","queryStateResults","info","lastArg","useQuery","querySubscriptionResults","isSuccess","isError","error","useDebugValue","buildMutationHook","fixedCacheKey","setPromise","reset","triggerMutation","promise2","mutationSelector","originalArgs","removeMutationResult","finalState","usePrefetch","defaultOptions","stableDefaultOptions","util","prefetch","hasData","currentData","buildHooks","injectEndpoint","definition","type","query","e","mutation","isMutationDefinition","useMutation","ApiProvider","props","configureStore","reducer","reducerPath","middleware","gDM","concat","setupListeners","Provider","children","createApi","QueryStatus","QueryStatus2","__generator","thisArg","body","f","y","t","g","label","sent","trys","ops","next","verb","iterator","this","n","v","op","TypeError","done","pop","push","step","_k","__objRest","source","exclude","indexOf","__async","__this","__arguments","generator","Promise","resolve","reject","fulfilled","rejected","throw","then","withoutTrailingSlash","url","withoutLeadingSlash","joinUrls","base","RegExp","test","isAbsoluteUrl","delimiter","endsWith","startsWith","flatten","arr","copyWithStructuralSharing","oldObj","newObj","Array","isArray","newKeys","oldKeys","isSameObject","mergeObj","newKeys_1","defaultFetchFn","fetch","defaultValidateStatus","response","defaultIsJsonContentType","headers","stripUndefined","copy","entries","_l","k","fetchBaseQuery","_this","baseUrl","prepareHeaders","fetchFn","paramsSerializer","isJsonContentType","_m","jsonContentType","jsonReplacer","defaultTimeout","timeout","globalResponseHandler","responseHandler","globalValidateStatus","validateStatus","baseFetchOptions","console","warn","signal","extra","endpoint","forced","meta","_a2","params","_o","rest","config","_p","isJsonifiable","divider","request","requestClone","timedOut","timeoutId","e_1","responseClone","resultData","responseText","handleResponseError_1","e_2","_q","Headers","toJSON","has","URLSearchParams","Request","setTimeout","abort","String","clearTimeout","clone","all","handleResponse","r","text","originalStatus","parse","HandledError","defaultBackoff","attempt","maxRetries","attempts","Math","min","random","res","EMPTY_OPTIONS","retryWithBackoff","baseQuery","extraOptions","possibleMaxRetries","defaultRetryCondition","retry2","result","e_3","filter","slice","__","backoff","retryCondition","throwImmediately","baseQueryApi","retry","fail","onFocus","createAction","onFocusLost","onOnline","onOffline","initialized","customHandler","handleFocus","handleOnline","handleOffline","handleVisibilityChange","visibilityState","addEventListener","removeEventListener","isQueryDefinition","calculateProvidedBy","description","queryArg","assertTagTypes","map","expandTagDescription","isNotNullish","forceQueryFnSymbol","isUpsertQuery","defaultTransformResponse","baseQueryReturnValue","calculateProvidedByThunk","action","assertTagType","isFulfilled","payload","isRejectedWithValue","baseQueryMeta","updateQuerySubstateIfExists","update","substate","getMutationCacheKey","id","updateMutationSubstateIfExists","initialState","skipToken","for","skipSelector","initialSubState","uninitialized","defaultQuerySubState","defaultMutationSubState","buildSelectors","selectSkippedQuery","selectSkippedMutation","buildQuerySelector","serializedArgs","finalSelectQuerySubState","selectInternalState","queries","withRequestFlags","buildMutationSelector","mutationId","finalSelectMutationSubstate","mutations","selectInvalidatedBy","tags","apiState","toInvalidate","Set","tag","provided","invalidateSubscriptions_1","values","invalidate","add","querySubState","rootState","buildCreateApi","modules","extractRehydrationInfo","optionsWithDefaults","keepUnusedDataFor","queryArgsApi","finalSerializeQueryArgs","endpointSQA_1","queryArgsApi2","initialResult","tagTypes","fn","apiUid","nanoid","hasRehydrationInfo","injectEndpoints","inject","evaluatedEndpoints","overrideExisting","initializedModules_1","initializedModules","enhanceEndpoints","addTagTypes","addTagTypes_1","eT","includes","partialDefinition","m","fakeBaseQuery","buildCacheCollectionHandler","internalState","removeQueryResult","unsubscribeQueryResult","anySubscriptionsRemainingForKey","subscriptions","currentSubscriptions","isObjectEmpty","currentRemovalTimeouts","handleUnsubscribe","api2","Infinity","finalKeepUnusedDataFor","max","currentTimeout","mwApi","internalState2","match","resetApiState","queryState","buildInvalidationByTagsHandler","mutationThunk","refetchQuery","isThunkActionWithTags","isAnyOf","invalidateTags","valuesArray_1","subscriptionSubState","buildPollingHandler","queryThunk","currentPolls","startNextPoll","lowestPollingInterval","findLowestPollingInterval","Number","isFinite","currentPoll","nextPollTimestamp","Date","now","currentInterval","updatePollingInterval","cleanupPollForKey","existingPoll","subscribers","POSITIVE_INFINITY","condition","clearPolls","neverResolvedError","buildCacheLifecycleHandler","isQueryThunk","isAsyncThunkAction","isMutationThunk","isFulfilledThunk","lifecycleMap","handleNewKey","onCacheEntryAdded","lifecycle","cacheEntryRemoved","cacheDataLoaded","race","valueResolved","catch","selector","extra2","lifecycleApi","getCacheEntry","updateCachedData","updateRecipe","updateQueryData","runningHandler","stateBefore","cacheKey","getCacheKey","oldState","cacheKey2","buildQueryLifecycleHandler","isPendingThunk","isPending","isRejectedThunk","isRejected","isFullfilledThunk","endpointName_1","originalArgs_1","onQueryStarted","lifecycle_1","queryFulfilled","selector_1","rejectedWithValue","isUnhandledError","buildDevCheckHandler","middlewareRegistered","queueMicrotaskShim","queueMicrotask","bind","globalThis","err","buildBatchedActionsHandler","subscriptionsPrefix","previousSubscriptions","dispatchQueued","didMutate","mutableState","subscribe","actuallyMutateSubscriptions","newSubscriptions","patches","subscriptionsUpdated","isSubscriptionSliceAction","isAdditionalSubscriptionAction","buildMiddleware","input","actions","handlerBuilders","initialized2","builderArgs","handlers","build","batchedActionsHandler","windowEventsHandler","refetchValidQueries","some","sub","every","buildWindowEventHandler","mwApiWithNext","actionShouldContinue","hasSubscription","isThisApiSliceAction","handlers_1","handler","override","coreModuleName","coreModule","executeEndpoint","_0","_1","transformResponse","baseQueryApi_1","forceQueryFn","error_1","catchedError","transformErrorResponse","e_4","rejectWithValue","fulfillWithValue","_r","isForcedQuery","queryFn","fulfilledTimeStamp","SHOULD_AUTOBATCH","requestState","baseFetchOnMountOrArgChange","fulfilledVal","refetchVal","createAsyncThunk","getPendingMeta","startedTimeStamp","queryThunkArgs","currentArg","previousArg","endpointState","dispatchConditionRejection","matchesEndpoint","force","hasTheForce","maxAge","hasMaxAge","ifOlderThan","queryAction","force2","latestStateValue","lastFulfilledTs","updateProvided","newValue","ret","inversePatches","undo","patchQueryData","path","upsertQueryData","queryResultPatched","providedTags","providesTags","updateProvidedBy","buildMatchThunkActions","thunk","matchPending","isAllOf","matchFulfilled","matchRejected","buildThunks","definitions","querySlice","createSlice","reducers","draft","prepare","prepareAutoBatched","extraReducers","builder","addCase","upserting","merge","fulfilledTimeStamp_1","arg_1","baseQueryMeta_1","requestId_1","newData","draftSubstateData","structuralSharing","addMatcher","entry","mutationSlice","track","invalidationSlice","tagTypeSubscriptions","idSubscriptions","foundAt","splice","providedTags_1","subscribedQueries","incomingTags","cacheKeys","cacheKeys_1","caseReducers","subscriptionSlice","d","internalSubscriptionsSlice","configSlice","online","navigator","onLine","focused","combinedReducer","combineReducers","unsubscribeMutationResult","buildSlice","sliceActions","middlewareActions","runningQueries","Map","runningMutations","buildInitiateQuery","thunkResult","stateAfter","middlewareWarning","skippedSynchronously","runningQuery","selectFromState","statePromise","unwrap","running_1","delete","buildInitiateMutation","returnValuePromise","running","getRunningQueryThunk","getRunningMutationThunk","_endpointName","fixedCacheKeyOrRequestId","getRunningQueriesThunk","getRunningMutationsThunk","getRunningOperationPromises","extract","flatMap","queriesForStore","removalWarning","buildInitiate","getRunningOperationPromise","extendStatics","__extends","setPrototypeOf","__proto__","p","constructor","create","createDraftSafeSelector","composeWithDevTools","__REDUX_DEVTOOLS_EXTENSION_COMPOSE__","compose","__REDUX_DEVTOOLS_EXTENSION__","proto","getPrototypeOf","baseProto","hasMatchFunction","prepareAction","actionCreator","prepared","toString","isAction","isActionCreator","isFSA","isValidKey","getType","createActionCreatorInvariantMiddleware","MiddlewareArray","_super","species","prepend","EnhancerArray","freezeDraftable","val","isImmutableDefault","isFrozen","createImmutableStateInvariantMiddleware","isPlain","findNonSerializableValue","isSerializable","getEntries","ignoredPaths","foundNestedSerializable","keyPath","hasIgnoredPaths","_loop_2","nestedValue","nestedPath","ignored","entries_1","state_2","isNestedFrozen","createSerializableStateInvariantMiddleware","getDefaultMiddleware","middlewareArray","immutableCheck","serializableCheck","actionCreatorCheck","withExtraArgument","extraArgument","IS_PRODUCTION","rootReducer","curriedGetDefaultMiddleware","devTools","preloadedState","enhancers","finalMiddleware","item","middlewareEnhancer","applyMiddleware","finalCompose","trace","defaultEnhancers","storeEnhancers","composedEnhancer","createStore","executeReducerBuilderCallback","builderCallback","defaultCaseReducer","actionsMap","actionMatchers","typeOrActionCreator","matcher","addDefaultCase","createReducer","mapOrBuilderCallback","getInitialState","finalActionMatchers","finalDefaultCaseReducer","frozenInitialState_1","cr","previousState","caseReducer","_reducer","reducerNames","sliceCaseReducersByName","sliceCaseReducersByType","actionCreators","buildReducer","finalCaseReducers","actionMatchers_1","forEach","reducerName","prepareCallback","maybeReducerWithPrepare","createStateOperator","mutator","runMutator","selectIdValue","entity","selectId","ensureEntitiesArray","entities","splitAddedUpdatedEntities","newEntities","added","updated","newEntities_1","changes","createUnsortedStateAdapter","addOneMutably","ids","addManyMutably","newEntities_2","setOneMutably","removeManyMutably","updateManyMutably","updates","updatesPerEntity","didMutateIds","original2","newKey","hasNewKey","takeNewKey","upsertManyMutably","removeAll","operator","addOne","addMany","setOne","setMany","newEntities_3","setAll","updateOne","updateMany","upsertOne","upsertMany","removeOne","removeMany","createEntityAdapter","sortComparer","instance","stateFactory","additionalState","selectorsFactory","getSelectors","selectState","selectIds","selectEntities","selectAll","selectById","selectTotal","selectGlobalizedEntities","stateAdapter","models","model","setManyMutably","appliedUpdates","updates_1","newId","resortEntities","allEntities","newSortedIds","areArraysEqual","createSortedStateAdapter","size","commonProperties","RejectWithValue","FulfillWithMeta","miniSerializeError","simpleError","commonProperties_1","property","message","createAsyncThunk2","typePrefix","payloadCreator","requestStatus","serializeError","aborted","AC","AbortController","class_1","dispatchEvent","onabort","reason","throwIfAborted","abortReason","idGenerator","abortController","finalAction","conditionResult","abortedPromise","err_1","unwrapResult","withTypes","matches","matchers","hasExpectedRequestMetadata","validStatus","hasValidRequestId","hasValidRequestStatus","isAsyncThunkArray","asyncThunks","asyncThunk","combinedMatcher","hasFlag","asyncThunks_1","assertFunction","func","expected","noop","catchRejection","onError","addAbortSignalListener","abortSignal","callback","once","abortControllerWithReason","listener","completed","cancelled","taskCancelled","taskCompleted","listenerCancelled","listenerCompleted","TaskAbortError","code","task","validateActive","raceWithSignal","cleanup","notifyRejection","finally","createPause","output","createDelay","pause","timeoutMs","INTERNAL_NIL_TOKEN","alm","createFork","parentAbortSignal","parentBlockingPromises","taskExecutor","opts","controller","childAbortController","task2","cleanUp","result2","delay","autoJoin","cancel","createTakePattern","startListening","predicate","tuplePromise","promises","stopListening","effect","listenerApi","getOriginalState","take","getListenerEntryPropsFrom","createListenerEntry","cancelActiveListeners","createClearListenerMiddleware","listenerMap","clear","safelyNotifyError","errorHandler","errorToNotify","errorInfo","errorHandlerError","addListener","clearAllListeners","removeListener","defaultErrorHandler","createListenerMiddleware","middlewareOptions","findListenerEntry","comparator","existingEntry","cancelOptions","cancelActive","insertEntry","entry2","notifyListener","internalTaskController","autoJoinPromises","listenerError_1","Boolean","fork","raisedBy","allSettled","clearListenerMiddleware","originalState","listenerEntries","listenerEntries_1","runListener","predicateError","clearListeners","createQueueWithTimer","notify","rAF","requestAnimationFrame","autoBatchEnhancer","notifying","shouldNotifyAtEndOfTick","notificationQueued","listeners","queueCallback","queueNotification","notifyListeners","l","listener2","Action","_extends","PopStateEventType","createMemoryHistory","initialEntries","initialIndex","v5Compat","index","createMemoryLocation","undefined","clampIndex","Pop","getCurrentLocation","location","createLocation","pathname","warning","charAt","createHref","createPath","createURL","URL","encodeLocation","parsePath","search","hash","Push","nextLocation","delta","Replace","go","nextIndex","listen","createBrowserHistory","getUrlBasedHistory","globalHistory","usr","invariant","cond","getHistoryState","idx","substr","_ref","parsedPath","hashIndex","searchIndex","getLocation","validateLocation","defaultView","history","getIndex","handlePop","origin","href","replaceState","historyState","pushState","DOMException","ResultType","matchRoutes","routes","locationArg","basename","matchRoutesImpl","allowPartial","stripBasename","branches","flattenRoutes","score","siblings","compareIndexes","routesMeta","childrenIndex","rankRouteBranches","decoded","decodePath","matchRouteBranch","parentsMeta","parentPath","flattenRoute","route","relativePath","caseSensitive","joinPaths","computeScore","_route$path","exploded","explodeOptionalSegments","segments","split","first","isOptional","required","restExploded","join","subpath","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","segment","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","pathnameBase","normalizePathname","pattern","compiledParams","regexpSource","paramName","compilePath","captureGroups","memo","splatValue","decodeURIComponent","toLowerCase","startIndex","nextChar","getInvalidPathError","char","field","dest","getPathContributingMatches","getResolveToMatches","v7_relativeSplatPath","pathMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","isEmptyPath","toPathname","routePathnameIndex","toSegments","shift","fromPathname","resolvePathname","normalizeSearch","normalizeHash","resolvePath","hasExplicitTrailingSlash","hasCurrentTrailingSlash","paths","AbortedDeferredError","isRouteErrorResponse","statusText","internal","validMutationMethodsArr","validRequestMethodsArr","runtime","exports","Op","hasOwn","desc","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","Context","makeInvokeMethod","tryCatch","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","NativeIteratorPrototype","Gp","defineIteratorMethods","method","_invoke","AsyncIterator","PromiseImpl","invoke","record","__await","unwrapped","previousPromise","callInvokeWithMethodAndArg","doneResult","delegate","delegateResult","maybeInvokeDelegate","_sent","dispatchException","abrupt","methodName","resultName","nextLoc","pushTryEntry","locs","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","iterable","iteratorMethod","isNaN","displayName","isGeneratorFunction","genFun","ctor","mark","awrap","async","iter","object","reverse","skipTempReset","prev","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","module","regeneratorRuntime","accidentalStrictMode","Function","NOT_FOUND","defaultEqualityCheck","defaultMemoize","equalityCheckOrOptions","equals","providedOptions","equalityCheck","_providedOptions$equa","_providedOptions$maxS","maxSize","resultEqualityCheck","createCacheKeyComparator","put","cacheIndex","findIndex","unshift","createLruCache","memoized","matchingEntry","find","clearCache","createSelectorCreator","memoize","_len","memoizeOptionsFromArgs","_key","_len2","funcs","_key2","_lastResult","_recomputations","directlyPassedOptions","memoizeOptions","resultFunc","_directlyPassedOption2","finalMemoizeOptions","dependencies","dep","dependencyTypes","getDependencies","memoizedResultFunc","recomputations","resetRecomputations","createSelector","Subject_1","ObjectUnsubscribedError_1","BehaviorSubject","_value","getValue","_subscribe","subscriber","subscription","closed","hasError","thrownError","ObjectUnsubscribedError","Subject","InnerSubscriber","parent","outerValue","outerIndex","_next","notifyNext","_error","notifyError","_complete","notifyComplete","Subscriber","Observable_1","Notification","kind","hasValue","observe","observer","do","accept","nextOrObserver","toObservable","Observable","of","empty","createNext","undefinedValueNotification","createError","createComplete","completeNotification","root_1","toSubscriber_1","observable_1","pipe_1","_isScalar","lift","observable","observerOrNext","sink","toSubscriber","syncErrorThrowable","_trySubscribe","syncErrorThrown","syncErrorValue","PromiseCtor","root","Rx","pipe","operations","pipeFromArray","toPromise","OuterSubscriber","innerValue","innerIndex","innerSub","destination","Scheduler","SchedulerAction","schedule","work","Subscriber_1","Subscription_1","SubjectSubscription_1","rxSubscriber_1","SubjectSubscriber","observers","isStopped","rxSubscriber","subject","AnonymousSubject","len","Subscription","EMPTY","SubjectSubscription","asObservable","subscriberIndex","isFunction_1","Observer_1","destinationOrNext","isTrustedSubscriber","trustedSubscriber","SafeSubscriber","_unsubscribeAndRecycle","_parent","_parents","_parentSubscriber","isFunction","_context","__tryOrSetError","__tryOrUnsub","wrappedComplete","_unsubscribe","isArray_1","isObject_1","tryCatch_1","errorObject_1","UnsubscriptionError_1","_subscriptions","errors","hasErrors","remove","errorObject","UnsubscriptionError","flattenUnsubscriptionErrors","isObject","teardown","_addParent","tmp","subscriptionIndex","errs","ajax_1","ajax","empty_1","from_1","interval_1","interval","of_1","throw_1","_throw","catch_1","_catch","combineLatest_1","combineLatest","concatMap_1","concatMap","count_1","count","delay_1","do_1","_do","filter_1","map_1","mergeMap_1","mergeMap","retryWhen_1","retryWhen","share_1","share","take_1","ScalarObservable_1","EmptyObservable_1","ArrayLikeObservable","arrayLike","scheduler","EmptyObservable","ScalarObservable","isScheduler_1","ArrayObservable","array","isScheduler","refCount_1","ConnectableObservable","subjectFactory","_refCount","_isComplete","getSubject","_subject","connect","connection","_connection","ConnectableSubscriber","refCount","connectableProto","connectableObservableDescriptor","connectable","RefCountSubscriber","RefCountOperator","refCounter","sharedConnection","ErrorObservable","isArrayLike_1","isPromise_1","PromiseObservable_1","IteratorObservable_1","ArrayObservable_1","ArrayLikeObservable_1","iterator_1","observeOn_1","FromObservable","ish","isPromise","PromiseObservable","IteratorObservable","isArrayLike","ObserveOnSubscriber","isNumeric_1","async_1","IntervalObservable","period","isNumeric","StringIterator","ArrayIterator","getIterator","return","o","valueAsNumber","sign","floor","abs","maxSafeInteger","toLength","pow","dispatchNext","dispatchError","getCORSRequest","XMLHttpRequest","XDomainRequest","ajaxGet","AjaxObservable","ajaxPost","ajaxDelete","ajaxPut","ajaxPatch","mapResponse","ajaxGetJSON","responseType","urlOrRequest","createXHR","crossDomain","progId","progIds","ActiveXObject","getXMLHttpRequest","withCredentials","AjaxSubscriber","post","patch","getJSON","FormData","serializeBody","send","xhr","AjaxResponse","user","password","setupEvents","open","setHeaders","contentType","splitIndex","substring","encodeURIComponent","setRequestHeader","progressSubscriber","xhrTimeout","AjaxTimeoutError","ontimeout","upload","xhrProgress_1","xhrError_1","onprogress","AjaxError","onerror","xhrReadyStateChange","readyState","status_1","onreadystatechange","originalEvent","parseXhrResponse","responseXML","AjaxObservable_1","FromObservable_1","IntervalObservable_1","ErrorObservable_1","catchError_1","catchError","observables","project","resultSelector","tap_1","tap","concurrent","notifier","OuterSubscriber_1","subscribeToResult_1","CatchOperator","CatchSubscriber","err2","subscribeToResult","none","CombineLatestOperator","CombineLatestSubscriber","active","toRespond","unused","oldVal","_tryProject","CountOperator","CountSubscriber","_tryPredicate","isDate_1","Notification_1","delayFor","isDate","DelayOperator","DelaySubscriber","queue","errored","time","notification","_schedule","scheduleNotification","DelayMessage","FilterOperator","FilterSubscriber","MapOperator","MapSubscriber","MergeMapOperator","MergeMapSubscriber","hasCompleted","buffer","_tryNext","_innerSub","_notifyResultSelector","ConnectableObservable_1","multicast","subjectOrSubjectFactory","MulticastOperator","observeOn","ObserveOnOperator","scheduleMessage","ObserveOnMessage","RetryWhenOperator","RetryWhenSubscriber","retries","retriesSubscription","multicast_1","shareSubjectFactory","ArgumentOutOfRangeError_1","TakeOperator","total","ArgumentOutOfRangeError","TakeSubscriber","DoOperator","DoSubscriber","safeSubscriber","AsyncAction","recycleAsyncId","requestAsyncId","setInterval","flush","clearInterval","execute","_execute","errorValue","AsyncScheduler","scheduled","AsyncAction_1","AsyncScheduler_1","symbolIteratorPonyfill","Set_1","Map_1","getOwnPropertyNames","$$iterator","getSymbolObservable","$$observable","$$rxSubscriber","stack","parseFloat","noop_1","fns","__window","__self","WorkerGlobalScope","__global","_root","InnerSubscriber_1","outerSubscriber","obs","msg","tryCatchTarget","tryCatcher","callBound","isRegex","$exec","$TypeError","regex","c","h","w","C","sortIndex","performance","unstable_now","q","u","z","A","B","D","E","F","setImmediate","G","startTime","expirationTime","H","I","J","K","L","M","priorityLevel","scheduling","isInputPending","S","N","O","P","Q","R","MessageChannel","T","U","port2","port1","onmessage","postMessage","unstable_IdlePriority","unstable_ImmediatePriority","unstable_LowPriority","unstable_NormalPriority","unstable_Profiling","unstable_UserBlockingPriority","unstable_cancelCallback","unstable_continueExecution","unstable_forceFrameRate","unstable_getCurrentPriorityLevel","unstable_getFirstCallbackNode","unstable_next","unstable_pauseExecution","unstable_requestPaint","unstable_runWithPriority","unstable_scheduleCallback","unstable_shouldYield","unstable_wrapCallback","GetIntrinsic","hasDescriptors","gOPD","$floor","loose","functionLengthIsConfigurable","functionLengthIsWritable","__importDefault","mod","__esModule","style_to_object_1","utilities_1","style","camelCase","CUSTOM_PROPERTY_REGEX","HYPHEN_REGEX","NO_HYPHEN_REGEX","VENDOR_PREFIX_REGEX","MS_VENDOR_PREFIX_REGEX","character","trimHyphen","prefix","skipCamelCase","reactCompat","StyleToObject","declaration","declarations","hasIterator","MS","MOZ","WEBKIT","COMMENT","RULESET","DECLARATION","IMPORT","KEYFRAMES","LAYER","collection","element","rulesheet","compile","rule","rules","rulesets","pseudo","points","offset","atrule","previous","variable","scanning","ampersand","reference","characters","comment","ruleset","line","column","position","node","peek","caret","begin","token","alloc","dealloc","delimit","whitespace","escaping","commenter","identifier","fromCharCode","charat","trim","exec","replacement","indexof","charCodeAt","strlen","sizeof","append","combine","extend","src","ssrDocument","activeElement","blur","nodeName","querySelectorAll","getElementById","createEvent","initEvent","childNodes","setAttribute","getElementsByTagName","createElementNS","importNode","host","hostname","protocol","getDocument","doc","ssrWindow","userAgent","back","CustomEvent","getComputedStyle","getPropertyValue","Image","screen","matchMedia","cancelAnimationFrame","getWindow","win","nextTick","getTranslate","el","axis","matrix","curTransform","transformMatrix","curStyle","currentStyle","WebKitCSSMatrix","transform","webkitTransform","MozTransform","OTransform","MsTransform","msTransform","m41","m42","noExtend","nextSource","HTMLElement","nodeType","keysArray","nextKey","getOwnPropertyDescriptor","__swiper__","setCSSProperty","varName","varValue","setProperty","animateCSSModeScroll","swiper","targetPosition","side","startPosition","translate","duration","speed","wrapperEl","scrollSnapType","cssModeFrameID","dir","isOutOfBound","animate","getTime","progress","easeProgress","cos","PI","currentPosition","scrollTo","overflow","getSlideTransformEl","slideEl","shadowEl","elementChildren","classes","classList","elementOffset","box","getBoundingClientRect","clientTop","clientLeft","scrollTop","scrollY","scrollLeft","scrollX","top","left","elementStyle","elementIndex","child","previousSibling","elementParents","parents","parentElement","elementTransitionEnd","fireCallBack","elementOuterSize","includeMargins","offsetWidth","support","deviceCached","browser","getSupport","smoothScroll","documentElement","touch","DocumentTouch","calcSupport","getDevice","overrides","platform","ua","device","ios","android","screenWidth","width","screenHeight","height","ipad","ipod","iphone","windows","macos","os","calcDevice","getBrowser","needPerspectiveFix","isSafari","major","minor","num","isWebView","calcBrowser","on","events","priority","eventsListeners","destroyed","event","onceHandler","off","__emitterProxy","onAny","eventsAnyListeners","offAny","eventHandler","emit","processLazyPreloader","imageEl","closest","isElement","slideClass","lazyEl","lazyPreloaderClass","unlazy","slides","removeAttribute","preload","amount","lazyPreloadPrevNext","slidesPerView","slidesPerViewDynamic","ceil","activeIndex","grid","rows","activeColumn","preloadColumns","slideIndexLastInView","rewind","loop","realIndex","updateSize","clientWidth","clientHeight","isHorizontal","isVertical","parseInt","updateSlides","getDirectionLabel","getDirectionPropertyValue","slidesEl","swiperSize","rtlTranslate","rtl","wrongRTL","isVirtual","virtual","enabled","previousSlidesLength","slidesLength","snapGrid","slidesGrid","slidesSizesGrid","offsetBefore","slidesOffsetBefore","offsetAfter","slidesOffsetAfter","previousSnapGridLength","previousSlidesGridLength","spaceBetween","slidePosition","prevSlideSize","virtualSize","marginLeft","marginRight","marginBottom","marginTop","centeredSlides","cssMode","gridEnabled","slideSize","initSlides","shouldResetSlideSize","breakpoints","slide","updateSlide","slideStyles","currentTransform","currentWebKitTransform","roundLengths","paddingLeft","paddingRight","boxSizing","swiperSlideSize","slidesPerGroup","slidesPerGroupSkip","setWrapperSize","updateWrapperSize","newSlidesGrid","slidesGridItem","groups","slidesBefore","slidesAfter","groupSize","slideIndex","centeredSlidesBounds","allSlidesSize","slideSizeValue","maxSnap","snap","centerInsufficientSlides","allSlidesOffset","snapIndex","addToSnapGrid","addToSlidesGrid","watchOverflow","checkOverflow","watchSlidesProgress","updateSlidesOffset","backFaceHiddenClass","containerModifierClass","hasClassBackfaceClassAdded","contains","maxBackfaceHiddenSlides","updateAutoHeight","activeSlides","newHeight","setTransition","getSlideByIndex","getSlideIndexByData","visibleSlides","offsetHeight","minusOffset","offsetLeft","offsetTop","swiperSlideOffset","cssOverflowAdjustment","updateSlidesProgress","offsetCenter","slideVisibleClass","visibleSlidesIndexes","slideOffset","slideProgress","minTranslate","originalSlideProgress","slideBefore","slideAfter","originalProgress","updateProgress","multiplier","translatesDiff","maxTranslate","isBeginning","isEnd","progressLoop","wasBeginning","wasEnd","isBeginningRounded","isEndRounded","firstSlideIndex","lastSlideIndex","firstSlideTranslate","lastSlideTranslate","translateMax","translateAbs","autoHeight","updateSlidesClasses","getFilteredSlide","activeSlide","slideActiveClass","slideNextClass","slidePrevClass","nextSlide","nextEls","nextElementSibling","elementNextAll","prevSlide","prevEls","previousElementSibling","elementPrevAll","emitSlidesClasses","updateActiveIndex","newActiveIndex","previousIndex","previousRealIndex","previousSnapIndex","getVirtualRealIndex","aIndex","normalizeSlideIndex","getActiveIndexByTranslate","getAttribute","runCallbacksOnInit","updateClickedSlide","slideFound","clickedSlide","clickedIndex","slideToClickedSlide","virtualTranslate","currentTranslate","setTranslate","byController","newProgress","previousTranslate","translateTo","runCallbacks","translateBounds","animating","preventInteractionOnTransition","newTranslate","isH","behavior","onTranslateToWrapperTransitionEnd","transitionEmit","direction","slideTo","initial","normalizedTranslate","normalizedGrid","normalizedGridNext","allowSlideNext","allowSlidePrev","transitionStart","transitionEnd","_immediateVirtual","_cssModeVirtualInitialSet","initialSlide","onSlideToWrapperTransitionEnd","slideToLoop","newIndex","slideNext","perGroup","slidesPerGroupAuto","increment","loopPreventsSliding","loopFix","_clientLeft","slidePrev","normalize","normalizedSnapGrid","prevSnap","prevSnapIndex","prevIndex","lastIndex","slideReset","slideToClosest","threshold","currentSnap","slideToIndex","slideSelector","loopedSlides","getSlideIndex","loopCreate","slideRealIndex","activeSlideIndex","byMousewheel","prependSlidesIndexes","appendSlidesIndexes","isNext","isPrev","slidesPrepended","slidesAppended","swiperLoopMoveDOM","recalcSlides","currentSlideTranslate","diff","touches","control","loopParams","loopDestroy","newSlidesOrder","swiperSlideIndex","onTouchStart","touchEventsData","evCache","simulateTouch","pointerType","targetEl","touchEventsTarget","which","button","isTouched","isMoved","swipingClassHasValue","noSwipingClass","eventPath","composedPath","shadowRoot","noSwipingSelector","isTargetShadow","noSwiping","__closestFrom","assignedSlot","found","getRootNode","closestElement","allowClick","swipeHandler","currentX","pageX","currentY","pageY","startX","startY","edgeSwipeDetection","iOSEdgeSwipeDetection","edgeSwipeThreshold","iOSEdgeSwipeThreshold","innerWidth","preventDefault","allowTouchCallbacks","isScrolling","startMoving","touchStartTime","swipeDirection","allowThresholdMove","focusableElements","shouldPreventDefault","allowTouchMove","touchStartPreventDefault","touchStartForcePreventDefault","isContentEditable","freeMode","onTouchMove","pointerIndex","cachedEv","pointerId","targetTouch","preventedByNestedSwiper","prevX","prevY","touchReleaseOnEdges","targetTouches","diffX","diffY","sqrt","touchAngle","atan2","zoom","cancelable","touchMoveStopPropagation","nested","stopPropagation","touchesDiff","previousX","previousY","oneWayMovement","touchRatio","prevTouchesDirection","touchesDirection","isLoop","startTranslate","evt","bubbles","allowMomentumBounce","grabCursor","setGrabCursor","loopFixed","disableParentSwiper","resistanceRatio","resistance","followFinger","onTouchEnd","touchEndTime","timeDiff","pathTree","lastClickTime","currentPos","stopIndex","rewindFirstIndex","rewindLastIndex","ratio","longSwipesMs","longSwipes","longSwipesRatio","shortSwipes","navigation","nextEl","prevEl","onResize","setBreakpoint","isVirtualLoop","autoplay","paused","resizeTimeout","resume","onClick","preventClicks","preventClicksPropagation","stopImmediatePropagation","onScroll","onLoad","dummyEventAttached","dummyEventListener","capture","domMethod","swiperMethod","passive","updateOnWindowResize","isGridEnabled","resizeObserver","createElements","breakpointsBase","uniqueNavElements","passiveListeners","wrapperClass","_emitClasses","moduleExtendParams","allModulesParams","moduleParamName","moduleParams","auto","prototypes","eventsEmitter","transition","transitionDuration","moving","isLocked","__preventObserver__","cursor","unsetGrabCursor","attachEvents","detachEvents","breakpoint","getBreakpoint","currentBreakpoint","breakpointParams","originalParams","wasMultiRow","isMultiRow","wasEnabled","emitContainerClasses","fill","wasModuleEnabled","isModuleEnabled","disable","enable","directionChanged","needsReLoop","changeDirection","isEnabled","containerEl","currentHeight","innerHeight","point","minRatio","wasLocked","lastSlideRightEdge","addClasses","classNames","suffixes","resultClasses","prepareClasses","removeClasses","extendedDefaults","Swiper","swipers","newParams","__modules__","extendParams","swiperParams","defaults","passedParams","eventName","velocity","trunc","clickTimeout","velocities","imagesToLoad","imagesLoaded","setProgress","cls","className","getSlideClasses","view","exact","spv","breakLoop","translateValue","translated","newDirection","needUpdate","currentDirection","changeLanguageDirection","mount","mounted","getWrapperSelector","getWrapper","destroy","deleteInstance","cleanStyles","deleteProps","extendDefaults","newDefaults","installModule","use","prototypeGroup","protoMethod","animationFrame","resizeHandler","orientationChangeHandler","ResizeObserver","newWidth","contentBoxSize","contentRect","inlineSize","blockSize","unobserve","attach","MutationObserver","WebkitMutationObserver","observerUpdate","attributes","childList","characterData","observeParents","observeSlideChildren","containerParents","disconnect","Virtual","cssModeTimeout","renderSlide","renderExternal","renderExternalUpdate","addSlidesBefore","addSlidesAfter","tempDOM","innerHTML","previousFrom","previousTo","previousSlidesGrid","previousOffset","offsetProp","onRendered","slidesToRender","prependIndexes","appendIndexes","loopFrom","loopTo","domSlidesAssigned","appendSlide","prependSlide","numberOfNewSlides","newCache","cachedIndex","cachedEl","cachedElIndex","removeSlide","slidesIndexes","removeAllSlides","Keyboard","kc","keyCode","charCode","pageUpDown","keyboard","isPageUp","isPageDown","isArrowLeft","isArrowRight","isArrowUp","isArrowDown","shiftKey","altKey","ctrlKey","metaKey","onlyInViewport","inView","swiperWidth","swiperHeight","windowWidth","windowHeight","swiperOffset","swiperCoord","returnValue","Mousewheel","mousewheel","releaseOnEdges","invert","forceToAxis","sensitivity","eventsTarget","thresholdDelta","thresholdTime","noMousewheelClass","lastEventBeforeSnap","lastScrollTime","recentWheelEvents","handleMouseEnter","mouseEntered","handleMouseLeave","animateSlider","newEvent","raw","targetElContainsTarget","rtlFactor","sX","sY","pX","pY","detail","wheelDelta","wheelDeltaY","wheelDeltaX","HORIZONTAL_AXIS","deltaY","deltaX","deltaMode","spinX","spinY","pixelX","pixelY","positions","ignoreWheelEvents","sticky","prevEvent","firstEvent","snapToThreshold","autoplayDisableOnInteraction","releaseScroll","createElementIfNotDefined","checkProps","Navigation","hideOnClick","disabledClass","hiddenClass","lockClass","navigationDisabledClass","makeElementsArray","getEl","toggleEl","disabled","subEl","tagName","onPrevClick","onNextClick","initButton","destroyButton","_s","pagination","clickable","isHidden","toggle","classesToSelector","Pagination","pfx","bulletSize","bulletElement","renderBullet","renderProgressbar","renderFraction","renderCustom","progressbarOpposite","dynamicBullets","dynamicMainBullets","formatFractionCurrent","number","formatFractionTotal","bulletClass","bulletActiveClass","modifierClass","currentClass","totalClass","progressbarFillClass","progressbarOppositeClass","clickableClass","horizontalClass","verticalClass","paginationDisabledClass","bullets","dynamicBulletIndex","isPaginationDisabled","setSideBullets","bulletEl","onBulletClick","newSlideIndex","currentSlideIndex","firstIndex","midIndex","classesToRemove","suffix","flat","bullet","bulletIndex","firstDisplayedBullet","lastDisplayedBullet","dynamicBulletsLength","bulletsOffset","subElIndex","fractionEl","textContent","totalEl","progressbarDirection","scale","scaleX","scaleY","progressEl","render","paginationHTML","numberOfBullets","Scrollbar","dragStartPos","dragSize","trackSize","dragTimeout","scrollbar","dragEl","newSize","newPos","hide","opacity","display","getPointerPosition","clientX","clientY","setDragPosition","positionRatio","onDragStart","onDragMove","onDragEnd","snapOnRelease","activeListener","passiveListener","eventMethod","swiperEl","dragClass","draggable","scrollbarDisabledClass","Parallax","parallax","setTransform","rotate","currentOpacity","_swiper","parallaxEl","parallaxDuration","Zoom","maxRatio","containerClass","zoomedSlideClass","fakeGestureTouched","fakeGestureMoved","currentScale","isScaling","gesture","originX","originY","slideWidth","slideHeight","imageWrapEl","image","minX","minY","maxX","maxY","touchesStart","touchesCurrent","prevPositionX","prevPositionY","prevTime","getDistanceBetweenTouches","x1","y1","x2","y2","eventWithinSlide","onGestureStart","scaleStart","getScaleOrigin","onGestureChange","scaleMove","onGestureEnd","eventWithinZoomContainer","scaledWidth","scaledHeight","scaleRatio","onTransitionEnd","zoomIn","touchX","touchY","offsetX","offsetY","translateX","translateY","imageWidth","imageHeight","translateMinX","translateMinY","translateMaxX","translateMaxY","touchAction","forceZoomRatio","zoomOut","zoomToggle","getListeners","activeListenerWithCapture","momentumDurationX","momentumDurationY","momentumDistanceX","newPositionX","momentumDistanceY","newPositionY","momentumDuration","in","out","Controller","LinearSpline","binarySearch","maxIndex","minIndex","guess","i1","i3","interpolate","removeSpline","spline","inverse","by","controlElement","onControllerSwiper","_t","controlled","controlledTranslate","setControlledTranslate","getInterpolateFunction","setControlledTransition","A11y","a11y","notificationClass","prevSlideMessage","nextSlideMessage","firstSlideMessage","lastSlideMessage","paginationBulletMessage","slideLabelMessage","containerMessage","containerRoleDescriptionMessage","itemRoleDescriptionMessage","slideRole","clicked","liveRegion","makeElFocusable","makeElNotFocusable","addElRole","role","addElRoleDescription","addElLabel","disableEl","enableEl","onEnterOrSpaceKey","click","hasPagination","hasClickablePagination","initNavEl","wrapperId","controls","addElControls","handlePointerDown","handlePointerUp","isActive","isVisible","sourceCapabilities","firesTouchEvents","repeat","round","getRandomNumber","live","addElLive","updateNavigation","updatePagination","History","keepQuery","slugify","getPathValues","urlOverride","pathArray","part","setHistory","scrollToSlide","setHistoryPopState","hashNavigation","HashNavigation","watchState","slideWithHash","onHashChange","newHash","activeSlideEl","setHash","activeSlideHash","Autoplay","raf","timeLeft","waitForTransition","disableOnInteraction","stopOnLastSlide","reverseDirection","pauseOnMouseEnter","autoplayTimeLeft","wasPaused","pausedByTouch","touchStartTimeout","slideChanged","pausedByInteraction","autoplayDelayTotal","autoplayDelayCurrent","autoplayStartTime","calcTimeLeft","run","delayForce","currentSlideDelay","getSlideDelay","proceed","start","onVisibilityChange","onPointerEnter","onPointerLeave","Thumb","thumbs","multipleActiveThumbs","autoScrollOffset","slideThumbActiveClass","thumbsContainerClass","swiperCreated","onThumbClick","thumbsSwiper","thumbsParams","SwiperClass","thumbsSwiperParams","thumbsToActivate","thumbActiveClass","useOffset","currentThumbsIndex","newThumbsIndex","newThumbsSlide","getThumbsElementAndInit","thumbsElement","onThumbsSwiper","watchForThumbsToAppear","momentum","momentumRatio","momentumBounce","momentumBounceRatio","momentumVelocityRatio","minimumVelocity","lastMoveEvent","velocityEvent","distance","momentumDistance","newPosition","afterBouncePosition","doBounce","bounceAmount","needsLoopFix","moveDistance","currentSlideSize","Grid","slidesNumberEvenToRows","slidesPerRow","numFullColumns","getSpaceBetween","newSlideOrderIndex","row","groupIndex","slideIndexInGroup","columnsInGroup","order","appendElement","prependElement","addSlide","activeIndexBuffer","baseLength","slidesBuffer","currentSlide","indexToRemove","Manipulation","effectInit","overwriteParams","perspective","recreateShadows","getEffectParams","requireUpdateOnVirtual","overwriteParamsResult","slideShadows","effectTarget","effectParams","transformEl","backfaceVisibility","effectVirtualTransitionEnd","transformElements","allSlides","transitionEndTarget","eventTriggered","parentNode","getSlide","EffectFade","fadeEffect","crossFade","tx","ty","slideOpacity","EffectCube","cubeEffect","shadow","shadowOffset","shadowScale","createSlideShadows","shadowBefore","shadowAfter","cubeShadowEl","wrapperRotate","slideAngle","tz","transformOrigin","shadowAngle","sin","scale1","scale2","zFactor","createShadow","shadowClass","shadowContainer","EffectFlip","flipEffect","limitRotation","rotateY","rotateX","zIndex","EffectCoverflow","coverflowEffect","stretch","depth","modifier","center","centerOffset","offsetMultiplier","translateZ","slideTransform","shadowBeforeEl","shadowAfterEl","EffectCreative","creativeEffect","limitProgress","shadowPerProgress","progressMultiplier","getTranslateValue","isCenteredSlides","margin","custom","translateString","rotateString","scaleString","opacityString","shadowOpacity","EffectCards","cardsEffect","perSlideRotate","perSlideOffset","tX","tY","tZ","tXAdd","isSwipeToNext","isSwipeToPrev","subProgress"],"sourceRoot":""}