{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/es/utils/subscription-manager.js","webpack:///./node_modules/framer-motion/dist/es/utils/array.js","webpack:///./node_modules/framesync/dist/es/on-next-frame.js","webpack:///./node_modules/framesync/dist/es/index.js","webpack:///./node_modules/framesync/dist/es/create-render-step.js","webpack:///./node_modules/popmotion/dist/es/utils/velocity-per-second.js","webpack:///./node_modules/framer-motion/dist/es/value/utils/is-motion-value.js","webpack:///./node_modules/framer-motion/dist/es/value/index.js","webpack:///./node_modules/tslib/tslib.es6.js"],"names":["SubscriptionManager","this","subscriptions","prototype","add","handler","_this","notify","a","b","c","numSubscriptions","length","i","getSize","clear","addUniqueItem","arr","item","indexOf","push","removeItem","index","splice","getCurrentTime","performance","now","Date","onNextFrame","window","callback","requestAnimationFrame","setTimeout","useDefaultElapsed","runNextFrame","isProcessing","delta","timestamp","stepsOrder","steps","reduce","acc","key","toRun","toRunNextFrame","numToRun","toKeepAlive","WeakSet","step","schedule","keepAlive","immediate","addToCurrentFrame","buffer","cancel","delete","process","frameData","_a","has","createRenderStep","sync","startLoop","cancelSync","flushSync","processStep","stepId","processFrame","Math","max","min","forEach","getFrameData","velocityPerSecond","velocity","frameDuration","isMotionValue","value","getVelocity","MotionValue","init","timeDelta","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","v","render","prev","current","postRender","scheduleVelocityCheck","velocityCheck","hasAnimated","isNaN","parseFloat","onChange","subscription","clearListeners","onRenderRequest","get","attach","passiveEffect","set","getPrevious","start","animation","stop","Promise","resolve","stopAnimation","then","clearAnimation","isAnimating","destroy","motionValue","extendStatics","d","Object","setPrototypeOf","__proto__","Array","p","hasOwnProperty","call","__extends","TypeError","String","__","constructor","create","__assign","assign","t","s","n","arguments","apply","__rest","e","getOwnPropertySymbols","propertyIsEnumerable","__read","o","m","Symbol","iterator","r","ar","next","done","error","__spreadArray","to","from","pack","l","slice","concat"],"mappings":"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","file":"2-d7ee157a42942e71f141.js","sourcesContent":["import { addUniqueItem, removeItem } from './array.js';\n\nvar SubscriptionManager = /** @class */ (function () {\n    function SubscriptionManager() {\n        this.subscriptions = [];\n    }\n    SubscriptionManager.prototype.add = function (handler) {\n        var _this = this;\n        addUniqueItem(this.subscriptions, handler);\n        return function () { return removeItem(_this.subscriptions, handler); };\n    };\n    SubscriptionManager.prototype.notify = function (a, b, c) {\n        var numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (var i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                var handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    };\n    SubscriptionManager.prototype.getSize = function () {\n        return this.subscriptions.length;\n    };\n    SubscriptionManager.prototype.clear = function () {\n        this.subscriptions.length = 0;\n    };\n    return SubscriptionManager;\n}());\n\nexport { SubscriptionManager };\n","function addUniqueItem(arr, item) {\n    arr.indexOf(item) === -1 && arr.push(item);\n}\nfunction removeItem(arr, item) {\n    var index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n\nexport { addUniqueItem, removeItem };\n","var defaultTimestep = (1 / 60) * 1000;\nvar getCurrentTime = typeof performance !== \"undefined\"\n    ? function () { return performance.now(); }\n    : function () { return Date.now(); };\nvar onNextFrame = typeof window !== \"undefined\"\n    ? function (callback) {\n        return window.requestAnimationFrame(callback);\n    }\n    : function (callback) {\n        return setTimeout(function () { return callback(getCurrentTime()); }, defaultTimestep);\n    };\n\nexport { defaultTimestep, onNextFrame };\n","import { onNextFrame, defaultTimestep } from './on-next-frame.js';\nimport { createRenderStep } from './create-render-step.js';\n\nvar maxElapsed = 40;\nvar useDefaultElapsed = true;\nvar runNextFrame = false;\nvar isProcessing = false;\nvar frame = {\n    delta: 0,\n    timestamp: 0\n};\nvar stepsOrder = [\"read\", \"update\", \"preRender\", \"render\", \"postRender\"];\nvar steps = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n    acc[key] = createRenderStep(function () {\n        return runNextFrame = true;\n    });\n    return acc;\n}, {});\nvar sync = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n    var step = steps[key];\n    acc[key] = function (process, keepAlive, immediate) {\n        if (keepAlive === void 0) {\n            keepAlive = false;\n        }\n        if (immediate === void 0) {\n            immediate = false;\n        }\n        if (!runNextFrame) startLoop();\n        return step.schedule(process, keepAlive, immediate);\n    };\n    return acc;\n}, {});\nvar cancelSync = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n    acc[key] = steps[key].cancel;\n    return acc;\n}, {});\nvar flushSync = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n    acc[key] = function () {\n        return steps[key].process(frame);\n    };\n    return acc;\n}, {});\nvar processStep = function (stepId) {\n    return steps[stepId].process(frame);\n};\nvar processFrame = function (timestamp) {\n    runNextFrame = false;\n    frame.delta = useDefaultElapsed ? defaultTimestep : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);\n    frame.timestamp = timestamp;\n    isProcessing = true;\n    stepsOrder.forEach(processStep);\n    isProcessing = false;\n    if (runNextFrame) {\n        useDefaultElapsed = false;\n        onNextFrame(processFrame);\n    }\n};\nvar startLoop = function () {\n    runNextFrame = true;\n    useDefaultElapsed = true;\n    if (!isProcessing) onNextFrame(processFrame);\n};\nvar getFrameData = function () {\n    return frame;\n};\n\nexport default sync;\nexport { cancelSync, flushSync, getFrameData };\n","function createRenderStep(runNextFrame) {\n    var toRun = [];\n    var toRunNextFrame = [];\n    var numToRun = 0;\n    var isProcessing = false;\n    var toKeepAlive = new WeakSet();\n    var step = {\n        schedule: function (callback, keepAlive, immediate) {\n            if (keepAlive === void 0) { keepAlive = false; }\n            if (immediate === void 0) { immediate = false; }\n            var addToCurrentFrame = immediate && isProcessing;\n            var buffer = addToCurrentFrame ? toRun : toRunNextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            if (buffer.indexOf(callback) === -1) {\n                buffer.push(callback);\n                if (addToCurrentFrame && isProcessing)\n                    numToRun = toRun.length;\n            }\n            return callback;\n        },\n        cancel: function (callback) {\n            var index = toRunNextFrame.indexOf(callback);\n            if (index !== -1)\n                toRunNextFrame.splice(index, 1);\n            toKeepAlive.delete(callback);\n        },\n        process: function (frameData) {\n            var _a;\n            isProcessing = true;\n            _a = [toRunNextFrame, toRun], toRun = _a[0], toRunNextFrame = _a[1];\n            toRunNextFrame.length = 0;\n            numToRun = toRun.length;\n            if (numToRun) {\n                for (var i = 0; i < numToRun; i++) {\n                    var callback = toRun[i];\n                    callback(frameData);\n                    if (toKeepAlive.has(callback)) {\n                        step.schedule(callback);\n                        runNextFrame();\n                    }\n                }\n            }\n            isProcessing = false;\n        },\n    };\n    return step;\n}\n\nexport { createRenderStep };\n","function velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nexport { velocityPerSecond };\n","var isMotionValue = function (value) {\n    return value !== null && typeof value === \"object\" && value.getVelocity;\n};\n\nexport { isMotionValue };\n","import sync, { getFrameData } from 'framesync';\nimport { velocityPerSecond } from 'popmotion';\nimport { SubscriptionManager } from '../utils/subscription-manager.js';\n\nvar isFloat = function (value) {\n    return !isNaN(parseFloat(value));\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nvar MotionValue = /** @class */ (function () {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    function MotionValue(init) {\n        var _this = this;\n        /**\n         * Duration, in milliseconds, since last updating frame.\n         *\n         * @internal\n         */\n        this.timeDelta = 0;\n        /**\n         * Timestamp of the last time this `MotionValue` was updated.\n         *\n         * @internal\n         */\n        this.lastUpdated = 0;\n        /**\n         * Functions to notify when the `MotionValue` updates.\n         *\n         * @internal\n         */\n        this.updateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the velocity updates.\n         *\n         * @internal\n         */\n        this.velocityUpdateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the `MotionValue` updates and `render` is set to `true`.\n         *\n         * @internal\n         */\n        this.renderSubscribers = new SubscriptionManager();\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = false;\n        this.updateAndNotify = function (v, render) {\n            if (render === void 0) { render = true; }\n            _this.prev = _this.current;\n            _this.current = v;\n            // Update timestamp\n            var _a = getFrameData(), delta = _a.delta, timestamp = _a.timestamp;\n            if (_this.lastUpdated !== timestamp) {\n                _this.timeDelta = delta;\n                _this.lastUpdated = timestamp;\n                sync.postRender(_this.scheduleVelocityCheck);\n            }\n            // Update update subscribers\n            if (_this.prev !== _this.current) {\n                _this.updateSubscribers.notify(_this.current);\n            }\n            // Update velocity subscribers\n            if (_this.velocityUpdateSubscribers.getSize()) {\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n            // Update render subscribers\n            if (render) {\n                _this.renderSubscribers.notify(_this.current);\n            }\n        };\n        /**\n         * Schedule a velocity check for the next frame.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.scheduleVelocityCheck = function () { return sync.postRender(_this.velocityCheck); };\n        /**\n         * Updates `prev` with `current` if the value hasn't been updated this frame.\n         * This ensures velocity calculations return `0`.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.velocityCheck = function (_a) {\n            var timestamp = _a.timestamp;\n            if (timestamp !== _this.lastUpdated) {\n                _this.prev = _this.current;\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n        };\n        this.hasAnimated = false;\n        this.prev = this.current = init;\n        this.canTrackVelocity = isFloat(this.current);\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * @library\n     *\n     * ```jsx\n     * function MyComponent() {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.onChange(updateOpacity)\n     *     const unsubscribeY = y.onChange(updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <Frame x={x} />\n     * }\n     * ```\n     *\n     * @motion\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.onChange(updateOpacity)\n     *     const unsubscribeY = y.onChange(updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @internalremarks\n     *\n     * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\n     *\n     * ```jsx\n     * useOnChange(x, () => {})\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @public\n     */\n    MotionValue.prototype.onChange = function (subscription) {\n        return this.updateSubscribers.add(subscription);\n    };\n    MotionValue.prototype.clearListeners = function () {\n        this.updateSubscribers.clear();\n    };\n    /**\n     * Adds a function that will be notified when the `MotionValue` requests a render.\n     *\n     * @param subscriber - A function that's provided the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @internal\n     */\n    MotionValue.prototype.onRenderRequest = function (subscription) {\n        // Render immediately\n        subscription(this.get());\n        return this.renderSubscribers.add(subscription);\n    };\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    MotionValue.prototype.attach = function (passiveEffect) {\n        this.passiveEffect = passiveEffect;\n    };\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    MotionValue.prototype.set = function (v, render) {\n        if (render === void 0) { render = true; }\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    };\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    MotionValue.prototype.get = function () {\n        return this.current;\n    };\n    /**\n     * @public\n     */\n    MotionValue.prototype.getPrevious = function () {\n        return this.prev;\n    };\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    MotionValue.prototype.getVelocity = function () {\n        // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n        return this.canTrackVelocity\n            ? // These casts could be avoided if parseFloat would be typed better\n                velocityPerSecond(parseFloat(this.current) -\n                    parseFloat(this.prev), this.timeDelta)\n            : 0;\n    };\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    MotionValue.prototype.start = function (animation) {\n        var _this = this;\n        this.stop();\n        return new Promise(function (resolve) {\n            _this.hasAnimated = true;\n            _this.stopAnimation = animation(resolve);\n        }).then(function () { return _this.clearAnimation(); });\n    };\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    MotionValue.prototype.stop = function () {\n        if (this.stopAnimation)\n            this.stopAnimation();\n        this.clearAnimation();\n    };\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    MotionValue.prototype.isAnimating = function () {\n        return !!this.stopAnimation;\n    };\n    MotionValue.prototype.clearAnimation = function () {\n        this.stopAnimation = null;\n    };\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    MotionValue.prototype.destroy = function () {\n        this.updateSubscribers.clear();\n        this.renderSubscribers.clear();\n        this.stop();\n    };\n    return MotionValue;\n}());\n/**\n * @internal\n */\nfunction motionValue(init) {\n    return new MotionValue(init);\n}\n\nexport { MotionValue, motionValue };\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar 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\r\nexport function __extends(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\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(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\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || from);\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n"],"sourceRoot":""}