{"version":3,"file":"js/chunk.f7109d962ff80df0.js","mappings":"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","sources":["webpack:///./node_modules/@ctrl/tinycolor/dist/module/index.js","webpack:///./node_modules/@umijs/use-params/es/index.js","webpack:///./node_modules/omit.js/es/index.js","webpack:///../src/index.ts","webpack:///./node_modules/scroll-into-view-if-needed/es/index.js","webpack:///./node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js"],"sourcesContent":["import { numberInputToObject, rgbaToHex, rgbToHex, rgbToHsl, rgbToHsv } from './conversion';\nimport { names } from './css-color-names';\nimport { inputToRGB } from './format-input';\nimport { bound01, boundAlpha, clamp01 } from './util';\nvar TinyColor = /** @class */ (function () {\n    function TinyColor(color, opts) {\n        if (color === void 0) { color = ''; }\n        if (opts === void 0) { opts = {}; }\n        var _a;\n        // If input is already a tinycolor, return itself\n        if (color instanceof TinyColor) {\n            // eslint-disable-next-line no-constructor-return\n            return color;\n        }\n        if (typeof color === 'number') {\n            color = numberInputToObject(color);\n        }\n        this.originalInput = color;\n        var rgb = inputToRGB(color);\n        this.originalInput = color;\n        this.r = rgb.r;\n        this.g = rgb.g;\n        this.b = rgb.b;\n        this.a = rgb.a;\n        this.roundA = Math.round(100 * this.a) / 100;\n        this.format = (_a = opts.format) !== null && _a !== void 0 ? _a : rgb.format;\n        this.gradientType = opts.gradientType;\n        // Don't let the range of [0,255] come back in [0,1].\n        // Potentially lose a little bit of precision here, but will fix issues where\n        // .5 gets interpreted as half of the total, instead of half of 1\n        // If it was supposed to be 128, this was already taken care of by `inputToRgb`\n        if (this.r < 1) {\n            this.r = Math.round(this.r);\n        }\n        if (this.g < 1) {\n            this.g = Math.round(this.g);\n        }\n        if (this.b < 1) {\n            this.b = Math.round(this.b);\n        }\n        this.isValid = rgb.ok;\n    }\n    TinyColor.prototype.isDark = function () {\n        return this.getBrightness() < 128;\n    };\n    TinyColor.prototype.isLight = function () {\n        return !this.isDark();\n    };\n    /**\n     * Returns the perceived brightness of the color, from 0-255.\n     */\n    TinyColor.prototype.getBrightness = function () {\n        // http://www.w3.org/TR/AERT#color-contrast\n        var rgb = this.toRgb();\n        return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;\n    };\n    /**\n     * Returns the perceived luminance of a color, from 0-1.\n     */\n    TinyColor.prototype.getLuminance = function () {\n        // http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef\n        var rgb = this.toRgb();\n        var R;\n        var G;\n        var B;\n        var RsRGB = rgb.r / 255;\n        var GsRGB = rgb.g / 255;\n        var BsRGB = rgb.b / 255;\n        if (RsRGB <= 0.03928) {\n            R = RsRGB / 12.92;\n        }\n        else {\n            // eslint-disable-next-line prefer-exponentiation-operator\n            R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);\n        }\n        if (GsRGB <= 0.03928) {\n            G = GsRGB / 12.92;\n        }\n        else {\n            // eslint-disable-next-line prefer-exponentiation-operator\n            G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);\n        }\n        if (BsRGB <= 0.03928) {\n            B = BsRGB / 12.92;\n        }\n        else {\n            // eslint-disable-next-line prefer-exponentiation-operator\n            B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);\n        }\n        return 0.2126 * R + 0.7152 * G + 0.0722 * B;\n    };\n    /**\n     * Returns the alpha value of a color, from 0-1.\n     */\n    TinyColor.prototype.getAlpha = function () {\n        return this.a;\n    };\n    /**\n     * Sets the alpha value on the current color.\n     *\n     * @param alpha - The new alpha value. The accepted range is 0-1.\n     */\n    TinyColor.prototype.setAlpha = function (alpha) {\n        this.a = boundAlpha(alpha);\n        this.roundA = Math.round(100 * this.a) / 100;\n        return this;\n    };\n    /**\n     * Returns whether the color is monochrome.\n     */\n    TinyColor.prototype.isMonochrome = function () {\n        var s = this.toHsl().s;\n        return s === 0;\n    };\n    /**\n     * Returns the object as a HSVA object.\n     */\n    TinyColor.prototype.toHsv = function () {\n        var hsv = rgbToHsv(this.r, this.g, this.b);\n        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this.a };\n    };\n    /**\n     * Returns the hsva values interpolated into a string with the following format:\n     * \"hsva(xxx, xxx, xxx, xx)\".\n     */\n    TinyColor.prototype.toHsvString = function () {\n        var hsv = rgbToHsv(this.r, this.g, this.b);\n        var h = Math.round(hsv.h * 360);\n        var s = Math.round(hsv.s * 100);\n        var v = Math.round(hsv.v * 100);\n        return this.a === 1 ? \"hsv(\".concat(h, \", \").concat(s, \"%, \").concat(v, \"%)\") : \"hsva(\".concat(h, \", \").concat(s, \"%, \").concat(v, \"%, \").concat(this.roundA, \")\");\n    };\n    /**\n     * Returns the object as a HSLA object.\n     */\n    TinyColor.prototype.toHsl = function () {\n        var hsl = rgbToHsl(this.r, this.g, this.b);\n        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this.a };\n    };\n    /**\n     * Returns the hsla values interpolated into a string with the following format:\n     * \"hsla(xxx, xxx, xxx, xx)\".\n     */\n    TinyColor.prototype.toHslString = function () {\n        var hsl = rgbToHsl(this.r, this.g, this.b);\n        var h = Math.round(hsl.h * 360);\n        var s = Math.round(hsl.s * 100);\n        var l = Math.round(hsl.l * 100);\n        return this.a === 1 ? \"hsl(\".concat(h, \", \").concat(s, \"%, \").concat(l, \"%)\") : \"hsla(\".concat(h, \", \").concat(s, \"%, \").concat(l, \"%, \").concat(this.roundA, \")\");\n    };\n    /**\n     * Returns the hex value of the color.\n     * @param allow3Char will shorten hex value to 3 char if possible\n     */\n    TinyColor.prototype.toHex = function (allow3Char) {\n        if (allow3Char === void 0) { allow3Char = false; }\n        return rgbToHex(this.r, this.g, this.b, allow3Char);\n    };\n    /**\n     * Returns the hex value of the color -with a # appened.\n     * @param allow3Char will shorten hex value to 3 char if possible\n     */\n    TinyColor.prototype.toHexString = function (allow3Char) {\n        if (allow3Char === void 0) { allow3Char = false; }\n        return '#' + this.toHex(allow3Char);\n    };\n    /**\n     * Returns the hex 8 value of the color.\n     * @param allow4Char will shorten hex value to 4 char if possible\n     */\n    TinyColor.prototype.toHex8 = function (allow4Char) {\n        if (allow4Char === void 0) { allow4Char = false; }\n        return rgbaToHex(this.r, this.g, this.b, this.a, allow4Char);\n    };\n    /**\n     * Returns the hex 8 value of the color -with a # appened.\n     * @param allow4Char will shorten hex value to 4 char if possible\n     */\n    TinyColor.prototype.toHex8String = function (allow4Char) {\n        if (allow4Char === void 0) { allow4Char = false; }\n        return '#' + this.toHex8(allow4Char);\n    };\n    /**\n     * Returns the object as a RGBA object.\n     */\n    TinyColor.prototype.toRgb = function () {\n        return {\n            r: Math.round(this.r),\n            g: Math.round(this.g),\n            b: Math.round(this.b),\n            a: this.a,\n        };\n    };\n    /**\n     * Returns the RGBA values interpolated into a string with the following format:\n     * \"RGBA(xxx, xxx, xxx, xx)\".\n     */\n    TinyColor.prototype.toRgbString = function () {\n        var r = Math.round(this.r);\n        var g = Math.round(this.g);\n        var b = Math.round(this.b);\n        return this.a === 1 ? \"rgb(\".concat(r, \", \").concat(g, \", \").concat(b, \")\") : \"rgba(\".concat(r, \", \").concat(g, \", \").concat(b, \", \").concat(this.roundA, \")\");\n    };\n    /**\n     * Returns the object as a RGBA object.\n     */\n    TinyColor.prototype.toPercentageRgb = function () {\n        var fmt = function (x) { return \"\".concat(Math.round(bound01(x, 255) * 100), \"%\"); };\n        return {\n            r: fmt(this.r),\n            g: fmt(this.g),\n            b: fmt(this.b),\n            a: this.a,\n        };\n    };\n    /**\n     * Returns the RGBA relative values interpolated into a string\n     */\n    TinyColor.prototype.toPercentageRgbString = function () {\n        var rnd = function (x) { return Math.round(bound01(x, 255) * 100); };\n        return this.a === 1\n            ? \"rgb(\".concat(rnd(this.r), \"%, \").concat(rnd(this.g), \"%, \").concat(rnd(this.b), \"%)\")\n            : \"rgba(\".concat(rnd(this.r), \"%, \").concat(rnd(this.g), \"%, \").concat(rnd(this.b), \"%, \").concat(this.roundA, \")\");\n    };\n    /**\n     * The 'real' name of the color -if there is one.\n     */\n    TinyColor.prototype.toName = function () {\n        if (this.a === 0) {\n            return 'transparent';\n        }\n        if (this.a < 1) {\n            return false;\n        }\n        var hex = '#' + rgbToHex(this.r, this.g, this.b, false);\n        for (var _i = 0, _a = Object.entries(names); _i < _a.length; _i++) {\n            var _b = _a[_i], key = _b[0], value = _b[1];\n            if (hex === value) {\n                return key;\n            }\n        }\n        return false;\n    };\n    TinyColor.prototype.toString = function (format) {\n        var formatSet = Boolean(format);\n        format = format !== null && format !== void 0 ? format : this.format;\n        var formattedString = false;\n        var hasAlpha = this.a < 1 && this.a >= 0;\n        var needsAlphaFormat = !formatSet && hasAlpha && (format.startsWith('hex') || format === 'name');\n        if (needsAlphaFormat) {\n            // Special case for \"transparent\", all other non-alpha formats\n            // will return rgba when there is transparency.\n            if (format === 'name' && this.a === 0) {\n                return this.toName();\n            }\n            return this.toRgbString();\n        }\n        if (format === 'rgb') {\n            formattedString = this.toRgbString();\n        }\n        if (format === 'prgb') {\n            formattedString = this.toPercentageRgbString();\n        }\n        if (format === 'hex' || format === 'hex6') {\n            formattedString = this.toHexString();\n        }\n        if (format === 'hex3') {\n            formattedString = this.toHexString(true);\n        }\n        if (format === 'hex4') {\n            formattedString = this.toHex8String(true);\n        }\n        if (format === 'hex8') {\n            formattedString = this.toHex8String();\n        }\n        if (format === 'name') {\n            formattedString = this.toName();\n        }\n        if (format === 'hsl') {\n            formattedString = this.toHslString();\n        }\n        if (format === 'hsv') {\n            formattedString = this.toHsvString();\n        }\n        return formattedString || this.toHexString();\n    };\n    TinyColor.prototype.toNumber = function () {\n        return (Math.round(this.r) << 16) + (Math.round(this.g) << 8) + Math.round(this.b);\n    };\n    TinyColor.prototype.clone = function () {\n        return new TinyColor(this.toString());\n    };\n    /**\n     * Lighten the color a given amount. Providing 100 will always return white.\n     * @param amount - valid between 1-100\n     */\n    TinyColor.prototype.lighten = function (amount) {\n        if (amount === void 0) { amount = 10; }\n        var hsl = this.toHsl();\n        hsl.l += amount / 100;\n        hsl.l = clamp01(hsl.l);\n        return new TinyColor(hsl);\n    };\n    /**\n     * Brighten the color a given amount, from 0 to 100.\n     * @param amount - valid between 1-100\n     */\n    TinyColor.prototype.brighten = function (amount) {\n        if (amount === void 0) { amount = 10; }\n        var rgb = this.toRgb();\n        rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));\n        rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));\n        rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));\n        return new TinyColor(rgb);\n    };\n    /**\n     * Darken the color a given amount, from 0 to 100.\n     * Providing 100 will always return black.\n     * @param amount - valid between 1-100\n     */\n    TinyColor.prototype.darken = function (amount) {\n        if (amount === void 0) { amount = 10; }\n        var hsl = this.toHsl();\n        hsl.l -= amount / 100;\n        hsl.l = clamp01(hsl.l);\n        return new TinyColor(hsl);\n    };\n    /**\n     * Mix the color with pure white, from 0 to 100.\n     * Providing 0 will do nothing, providing 100 will always return white.\n     * @param amount - valid between 1-100\n     */\n    TinyColor.prototype.tint = function (amount) {\n        if (amount === void 0) { amount = 10; }\n        return this.mix('white', amount);\n    };\n    /**\n     * Mix the color with pure black, from 0 to 100.\n     * Providing 0 will do nothing, providing 100 will always return black.\n     * @param amount - valid between 1-100\n     */\n    TinyColor.prototype.shade = function (amount) {\n        if (amount === void 0) { amount = 10; }\n        return this.mix('black', amount);\n    };\n    /**\n     * Desaturate the color a given amount, from 0 to 100.\n     * Providing 100 will is the same as calling greyscale\n     * @param amount - valid between 1-100\n     */\n    TinyColor.prototype.desaturate = function (amount) {\n        if (amount === void 0) { amount = 10; }\n        var hsl = this.toHsl();\n        hsl.s -= amount / 100;\n        hsl.s = clamp01(hsl.s);\n        return new TinyColor(hsl);\n    };\n    /**\n     * Saturate the color a given amount, from 0 to 100.\n     * @param amount - valid between 1-100\n     */\n    TinyColor.prototype.saturate = function (amount) {\n        if (amount === void 0) { amount = 10; }\n        var hsl = this.toHsl();\n        hsl.s += amount / 100;\n        hsl.s = clamp01(hsl.s);\n        return new TinyColor(hsl);\n    };\n    /**\n     * Completely desaturates a color into greyscale.\n     * Same as calling `desaturate(100)`\n     */\n    TinyColor.prototype.greyscale = function () {\n        return this.desaturate(100);\n    };\n    /**\n     * Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.\n     * Values outside of this range will be wrapped into this range.\n     */\n    TinyColor.prototype.spin = function (amount) {\n        var hsl = this.toHsl();\n        var hue = (hsl.h + amount) % 360;\n        hsl.h = hue < 0 ? 360 + hue : hue;\n        return new TinyColor(hsl);\n    };\n    /**\n     * Mix the current color a given amount with another color, from 0 to 100.\n     * 0 means no mixing (return current color).\n     */\n    TinyColor.prototype.mix = function (color, amount) {\n        if (amount === void 0) { amount = 50; }\n        var rgb1 = this.toRgb();\n        var rgb2 = new TinyColor(color).toRgb();\n        var p = amount / 100;\n        var rgba = {\n            r: (rgb2.r - rgb1.r) * p + rgb1.r,\n            g: (rgb2.g - rgb1.g) * p + rgb1.g,\n            b: (rgb2.b - rgb1.b) * p + rgb1.b,\n            a: (rgb2.a - rgb1.a) * p + rgb1.a,\n        };\n        return new TinyColor(rgba);\n    };\n    TinyColor.prototype.analogous = function (results, slices) {\n        if (results === void 0) { results = 6; }\n        if (slices === void 0) { slices = 30; }\n        var hsl = this.toHsl();\n        var part = 360 / slices;\n        var ret = [this];\n        for (hsl.h = (hsl.h - ((part * results) >> 1) + 720) % 360; --results;) {\n            hsl.h = (hsl.h + part) % 360;\n            ret.push(new TinyColor(hsl));\n        }\n        return ret;\n    };\n    /**\n     * taken from https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js\n     */\n    TinyColor.prototype.complement = function () {\n        var hsl = this.toHsl();\n        hsl.h = (hsl.h + 180) % 360;\n        return new TinyColor(hsl);\n    };\n    TinyColor.prototype.monochromatic = function (results) {\n        if (results === void 0) { results = 6; }\n        var hsv = this.toHsv();\n        var h = hsv.h;\n        var s = hsv.s;\n        var v = hsv.v;\n        var res = [];\n        var modification = 1 / results;\n        while (results--) {\n            res.push(new TinyColor({ h: h, s: s, v: v }));\n            v = (v + modification) % 1;\n        }\n        return res;\n    };\n    TinyColor.prototype.splitcomplement = function () {\n        var hsl = this.toHsl();\n        var h = hsl.h;\n        return [\n            this,\n            new TinyColor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l }),\n            new TinyColor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l }),\n        ];\n    };\n    /**\n     * Compute how the color would appear on a background\n     */\n    TinyColor.prototype.onBackground = function (background) {\n        var fg = this.toRgb();\n        var bg = new TinyColor(background).toRgb();\n        return new TinyColor({\n            r: bg.r + (fg.r - bg.r) * fg.a,\n            g: bg.g + (fg.g - bg.g) * fg.a,\n            b: bg.b + (fg.b - bg.b) * fg.a,\n        });\n    };\n    /**\n     * Alias for `polyad(3)`\n     */\n    TinyColor.prototype.triad = function () {\n        return this.polyad(3);\n    };\n    /**\n     * Alias for `polyad(4)`\n     */\n    TinyColor.prototype.tetrad = function () {\n        return this.polyad(4);\n    };\n    /**\n     * Get polyad colors, like (for 1, 2, 3, 4, 5, 6, 7, 8, etc...)\n     * monad, dyad, triad, tetrad, pentad, hexad, heptad, octad, etc...\n     */\n    TinyColor.prototype.polyad = function (n) {\n        var hsl = this.toHsl();\n        var h = hsl.h;\n        var result = [this];\n        var increment = 360 / n;\n        for (var i = 1; i < n; i++) {\n            result.push(new TinyColor({ h: (h + i * increment) % 360, s: hsl.s, l: hsl.l }));\n        }\n        return result;\n    };\n    /**\n     * compare color vs current color\n     */\n    TinyColor.prototype.equals = function (color) {\n        return this.toRgbString() === new TinyColor(color).toRgbString();\n    };\n    return TinyColor;\n}());\nexport { TinyColor };\n// kept for backwards compatability with v1\nexport function tinycolor(color, opts) {\n    if (color === void 0) { color = ''; }\n    if (opts === void 0) { opts = {}; }\n    return new TinyColor(color, opts);\n}\n","var __assign = (this && this.__assign) || function () {\r\n    __assign = Object.assign || function(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))\r\n                t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\n/* eslint-disable no-restricted-syntax */\r\nimport { useEffect, useMemo, useState } from 'react';\r\n/**\r\n *\r\n * @param {object} params\r\n * @returns {URL}\r\n */\r\nfunction setQueryToCurrentUrl(params) {\r\n    var _a;\r\n    var URL = (typeof window !== 'undefined' ? window : {}).URL;\r\n    var url = new URL((_a = window === null || window === void 0 ? void 0 : window.location) === null || _a === void 0 ? void 0 : _a.href);\r\n    Object.keys(params).forEach(function (key) {\r\n        var value = params[key];\r\n        if (value !== null && value !== undefined) {\r\n            if (Array.isArray(value)) {\r\n                url.searchParams.delete(key);\r\n                value.forEach(function (valueItem) {\r\n                    url.searchParams.append(key, valueItem);\r\n                });\r\n            }\r\n            else if (value instanceof Date) {\r\n                if (!Number.isNaN(value.getTime())) {\r\n                    url.searchParams.set(key, value.toISOString());\r\n                }\r\n            }\r\n            else if (typeof value === 'object') {\r\n                url.searchParams.set(key, JSON.stringify(value));\r\n            }\r\n            else {\r\n                url.searchParams.set(key, value);\r\n            }\r\n        }\r\n        else {\r\n            url.searchParams.delete(key);\r\n        }\r\n    });\r\n    return url;\r\n}\r\nexport function useUrlSearchParams(initial, config) {\r\n    var _a;\r\n    if (initial === void 0) { initial = {}; }\r\n    if (config === void 0) { config = { disabled: false }; }\r\n    /**\r\n     * The main idea of this hook is to make things response to change of `window.location.search`,\r\n     * so no need for introducing new state (in the mean time).\r\n     * Whenever `window.location.search` is changed but  not cause re-render, call `forceUpdate()`.\r\n     * Whenever the component - user of this hook - re-render, this hook should return\r\n     * the query object that corresponse to the current `window.location.search`\r\n     */\r\n    var _b = useState(), forceUpdate = _b[1];\r\n    var locationSearch = typeof window !== 'undefined' && ((_a = window === null || window === void 0 ? void 0 : window.location) === null || _a === void 0 ? void 0 : _a.search);\r\n    /**\r\n     * @type {URLSearchParams}\r\n     */\r\n    var urlSearchParams = useMemo(function () {\r\n        if (config.disabled)\r\n            return {};\r\n        return new URLSearchParams(locationSearch || {});\r\n    }, [config.disabled, locationSearch]);\r\n    var params = useMemo(function () {\r\n        if (config.disabled)\r\n            return {};\r\n        if (typeof window === 'undefined' || !window.URL)\r\n            return {};\r\n        var result = [];\r\n        // @ts-ignore\r\n        urlSearchParams.forEach(function (value, key) {\r\n            result.push({\r\n                key: key,\r\n                value: value,\r\n            });\r\n        });\r\n        // group by key\r\n        result = result.reduce(function (acc, val) {\r\n            (acc[val.key] = acc[val.key] || []).push(val);\r\n            return acc;\r\n        }, {});\r\n        result = Object.keys(result).map(function (key) {\r\n            var valueGroup = result[key];\r\n            if (valueGroup.length === 1) {\r\n                return [key, valueGroup[0].value];\r\n            }\r\n            return [key, valueGroup.map(function (_a) {\r\n                    var value = _a.value;\r\n                    return value;\r\n                })];\r\n        });\r\n        var newParams = __assign({}, initial);\r\n        result.forEach(function (_a) {\r\n            var key = _a[0], value = _a[1];\r\n            newParams[key] = parseValue(key, value, {}, initial);\r\n        });\r\n        return newParams;\r\n    }, [config.disabled, initial, urlSearchParams]);\r\n    function redirectToNewSearchParams(newParams) {\r\n        if (typeof window === 'undefined' || !window.URL)\r\n            return;\r\n        var url = setQueryToCurrentUrl(newParams);\r\n        if (window.location.search !== url.search) {\r\n            window.history.replaceState({}, '', url.toString());\r\n        }\r\n        if (urlSearchParams.toString() !== url.searchParams.toString()) {\r\n            forceUpdate({});\r\n        }\r\n    }\r\n    useEffect(function () {\r\n        if (config.disabled)\r\n            return;\r\n        if (typeof window === 'undefined' || !window.URL)\r\n            return;\r\n        redirectToNewSearchParams(__assign(__assign({}, initial), params));\r\n    }, [config.disabled, params]);\r\n    var setParams = function (newParams) {\r\n        redirectToNewSearchParams(newParams);\r\n    };\r\n    useEffect(function () {\r\n        if (config.disabled)\r\n            return function () { };\r\n        if (typeof window === 'undefined' || !window.URL)\r\n            return function () { };\r\n        var onPopState = function () {\r\n            forceUpdate({});\r\n        };\r\n        window.addEventListener('popstate', onPopState);\r\n        return function () {\r\n            window.removeEventListener('popstate', onPopState);\r\n        };\r\n    }, [config.disabled]);\r\n    return [params, setParams];\r\n}\r\nvar booleanValues = {\r\n    true: true,\r\n    false: false,\r\n};\r\nfunction parseValue(key, _value, types, defaultParams) {\r\n    if (!types)\r\n        return _value;\r\n    var type = types[key];\r\n    var value = _value === undefined ? defaultParams[key] : _value;\r\n    if (type === Number) {\r\n        return Number(value);\r\n    }\r\n    if (type === Boolean || _value === 'true' || _value === 'false') {\r\n        return booleanValues[value];\r\n    }\r\n    if (Array.isArray(type)) {\r\n        // eslint-disable-next-line eqeqeq\r\n        return type.find(function (item) { return item == value; }) || defaultParams[key];\r\n    }\r\n    return value;\r\n}\r\n","function omit(obj, fields) {\n  // eslint-disable-next-line prefer-object-spread\n  var shallowCopy = Object.assign({}, obj);\n\n  for (var i = 0; i < fields.length; i += 1) {\n    var key = fields[i];\n    delete shallowCopy[key];\n  }\n\n  return shallowCopy;\n}\n\nexport default omit;","// Compute what scrolling needs to be done on required scrolling boxes for target to be in view\n\n// The type names here are named after the spec to make it easier to find more information around what they mean:\n// To reduce churn and reduce things that need be maintained things from the official TS DOM library is used here\n// https://drafts.csswg.org/cssom-view/\n\n// For a definition on what is \"block flow direction\" exactly, check this: https://drafts.csswg.org/css-writing-modes-4/#block-flow-direction\n\n// add support for visualViewport object currently implemented in chrome\ninterface visualViewport {\n  height: number\n  width: number\n}\n\ntype ScrollLogicalPosition = 'start' | 'center' | 'end' | 'nearest'\n// This new option is tracked in this PR, which is the most likely candidate at the time: https://github.com/w3c/csswg-drafts/pull/1805\ntype ScrollMode = 'always' | 'if-needed'\n// New option that skips auto-scrolling all nodes with overflow: hidden set\n// See FF implementation: https://hg.mozilla.org/integration/fx-team/rev/c48c3ec05012#l7.18\ntype SkipOverflowHiddenElements = boolean\n\ninterface Options {\n  block?: ScrollLogicalPosition\n  inline?: ScrollLogicalPosition\n  scrollMode?: ScrollMode\n  boundary?: CustomScrollBoundary\n  skipOverflowHiddenElements?: SkipOverflowHiddenElements\n}\n\n// Custom behavior, not in any spec\ntype CustomScrollBoundaryCallback = (parent: Element) => boolean\ntype CustomScrollBoundary = Element | CustomScrollBoundaryCallback | null\ninterface CustomScrollAction {\n  el: Element\n  top: number\n  left: number\n}\n\n// @TODO better shadowdom test, 11 = document fragment\nfunction isElement(el: any): el is Element {\n  return typeof el === 'object' && el != null && el.nodeType === 1\n}\n\nfunction canOverflow(\n  overflow: string | null,\n  skipOverflowHiddenElements?: boolean\n) {\n  if (skipOverflowHiddenElements && overflow === 'hidden') {\n    return false\n  }\n\n  return overflow !== 'visible' && overflow !== 'clip'\n}\n\nfunction getFrameElement(el: Element) {\n  if (!el.ownerDocument || !el.ownerDocument.defaultView) {\n    return null\n  }\n\n  try {\n    return el.ownerDocument.defaultView.frameElement\n  } catch (e) {\n    return null\n  }\n}\n\nfunction isHiddenByFrame(el: Element): boolean {\n  const frame = getFrameElement(el)\n  if (!frame) {\n    return false\n  }\n\n  return (\n    frame.clientHeight < el.scrollHeight || frame.clientWidth < el.scrollWidth\n  )\n}\n\nfunction isScrollable(el: Element, skipOverflowHiddenElements?: boolean) {\n  if (el.clientHeight < el.scrollHeight || el.clientWidth < el.scrollWidth) {\n    const style = getComputedStyle(el, null)\n    return (\n      canOverflow(style.overflowY, skipOverflowHiddenElements) ||\n      canOverflow(style.overflowX, skipOverflowHiddenElements) ||\n      isHiddenByFrame(el)\n    )\n  }\n\n  return false\n}\n/**\n * Find out which edge to align against when logical scroll position is \"nearest\"\n * Interesting fact: \"nearest\" works similarily to \"if-needed\", if the element is fully visible it will not scroll it\n *\n * Legends:\n * ┌────────┐ ┏ ━ ━ ━ ┓\n * │ target │   frame\n * └────────┘ ┗ ━ ━ ━ ┛\n */\nfunction alignNearest(\n  scrollingEdgeStart: number,\n  scrollingEdgeEnd: number,\n  scrollingSize: number,\n  scrollingBorderStart: number,\n  scrollingBorderEnd: number,\n  elementEdgeStart: number,\n  elementEdgeEnd: number,\n  elementSize: number\n) {\n  /**\n   * If element edge A and element edge B are both outside scrolling box edge A and scrolling box edge B\n   *\n   *          ┌──┐\n   *        ┏━│━━│━┓\n   *          │  │\n   *        ┃ │  │ ┃        do nothing\n   *          │  │\n   *        ┗━│━━│━┛\n   *          └──┘\n   *\n   *  If element edge C and element edge D are both outside scrolling box edge C and scrolling box edge D\n   *\n   *    ┏ ━ ━ ━ ━ ┓\n   *   ┌───────────┐\n   *   │┃         ┃│        do nothing\n   *   └───────────┘\n   *    ┗ ━ ━ ━ ━ ┛\n   */\n  if (\n    (elementEdgeStart < scrollingEdgeStart &&\n      elementEdgeEnd > scrollingEdgeEnd) ||\n    (elementEdgeStart > scrollingEdgeStart && elementEdgeEnd < scrollingEdgeEnd)\n  ) {\n    return 0\n  }\n\n  /**\n   * If element edge A is outside scrolling box edge A and element height is less than scrolling box height\n   *\n   *          ┌──┐\n   *        ┏━│━━│━┓         ┏━┌━━┐━┓\n   *          └──┘             │  │\n   *  from  ┃      ┃     to  ┃ └──┘ ┃\n   *\n   *        ┗━ ━━ ━┛         ┗━ ━━ ━┛\n   *\n   * If element edge B is outside scrolling box edge B and element height is greater than scrolling box height\n   *\n   *        ┏━ ━━ ━┓         ┏━┌━━┐━┓\n   *                           │  │\n   *  from  ┃ ┌──┐ ┃     to  ┃ │  │ ┃\n   *          │  │             │  │\n   *        ┗━│━━│━┛         ┗━│━━│━┛\n   *          │  │             └──┘\n   *          │  │\n   *          └──┘\n   *\n   * If element edge C is outside scrolling box edge C and element width is less than scrolling box width\n   *\n   *       from                 to\n   *    ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓\n   *  ┌───┐                 ┌───┐\n   *  │ ┃ │       ┃         ┃   │     ┃\n   *  └───┘                 └───┘\n   *    ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛\n   *\n   * If element edge D is outside scrolling box edge D and element width is greater than scrolling box width\n   *\n   *       from                 to\n   *    ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓\n   *        ┌───────────┐   ┌───────────┐\n   *    ┃   │     ┃     │   ┃         ┃ │\n   *        └───────────┘   └───────────┘\n   *    ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛\n   */\n  if (\n    (elementEdgeStart <= scrollingEdgeStart && elementSize <= scrollingSize) ||\n    (elementEdgeEnd >= scrollingEdgeEnd && elementSize >= scrollingSize)\n  ) {\n    return elementEdgeStart - scrollingEdgeStart - scrollingBorderStart\n  }\n\n  /**\n   * If element edge B is outside scrolling box edge B and element height is less than scrolling box height\n   *\n   *        ┏━ ━━ ━┓         ┏━ ━━ ━┓\n   *\n   *  from  ┃      ┃     to  ┃ ┌──┐ ┃\n   *          ┌──┐             │  │\n   *        ┗━│━━│━┛         ┗━└━━┘━┛\n   *          └──┘\n   *\n   * If element edge A is outside scrolling box edge A and element height is greater than scrolling box height\n   *\n   *          ┌──┐\n   *          │  │\n   *          │  │             ┌──┐\n   *        ┏━│━━│━┓         ┏━│━━│━┓\n   *          │  │             │  │\n   *  from  ┃ └──┘ ┃     to  ┃ │  │ ┃\n   *                           │  │\n   *        ┗━ ━━ ━┛         ┗━└━━┘━┛\n   *\n   * If element edge C is outside scrolling box edge C and element width is greater than scrolling box width\n   *\n   *           from                 to\n   *        ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓\n   *  ┌───────────┐           ┌───────────┐\n   *  │     ┃     │   ┃       │ ┃         ┃\n   *  └───────────┘           └───────────┘\n   *        ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛\n   *\n   * If element edge D is outside scrolling box edge D and element width is less than scrolling box width\n   *\n   *           from                 to\n   *        ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓\n   *                ┌───┐             ┌───┐\n   *        ┃       │ ┃ │       ┃     │   ┃\n   *                └───┘             └───┘\n   *        ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛\n   *\n   */\n  if (\n    (elementEdgeEnd > scrollingEdgeEnd && elementSize < scrollingSize) ||\n    (elementEdgeStart < scrollingEdgeStart && elementSize > scrollingSize)\n  ) {\n    return elementEdgeEnd - scrollingEdgeEnd + scrollingBorderEnd\n  }\n\n  return 0\n}\n\nfunction getParentElement(element: Node): Element | null {\n  const parent = element.parentElement\n  if (parent == null) {\n    return (element.getRootNode() as ShadowRoot).host || null\n  }\n  return parent\n}\n\nexport default (target: Element, options: Options): CustomScrollAction[] => {\n  //TODO: remove this hack when microbundle will support typescript >= 4.0\n  const windowWithViewport = window as unknown as Window & {\n    visualViewport: visualViewport\n  }\n\n  const { scrollMode, block, inline, boundary, skipOverflowHiddenElements } =\n    options\n  // Allow using a callback to check the boundary\n  // The default behavior is to check if the current target matches the boundary element or not\n  // If undefined it'll check that target is never undefined (can happen as we recurse up the tree)\n  const checkBoundary =\n    typeof boundary === 'function' ? boundary : (node: any) => node !== boundary\n\n  if (!isElement(target)) {\n    throw new TypeError('Invalid target')\n  }\n\n  // Used to handle the top most element that can be scrolled\n  const scrollingElement = document.scrollingElement || document.documentElement\n\n  // Collect all the scrolling boxes, as defined in the spec: https://drafts.csswg.org/cssom-view/#scrolling-box\n  const frames: Element[] = []\n  let cursor: Element | null = target\n  while (isElement(cursor) && checkBoundary(cursor)) {\n    // Move cursor to parent\n    cursor = getParentElement(cursor)\n\n    // Stop when we reach the viewport\n    if (cursor === scrollingElement) {\n      frames.push(cursor)\n      break\n    }\n\n    // Skip document.body if it's not the scrollingElement and documentElement isn't independently scrollable\n    if (\n      cursor != null &&\n      cursor === document.body &&\n      isScrollable(cursor) &&\n      !isScrollable(document.documentElement)\n    ) {\n      continue\n    }\n\n    // Now we check if the element is scrollable, this code only runs if the loop haven't already hit the viewport or a custom boundary\n    if (cursor != null && isScrollable(cursor, skipOverflowHiddenElements)) {\n      frames.push(cursor)\n    }\n  }\n\n  // Support pinch-zooming properly, making sure elements scroll into the visual viewport\n  // Browsers that don't support visualViewport will report the layout viewport dimensions on document.documentElement.clientWidth/Height\n  // and viewport dimensions on window.innerWidth/Height\n  // https://www.quirksmode.org/mobile/viewports2.html\n  // https://bokand.github.io/viewport/index.html\n  const viewportWidth = windowWithViewport.visualViewport\n    ? windowWithViewport.visualViewport.width\n    : innerWidth\n  const viewportHeight = windowWithViewport.visualViewport\n    ? windowWithViewport.visualViewport.height\n    : innerHeight\n\n  // Newer browsers supports scroll[X|Y], page[X|Y]Offset is\n  const viewportX = window.scrollX || pageXOffset\n  const viewportY = window.scrollY || pageYOffset\n\n  const {\n    height: targetHeight,\n    width: targetWidth,\n    top: targetTop,\n    right: targetRight,\n    bottom: targetBottom,\n    left: targetLeft,\n  } = target.getBoundingClientRect()\n\n  // These values mutate as we loop through and generate scroll coordinates\n  let targetBlock: number =\n    block === 'start' || block === 'nearest'\n      ? targetTop\n      : block === 'end'\n      ? targetBottom\n      : targetTop + targetHeight / 2 // block === 'center\n  let targetInline: number =\n    inline === 'center'\n      ? targetLeft + targetWidth / 2\n      : inline === 'end'\n      ? targetRight\n      : targetLeft // inline === 'start || inline === 'nearest\n\n  // Collect new scroll positions\n  const computations: CustomScrollAction[] = []\n  // In chrome there's no longer a difference between caching the `frames.length` to a var or not, so we don't in this case (size > speed anyways)\n  for (let index = 0; index < frames.length; index++) {\n    const frame = frames[index]\n\n    // @TODO add a shouldScroll hook here that allows userland code to take control\n\n    const { height, width, top, right, bottom, left } =\n      frame.getBoundingClientRect()\n\n    // If the element is already visible we can end it here\n    // @TODO targetBlock and targetInline should be taken into account to be compliant with https://github.com/w3c/csswg-drafts/pull/1805/files#diff-3c17f0e43c20f8ecf89419d49e7ef5e0R1333\n    if (\n      scrollMode === 'if-needed' &&\n      targetTop >= 0 &&\n      targetLeft >= 0 &&\n      targetBottom <= viewportHeight &&\n      targetRight <= viewportWidth &&\n      targetTop >= top &&\n      targetBottom <= bottom &&\n      targetLeft >= left &&\n      targetRight <= right\n    ) {\n      // Break the loop and return the computations for things that are not fully visible\n      return computations\n    }\n\n    const frameStyle = getComputedStyle(frame)\n    const borderLeft = parseInt(frameStyle.borderLeftWidth as string, 10)\n    const borderTop = parseInt(frameStyle.borderTopWidth as string, 10)\n    const borderRight = parseInt(frameStyle.borderRightWidth as string, 10)\n    const borderBottom = parseInt(frameStyle.borderBottomWidth as string, 10)\n\n    let blockScroll: number = 0\n    let inlineScroll: number = 0\n\n    // The property existance checks for offfset[Width|Height] is because only HTMLElement objects have them, but any Element might pass by here\n    // @TODO find out if the \"as HTMLElement\" overrides can be dropped\n    const scrollbarWidth =\n      'offsetWidth' in frame\n        ? (frame as HTMLElement).offsetWidth -\n          (frame as HTMLElement).clientWidth -\n          borderLeft -\n          borderRight\n        : 0\n    const scrollbarHeight =\n      'offsetHeight' in frame\n        ? (frame as HTMLElement).offsetHeight -\n          (frame as HTMLElement).clientHeight -\n          borderTop -\n          borderBottom\n        : 0\n\n    const scaleX =\n      'offsetWidth' in frame\n        ? (frame as HTMLElement).offsetWidth === 0\n          ? 0\n          : width / (frame as HTMLElement).offsetWidth\n        : 0\n    const scaleY =\n      'offsetHeight' in frame\n        ? (frame as HTMLElement).offsetHeight === 0\n          ? 0\n          : height / (frame as HTMLElement).offsetHeight\n        : 0\n\n    if (scrollingElement === frame) {\n      // Handle viewport logic (document.documentElement or document.body)\n\n      if (block === 'start') {\n        blockScroll = targetBlock\n      } else if (block === 'end') {\n        blockScroll = targetBlock - viewportHeight\n      } else if (block === 'nearest') {\n        blockScroll = alignNearest(\n          viewportY,\n          viewportY + viewportHeight,\n          viewportHeight,\n          borderTop,\n          borderBottom,\n          viewportY + targetBlock,\n          viewportY + targetBlock + targetHeight,\n          targetHeight\n        )\n      } else {\n        // block === 'center' is the default\n        blockScroll = targetBlock - viewportHeight / 2\n      }\n\n      if (inline === 'start') {\n        inlineScroll = targetInline\n      } else if (inline === 'center') {\n        inlineScroll = targetInline - viewportWidth / 2\n      } else if (inline === 'end') {\n        inlineScroll = targetInline - viewportWidth\n      } else {\n        // inline === 'nearest' is the default\n        inlineScroll = alignNearest(\n          viewportX,\n          viewportX + viewportWidth,\n          viewportWidth,\n          borderLeft,\n          borderRight,\n          viewportX + targetInline,\n          viewportX + targetInline + targetWidth,\n          targetWidth\n        )\n      }\n\n      // Apply scroll position offsets and ensure they are within bounds\n      // @TODO add more test cases to cover this 100%\n      blockScroll = Math.max(0, blockScroll + viewportY)\n      inlineScroll = Math.max(0, inlineScroll + viewportX)\n    } else {\n      // Handle each scrolling frame that might exist between the target and the viewport\n\n      if (block === 'start') {\n        blockScroll = targetBlock - top - borderTop\n      } else if (block === 'end') {\n        blockScroll = targetBlock - bottom + borderBottom + scrollbarHeight\n      } else if (block === 'nearest') {\n        blockScroll = alignNearest(\n          top,\n          bottom,\n          height,\n          borderTop,\n          borderBottom + scrollbarHeight,\n          targetBlock,\n          targetBlock + targetHeight,\n          targetHeight\n        )\n      } else {\n        // block === 'center' is the default\n        blockScroll = targetBlock - (top + height / 2) + scrollbarHeight / 2\n      }\n\n      if (inline === 'start') {\n        inlineScroll = targetInline - left - borderLeft\n      } else if (inline === 'center') {\n        inlineScroll = targetInline - (left + width / 2) + scrollbarWidth / 2\n      } else if (inline === 'end') {\n        inlineScroll = targetInline - right + borderRight + scrollbarWidth\n      } else {\n        // inline === 'nearest' is the default\n        inlineScroll = alignNearest(\n          left,\n          right,\n          width,\n          borderLeft,\n          borderRight + scrollbarWidth,\n          targetInline,\n          targetInline + targetWidth,\n          targetWidth\n        )\n      }\n\n      const { scrollLeft, scrollTop } = frame\n      // Ensure scroll coordinates are not out of bounds while applying scroll offsets\n      blockScroll = Math.max(\n        0,\n        Math.min(\n          scrollTop + blockScroll / scaleY,\n          frame.scrollHeight - height / scaleY + scrollbarHeight\n        )\n      )\n      inlineScroll = Math.max(\n        0,\n        Math.min(\n          scrollLeft + inlineScroll / scaleX,\n          frame.scrollWidth - width / scaleX + scrollbarWidth\n        )\n      )\n\n      // Cache the offset so that parent frames can scroll this into view correctly\n      targetBlock += scrollTop - blockScroll\n      targetInline += scrollLeft - inlineScroll\n    }\n\n    computations.push({ el: frame, top: blockScroll, left: inlineScroll })\n  }\n\n  return computations\n}\n","import compute from 'compute-scroll-into-view';\nfunction isOptionsObject(options) {\n  return options === Object(options) && Object.keys(options).length !== 0;\n}\nfunction defaultBehavior(actions, behavior) {\n  if (behavior === void 0) {\n    behavior = 'auto';\n  }\n  var canSmoothScroll = ('scrollBehavior' in document.body.style);\n  actions.forEach(function (_ref) {\n    var el = _ref.el,\n      top = _ref.top,\n      left = _ref.left;\n    if (el.scroll && canSmoothScroll) {\n      el.scroll({\n        top: top,\n        left: left,\n        behavior: behavior\n      });\n    } else {\n      el.scrollTop = top;\n      el.scrollLeft = left;\n    }\n  });\n}\nfunction getOptions(options) {\n  if (options === false) {\n    return {\n      block: 'end',\n      inline: 'nearest'\n    };\n  }\n  if (isOptionsObject(options)) {\n    return options;\n  }\n  return {\n    block: 'start',\n    inline: 'nearest'\n  };\n}\nfunction scrollIntoView(target, options) {\n  var isTargetAttached = target.isConnected || target.ownerDocument.documentElement.contains(target);\n  if (isOptionsObject(options) && typeof options.behavior === 'function') {\n    return options.behavior(isTargetAttached ? compute(target, options) : []);\n  }\n  if (!isTargetAttached) {\n    return;\n  }\n  var computeOptions = getOptions(options);\n  return defaultBehavior(compute(target, computeOptions), computeOptions.behavior);\n}\nexport default scrollIntoView;","import unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nexport default function _createForOfIteratorHelper(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (!it) {\n    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n      var F = function F() {};\n      return {\n        s: F,\n        n: function n() {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function e(_e) {\n          throw _e;\n        },\n        f: F\n      };\n    }\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n  var normalCompletion = true,\n    didErr = false,\n    err;\n  return {\n    s: function s() {\n      it = it.call(o);\n    },\n    n: function n() {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function e(_e2) {\n      didErr = true;\n      err = _e2;\n    },\n    f: function f() {\n      try {\n        if (!normalCompletion && it[\"return\"] != null) it[\"return\"]();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}"],"names":["TinyColor","color","opts","_a","numberInputToObject","this","originalInput","rgb","inputToRGB","r","g","b","a","roundA","Math","round","format","gradientType","isValid","ok","prototype","isDark","getBrightness","isLight","toRgb","getLuminance","RsRGB","GsRGB","BsRGB","pow","getAlpha","setAlpha","alpha","boundAlpha","isMonochrome","toHsl","s","toHsv","hsv","rgbToHsv","h","v","toHsvString","concat","hsl","rgbToHsl","l","toHslString","toHex","allow3Char","rgbToHex","toHexString","toHex8","allow4Char","rgbaToHex","toHex8String","toRgbString","toPercentageRgb","fmt","x","bound01","toPercentageRgbString","rnd","toName","hex","_i","Object","entries","names","length","_b","key","toString","formatSet","Boolean","formattedString","hasAlpha","startsWith","toNumber","clone","lighten","amount","clamp01","brighten","max","min","darken","tint","mix","shade","desaturate","saturate","greyscale","spin","hue","rgb1","rgb2","p","analogous","results","slices","part","ret","push","complement","monochromatic","res","modification","splitcomplement","onBackground","background","fg","bg","triad","polyad","tetrad","n","result","increment","i","equals","__assign","assign","t","arguments","hasOwnProperty","call","apply","useUrlSearchParams","initial","config","disabled","forceUpdate","useState","locationSearch","window","location","search","urlSearchParams","useMemo","URLSearchParams","params","URL","forEach","value","reduce","acc","val","keys","map","valueGroup","newParams","_value","types","defaultParams","type","undefined","Number","booleanValues","Array","isArray","find","item","parseValue","redirectToNewSearchParams","url","href","searchParams","delete","valueItem","append","Date","isNaN","getTime","set","toISOString","JSON","stringify","setQueryToCurrentUrl","history","replaceState","useEffect","onPopState","addEventListener","removeEventListener","true","false","obj","fields","shallowCopy","el","nodeType","canOverflow","overflow","skipOverflowHiddenElements","isScrollable","clientHeight","scrollHeight","clientWidth","scrollWidth","style","getComputedStyle","overflowY","overflowX","frame","ownerDocument","defaultView","frameElement","e","scrollingEdgeStart","scrollingEdgeEnd","scrollingSize","scrollingBorderStart","scrollingBorderEnd","elementEdgeStart","elementEdgeEnd","elementSize","target","options","windowWithViewport","scrollMode","block","inline","boundary","checkBoundary","node","isElement","TypeError","element","parent","scrollingElement","document","documentElement","frames","cursor","parentElement","getRootNode","host","body","viewportWidth","visualViewport","width","innerWidth","viewportHeight","height","innerHeight","scrollX","pageXOffset","viewportY","scrollY","pageYOffset","_target$getBoundingCl","getBoundingClientRect","targetHeight","targetWidth","targetTop","top","targetRight","right","targetBottom","bottom","targetLeft","left","targetBlock","targetInline","computations","index","_frame$getBoundingCli","frameStyle","borderLeft","parseInt","borderLeftWidth","borderTop","borderTopWidth","A","borderRightWidth","borderBottom","borderBottomWidth","blockScroll","inlineScroll","scrollbarWidth","offsetWidth","borderRight","scrollbarHeight","offsetHeight","scaleX","scaleY","alignNearest","viewportX","scrollLeft","scrollTop","isOptionsObject","isTargetAttached","isConnected","contains","behavior","compute","computeOptions","getOptions","actions","canSmoothScroll","_ref","scroll","defaultBehavior","_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","unsupportedIterableToArray","F","done","_e","f","err","normalCompletion","didErr","step","next","_e2"],"sourceRoot":""}