agmon 0.1.1 → 0.1.3

package/.next/server/chunks/ssr/node_modules_pixi_js_lib_0hcyh9uzlz7ci._.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../node_modules/pixi.js/src/assets/loader/parsers/LoaderParser.ts","../../../../node_modules/pixi.js/src/utils/path.ts","../../../../node_modules/pixi.js/src/assets/utils/convertToList.ts","../../../../node_modules/pixi.js/src/assets/cache/Cache.ts","../../../../node_modules/pixi.js/src/rendering/renderers/shared/texture/utils/textureFrom.ts","../../../../node_modules/pixi.js/src/rendering/init.ts","../../../../node_modules/pixi.js/src/utils/browser/detectVideoAlphaMode.ts","../../../../node_modules/pixi.js/src/rendering/mask/color/ColorMask.ts","../../../../node_modules/pixi.js/src/rendering/mask/utils/addMaskBounds.ts","../../../../node_modules/pixi.js/src/rendering/mask/utils/addMaskLocalBounds.ts","../../../../node_modules/pixi.js/src/rendering/renderers/shared/texture/sources/VideoSource.ts","../../../../node_modules/pixi.js/src/rendering/mask/alpha/AlphaMask.ts","../../../../node_modules/pixi.js/src/rendering/mask/stencil/StencilMask.ts","../../../../node_modules/pixi.js/src/scene/text/utils/getPo2TextureFromSource.ts","../../../../node_modules/pixi.js/src/assets/utils/copySearchParams.ts","../../../../node_modules/pixi.js/src/assets/utils/createStringVariations.ts","../../../../node_modules/pixi.js/src/assets/utils/isSingleItem.ts","../../../../node_modules/pixi.js/src/spritesheet/init.ts","../../../../node_modules/pixi.js/src/spritesheet/Spritesheet.ts","../../../../node_modules/pixi.js/src/assets/resolver/Resolver.ts","../../../../node_modules/pixi.js/src/spritesheet/spritesheetAsset.ts"],"sourcesContent":["import type { ExtensionMetadata } from '../../../extensions/Extensions';\nimport type { ResolvedAsset } from '../../types';\nimport type { Loader } from '../Loader';\n\n/**\n * The extension priority for loader parsers.\n * Helpful when managing multiple parsers that share the same extension test.\n * The higher priority parsers will be checked first.\n * @category assets\n * @advanced\n */\nexport enum LoaderParserPriority\n{\n    /** Generic parsers: txt, json, webfonts */\n    Low = 0,\n    /** PixiJS assets with generic extensions: spritesheets, bitmapfonts  */\n    Normal = 1,\n    /** Specific texture types: svg, png, ktx, dds, basis */\n    High = 2,\n}\n\n/**\n * A more verbose version of the LoaderParser, allowing you to set the loaded, parsed, and unloaded asset separately\n * @category assets\n * @advanced\n */\nexport interface LoaderParserAdvanced<\n    ASSET = any,\n    PARSED_ASSET = ASSET,\n    UNLOAD_ASSET = ASSET,\n    META_DATA = any,\n    CONFIG = Record<string, any>\n>\n{\n    /** Should be ExtensionType.LoaderParser */\n    extension?: ExtensionMetadata;\n\n    /** A config to adjust the parser */\n    config?: CONFIG;\n\n    /**\n     * @deprecated Use `id` instead.\n     */\n    name?: string;\n    /** The name of the parser (this can be used when specifying parser in a ResolvedAsset) */\n    id: string;\n\n    /**\n     * Each URL to load will be tested here,\n     * if the test is passed the assets are loaded using the load function below.\n     * Good place to test for things like file extensions!\n     * @param url - The URL to test\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    test?: (url: string, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => boolean;\n\n    /**\n     * This is the promise that loads the URL provided\n     * resolves with a loaded asset if returned by the parser.\n     * @param url - The URL to load\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    load?: <T>(url: string, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<ASSET | T>;\n\n    /**\n     * This function is used to test if the parse function should be run on the asset\n     * If this returns true then parse is called with the asset\n     * @param asset - The loaded asset data\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    testParse?: (asset: ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<boolean>;\n\n    /**\n     * Gets called on the asset it testParse passes. Useful to convert a raw asset into something more useful\n     * @param asset - The loaded asset data\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    parse?: <T>(asset: ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<PARSED_ASSET | T>;\n\n    /**\n     * If an asset is parsed using this parser, the unload function will be called when the user requests an asset\n     * to be unloaded. This is useful for things like sounds or textures that can be unloaded from memory\n     * @param asset - The asset to unload/destroy\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    unload?: (asset: UNLOAD_ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<void> | void;\n}\n\n/**\n * The interface to define a loader parser *(all functions are optional)*.\n *\n * When you create a `parser` object, the flow for every asset loaded is:\n *\n * 1. `parser.test()` - Each URL to load will be tested here, if the test is passed the assets are\n * loaded using the load function below. Good place to test for things like file extensions!\n * 2. `parser.load()` - This is the promise that loads the URL provided resolves with a loaded asset\n * if returned by the parser.\n * 3. `parser.testParse()` - This function is used to test if the parse function should be run on the\n *  asset If this returns true then parse is called with the asset\n * 4. `parse.parse()` - Gets called on the asset it testParse passes. Useful to convert a raw asset\n *  into something more useful\n *\n * <br/>\n * Some loaders may only be used for parsing, some only for loading, and some for both!\n * @category assets\n * @advanced\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface LoaderParser<ASSET = any, META_DATA = any, CONFIG = Record<string, any>>\n    extends LoaderParserAdvanced<ASSET, ASSET, ASSET, META_DATA, CONFIG> {}\n","import { DOMAdapter } from '../environment/adapter';\n\nfunction assertPath(path: string)\n{\n    if (typeof path !== 'string')\n    {\n        throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`);\n    }\n}\n\nfunction removeUrlParams(url: string): string\n{\n    const re = url.split('?')[0];\n\n    return re.split('#')[0];\n}\n\nfunction escapeRegExp(string: string)\n{\n    return string.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'); // $& means the whole matched string\n}\n\nfunction replaceAll(str: string, find: string, replace: string)\n{\n    return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path: string, allowAboveRoot: boolean)\n{\n    let res = '';\n    let lastSegmentLength = 0;\n    let lastSlash = -1;\n    let dots = 0;\n    let code = -1;\n\n    for (let i = 0; i <= path.length; ++i)\n    {\n        if (i < path.length)\n        {\n            code = path.charCodeAt(i);\n        }\n        else if (code === 47)\n        {\n            break;\n        }\n        else\n        {\n            code = 47;\n        }\n        if (code === 47)\n        {\n            if (lastSlash === i - 1 || dots === 1)\n            {\n                // NOOP\n            }\n            else if (lastSlash !== i - 1 && dots === 2)\n            {\n                if (\n                    res.length < 2\n                    || lastSegmentLength !== 2\n                    || res.charCodeAt(res.length - 1) !== 46\n                    || res.charCodeAt(res.length - 2) !== 46\n                )\n                {\n                    if (res.length > 2)\n                    {\n                        const lastSlashIndex = res.lastIndexOf('/');\n\n                        if (lastSlashIndex !== res.length - 1)\n                        {\n                            if (lastSlashIndex === -1)\n                            {\n                                res = '';\n                                lastSegmentLength = 0;\n                            }\n                            else\n                            {\n                                res = res.slice(0, lastSlashIndex);\n                                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');\n                            }\n                            lastSlash = i;\n                            dots = 0;\n                            continue;\n                        }\n                    }\n                    else if (res.length === 2 || res.length === 1)\n                    {\n                        res = '';\n                        lastSegmentLength = 0;\n                        lastSlash = i;\n                        dots = 0;\n                        continue;\n                    }\n                }\n                if (allowAboveRoot)\n                {\n                    if (res.length > 0)\n                    { res += '/..'; }\n                    else\n                    { res = '..'; }\n                    lastSegmentLength = 2;\n                }\n            }\n            else\n            {\n                if (res.length > 0)\n                {\n                    res += `/${path.slice(lastSlash + 1, i)}`;\n                }\n                else\n                {\n                    res = path.slice(lastSlash + 1, i);\n                }\n                lastSegmentLength = i - lastSlash - 1;\n            }\n            lastSlash = i;\n            dots = 0;\n        }\n        else if (code === 46 && dots !== -1)\n        {\n            ++dots;\n        }\n        else\n        {\n            dots = -1;\n        }\n    }\n\n    return res;\n}\n\n/**\n * Path utilities for working with URLs and file paths in a cross-platform way.\n * All paths that are passed in will become normalized to have posix separators.\n * ```js\n * import { path } from 'pixi.js';\n *\n * path.normalize('http://www.example.com/foo/bar/../baz'); // http://www.example.com/foo/baz\n * ```\n * @category utils\n * @advanced\n */\nexport interface Path\n{\n    /**\n     * Converts a path to posix format.\n     * @param path - The path to convert to posix\n     */\n    toPosix: (path: string) => string;\n    /**\n     * Checks if the path is a URL e.g. http://, https://\n     * @param path - The path to check\n     */\n    isUrl: (path: string) => boolean;\n    /**\n     * Checks if the path is a data URL\n     * @param path - The path to check\n     */\n    isDataUrl: (path: string) => boolean;\n    /**\n     * Checks if the path is a blob URL\n     * @param path - The path to check\n     */\n    isBlobUrl: (path: string) => boolean;\n    /**\n     * Checks if the path has a protocol e.g. http://, https://, file:///, data:, blob:, C:/\n     * This will return true for windows file paths\n     * @param path - The path to check\n     */\n    hasProtocol: (path: string) => boolean;\n    /**\n     * Returns the protocol of the path e.g. http://, https://, file:///, data:, blob:, C:/\n     * @param path - The path to get the protocol from\n     */\n    getProtocol: (path: string) => string;\n    /**\n     * Converts URL to an absolute path.\n     * When loading from a Web Worker, we must use absolute paths.\n     * If the URL is already absolute we return it as is\n     * If it's not, we convert it\n     * @param url - The URL to test\n     * @param baseUrl - The base URL to use\n     * @param rootUrl - The root URL to use\n     */\n    toAbsolute: (url: string, baseUrl?: string, rootUrl?: string) => string;\n    /**\n     * Normalizes the given path, resolving '..' and '.' segments\n     * @param path - The path to normalize\n     */\n    normalize: (path: string) => string;\n    /**\n     * Determines if path is an absolute path.\n     * Absolute paths can be urls, data urls, or paths on disk\n     * @param path - The path to test\n     */\n    isAbsolute: (path: string) => boolean;\n    /**\n     * Joins all given path segments together using the platform-specific separator as a delimiter,\n     * then normalizes the resulting path\n     * @param paths - The segments of the path to join\n     */\n    join: (...paths: string[]) => string;\n    /**\n     * Returns the directory name of a path\n     * @param path - The path to parse\n     */\n    dirname: (path: string) => string;\n    /**\n     * Returns the root of the path e.g. /, C:/, file:///, http://domain.com/\n     * @param path - The path to parse\n     */\n    rootname: (path: string) => string;\n    /**\n     * Returns the last portion of a path\n     * @param path - The path to test\n     * @param ext - Optional extension to remove\n     */\n    basename: (path: string, ext?: string) => string;\n    /**\n     * Returns the extension of the path, from the last occurrence of the . (period) character to end of string in the last\n     * portion of the path. If there is no . in the last portion of the path, or if there are no . characters other than\n     * the first character of the basename of path, an empty string is returned.\n     * @param path - The path to parse\n     */\n    extname: (path: string) => string;\n    /**\n     * Parses a path into an object containing the 'root', `dir`, `base`, `ext`, and `name` properties.\n     * @param path - The path to parse\n     */\n    parse: (path: string) => { root?: string, dir?: string, base?: string, ext?: string, name?: string };\n    sep: string,\n    delimiter: string,\n    joinExtensions: string[],\n}\n\n/**\n * Path utilities for working with URLs and file paths in a cross-platform way.\n * All paths that are passed in will become normalized to have posix separators.\n * @example\n * ```ts\n * import { path } from 'pixi.js';\n *\n * // Basic path normalization\n * path.normalize('http://www.example.com/foo/bar/../baz');\n * // -> 'http://www.example.com/foo/baz'\n *\n * // Working with file paths\n * path.join('assets', 'images', 'sprite.png');\n * // -> 'assets/images/sprite.png'\n *\n * // URL handling\n * path.toAbsolute('images/texture.png', 'http://example.com/assets/');\n * // -> 'http://example.com/assets/images/texture.png'\n * ```\n * @remarks\n * - Normalizes to POSIX separators (forward slashes)\n * - Handles URLs, data URLs, and file paths\n * - Supports path composition and decomposition\n * - Common in asset loading and URL management\n * @category utils\n * @standard\n * @see {@link Path} For full API reference\n * @see {@link DOMAdapter} For platform-specific path handling\n */\nexport const path: Path = {\n    /**\n     * Converts a path to posix format.\n     * @param path - The path to convert to posix\n     * @example\n     * ```ts\n     * // Convert a Windows path to POSIX format\n     * path.toPosix('C:\\\\Users\\\\User\\\\Documents\\\\file.txt');\n     * // -> 'C:/Users/User/Documents/file.txt'\n     * ```\n     */\n    toPosix(path: string) { return replaceAll(path, '\\\\', '/'); },\n    /**\n     * Checks if the path is a URL e.g. http://, https://\n     * @param path - The path to check\n     * @example\n     * ```ts\n     * // Check if a path is a URL\n     * path.isUrl('http://www.example.com');\n     * // -> true\n     * path.isUrl('C:/Users/User/Documents/file.txt');\n     * // -> false\n     * ```\n     */\n    isUrl(path: string) { return (/^https?:/).test(this.toPosix(path)); },\n    /**\n     * Checks if the path is a data URL\n     * @param path - The path to check\n     * @example\n     * ```ts\n     * // Check if a path is a data URL\n     * path.isDataUrl('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA...');\n     * // -> true\n     * ```\n     */\n    isDataUrl(path: string)\n    {\n        // eslint-disable-next-line max-len\n        return (/^data:([a-z]+\\/[a-z0-9-+.]+(;[a-z0-9-.!#$%*+.{}|~`]+=[a-z0-9-.!#$%*+.{}()_|~`]+)*)?(;base64)?,([a-z0-9!$&',()*+;=\\-._~:@\\/?%\\s<>]*?)$/i)\n            .test(path);\n    },\n    /**\n     * Checks if the path is a blob URL\n     * @param path - The path to check\n     * @example\n     * ```ts\n     * // Check if a path is a blob URL\n     * path.isBlobUrl('blob:http://www.example.com/12345678-1234-1234-1234-123456789012');\n     * // -> true\n     * ```\n     */\n    isBlobUrl(path: string)\n    {\n        // Not necessary to have an exact regex to match the blob URLs\n        return path.startsWith('blob:');\n    },\n    /**\n     * Checks if the path has a protocol e.g. http://, https://, file:///, data:, blob:, C:/\n     * This will return true for windows file paths\n     * @param path - The path to check\n     * @example\n     * ```ts\n     * // Check if a path has a protocol\n     * path.hasProtocol('http://www.example.com');\n     * // -> true\n     * path.hasProtocol('C:/Users/User/Documents/file.txt');\n     * // -> true\n     * ```\n     */\n    hasProtocol(path: string) { return (/^[^/:]+:/).test(this.toPosix(path)); },\n    /**\n     * Returns the protocol of the path e.g. http://, https://, file:///, data:, blob:, C:/\n     * @param path - The path to get the protocol from\n     * @example\n     * ```ts\n     * // Get the protocol from a URL\n     * path.getProtocol('http://www.example.com/path/to/resource');\n     * // -> 'http://'\n     * // Get the protocol from a file path\n     * path.getProtocol('C:/Users/User/Documents/file.txt');\n     * // -> 'C:/'\n     * ```\n     */\n    getProtocol(path: string)\n    {\n        assertPath(path);\n        path = this.toPosix(path);\n\n        const matchFile = (/^file:\\/\\/\\//).exec(path);\n\n        if (matchFile)\n        {\n            return matchFile[0];\n        }\n\n        const matchProtocol = (/^[^/:]+:\\/{0,2}/).exec(path);\n\n        if (matchProtocol)\n        {\n            return matchProtocol[0];\n        }\n\n        return '';\n    },\n\n    /**\n     * Converts URL to an absolute path.\n     * When loading from a Web Worker, we must use absolute paths.\n     * If the URL is already absolute we return it as is\n     * If it's not, we convert it\n     * @param url - The URL to test\n     * @param customBaseUrl - The base URL to use\n     * @param customRootUrl - The root URL to use\n     * @example\n     * ```ts\n     * // Convert a relative URL to an absolute path\n     * path.toAbsolute('images/texture.png', 'http://example.com/assets/');\n     * // -> 'http://example.com/assets/images/texture.png'\n     * ```\n     */\n    toAbsolute(url: string, customBaseUrl?: string, customRootUrl?: string)\n    {\n        assertPath(url);\n\n        if (this.isDataUrl(url) || this.isBlobUrl(url)) return url;\n\n        const baseUrl = removeUrlParams(this.toPosix(customBaseUrl ?? DOMAdapter.get().getBaseUrl()));\n        const rootUrl = removeUrlParams(this.toPosix(customRootUrl ?? this.rootname(baseUrl)));\n\n        url = this.toPosix(url);\n\n        // root relative url\n        if (url.startsWith('/'))\n        {\n            return path.join(rootUrl, url.slice(1));\n        }\n\n        const absolutePath = this.isAbsolute(url) ? url : this.join(baseUrl, url);\n\n        return absolutePath;\n    },\n\n    /**\n     * Normalizes the given path, resolving '..' and '.' segments\n     * @param path - The path to normalize\n     * @example\n     * ```ts\n     * // Normalize a path with relative segments\n     * path.normalize('http://www.example.com/foo/bar/../baz');\n     * // -> 'http://www.example.com/foo/baz'\n     * // Normalize a file path with relative segments\n     * path.normalize('C:\\\\Users\\\\User\\\\Documents\\\\..\\\\file.txt');\n     * // -> 'C:/Users/User/file.txt'\n     * ```\n     */\n    normalize(path: string)\n    {\n        assertPath(path);\n\n        if (path.length === 0) return '.';\n        if (this.isDataUrl(path) || this.isBlobUrl(path)) return path;\n\n        path = this.toPosix(path);\n\n        let protocol = '';\n        const isAbsolute = path.startsWith('/');\n\n        if (this.hasProtocol(path))\n        {\n            protocol = this.rootname(path);\n            path = path.slice(protocol.length);\n        }\n\n        const trailingSeparator = path.endsWith('/');\n\n        // Normalize the path\n        path = normalizeStringPosix(path, false);\n\n        if (path.length > 0 && trailingSeparator) path += '/';\n        if (isAbsolute) return `/${path}`;\n\n        return protocol + path;\n    },\n\n    /**\n     * Determines if path is an absolute path.\n     * Absolute paths can be urls, data urls, or paths on disk\n     * @param path - The path to test\n     * @example\n     * ```ts\n     * // Check if a path is absolute\n     * path.isAbsolute('http://www.example.com/foo/bar');\n     * // -> true\n     * path.isAbsolute('C:/Users/User/Documents/file.txt');\n     * // -> true\n     * ```\n     */\n    isAbsolute(path: string)\n    {\n        assertPath(path);\n        path = this.toPosix(path);\n\n        if (this.hasProtocol(path)) return true;\n\n        return path.startsWith('/');\n    },\n\n    /**\n     * Joins all given path segments together using the platform-specific separator as a delimiter,\n     * then normalizes the resulting path\n     * @param segments - The segments of the path to join\n     * @example\n     * ```ts\n     * // Join multiple path segments\n     * path.join('assets', 'images', 'sprite.png');\n     * // -> 'assets/images/sprite.png'\n     * // Join with relative segments\n     * path.join('assets', 'images', '../textures', 'sprite.png');\n     * // -> 'assets/textures/sprite.png'\n     * ```\n     */\n    join(...segments: string[])\n    {\n        if (segments.length === 0)\n        { return '.'; }\n        let joined;\n\n        for (let i = 0; i < segments.length; ++i)\n        {\n            const arg = segments[i];\n\n            assertPath(arg);\n            if (arg.length > 0)\n            {\n                if (joined === undefined) joined = arg;\n                else\n                {\n                    const prevArg = segments[i - 1] ?? '';\n\n                    if (this.joinExtensions.includes(this.extname(prevArg).toLowerCase()))\n                    {\n                        joined += `/../${arg}`;\n                    }\n                    else\n                    {\n                        joined += `/${arg}`;\n                    }\n                }\n            }\n        }\n        if (joined === undefined) { return '.'; }\n\n        return this.normalize(joined);\n    },\n\n    /**\n     * Returns the directory name of a path\n     * @param path - The path to parse\n     * @example\n     * ```ts\n     * // Get the directory name of a path\n     * path.dirname('http://www.example.com/foo/bar/baz.png');\n     * // -> 'http://www.example.com/foo/bar'\n     * // Get the directory name of a file path\n     * path.dirname('C:/Users/User/Documents/file.txt');\n     * // -> 'C:/Users/User/Documents'\n     * ```\n     */\n    dirname(path: string)\n    {\n        assertPath(path);\n        if (path.length === 0) return '.';\n        path = this.toPosix(path);\n        let code = path.charCodeAt(0);\n        const hasRoot = code === 47;\n        let end = -1;\n        let matchedSlash = true;\n\n        const proto = this.getProtocol(path);\n        const origpath = path;\n\n        path = path.slice(proto.length);\n\n        for (let i = path.length - 1; i >= 1; --i)\n        {\n            code = path.charCodeAt(i);\n            if (code === 47)\n            {\n                if (!matchedSlash)\n                {\n                    end = i;\n                    break;\n                }\n            }\n            else\n            {\n                // We saw the first non-path separator\n                matchedSlash = false;\n            }\n        }\n\n        // if end is -1 and its a url then we need to add the path back\n        // eslint-disable-next-line no-nested-ternary\n        if (end === -1) return hasRoot ? '/' : this.isUrl(origpath) ? proto + path : proto;\n        if (hasRoot && end === 1) return '//';\n\n        return proto + path.slice(0, end);\n    },\n\n    /**\n     * Returns the root of the path e.g. /, C:/, file:///, http://domain.com/\n     * @param path - The path to parse\n     * @example\n     * ```ts\n     * // Get the root of a URL\n     * path.rootname('http://www.example.com/foo/bar/baz.png');\n     * // -> 'http://www.example.com/'\n     * // Get the root of a file path\n     * path.rootname('C:/Users/User/Documents/file.txt');\n     * // -> 'C:/'\n     * ```\n     */\n    rootname(path: string)\n    {\n        assertPath(path);\n        path = this.toPosix(path);\n\n        let root = '';\n\n        if (path.startsWith('/')) root = '/';\n        else\n        {\n            root = this.getProtocol(path);\n        }\n\n        if (this.isUrl(path))\n        {\n            // need to find the first path separator\n            const index = path.indexOf('/', root.length);\n\n            if (index !== -1)\n            {\n                root = path.slice(0, index);\n            }\n            else root = path;\n\n            if (!root.endsWith('/')) root += '/';\n        }\n\n        return root;\n    },\n\n    /**\n     * Returns the last portion of a path\n     * @param path - The path to test\n     * @param ext - Optional extension to remove\n     * @example\n     * ```ts\n     * // Get the basename of a URL\n     * path.basename('http://www.example.com/foo/bar/baz.png');\n     * // -> 'baz.png'\n     * // Get the basename of a file path\n     * path.basename('C:/Users/User/Documents/file.txt');\n     * // -> 'file.txt'\n     * ```\n     */\n    basename(path: string, ext?: string)\n    {\n        assertPath(path);\n        if (ext) assertPath(ext);\n\n        path = removeUrlParams(this.toPosix(path));\n\n        let start = 0;\n        let end = -1;\n        let matchedSlash = true;\n        let i: number;\n\n        if (ext !== undefined && ext.length > 0 && ext.length <= path.length)\n        {\n            if (ext.length === path.length && ext === path) return '';\n            let extIdx = ext.length - 1;\n            let firstNonSlashEnd = -1;\n\n            for (i = path.length - 1; i >= 0; --i)\n            {\n                const code = path.charCodeAt(i);\n\n                if (code === 47)\n                {\n                    // If we reached a path separator that was not part of a set of path\n                    // separators at the end of the string, stop now\n                    if (!matchedSlash)\n                    {\n                        start = i + 1;\n                        break;\n                    }\n                }\n                else\n                {\n                    if (firstNonSlashEnd === -1)\n                    {\n                        // We saw the first non-path separator, remember this index in case\n                        // we need it if the extension ends up not matching\n                        matchedSlash = false;\n                        firstNonSlashEnd = i + 1;\n                    }\n                    if (extIdx >= 0)\n                    {\n                        // Try to match the explicit extension\n                        if (code === ext.charCodeAt(extIdx))\n                        {\n                            if (--extIdx === -1)\n                            {\n                                // We matched the extension, so mark this as the end of our path\n                                // component\n                                end = i;\n                            }\n                        }\n                        else\n                        {\n                            // Extension does not match, so our result is the entire path\n                            // component\n                            extIdx = -1;\n                            end = firstNonSlashEnd;\n                        }\n                    }\n                }\n            }\n\n            if (start === end) end = firstNonSlashEnd; else if (end === -1) end = path.length;\n\n            return path.slice(start, end);\n        }\n        for (i = path.length - 1; i >= 0; --i)\n        {\n            if (path.charCodeAt(i) === 47)\n            {\n                // If we reached a path separator that was not part of a set of path\n                // separators at the end of the string, stop now\n                if (!matchedSlash)\n                {\n                    start = i + 1;\n                    break;\n                }\n            }\n            else if (end === -1)\n            {\n                // We saw the first non-path separator, mark this as the end of our\n                // path component\n                matchedSlash = false;\n                end = i + 1;\n            }\n        }\n\n        if (end === -1) return '';\n\n        return path.slice(start, end);\n    },\n\n    /**\n     * Returns the extension of the path, from the last occurrence of the . (period) character to end of string in the last\n     * portion of the path. If there is no . in the last portion of the path, or if there are no . characters other than\n     * the first character of the basename of path, an empty string is returned.\n     * @param path - The path to parse\n     * @example\n     * ```ts\n     * // Get the extension of a URL\n     * path.extname('http://www.example.com/foo/bar/baz.png');\n     * // -> '.png'\n     * // Get the extension of a file path\n     * path.extname('C:/Users/User/Documents/file.txt');\n     * // -> '.txt'\n     * ```\n     */\n    extname(path: string)\n    {\n        assertPath(path);\n        path = removeUrlParams(this.toPosix(path));\n\n        let startDot = -1;\n        let startPart = 0;\n        let end = -1;\n        let matchedSlash = true;\n        // Track the state of characters (if any) we see before our first dot and\n        // after any path separator we find\n        let preDotState = 0;\n\n        for (let i = path.length - 1; i >= 0; --i)\n        {\n            const code = path.charCodeAt(i);\n\n            if (code === 47)\n            {\n                // If we reached a path separator that was not part of a set of path\n                // separators at the end of the string, stop now\n                if (!matchedSlash)\n                {\n                    startPart = i + 1;\n                    break;\n                }\n                continue;\n            }\n            if (end === -1)\n            {\n                // We saw the first non-path separator, mark this as the end of our\n                // extension\n                matchedSlash = false;\n                end = i + 1;\n            }\n            if (code === 46)\n            {\n                // If this is our first dot, mark it as the start of our extension\n                if (startDot === -1) startDot = i;\n                else if (preDotState !== 1) preDotState = 1;\n            }\n            else if (startDot !== -1)\n            {\n                // We saw a non-dot and non-path separator before our dot, so we should\n                // have a good chance at having a non-empty extension\n                preDotState = -1;\n            }\n        }\n\n        if (\n            startDot === -1 || end === -1\n            // We saw a non-dot character immediately before the dot\n            || preDotState === 0\n            // The (right-most) trimmed path component is exactly '..'\n            // eslint-disable-next-line no-mixed-operators/no-mixed-operators\n            || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1\n        )\n        {\n            return '';\n        }\n\n        return path.slice(startDot, end);\n    },\n\n    /**\n     * Parses a path into an object containing the 'root', `dir`, `base`, `ext`, and `name` properties.\n     * @param path - The path to parse\n     * @example\n     * ```ts\n     * // Parse a URL\n     * const parsed = path.parse('http://www.example.com/foo/bar/baz.png');\n     * // -> {\n     * //   root: 'http://www.example.com/',\n     * //   dir: 'http://www.example.com/foo/bar',\n     * //   base: 'baz.png',\n     * //   ext: '.png',\n     * //   name: 'baz'\n     * // }\n     * // Parse a file path\n     * const parsedFile = path.parse('C:/Users/User/Documents/file.txt');\n     * // -> {\n     * //   root: 'C:/',\n     * //   dir: 'C:/Users/User/Documents',\n     * //   base: 'file.txt',\n     * //   ext: '.txt',\n     * //   name: 'file'\n     * // }\n     * ```\n     */\n    parse(path: string)\n    {\n        assertPath(path);\n\n        const ret = { root: '', dir: '', base: '', ext: '', name: '' };\n\n        if (path.length === 0) return ret;\n        path = removeUrlParams(this.toPosix(path));\n\n        let code = path.charCodeAt(0);\n        const isAbsolute = this.isAbsolute(path);\n        let start: number;\n        const protocol = '';\n\n        ret.root = this.rootname(path);\n\n        if (isAbsolute || this.hasProtocol(path))\n        {\n            start = 1;\n        }\n        else\n        {\n            start = 0;\n        }\n        let startDot = -1;\n        let startPart = 0;\n        let end = -1;\n        let matchedSlash = true;\n        let i = path.length - 1;\n\n        // Track the state of characters (if any) we see before our first dot and\n        // after any path separator we find\n        let preDotState = 0;\n\n        // Get non-dir info\n        for (; i >= start; --i)\n        {\n            code = path.charCodeAt(i);\n            if (code === 47)\n            {\n                // If we reached a path separator that was not part of a set of path\n                // separators at the end of the string, stop now\n                if (!matchedSlash)\n                {\n                    startPart = i + 1;\n                    break;\n                }\n                continue;\n            }\n            if (end === -1)\n            {\n                // We saw the first non-path separator, mark this as the end of our\n                // extension\n                matchedSlash = false;\n                end = i + 1;\n            }\n            if (code === 46)\n            {\n                // If this is our first dot, mark it as the start of our extension\n                if (startDot === -1) startDot = i;\n                else if (preDotState !== 1) preDotState = 1;\n            }\n            else if (startDot !== -1)\n            {\n                // We saw a non-dot and non-path separator before our dot, so we should\n                // have a good chance at having a non-empty extension\n                preDotState = -1;\n            }\n        }\n\n        if (\n            startDot === -1 || end === -1\n            // We saw a non-dot character immediately before the dot\n            || preDotState === 0\n            // The (right-most) trimmed path component is exactly '..'\n            // eslint-disable-next-line no-mixed-operators/no-mixed-operators\n            || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1\n        )\n        {\n            if (end !== -1)\n            {\n                if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);\n                else ret.base = ret.name = path.slice(startPart, end);\n            }\n        }\n        else\n        {\n            if (startPart === 0 && isAbsolute)\n            {\n                ret.name = path.slice(1, startDot);\n                ret.base = path.slice(1, end);\n            }\n            else\n            {\n                ret.name = path.slice(startPart, startDot);\n                ret.base = path.slice(startPart, end);\n            }\n            ret.ext = path.slice(startDot, end);\n        }\n\n        ret.dir = this.dirname(path);\n        if (protocol) ret.dir = protocol + ret.dir;\n\n        return ret;\n    },\n\n    sep: '/',\n    delimiter: ':',\n    joinExtensions: ['.html'],\n} as Path;\n","/**\n * @param input\n * @param transform\n * @param forceTransform\n * @internal\n */\nexport const convertToList = <T>(\n    input: string | T | (string | T)[],\n    transform?: (input: string) => T,\n    forceTransform = false\n): T[] =>\n{\n    if (!Array.isArray(input))\n    {\n        input = [input as T];\n    }\n\n    if (!transform)\n    {\n        return input as T[];\n    }\n\n    return (input as (string | T)[]).map((item): T =>\n    {\n        if (typeof item === 'string' || forceTransform)\n        {\n            return transform(item as string);\n        }\n\n        return item as T;\n    });\n};\n","import { warn } from '../../utils/logging/warn';\nimport { convertToList } from '../utils/convertToList';\n\nimport type { CacheParser } from './CacheParser';\n\n/** @internal */\nclass CacheClass\n{\n    private readonly _parsers: CacheParser[] = [];\n\n    private readonly _cache: Map<any, any> = new Map();\n    private readonly _cacheMap: Map<string, {\n        keys: string[],\n        cacheKeys: string[],\n    }> = new Map();\n\n    /** Clear all entries. */\n    public reset(): void\n    {\n        this._cacheMap.clear();\n        this._cache.clear();\n    }\n\n    /**\n     * Check if the key exists\n     * @param key - The key to check\n     */\n    public has(key: any): boolean\n    {\n        return this._cache.has(key);\n    }\n\n    /**\n     * Fetch entry by key\n     * @param key - The key of the entry to get\n     */\n    public get<T = any>(key: any): T\n    {\n        const result = this._cache.get(key);\n\n        if (!result)\n        {\n            // #if _DEBUG\n            warn(`[Assets] Asset id ${key} was not found in the Cache`);\n            // #endif\n        }\n\n        return result as T;\n    }\n\n    /**\n     * Set a value by key or keys name\n     * @param key - The key or keys to set\n     * @param value - The value to store in the cache or from which cacheable assets will be derived.\n     */\n    public set<T = any>(key: any | any[], value: T): void\n    {\n        const keys = convertToList<string>(key);\n\n        let cacheableAssets: Record<string, any>;\n\n        for (let i = 0; i < this.parsers.length; i++)\n        {\n            const parser = this.parsers[i];\n\n            if (parser.test(value))\n            {\n                cacheableAssets = parser.getCacheableAssets(keys, value);\n\n                break;\n            }\n        }\n\n        // convert cacheable assets to a map of key-value pairs\n        const cacheableMap = new Map(Object.entries(cacheableAssets || {}));\n\n        if (!cacheableAssets)\n        {\n            keys.forEach((key) =>\n            {\n                cacheableMap.set(key, value);\n            });\n        }\n\n        const cacheKeys = [...cacheableMap.keys()];\n\n        const cachedAssets = {\n            cacheKeys,\n            keys\n        };\n\n        // this is so we can remove them later..\n        keys.forEach((key) =>\n        {\n            this._cacheMap.set(key, cachedAssets as any);\n        });\n\n        cacheKeys.forEach((key) =>\n        {\n            const val = cacheableAssets ? cacheableAssets[key] : value;\n\n            if (this._cache.has(key) && this._cache.get(key) !== val)\n            {\n                // #if _DEBUG\n                warn('[Cache] already has key:', key);\n                // #endif\n            }\n\n            this._cache.set(key, cacheableMap.get(key));\n        });\n    }\n\n    /**\n     * Remove entry by key\n     *\n     * This function will also remove any associated alias from the cache also.\n     * @param key - The key of the entry to remove\n     */\n    public remove(key: any): void\n    {\n        if (!this._cacheMap.has(key))\n        {\n            // #if _DEBUG\n            warn(`[Assets] Asset id ${key} was not found in the Cache`);\n            // #endif\n\n            return;\n        }\n\n        const cacheMap = this._cacheMap.get(key);\n\n        const cacheKeys = cacheMap.cacheKeys;\n\n        cacheKeys.forEach((key) =>\n        {\n            this._cache.delete(key);\n        });\n\n        cacheMap.keys.forEach((key: string) =>\n        {\n            this._cacheMap.delete(key);\n        });\n    }\n\n    /**\n     * All loader parsers registered\n     * @advanced\n     */\n    public get parsers(): CacheParser[]\n    {\n        return this._parsers;\n    }\n}\n\n/**\n * A global cache for all assets in your PixiJS application. The cache system provides fast\n * access to loaded assets and prevents duplicate loading.\n *\n * Key Features:\n * - Automatic caching of loaded assets\n * - Support for custom cache parsers\n * - Automatic parsing of complex assets (e.g., spritesheets)\n * - Memory management utilities\n * > [!IMPORTANT] You typically do not need to use this class directly.\n * > Use the main {@link Assets} class for high-level asset management.\n * > `Assets.get(key)` will automatically use the cache.\n * @example\n * ```ts\n * import { Cache } from 'pixi.js';\n *\n * // Store an asset in the cache\n * Cache.set('myTexture', texture);\n *\n * // Retrieve an asset\n * const texture = Cache.get('myTexture');\n *\n * // Check if an asset exists\n * if (Cache.has('myTexture')) {\n *     // Use the cached asset\n *     const sprite = new Sprite(Cache.get('myTexture'));\n * }\n *\n * // Remove an asset from cache\n * Cache.remove('myTexture');\n *\n * // Clear all cached assets\n * Cache.reset();\n * ```\n * @remarks\n * The Cache is a core component of PixiJS' asset management system:\n * - Used internally by the {@link Assets} class\n * - Supports automatic parsing via {@link CacheParser}\n * - Handles complex asset types like spritesheets\n * - Manages memory through asset removal\n *\n * > [!IMPORTANT]\n * > This is a singleton class and should not be instantiated directly.\n * > Use the exported `Cache` instance instead.\n * @see {@link Assets} For high-level asset management\n * @see {@link CacheParser} For custom cache parsing\n * @category assets\n * @class\n * @advanced\n */\nexport const Cache = new CacheClass();\n","import { Cache } from '../../../../../assets/cache/Cache';\nimport { extensions, ExtensionType } from '../../../../../extensions/Extensions';\nimport { TextureSource } from '../sources/TextureSource';\nimport { Texture } from '../Texture';\n\nimport type { ICanvas } from '../../../../../environment/canvas/ICanvas';\nimport type { TypedArray } from '../../buffer/Buffer';\nimport type { BufferSourceOptions } from '../sources/BufferImageSource';\nimport type { CanvasSourceOptions } from '../sources/CanvasSource';\nimport type { ImageResource } from '../sources/ImageSource';\nimport type { TextureSourceOptions } from '../sources/TextureSource';\nimport type { TextureSourceLike } from '../Texture';\n\ninterface TextureSourceConstructor<T extends TextureSource = TextureSource>\n{\n    new (options: TextureSourceOptions): T;\n    test(options: ImageResource | TypedArray | ArrayBuffer | ICanvas): boolean;\n}\n\nconst sources: TextureSourceConstructor[] = [];\n\nextensions.handleByList(ExtensionType.TextureSource, sources);\n\n/**\n * The type of resource or options that can be used to create a texture source.\n *\n * Opt-in packages widen this union by augmenting `PixiMixins.TextureSourceResources` (see\n * `RenderingMixins.d.ts`). For example, importing `pixi.js/html-source` adds support for live\n * `Element`s and `ElementImage` snapshots.\n * @category rendering\n * @advanced\n */\nexport type TextureResourceOrOptions =\n  ImageResource\n  | TextureSourceOptions<ImageResource>\n  | BufferSourceOptions\n  | CanvasSourceOptions\n  | PixiMixins.TextureSourceResources[keyof PixiMixins.TextureSourceResources];\n\n/**\n * @param options\n * @deprecated since v8.2.0\n * @see TextureSource.from\n * @category rendering\n * @internal\n */\nexport function autoDetectSource(options: TextureResourceOrOptions = {}): TextureSource\n{\n    return textureSourceFrom(options);\n}\n\n/**\n * Creates a texture source from the options provided\n * @param options - The options to create the texture source from. This can be\n */\nfunction textureSourceFrom(options: TextureResourceOrOptions = {}): TextureSource\n{\n    const hasResource = options && (options as TextureSourceOptions).resource;\n    const res = hasResource ? (options as TextureSourceOptions).resource : options;\n    const opts = hasResource ? options as TextureSourceOptions : { resource: options } as TextureSourceOptions;\n\n    for (let i = 0; i < sources.length; i++)\n    {\n        const Source = sources[i];\n\n        if (Source.test(res))\n        {\n            return new Source(opts);\n        }\n    }\n\n    throw new Error(`Could not find a source type for resource: ${opts.resource}`);\n}\n\n/**\n * @param options\n * @param skipCache\n * @internal\n */\nexport function resourceToTexture(\n    options: TextureResourceOrOptions = {},\n    skipCache = false\n): Texture\n{\n    const hasResource = options && (options as TextureSourceOptions).resource;\n    const resource = hasResource ? (options as TextureSourceOptions).resource : options;\n    const opts = hasResource ? options as TextureSourceOptions : { resource: options } as TextureSourceOptions;\n\n    if (!skipCache && Cache.has(resource))\n    {\n        return Cache.get(resource);\n    }\n\n    const texture = new Texture({ source: textureSourceFrom(opts) });\n\n    texture.on('destroy', () =>\n    {\n        if (Cache.has(resource))\n        {\n            Cache.remove(resource);\n        }\n    });\n\n    if (!skipCache)\n    {\n        Cache.set(resource, texture);\n    }\n\n    return texture;\n}\n\n/**\n * Helper function that creates a returns Texture based on the source you provide.\n * The source should be loaded and ready to go. If not its best to grab the asset using Assets.\n * @param id - String or Source to create texture from\n * @param skipCache - Skip adding the texture to the cache\n * @returns The texture based on the Id provided\n * @category utils\n * @internal\n */\nexport function textureFrom(id: TextureSourceLike, skipCache = false): Texture\n{\n    if (typeof id === 'string')\n    {\n        return Cache.get(id);\n    }\n    else if (id instanceof TextureSource)\n    {\n        return new Texture({ source: id });\n    }\n\n    // return a auto generated texture from resource\n    return resourceToTexture(id, skipCache);\n}\n\nTexture.from = textureFrom;\nTextureSource.from = textureSourceFrom;\n","import { extensions } from '../extensions/Extensions';\nimport { AlphaMask } from './mask/alpha/AlphaMask';\nimport { ColorMask } from './mask/color/ColorMask';\nimport { StencilMask } from './mask/stencil/StencilMask';\nimport { BufferImageSource } from './renderers/shared/texture/sources/BufferImageSource';\nimport { CanvasSource } from './renderers/shared/texture/sources/CanvasSource';\nimport { ImageSource } from './renderers/shared/texture/sources/ImageSource';\nimport { VideoSource } from './renderers/shared/texture/sources/VideoSource';\nimport './renderers/shared/texture/utils/textureFrom';\nimport './mask/MaskEffectManager';\n\nextensions.add(\n    AlphaMask,\n    ColorMask,\n    StencilMask,\n    VideoSource,\n    ImageSource,\n    CanvasSource,\n    BufferImageSource,\n);\n\n","/* eslint-disable no-restricted-globals */\nimport { DOMAdapter } from '../../environment/adapter';\n\nimport type { ALPHA_MODES } from '../../rendering/renderers/shared/texture/const';\n\nlet promise: Promise<ALPHA_MODES> | undefined;\n\n/**\n * Helper for detecting the correct alpha mode for video textures.\n * For some reason, some browsers/devices/WebGL implementations premultiply the alpha\n * of a video before and then a second time if `UNPACK_PREMULTIPLY_ALPHA_WEBGL`\n * is true. So the video is premultiplied twice if the alpha mode is `UNPACK`.\n * In this case we need the alpha mode to be `PMA`. This function detects\n * the upload behavior by uploading a white 2x2 webm with 50% alpha\n * without `UNPACK_PREMULTIPLY_ALPHA_WEBGL` and then checking whether\n * the uploaded pixels are premultiplied.\n * @category utils\n * @internal\n * @returns {Promise<ALPHA_MODES>} The correct alpha mode for video textures.\n */\nexport async function detectVideoAlphaMode(): Promise<ALPHA_MODES>\n{\n    promise ??= (async () =>\n    {\n        const canvas = DOMAdapter.get().createCanvas(1, 1);\n        const gl = canvas.getContext('webgl');\n\n        if (!gl)\n        {\n            return 'premultiply-alpha-on-upload';\n        }\n\n        const video = await new Promise<HTMLVideoElement | null>((resolve) =>\n        {\n            const video = document.createElement('video');\n\n            video.onloadeddata = () => resolve(video);\n            video.onerror = () => resolve(null);\n            video.autoplay = false;\n            video.crossOrigin = 'anonymous';\n            video.preload = 'auto';\n            // eslint-disable-next-line max-len\n            video.src = 'data:video/webm;base64,GkXfo59ChoEBQveBAULygQRC84EIQoKEd2VibUKHgQJChYECGFOAZwEAAAAAAAHTEU2bdLpNu4tTq4QVSalmU6yBoU27i1OrhBZUrmtTrIHGTbuMU6uEElTDZ1OsggEXTbuMU6uEHFO7a1OsggG97AEAAAAAAABZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVSalmoCrXsYMPQkBNgIRMYXZmV0GETGF2ZkSJiEBEAAAAAAAAFlSua8yuAQAAAAAAAEPXgQFzxYgAAAAAAAAAAZyBACK1nIN1bmSIgQCGhVZfVlA5g4EBI+ODhAJiWgDglLCBArqBApqBAlPAgQFVsIRVuYEBElTDZ9Vzc9JjwItjxYgAAAAAAAAAAWfInEWjh0VOQ09ERVJEh49MYXZjIGxpYnZweC12cDlnyKJFo4hEVVJBVElPTkSHlDAwOjAwOjAwLjA0MDAwMDAwMAAAH0O2dcfngQCgwqGggQAAAIJJg0IAABAAFgA4JBwYSgAAICAAEb///4r+AAB1oZ2mm+6BAaWWgkmDQgAAEAAWADgkHBhKAAAgIABIQBxTu2uRu4+zgQC3iveBAfGCAXHwgQM=';\n            video.load();\n        });\n\n        if (!video)\n        {\n            return 'premultiply-alpha-on-upload';\n        }\n\n        const texture = gl.createTexture();\n\n        gl.bindTexture(gl.TEXTURE_2D, texture);\n\n        const framebuffer = gl.createFramebuffer();\n\n        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);\n        gl.framebufferTexture2D(\n            gl.FRAMEBUFFER,\n            gl.COLOR_ATTACHMENT0,\n            gl.TEXTURE_2D,\n            texture,\n            0\n        );\n\n        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);\n        gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);\n        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, video);\n\n        const pixel = new Uint8Array(4);\n\n        gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);\n\n        gl.deleteFramebuffer(framebuffer);\n        gl.deleteTexture(texture);\n        gl.getExtension('WEBGL_lose_context')?.loseContext();\n\n        return pixel[0] <= pixel[3] ? 'premultiplied-alpha' : 'premultiply-alpha-on-upload';\n    })();\n\n    return promise;\n}\n","import { ExtensionType } from '../../../extensions/Extensions';\n\nimport type { ExtensionMetadata } from '../../../extensions/Extensions';\nimport type { Effect } from '../../../scene/container/Effect';\nimport type { PoolItem } from '../../../utils/pool/Pool';\n\n/**\n * The ColorMask effect allows you to apply a color mask to the rendering process.\n * This can be useful for selectively rendering certain colors or for creating\n * effects based on color values.\n * @category rendering\n * @advanced\n */\nexport class ColorMask implements Effect, PoolItem\n{\n    public static extension: ExtensionMetadata = ExtensionType.MaskEffect;\n\n    public priority = 0;\n    public mask: number;\n    public pipe = 'colorMask';\n\n    constructor(options: {mask: number})\n    {\n        if (options?.mask)\n        {\n            this.init(options.mask);\n        }\n    }\n\n    public init(mask: number): void\n    {\n        this.mask = mask;\n    }\n\n    public destroy(): void\n    {\n        // nothing to destroy\n    }\n\n    public static test(mask: any): boolean\n    {\n        return typeof mask === 'number';\n    }\n}\n","import { Bounds } from '../../../scene/container/bounds/Bounds';\nimport { getGlobalBounds } from '../../../scene/container/bounds/getGlobalBounds';\n\nimport type { Container } from '../../../scene/container/Container';\n\nconst tempBounds = new Bounds();\n\n/**\n * @param mask\n * @param bounds\n * @param skipUpdateTransform\n * @internal\n */\nexport function addMaskBounds(mask: Container, bounds: Bounds, skipUpdateTransform: boolean): void\n{\n    const boundsToMask = tempBounds;\n\n    mask.measurable = true;\n\n    getGlobalBounds(mask, skipUpdateTransform, boundsToMask);\n\n    bounds.addBoundsMask(boundsToMask);\n\n    mask.measurable = false;\n}\n\n","import { getLocalBounds } from '../../../scene/container/bounds/getLocalBounds';\nimport { boundsPool, matrixPool } from '../../../scene/container/bounds/utils/matrixAndBoundsPool';\nimport { warn } from '../../../utils/logging/warn';\n\nimport type { Matrix } from '../../../maths/matrix/Matrix';\nimport type { Bounds } from '../../../scene/container/bounds/Bounds';\nimport type { Container } from '../../../scene/container/Container';\n\n/**\n * @param mask\n * @param bounds\n * @param localRoot\n * @internal\n */\nexport function addMaskLocalBounds(mask: Container, bounds: Bounds, localRoot: Container): void\n{\n    const boundsToMask = boundsPool.get();\n\n    mask.measurable = true;\n\n    const tempMatrix = matrixPool.get().identity();\n\n    const relativeMask = getMatrixRelativeToParent(mask, localRoot, tempMatrix);\n\n    getLocalBounds(mask, boundsToMask, relativeMask);\n\n    mask.measurable = false;\n\n    bounds.addBoundsMask(boundsToMask);\n\n    matrixPool.return(tempMatrix);\n    boundsPool.return(boundsToMask);\n}\n\nfunction getMatrixRelativeToParent(target: Container, root: Container, matrix: Matrix): Matrix\n{\n    if (!target)\n    {\n        // we have reach the top of the tree!\n        // #if _DEBUG\n        warn('Mask bounds, renderable is not inside the root container');\n        // #endif\n\n        return matrix;\n    }\n\n    if (target !== root)\n    {\n        getMatrixRelativeToParent(target.parent, root, matrix);\n\n        target.updateLocalTransform();\n\n        matrix.append(target.localTransform);\n    }\n\n    return matrix;\n}\n","// VideoSource.ts\n\nimport { ExtensionType } from '../../../../../extensions/Extensions';\nimport { Ticker } from '../../../../../ticker/Ticker';\nimport { detectVideoAlphaMode } from '../../../../../utils/browser/detectVideoAlphaMode';\nimport { TextureSource } from './TextureSource';\n\nimport type { ExtensionMetadata } from '../../../../../extensions/Extensions';\nimport type { Dict } from '../../../../../utils/types';\nimport type { ALPHA_MODES } from '../const';\nimport type { TextureSourceOptions } from './TextureSource';\n\n/**\n * The type of resource used for video textures.\n * This is typically an HTMLVideoElement.\n * @category rendering\n * @advanced\n */\nexport type VideoResource = HTMLVideoElement;\n\n/**\n * Options for video sources.\n * @category rendering\n * @advanced\n */\nexport interface VideoSourceOptions extends TextureSourceOptions<VideoResource>\n{\n    /** If true, the video will start loading immediately. */\n    autoLoad?: boolean;\n    /** If true, the video will start playing as soon as it is loaded. */\n    autoPlay?: boolean;\n    /** The number of times a second to update the texture from the video. Leave at 0 to update at every render. */\n    updateFPS?: number;\n    /** If true, the video will be loaded with the `crossorigin` attribute. */\n    crossorigin?: boolean | string;\n    /** If true, the video will loop when it ends. */\n    loop?: boolean;\n    /** If true, the video will be muted. */\n    muted?: boolean;\n    /** If true, the video will play inline. */\n    playsinline?: boolean;\n    /** If true, the video will be preloaded. */\n    preload?: boolean;\n    /** The time in milliseconds to wait for the video to preload before timing out. */\n    preloadTimeoutMs?: number;\n    /** The alpha mode of the video. */\n    alphaMode?: ALPHA_MODES;\n}\n\n/**\n * A texture source that uses a video as its resource.\n * It automatically resizes the texture based on the video dimensions.\n * It also provides methods to control playback and handle video events.\n * This class supports automatic loading, playback, and frame updates.\n * It can also handle cross-origin videos and provides options for looping, muting, and inline playback.\n * @category rendering\n * @advanced\n */\nexport class VideoSource extends TextureSource<VideoResource>\n{\n    public static extension: ExtensionMetadata = ExtensionType.TextureSource;\n\n    /** The default options for video sources. */\n    public static defaultOptions: VideoSourceOptions = {\n        ...TextureSource.defaultOptions,\n        /** If true, the video will start loading immediately. */\n        autoLoad: true,\n        /** If true, the video will start playing as soon as it is loaded. */\n        autoPlay: true,\n        /** The number of times a second to update the texture from the video. Leave at 0 to update at every render. */\n        updateFPS: 0,\n        /** If true, the video will be loaded with the `crossorigin` attribute. */\n        crossorigin: true,\n        /** If true, the video will loop when it ends. */\n        loop: false,\n        /** If true, the video will be muted. */\n        muted: true,\n        /** If true, the video will play inline. */\n        playsinline: true,\n        /** If true, the video will be preloaded. */\n        preload: false,\n    };\n\n    // Public\n    /** Whether or not the video is ready to play. */\n    public isReady = false;\n    /** The upload method for this texture. */\n    public uploadMethodId = 'video';\n\n    // Protected\n    /**\n     * When set to true will automatically play videos used by this texture once\n     * they are loaded. If false, it will not modify the playing state.\n     * @default true\n     */\n    protected autoPlay: boolean;\n\n    // Private\n    /**\n     * `true` to use Ticker.shared to auto update the base texture.\n     * @default true\n     */\n    private _autoUpdate: boolean;\n\n    /**\n     * `true` if the instance is currently connected to Ticker.shared to auto update the base texture.\n     * @default false\n     */\n    private _isConnectedToTicker: boolean;\n\n    /**\n     * Promise when loading.\n     * @default null\n     */\n    private _load: Promise<this>;\n\n    private _msToNextUpdate: number;\n    private _preloadTimeout: number;\n\n    /** Callback when completed with load. */\n    private _resolve: (value?: this | PromiseLike<this>) => void;\n    private _reject: (error: ErrorEvent) => void;\n\n    private _updateFPS: number;\n    private _videoFrameRequestCallbackHandle: number | null;\n\n    constructor(\n        options: VideoSourceOptions\n    )\n    {\n        super(options);\n\n        // Merge provided options with default ones\n        options = {\n            ...VideoSource.defaultOptions,\n            ...options\n        };\n\n        this._autoUpdate = true;\n        this._isConnectedToTicker = false;\n        this._updateFPS = options.updateFPS || 0;\n        this._msToNextUpdate = 0;\n        this.autoPlay = options.autoPlay !== false;\n        this.alphaMode = options.alphaMode ?? 'premultiply-alpha-on-upload';\n\n        // Binding for frame updates\n        this._videoFrameRequestCallback = this._videoFrameRequestCallback.bind(this);\n        this._videoFrameRequestCallbackHandle = null;\n\n        this._load = null;\n        this._resolve = null;\n        this._reject = null;\n\n        // Bind for listeners\n        this._onCanPlay = this._onCanPlay.bind(this);\n        this._onCanPlayThrough = this._onCanPlayThrough.bind(this);\n        this._onError = this._onError.bind(this);\n        this._onPlayStart = this._onPlayStart.bind(this);\n        this._onPlayStop = this._onPlayStop.bind(this);\n        this._onSeeked = this._onSeeked.bind(this);\n        this._onLoadedMetadata = this._onLoadedMetadata.bind(this);\n\n        if (options.autoLoad !== false)\n        {\n            void this.load();\n        }\n    }\n\n    /** Update the video frame if the source is not destroyed and meets certain conditions. */\n    protected updateFrame(): void\n    {\n        if (this.destroyed)\n        {\n            return;\n        }\n\n        if (this._updateFPS)\n        {\n            // Account for if video has had its playbackRate changed\n            const elapsedMS = Ticker.shared.elapsedMS * this.resource.playbackRate;\n\n            this._msToNextUpdate = Math.floor(this._msToNextUpdate - elapsedMS);\n        }\n\n        if (!this._updateFPS || this._msToNextUpdate <= 0)\n        {\n            this._msToNextUpdate = this._updateFPS ? Math.floor(1000 / this._updateFPS) : 0;\n        }\n\n        if (this.isValid)\n        {\n            this.update();\n        }\n    }\n\n    /** Callback to update the video frame and potentially request the next frame update. */\n    private _videoFrameRequestCallback(): void\n    {\n        this.updateFrame();\n\n        if (this.destroyed)\n        {\n            this._videoFrameRequestCallbackHandle = null;\n        }\n        else\n        {\n            this._videoFrameRequestCallbackHandle = this.resource.requestVideoFrameCallback(\n                this._videoFrameRequestCallback\n            );\n        }\n    }\n\n    /**\n     * Checks if the resource has valid dimensions.\n     * @returns {boolean} True if width and height are set, otherwise false.\n     */\n    public get isValid(): boolean\n    {\n        return !!this.resource.videoWidth && !!this.resource.videoHeight;\n    }\n\n    /**\n     * Start preloading the video resource.\n     * @returns {Promise<this>} Handle the validate event\n     */\n    public async load(): Promise<this>\n    {\n        if (this._load)\n        {\n            return this._load;\n        }\n\n        const source = this.resource;\n        const options = this.options as VideoSourceOptions;\n\n        // Check if source data is enough and set it to complete if needed\n        if ((source.readyState === source.HAVE_ENOUGH_DATA || source.readyState === source.HAVE_FUTURE_DATA)\n            && source.width && source.height)\n        {\n            (source as any).complete = true;\n        }\n\n        // Add event listeners related to playback and seeking\n        source.addEventListener('play', this._onPlayStart);\n        source.addEventListener('pause', this._onPlayStop);\n        source.addEventListener('seeked', this._onSeeked);\n\n        // Add or handle source readiness event listeners\n        if (!this._isSourceReady())\n        {\n            if (!options.preload)\n            {\n                // since this event fires early, only bind if not waiting for a preload event\n                source.addEventListener('canplay', this._onCanPlay);\n            }\n            source.addEventListener('canplaythrough', this._onCanPlayThrough);\n            source.addEventListener('error', this._onError, true);\n        }\n        else\n        {\n            // Source is already ready, so handle it immediately\n            this._mediaReady();\n        }\n\n        // play may fire before dimensions exist (e.g. MediaStream). canplay can also precede\n        // videoWidth/height; keep listening until we have a drawable size (#11133).\n        if (!this.isValid)\n        {\n            source.addEventListener('loadedmetadata', this._onLoadedMetadata);\n        }\n\n        this.alphaMode = await detectVideoAlphaMode();\n\n        // Create and return the loading promise\n        this._load = new Promise((resolve, reject): void =>\n        {\n            if (this.isValid)\n            {\n                resolve(this);\n            }\n            else\n            {\n                this._resolve = resolve;\n                this._reject = reject;\n\n                if (options.preloadTimeoutMs !== undefined)\n                {\n                    this._preloadTimeout = setTimeout(() =>\n                    {\n                        this._onError(new ErrorEvent(`Preload exceeded timeout of ${options.preloadTimeoutMs}ms`));\n                    }) as unknown as number;\n                }\n                source.load();\n            }\n        });\n\n        return this._load;\n    }\n\n    /**\n     * Handle video error events.\n     * @param event - The error event\n     */\n    private _onError(event: ErrorEvent): void\n    {\n        this.resource.removeEventListener('error', this._onError, true);\n        this.emit('error', event);\n\n        if (this._reject)\n        {\n            this._reject(event);\n            this._reject = null;\n            this._resolve = null;\n        }\n    }\n\n    /**\n     * Checks if the underlying source is playing.\n     * @returns True if playing.\n     */\n    private _isSourcePlaying(): boolean\n    {\n        const source = this.resource;\n\n        return (!source.paused && !source.ended);\n    }\n\n    /**\n     * Checks if the underlying source is ready for playing.\n     * @returns True if ready.\n     */\n    private _isSourceReady(): boolean\n    {\n        const source = this.resource;\n\n        return source.readyState > 2;\n    }\n\n    /** Runs the update loop when the video is ready to play. */\n    private _onPlayStart(): void\n    {\n        // Do not call _mediaReady() when !isValid: `play` can precede intrinsic size\n        // (MediaStream / srcObject), and `_mediaReady` calls back into `_onPlayStart` while\n        // still playing → stack overflow (#11133). Readiness stays on canplay / canplaythrough /\n        // loadedmetadata instead.\n        this._configureAutoUpdate();\n    }\n\n    /** Stops the update loop when a pause event is triggered. */\n    private _onPlayStop(): void\n    {\n        this._configureAutoUpdate();\n    }\n\n    /** Handles behavior when the video completes seeking to the current playback position. */\n    private _onSeeked(): void\n    {\n        if (this._autoUpdate && !this._isSourcePlaying())\n        {\n            this._msToNextUpdate = 0;\n            this.updateFrame();\n            this._msToNextUpdate = 0;\n        }\n    }\n\n    /** When intrinsic size becomes known after play / canplay (common with MediaStream). */\n    private _onLoadedMetadata(): void\n    {\n        if (!this.isValid)\n        {\n            return;\n        }\n\n        this._mediaReady();\n    }\n\n    private _onCanPlay(): void\n    {\n        const source = this.resource;\n\n        // Remove event listeners\n        source.removeEventListener('canplay', this._onCanPlay);\n\n        this._mediaReady();\n    }\n\n    private _onCanPlayThrough(): void\n    {\n        const source = this.resource;\n\n        // Remove event listeners\n        source.removeEventListener('canplaythrough', this._onCanPlayThrough);\n\n        if (this._preloadTimeout)\n        {\n            clearTimeout(this._preloadTimeout);\n            this._preloadTimeout = undefined;\n        }\n\n        this._mediaReady();\n    }\n\n    /** Fired when the video is loaded and ready to play. */\n    private _mediaReady(): void\n    {\n        const source = this.resource;\n\n        if (this.isValid)\n        {\n            this.isReady = true;\n            this.resize(source.videoWidth, source.videoHeight);\n        }\n\n        // Reset update timers and perform a frame update\n        this._msToNextUpdate = 0;\n        this.updateFrame();\n        this._msToNextUpdate = 0;\n\n        // Resolve the loading promise only once dimensions are known (avoid resolving at 0×0).\n        if (this._resolve && this.isValid)\n        {\n            this._resolve(this);\n            this._resolve = null;\n            this._reject = null;\n        }\n\n        // Handle play behavior based on current source status\n        if (this._isSourcePlaying())\n        {\n            this._onPlayStart();\n        }\n        else if (this.autoPlay)\n        {\n            void this.resource.play();\n        }\n    }\n\n    /** Cleans up resources and event listeners associated with this texture. */\n    public destroy()\n    {\n        this._configureAutoUpdate();\n\n        const source = this.resource;\n\n        if (source)\n        {\n            // Remove event listeners\n            source.removeEventListener('play', this._onPlayStart);\n            source.removeEventListener('pause', this._onPlayStop);\n            source.removeEventListener('seeked', this._onSeeked);\n            source.removeEventListener('canplay', this._onCanPlay);\n            source.removeEventListener('canplaythrough', this._onCanPlayThrough);\n            source.removeEventListener('loadedmetadata', this._onLoadedMetadata);\n            source.removeEventListener('error', this._onError, true);\n\n            // Clear the video source and pause\n            source.pause();\n            source.src = '';\n            source.load();\n        }\n\n        super.destroy();\n    }\n\n    /** Should the base texture automatically update itself, set to true by default. */\n    get autoUpdate(): boolean\n    {\n        return this._autoUpdate;\n    }\n\n    set autoUpdate(value: boolean)\n    {\n        if (value !== this._autoUpdate)\n        {\n            this._autoUpdate = value;\n            this._configureAutoUpdate();\n        }\n    }\n\n    /**\n     * How many times a second to update the texture from the video.\n     * Leave at 0 to update at every render.\n     * A lower fps can help performance, as updating the texture at 60fps on a 30ps video may not be efficient.\n     */\n    get updateFPS(): number\n    {\n        return this._updateFPS;\n    }\n\n    set updateFPS(value: number)\n    {\n        if (value !== this._updateFPS)\n        {\n            this._updateFPS = value;\n            this._configureAutoUpdate();\n        }\n    }\n\n    /**\n     * Configures the updating mechanism based on the current state and settings.\n     *\n     * This method decides between using the browser's native video frame callback or a custom ticker\n     * for updating the video frame. It ensures optimal performance and responsiveness\n     * based on the video's state, playback status, and the desired frames-per-second setting.\n     *\n     * - If `_autoUpdate` is enabled and the video source is playing:\n     *   - It will prefer the native video frame callback if available and no specific FPS is set.\n     *   - Otherwise, it will use a custom ticker for manual updates.\n     * - If `_autoUpdate` is disabled or the video isn't playing, any active update mechanisms are halted.\n     */\n    private _configureAutoUpdate(): void\n    {\n        // Check if automatic updating is enabled and if the source is currently playing\n        if (this._autoUpdate && this._isSourcePlaying())\n        {\n            // Determine if we should use the browser's native video frame callback (generally for better performance)\n            if (!this._updateFPS && this.resource.requestVideoFrameCallback)\n            {\n                // If connected to a custom ticker, remove the update frame function from it\n                if (this._isConnectedToTicker)\n                {\n                    Ticker.shared.remove(this.updateFrame, this);\n                    this._isConnectedToTicker = false;\n                    // Reset the time until the next update\n                    this._msToNextUpdate = 0;\n                }\n\n                // Check if we haven't already requested a video frame callback, and if not, request one\n                if (this._videoFrameRequestCallbackHandle === null)\n                {\n                    this._videoFrameRequestCallbackHandle = this.resource.requestVideoFrameCallback(\n                        this._videoFrameRequestCallback\n                    );\n                }\n            }\n            else\n            {\n                // If a video frame request callback exists, cancel it, as we are switching to manual ticker-based updates\n                if (this._videoFrameRequestCallbackHandle !== null)\n                {\n                    this.resource.cancelVideoFrameCallback(this._videoFrameRequestCallbackHandle);\n                    this._videoFrameRequestCallbackHandle = null;\n                }\n\n                // If not connected to the custom ticker, add the update frame function to it\n                if (!this._isConnectedToTicker)\n                {\n                    Ticker.shared.add(this.updateFrame, this);\n                    this._isConnectedToTicker = true;\n                    // Reset the time until the next update\n                    this._msToNextUpdate = 0;\n                }\n            }\n        }\n        else\n        {\n            // If automatic updating is disabled or the source isn't playing, perform cleanup\n\n            // Cancel any existing video frame callback request\n            if (this._videoFrameRequestCallbackHandle !== null)\n            {\n                this.resource.cancelVideoFrameCallback(this._videoFrameRequestCallbackHandle);\n                this._videoFrameRequestCallbackHandle = null;\n            }\n\n            // Remove the update frame function from the custom ticker\n            if (this._isConnectedToTicker)\n            {\n                Ticker.shared.remove(this.updateFrame, this);\n                this._isConnectedToTicker = false;\n                // Reset the time until the next update\n                this._msToNextUpdate = 0;\n            }\n        }\n    }\n\n    /**\n     * Map of video MIME types that can't be directly derived from file extensions.\n     * @readonly\n     */\n    public static MIME_TYPES: Dict<string>\n        = {\n            ogv: 'video/ogg',\n            mov: 'video/quicktime',\n            m4v: 'video/mp4',\n        };\n\n    public static test(resource: any): resource is VideoResource\n    {\n        return (globalThis.HTMLVideoElement && resource instanceof HTMLVideoElement);\n    }\n}\n","import { ExtensionType } from '../../../extensions/Extensions';\nimport { Sprite } from '../../../scene/sprite/Sprite';\nimport { addMaskBounds } from '../utils/addMaskBounds';\nimport { addMaskLocalBounds } from '../utils/addMaskLocalBounds';\n\nimport type { ExtensionMetadata } from '../../../extensions/Extensions';\nimport type { MaskChannel } from '../../../filters/mask/MaskFilter';\nimport type { Point } from '../../../maths/point/Point';\nimport type { Bounds } from '../../../scene/container/bounds/Bounds';\nimport type { Container } from '../../../scene/container/Container';\nimport type { Effect } from '../../../scene/container/Effect';\nimport type { PoolItem } from '../../../utils/pool/Pool';\n\n/**\n * AlphaMask is an effect that applies a mask to a container using a sprite texture.\n * By default, the red channel of the mask texture controls visibility. Set `channel` to `'alpha'`\n * to use the alpha channel instead, which is useful for masks defined by transparency.\n * The mask can be inverted, and non-sprite masks are rendered to a texture automatically.\n * @category rendering\n * @advanced\n */\nexport class AlphaMask implements Effect, PoolItem\n{\n    public static extension: ExtensionMetadata = ExtensionType.MaskEffect;\n\n    public priority = 0;\n    public mask: Container;\n    public inverse: boolean = false;\n    public channel: MaskChannel = 'red';\n    public pipe = 'alphaMask';\n    public renderMaskToTexture: boolean;\n\n    constructor(options?: {mask: Container})\n    {\n        if (options?.mask)\n        {\n            this.init(options.mask);\n        }\n    }\n\n    public init(mask: Container): void\n    {\n        this.mask = mask;\n\n        // TODO - might want to change this to adjust on the fly\n        // user may add children to the sprite..\n        this.renderMaskToTexture = !(mask instanceof Sprite);\n\n        this.mask.renderable = this.renderMaskToTexture;\n        this.mask.includeInBuild = !this.renderMaskToTexture;\n\n        this.mask.measurable = false;\n    }\n\n    public reset()\n    {\n        if (this.mask === null) return;\n        this.mask.measurable = true;\n        this.mask = null;\n    }\n\n    public addBounds(bounds: Bounds, skipUpdateTransform?: boolean): void\n    {\n        if (!this.inverse)\n        {\n            addMaskBounds(this.mask, bounds, skipUpdateTransform);\n        }\n    }\n\n    public addLocalBounds(bounds: Bounds, localRoot: Container): void\n    {\n        addMaskLocalBounds(this.mask, bounds, localRoot);\n    }\n\n    public containsPoint(point: Point, hitTestFn: (container: Container, point: Point) => boolean): boolean\n    {\n        const mask = this.mask as any;\n\n        // if the point is in the mask, yay!\n        return hitTestFn(mask, point);\n    }\n\n    public destroy(): void\n    {\n        this.reset();\n    }\n\n    public static test(mask: any): boolean\n    {\n        return mask instanceof Sprite;\n    }\n}\n","import { ExtensionType } from '../../../extensions/Extensions';\nimport { Container } from '../../../scene/container/Container';\nimport { addMaskBounds } from '../utils/addMaskBounds';\nimport { addMaskLocalBounds } from '../utils/addMaskLocalBounds';\n\nimport type { ExtensionMetadata } from '../../../extensions/Extensions';\nimport type { Point } from '../../../maths/point/Point';\nimport type { Bounds } from '../../../scene/container/bounds/Bounds';\nimport type { Effect } from '../../../scene/container/Effect';\nimport type { PoolItem } from '../../../utils/pool/Pool';\n\n/**\n * A mask that uses the stencil buffer to clip the rendering of a container.\n * This is useful for complex masks that cannot be achieved with simple shapes.\n * It is more performant than using a `Graphics` mask, but requires WebGL support.\n * It is also useful for masking with `Container` objects that have complex shapes.\n * @category rendering\n * @advanced\n */\nexport class StencilMask implements Effect, PoolItem\n{\n    public static extension: ExtensionMetadata = ExtensionType.MaskEffect;\n\n    public priority = 0;\n    public mask: Container;\n    public pipe = 'stencilMask';\n\n    constructor(options: {mask: Container})\n    {\n        if (options?.mask)\n        {\n            this.init(options.mask);\n        }\n    }\n\n    public init(mask: Container): void\n    {\n        this.mask = mask;\n        this.mask.includeInBuild = false;\n        this.mask.measurable = false;\n    }\n\n    public reset()\n    {\n        if (this.mask === null) return;\n        this.mask.measurable = true;\n        this.mask.includeInBuild = true;\n        this.mask = null;\n    }\n\n    public addBounds(bounds: Bounds, skipUpdateTransform: boolean): void\n    {\n        addMaskBounds(this.mask, bounds, skipUpdateTransform);\n    }\n\n    public addLocalBounds(bounds: Bounds, localRoot: Container): void\n    {\n        addMaskLocalBounds(this.mask, bounds, localRoot);\n    }\n\n    public containsPoint(point: Point, hitTestFn: (container: Container, point: Point) => boolean): boolean\n    {\n        const mask = this.mask as any;\n\n        // if the point is in the mask, yay!\n        return hitTestFn(mask, point);\n    }\n\n    public destroy(): void\n    {\n        this.reset();\n    }\n\n    public static test(mask: any): boolean\n    {\n        return mask instanceof Container;\n    }\n}\n","import { type ImageLike } from '../../../environment/ImageLike';\nimport { TexturePool } from '../../../rendering/renderers/shared/texture/TexturePool';\nimport { Bounds } from '../../container/bounds/Bounds';\n\nimport type { ICanvas } from '../../../environment/canvas/ICanvas';\nimport type { SCALE_MODE } from '../../../rendering/renderers/shared/texture/const';\nimport type { Texture } from '../../../rendering/renderers/shared/texture/Texture';\n\nconst tempBounds = new Bounds();\n\n/**\n * Takes an image and creates a texture from it, using a power of two or screen sized texture from the texture pool.\n * Remember to return the texture when you don't need it any more!\n * @param image - The image to create a texture from\n * @param width - the frame width of the texture\n * @param height - the frame height of the texture\n * @param resolution - The resolution of the texture\n * @param autoGenerateMipmaps - Whether to generate mipmaps for the texture\n * @param scaleMode - The scale mode of the texture\n * @returns - The texture\n * @internal\n */\nexport function getPo2TextureFromSource(\n    image: ImageLike | HTMLCanvasElement | ICanvas,\n    width: number,\n    height: number,\n    resolution: number,\n    autoGenerateMipmaps = false,\n    scaleMode?: SCALE_MODE\n): Texture\n{\n    const bounds = tempBounds;\n\n    bounds.minX = 0;\n    bounds.minY = 0;\n\n    bounds.maxX = (image.width / resolution) | 0;\n    bounds.maxY = (image.height / resolution) | 0;\n\n    const texture = TexturePool.getOptimalTexture({\n        width: bounds.width,\n        height: bounds.height,\n        resolution,\n        autoGenerateMipmaps,\n        scaleMode,\n    });\n\n    texture.source.uploadMethodId = 'image';\n    texture.source.resource = image;\n    texture.source.alphaMode = 'premultiply-alpha-on-upload';\n\n    texture.frame.width = width / resolution;\n    texture.frame.height = height / resolution;\n\n    // We want to update the resource on the GPU,\n    // but we do not want to resize the texture.\n    // calling `texture.source.update` will fit the resource to the texture\n    // causing a resize of the texture on the GPU.\n    // which is not what we want!\n    texture.source.emit('update', texture.source);\n\n    texture.updateUvs();\n\n    return texture;\n}\n","/**\n * Copies the search params from one url to another\n * @param targetUrl - the url to copy the search params to\n * @param sourceUrl - the url container the search params we want to copy\n * @returns the url with the search params copied\n * @internal\n */\nexport const copySearchParams = (targetUrl: string, sourceUrl: string) =>\n{\n    const searchParams = sourceUrl.split('?')[1];\n\n    if (searchParams)\n    {\n        targetUrl += `?${searchParams}`;\n    }\n\n    return targetUrl;\n};\n","function processX(base: string, ids: string[][], depth: number, result: string[], tags: string[])\n{\n    const id = ids[depth];\n\n    for (let i = 0; i < id.length; i++)\n    {\n        const value = id[i];\n\n        if (depth < ids.length - 1)\n        {\n            processX(base.replace(result[depth], value), ids, depth + 1, result, tags);\n        }\n        else\n        {\n            tags.push(base.replace(result[depth], value));\n        }\n    }\n}\n\n/**\n * Creates a list of all possible combinations of the given strings.\n * @example\n * const out2 = createStringVariations('name is {chicken,wolf,sheep}');\n * console.log(out2); // [ 'name is chicken', 'name is wolf', 'name is sheep' ]\n * @param string - The string to process\n * @internal\n */\nexport function createStringVariations(string: string): string[]\n{\n    const regex = /\\{(.*?)\\}/g;\n\n    const result = string.match(regex);\n\n    const tags: string[] = [];\n\n    if (result)\n    {\n        const ids: string[][] = [];\n\n        result.forEach((vars) =>\n        {\n            // first remove the brackets...\n            const split = vars.substring(1, vars.length - 1).split(',');\n\n            ids.push(split);\n        });\n\n        processX(string, ids, 0, result, tags);\n    }\n    else\n    {\n        tags.push(string);\n    }\n\n    return tags;\n}\n","/**\n * Checks if the given value is an array.\n * @param item - The item to test\n * @internal\n */\nexport const isSingleItem = (item: unknown): boolean => (!Array.isArray(item));\n","import { extensions } from '../extensions/Extensions';\nimport { spritesheetAsset } from './spritesheetAsset';\n\nextensions.add(spritesheetAsset);\n","import { Rectangle } from '../maths/shapes/Rectangle';\nimport { TextureSource } from '../rendering/renderers/shared/texture/sources/TextureSource';\nimport { Texture } from '../rendering/renderers/shared/texture/Texture';\n\nimport type { PointData } from '../maths/point/PointData';\nimport type { BindableTexture, TextureBorders } from '../rendering/renderers/shared/texture/Texture';\nimport type { Dict } from '../utils/types';\n\n/**\n * Represents the JSON data for a spritesheet atlas.\n * @category assets\n * @advanced\n */\nexport interface SpritesheetFrameData\n{\n    /** The frame rectangle of the texture. */\n    frame: {\n        x: number;\n        y: number;\n        w: number;\n        h: number;\n    };\n    /** Whether the texture is trimmed. */\n    trimmed?: boolean;\n    /** Whether the texture is rotated. */\n    rotated?: boolean;\n    /** The source size of the texture. */\n    sourceSize?: {\n        w: number;\n        h: number;\n    };\n    /** The sprite source size. */\n    spriteSourceSize?: {\n        h?: number;\n        w?: number;\n        x: number;\n        y: number;\n    };\n    /** The anchor point of the texture. */\n    anchor?: PointData;\n    /** The 9-slice borders of the texture. */\n    borders?: TextureBorders\n}\n\n/**\n * Atlas format.\n * @category assets\n * @advanced\n */\nexport interface SpritesheetData\n{\n    /** The frames of the atlas. */\n    frames: Dict<SpritesheetFrameData>;\n    /** The animations of the atlas. */\n    animations?: Dict<string[]>;\n    /** The meta data of the atlas. */\n    meta: {\n        app?: string;\n        format?: string;\n        frameTags?: {\n            from: number;\n            name: string;\n            to: number;\n            direction: string;\n        }[];\n        image?: string;\n        layers?: {\n            blendMode: string;\n            name: string;\n            opacity: number;\n        }[];\n        scale: number | string;\n        size?: {\n            h: number;\n            w: number;\n        };\n        slices?: {\n            color: string;\n            name: string;\n            keys: {\n                frame: number,\n                bounds: {\n                    x: number;\n                    y: number;\n                    w: number;\n                    h: number;\n                };\n            }[];\n        }[];\n        related_multi_packs?: string[];\n        version?: string;\n    };\n}\n\n/**\n * Options for loading a spritesheet from an atlas.\n * @category assets\n * @advanced\n */\nexport interface SpritesheetOptions<S extends SpritesheetData = SpritesheetData>\n{\n    /** Reference to Texture */\n    texture: BindableTexture;\n    /** JSON data for the atlas. */\n    data: S;\n    /** The filename to consider when determining the resolution of the spritesheet. */\n    resolutionFilename?: string;\n    /**\n     * Prefix to add to texture names when adding to global TextureCache,\n     * using this option can be helpful if you have multiple texture atlases\n     * that share texture names and you need to disambiguate them.\n     */\n    cachePrefix?: string;\n}\n\n/**\n * Utility class for maintaining reference to a collection\n * of Textures on a single Spritesheet.\n *\n * To access a sprite sheet from your code you may pass its JSON data file to Pixi's loader:\n *\n * ```js\n * import { Assets } from 'pixi.js';\n *\n * const sheet = await Assets.load('images/spritesheet.json');\n * ```\n *\n * Alternately, you may circumvent the loader by instantiating the Spritesheet directly:\n *\n * ```js\n * import { Spritesheet } from 'pixi.js';\n *\n * const sheet = new Spritesheet(texture, spritesheetData);\n * await sheet.parse();\n * console.log('Spritesheet ready to use!');\n * ```\n *\n * With the `sheet.textures` you can create Sprite objects, and `sheet.animations` can be used to create an AnimatedSprite.\n *\n * Here's an example of a sprite sheet JSON data file:\n * ```json\n * {\n *     \"frames\": {\n *         \"enemy1.png\":\n *         {\n *             \"frame\": {\"x\":103,\"y\":1,\"w\":32,\"h\":32},\n *             \"spriteSourceSize\": {\"x\":0,\"y\":0,\"w\":32,\"h\":32},\n *             \"sourceSize\": {\"w\":32,\"h\":32},\n *             \"anchor\": {\"x\":0.5,\"y\":0.5}\n *         },\n *         \"enemy2.png\":\n *         {\n *             \"frame\": {\"x\":103,\"y\":35,\"w\":32,\"h\":32},\n *             \"spriteSourceSize\": {\"x\":0,\"y\":0,\"w\":32,\"h\":32},\n *             \"sourceSize\": {\"w\":32,\"h\":32},\n *             \"anchor\": {\"x\":0.5,\"y\":0.5}\n *         },\n *         \"button.png\":\n *         {\n *             \"frame\": {\"x\":1,\"y\":1,\"w\":100,\"h\":100},\n *             \"spriteSourceSize\": {\"x\":0,\"y\":0,\"w\":100,\"h\":100},\n *             \"sourceSize\": {\"w\":100,\"h\":100},\n *             \"anchor\": {\"x\":0,\"y\":0},\n *             \"borders\": {\"left\":35,\"top\":35,\"right\":35,\"bottom\":35}\n *         }\n *     },\n *\n *     \"animations\": {\n *         \"enemy\": [\"enemy1.png\",\"enemy2.png\"]\n *     },\n *\n *     \"meta\": {\n *         \"image\": \"sheet.png\",\n *         \"format\": \"RGBA8888\",\n *         \"size\": {\"w\":136,\"h\":102},\n *         \"scale\": \"1\"\n *     }\n * }\n * ```\n * Sprite sheets can be packed using tools like {@link https://codeandweb.com/texturepacker|TexturePacker},\n * {@link https://renderhjs.net/shoebox/|Shoebox} or {@link https://github.com/krzysztof-o/spritesheet.js|Spritesheet.js}.\n * Default anchor points (see {@link Texture#defaultAnchor}), default 9-slice borders\n * (see {@link Texture#defaultBorders}) and grouping of animation sprites are currently only\n * supported by TexturePacker.\n *\n * Alternative ways for loading spritesheet image if you need more control:\n *\n * ```js\n * import { Assets } from 'pixi.js';\n *\n * const sheetTexture = await Assets.load('images/spritesheet.png');\n * Assets.add({\n *     alias: 'atlas',\n *     src: 'images/spritesheet.json',\n *     data: {texture: sheetTexture} // using of preloaded texture\n * });\n * const sheet = await Assets.load('atlas')\n * ```\n *\n * or:\n *\n * ```js\n * import { Assets } from 'pixi.js';\n *\n * Assets.add({\n *     alias: 'atlas',\n *     src: 'images/spritesheet.json',\n *     data: {imageFilename: 'my-spritesheet.2x.avif'} // using of custom filename located in \"images/my-spritesheet.2x.avif\"\n * });\n * const sheet = await Assets.load('atlas')\n * ```\n * @category assets\n * @standard\n */\nexport class Spritesheet<S extends SpritesheetData = SpritesheetData>\n{\n    /**\n     * The maximum number of Textures to build per process.\n     * @advanced\n     */\n    public static readonly BATCH_SIZE = 1000;\n\n    /** For multi-packed spritesheets, this contains a reference to all the other spritesheets it depends on. */\n    public linkedSheets: Spritesheet<S>[] = [];\n\n    /** Reference to the source texture. */\n    public textureSource: TextureSource;\n\n    /**\n     * A map containing all textures of the sprite sheet.\n     * Can be used to create a {@link Sprite}:\n     * @example\n     * import { Sprite } from 'pixi.js';\n     *\n     * new Sprite(sheet.textures['image.png']);\n     */\n    public textures: Record<keyof S['frames'], Texture>;\n\n    /**\n     * A map containing the textures for each animation.\n     * Can be used to create an {@link AnimatedSprite}:\n     * @example\n     * import { AnimatedSprite } from 'pixi.js';\n     *\n     * new AnimatedSprite(sheet.animations['anim_name']);\n     */\n    public animations: Record<keyof NonNullable<S['animations']>, Texture[]>;\n\n    /**\n     * Reference to the original JSON data.\n     * @type {object}\n     */\n    public data: S;\n\n    /** The resolution of the spritesheet. */\n    public resolution: number;\n\n    /**\n     * Reference to original source image from the Loader. This reference is retained so we\n     * can destroy the Texture later on. It is never used internally.\n     */\n    private _texture: Texture;\n\n    /**\n     * Map of spritesheet frames.\n     * @type {object}\n     */\n    private _frames: S['frames'];\n\n    /** Collection of frame names. */\n    private _frameKeys: (keyof S['frames'])[];\n\n    /** Current batch index being processed. */\n    private _batchIndex: number;\n\n    /**\n     * Callback when parse is completed.\n     * @type {Function}\n     */\n    private _callback: (textures: Dict<Texture>) => void;\n\n    /** Prefix string to add to global cache */\n    public readonly cachePrefix: string;\n\n    /**\n     * @class\n     * @param options - Options to use when constructing a new Spritesheet.\n     */\n    constructor(options: SpritesheetOptions<S>);\n\n    /**\n     * @param texture - Reference to the source BaseTexture object.\n     * @param {object} data - Spritesheet image data.\n     */\n    constructor(texture: BindableTexture, data: S);\n\n    constructor(optionsOrTexture: SpritesheetOptions<S> | BindableTexture, arg1?: S)\n    {\n        let options = optionsOrTexture as SpritesheetOptions<S>;\n\n        if ((optionsOrTexture as BindableTexture)?.source instanceof TextureSource)\n        {\n            options = {\n                texture: optionsOrTexture as BindableTexture,\n                data: arg1,\n            };\n        }\n        const { texture, data, cachePrefix = '' } = options;\n\n        this.cachePrefix = cachePrefix;\n        this._texture = texture instanceof Texture ? texture : null;\n        this.textureSource = texture.source;\n        this.textures = {} as Record<keyof S['frames'], Texture>;\n        this.animations = {} as Record<keyof NonNullable<S['animations']>, Texture[]>;\n        this.data = data;\n\n        const metaResolution = parseFloat(data.meta.scale as string);\n\n        if (metaResolution)\n        {\n            this.resolution = metaResolution;\n            texture.source.resolution = this.resolution;\n        }\n        else\n        {\n            this.resolution = texture.source._resolution;\n        }\n\n        this._frames = this.data.frames;\n        this._frameKeys = Object.keys(this._frames);\n        this._batchIndex = 0;\n        this._callback = null;\n    }\n\n    /**\n     * Parse spritesheet from loaded data. This is done asynchronously\n     * to prevent creating too many Texture within a single process.\n     */\n    public parse(): Promise<Record<string, Texture>>\n    {\n        return new Promise((resolve) =>\n        {\n            this._callback = resolve;\n            this._batchIndex = 0;\n\n            if (this._frameKeys.length <= Spritesheet.BATCH_SIZE)\n            {\n                this._processFrames(0);\n                this._processAnimations();\n                this._parseComplete();\n            }\n            else\n            {\n                this._nextBatch();\n            }\n        });\n    }\n\n    /**\n     * Parse spritesheet from loaded data. This is done synchronously\n     * and is only suitable for smaller spritesheets (less than ~1000 frames)\n     * or may cause too many Texture within a single process. However, synchronous parsing may be\n     * more convenient since the called does not need to be asynchronous and is safe for\n     * small-to-medium sized spritesheets.\n     *\n     * Other than being synchronous, `parseSync` is otherwise identical to `.parse()`.\n     */\n    public parseSync(): Record<keyof S['frames'], Texture>\n    {\n        this._processFrames(0, true);\n        this._processAnimations();\n\n        return this.textures;\n    }\n\n    /**\n     * Process a batch of frames\n     * @param initialFrameIndex - The index of frame to start.\n     * @param processAll - if true will process all frames in a single batch, ignoring BATCH_SIZE - this\n     * is used for synchronous parsing.\n     */\n    private _processFrames(initialFrameIndex: number, processAll: boolean = false): void\n    {\n        let frameIndex = initialFrameIndex;\n        const maxFrames = processAll ? Infinity : Spritesheet.BATCH_SIZE;\n\n        while (frameIndex - initialFrameIndex < maxFrames && frameIndex < this._frameKeys.length)\n        {\n            const i = this._frameKeys[frameIndex];\n            const data = this._frames[i];\n            const rect = data.frame;\n\n            if (rect)\n            {\n                let frame = null;\n                let trim = null;\n                const sourceSize = data.trimmed !== false && data.sourceSize\n                    ? data.sourceSize : data.frame;\n\n                const orig = new Rectangle(\n                    0,\n                    0,\n                    Math.floor(sourceSize.w) / this.resolution,\n                    Math.floor(sourceSize.h) / this.resolution\n                );\n\n                if (data.rotated)\n                {\n                    frame = new Rectangle(\n                        Math.floor(rect.x) / this.resolution,\n                        Math.floor(rect.y) / this.resolution,\n                        Math.floor(rect.h) / this.resolution,\n                        Math.floor(rect.w) / this.resolution\n                    );\n                }\n                else\n                {\n                    frame = new Rectangle(\n                        Math.floor(rect.x) / this.resolution,\n                        Math.floor(rect.y) / this.resolution,\n                        Math.floor(rect.w) / this.resolution,\n                        Math.floor(rect.h) / this.resolution\n                    );\n                }\n\n                //  Check to see if the sprite is trimmed\n                if (data.trimmed !== false && data.spriteSourceSize)\n                {\n                    trim = new Rectangle(\n                        Math.floor(data.spriteSourceSize.x) / this.resolution,\n                        Math.floor(data.spriteSourceSize.y) / this.resolution,\n                        Math.floor(rect.w) / this.resolution,\n                        Math.floor(rect.h) / this.resolution\n                    );\n                }\n\n                this.textures[i] = new Texture({\n                    source: this.textureSource,\n\n                    frame,\n                    orig,\n                    trim,\n                    rotate: data.rotated ? 2 : 0,\n                    defaultAnchor: data.anchor,\n                    defaultBorders: data.borders,\n\n                    label: i.toString(),\n                });\n            }\n\n            frameIndex++;\n        }\n    }\n\n    /** Parse animations config. */\n    private _processAnimations(): void\n    {\n        const animations = this.data.animations || {};\n\n        for (const animName in animations)\n        {\n            this.animations[animName as keyof S['animations']] = [];\n            for (let i = 0; i < animations[animName].length; i++)\n            {\n                const frameName = animations[animName][i];\n\n                this.animations[animName].push(this.textures[frameName]);\n            }\n        }\n    }\n\n    /** The parse has completed. */\n    private _parseComplete(): void\n    {\n        const callback = this._callback;\n\n        this._callback = null;\n        this._batchIndex = 0;\n        callback.call(this, this.textures);\n    }\n\n    /** Begin the next batch of textures. */\n    private _nextBatch(): void\n    {\n        this._processFrames(this._batchIndex * Spritesheet.BATCH_SIZE);\n        this._batchIndex++;\n        setTimeout(() =>\n        {\n            if (this._batchIndex * Spritesheet.BATCH_SIZE < this._frameKeys.length)\n            {\n                this._nextBatch();\n            }\n            else\n            {\n                this._processAnimations();\n                this._parseComplete();\n            }\n        }, 0);\n    }\n\n    /**\n     * Destroy Spritesheet and don't use after this.\n     * @param {boolean} [destroyBase=false] - Whether to destroy the base texture as well\n     */\n    public destroy(destroyBase = false): void\n    {\n        for (const i in this.textures)\n        {\n            this.textures[i].destroy();\n        }\n        this._frames = null;\n        this._frameKeys = null;\n        this.data = null;\n        this.textures = null;\n        if (destroyBase)\n        {\n            this._texture?.destroy();\n            this.textureSource.destroy();\n        }\n        this._texture = null;\n        this.textureSource = null;\n        this.linkedSheets = [];\n    }\n}\n","import { warn } from '../../utils/logging/warn';\nimport { path } from '../../utils/path';\nimport { convertToList } from '../utils/convertToList';\nimport { createStringVariations } from '../utils/createStringVariations';\nimport { isSingleItem } from '../utils/isSingleItem';\n\nimport type {\n    ArrayOr,\n    AssetsBundle,\n    AssetsManifest,\n    AssetSrc,\n    ResolvedAsset,\n    ResolvedSrc,\n    UnresolvedAsset,\n} from '../types';\nimport type { PreferOrder, ResolveURLParser } from './types';\n\n/**\n * Options for how the resolver deals with generating bundle ids\n * @category assets\n * @advanced\n */\nexport interface BundleIdentifierOptions\n{\n    /** The character that is used to connect the bundleId and the assetId when generating a bundle asset id key */\n    connector?: string;\n    /**\n     * A function that generates a bundle asset id key from a bundleId and an assetId\n     * @param bundleId - the bundleId\n     * @param assetId  - the assetId\n     * @returns the bundle asset id key\n     */\n    createBundleAssetId?: (bundleId: string, assetId: string) => string;\n    /**\n     * A function that generates an assetId from a bundle asset id key. This is the reverse of generateBundleAssetId\n     * @param bundleId - the bundleId\n     * @param assetBundleId - the bundle asset id key\n     * @returns the assetId\n     */\n    extractAssetIdFromBundle?: (bundleId: string, assetBundleId: string) => string;\n}\n\n/**\n * A class that is responsible for resolving mapping asset URLs to keys.\n * At its most basic it can be used for Aliases:\n *\n * ```js\n * resolver.add('foo', 'bar');\n * resolver.resolveUrl('foo') // => 'bar'\n * ```\n *\n * It can also be used to resolve the most appropriate asset for a given URL:\n *\n * ```js\n * resolver.prefer({\n *     params: {\n *         format: 'webp',\n *         resolution: 2,\n *     }\n * });\n *\n * resolver.add('foo', ['bar@2x.webp', 'bar@2x.png', 'bar.webp', 'bar.png']);\n *\n * resolver.resolveUrl('foo') // => 'bar@2x.webp'\n * ```\n * Other features include:\n * - Ability to process a manifest file to get the correct understanding of how to resolve all assets\n * - Ability to add custom parsers for specific file types\n * - Ability to add custom prefer rules\n *\n * This class only cares about the URL, not the loading of the asset itself.\n *\n * It is not intended that this class is created by developers - its part of the Asset class\n * This is the third major system of PixiJS' main Assets class\n * @category assets\n * @advanced\n */\nexport class Resolver\n{\n    /**\n     * The prefix that denotes a URL is for a retina asset.\n     * @default /@([0-9\\.]+)x/\n     * @example `@2x`\n     */\n    public static RETINA_PREFIX = /@([0-9\\.]+)x/;\n\n    private readonly _defaultBundleIdentifierOptions: Required<BundleIdentifierOptions> = {\n        connector: '-',\n        createBundleAssetId: (bundleId, assetId) =>\n            `${bundleId}${this._bundleIdConnector}${assetId}`,\n        extractAssetIdFromBundle: (bundleId, assetBundleId) =>\n            assetBundleId.replace(`${bundleId}${this._bundleIdConnector}`, ''),\n    };\n\n    /** The character that is used to connect the bundleId and the assetId when generating a bundle asset id key */\n    private _bundleIdConnector = this._defaultBundleIdentifierOptions.connector;\n\n    /**\n     * A function that generates a bundle asset id key from a bundleId and an assetId\n     * @param bundleId - the bundleId\n     * @param assetId  - the assetId\n     * @returns the bundle asset id key\n     */\n    private _createBundleAssetId: (\n        bundleId: string,\n        assetId: string\n    ) => string = this._defaultBundleIdentifierOptions.createBundleAssetId;\n\n    /**\n     * A function that generates an assetId from a bundle asset id key. This is the reverse of generateBundleAssetId\n     * @param bundleId - the bundleId\n     * @param assetBundleId - the bundle asset id key\n     * @returns the assetId\n     */\n    private _extractAssetIdFromBundle: (\n        bundleId: string,\n        assetBundleId: string\n    ) => string = this._defaultBundleIdentifierOptions.extractAssetIdFromBundle;\n\n    private _assetMap: Record<string, ResolvedAsset[]> = {};\n    private _preferredOrder: PreferOrder[] = [];\n    private readonly _parsers: ResolveURLParser[] = [];\n\n    private _resolverHash: Record<string, ResolvedAsset> = {};\n    private _rootPath: string;\n    private _basePath: string;\n    private _manifest: AssetsManifest;\n    private _bundles: Record<string, string[]> = {};\n    private _defaultSearchParams: string;\n\n    /**\n     * Override how the resolver deals with generating bundle ids.\n     * must be called before any bundles are added\n     * @param bundleIdentifier - the bundle identifier options\n     */\n    public setBundleIdentifier(bundleIdentifier: BundleIdentifierOptions): void\n    {\n        this._bundleIdConnector = bundleIdentifier.connector ?? this._bundleIdConnector;\n        this._createBundleAssetId = bundleIdentifier.createBundleAssetId ?? this._createBundleAssetId;\n        this._extractAssetIdFromBundle = bundleIdentifier.extractAssetIdFromBundle ?? this._extractAssetIdFromBundle;\n\n        if (this._extractAssetIdFromBundle('foo', this._createBundleAssetId('foo', 'bar')) !== 'bar')\n        {\n            throw new Error('[Resolver] GenerateBundleAssetId are not working correctly');\n        }\n    }\n\n    /**\n     * Let the resolver know which assets you prefer to use when resolving assets.\n     * Multiple prefer user defined rules can be added.\n     * @example\n     * resolver.prefer({\n     *     // first look for something with the correct format, and then then correct resolution\n     *     priority: ['format', 'resolution'],\n     *     params:{\n     *         format:'webp', // prefer webp images\n     *         resolution: 2, // prefer a resolution of 2\n     *     }\n     * })\n     * resolver.add('foo', ['bar@2x.webp', 'bar@2x.png', 'bar.webp', 'bar.png']);\n     * resolver.resolveUrl('foo') // => 'bar@2x.webp'\n     * @param preferOrders - the prefer options\n     */\n    public prefer(...preferOrders: PreferOrder[]): void\n    {\n        preferOrders.forEach((prefer) =>\n        {\n            this._preferredOrder.push(prefer);\n\n            if (!prefer.priority)\n            {\n                // generate the priority based on the order of the object\n                prefer.priority = Object.keys(prefer.params);\n            }\n        });\n\n        this._resolverHash = {};\n    }\n\n    /**\n     * Set the base path to prepend to all urls when resolving\n     * @example\n     * resolver.basePath = 'https://home.com/';\n     * resolver.add('foo', 'bar.ong');\n     * resolver.resolveUrl('foo', 'bar.png'); // => 'https://home.com/bar.png'\n     * @param basePath - the base path to use\n     */\n    public set basePath(basePath: string)\n    {\n        this._basePath = basePath;\n    }\n\n    public get basePath(): string\n    {\n        return this._basePath;\n    }\n\n    /**\n     * Set the root path for root-relative URLs. By default the `basePath`'s root is used. If no `basePath` is set, then the\n     * default value for browsers is `window.location.origin`\n     * @example\n     * // Application hosted on https://home.com/some-path/index.html\n     * resolver.basePath = 'https://home.com/some-path/';\n     * resolver.rootPath = 'https://home.com/';\n     * resolver.add('foo', '/bar.png');\n     * resolver.resolveUrl('foo', '/bar.png'); // => 'https://home.com/bar.png'\n     * @param rootPath - the root path to use\n     */\n    public set rootPath(rootPath: string)\n    {\n        this._rootPath = rootPath;\n    }\n\n    public get rootPath(): string\n    {\n        return this._rootPath;\n    }\n\n    /**\n     * All the active URL parsers that help the parser to extract information and create\n     * an asset object-based on parsing the URL itself.\n     *\n     * Can be added using the extensions API\n     * @example\n     * resolver.add('foo', [\n     *     {\n     *         resolution: 2,\n     *         format: 'png',\n     *         src: 'image@2x.png',\n     *     },\n     *     {\n     *         resolution:1,\n     *         format:'png',\n     *         src: 'image.png',\n     *     },\n     * ]);\n     *\n     * // With a url parser the information such as resolution and file format could extracted from the url itself:\n     * extensions.add({\n     *     extension: ExtensionType.ResolveParser,\n     *     test: loadTextures.test, // test if url ends in an image\n     *     parse: (value: string) =>\n     *     ({\n     *         resolution: parseFloat(Resolver.RETINA_PREFIX.exec(value)?.[1] ?? '1'),\n     *         format: value.split('.').pop(),\n     *         src: value,\n     *     }),\n     * });\n     *\n     * // Now resolution and format can be extracted from the url\n     * resolver.add('foo', [\n     *     'image@2x.png',\n     *     'image.png',\n     * ]);\n     */\n    public get parsers(): ResolveURLParser[]\n    {\n        return this._parsers;\n    }\n\n    /** Used for testing, this resets the resolver to its initial state */\n    public reset(): void\n    {\n        this.setBundleIdentifier(this._defaultBundleIdentifierOptions);\n\n        this._assetMap = {};\n        this._preferredOrder = [];\n        // Do not reset this._parsers\n\n        this._resolverHash = {};\n        this._rootPath = null;\n        this._basePath = null;\n        this._manifest = null;\n        this._bundles = {};\n        this._defaultSearchParams = null;\n    }\n\n    /**\n     * Sets the default URL search parameters for the URL resolver. The urls can be specified as a string or an object.\n     * @param searchParams - the default url parameters to append when resolving urls\n     */\n    public setDefaultSearchParams(searchParams: string | Record<string, unknown>): void\n    {\n        if (typeof searchParams === 'string')\n        {\n            this._defaultSearchParams = searchParams;\n        }\n        else\n        {\n            const queryValues = searchParams as Record<string, any>;\n\n            this._defaultSearchParams = Object.keys(queryValues)\n                .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(queryValues[key])}`)\n                .join('&');\n        }\n    }\n\n    /**\n     * Returns the aliases for a given asset\n     * @param asset - the asset to get the aliases for\n     */\n    public getAlias(asset: UnresolvedAsset): string[]\n    {\n        const { alias, src } = asset;\n        const aliasesToUse = convertToList<ArrayOr<string | AssetSrc>>(\n            alias || src, (value: string | AssetSrc) =>\n            {\n                if (typeof value === 'string') return value;\n\n                if (Array.isArray(value)) return value.map((v) => (v as ResolvedSrc)?.src ?? v);\n\n                if (value?.src) return value.src;\n\n                return value;\n            }, true) as string[];\n\n        return aliasesToUse;\n    }\n\n    /**\n     * Removes the specified alias for an asset.\n     *\n     * This only removes the alias mapping. It does **not** remove, unload, or destroy the\n     * underlying asset. If the asset is already cached, it stays in memory until you call\n     * `Assets.unload`.\n     *\n     * If `asset` is provided, the alias is only removed when the resolver's current mapping for\n     * that alias matches the given `ResolvedAsset`. This lets you avoid accidentally removing an\n     * alias that has been reassigned.\n     *\n     * Silently returns if the alias does not exist or the asset does not match.\n     * @param alias - the alias to remove\n     * @param asset - only remove the alias if it is currently assigned to this asset\n     * @example\n     * ```ts\n     * resolver.add({ alias: 'hero', src: 'hero.png' });\n     *\n     * // Simple removal\n     * resolver.removeAlias('hero');\n     *\n     * // Conditional removal — only if alias currently maps to a specific asset\n     * const resolved = resolver.resolve('hero');\n     * resolver.removeAlias('hero', resolved);\n     * ```\n     */\n    public removeAlias(alias: string, asset?: ResolvedAsset): void\n    {\n        if (!this._assetMap[alias])\n        {\n            return;\n        }\n\n        if (asset && asset !== this._resolverHash[alias])\n        {\n            return;\n        }\n\n        delete this._resolverHash[alias];\n        delete this._assetMap[alias];\n    }\n\n    /**\n     * Add a manifest to the asset resolver. This is a nice way to add all the asset information in one go.\n     * generally a manifest would be built using a tool.\n     * @param manifest - the manifest to add to the resolver\n     */\n    public addManifest(manifest: AssetsManifest): void\n    {\n        if (this._manifest)\n        {\n            // #if _DEBUG\n            warn('[Resolver] Manifest already exists, this will be overwritten');\n            // #endif\n        }\n\n        this._manifest = manifest;\n\n        manifest.bundles.forEach((bundle) =>\n        {\n            this.addBundle(bundle.name, bundle.assets);\n        });\n    }\n\n    /**\n     * This adds a bundle of assets in one go so that you can resolve them as a group.\n     * For example you could add a bundle for each screen in you pixi app\n     * @example\n     * resolver.addBundle('animals', [\n     *  { alias: 'bunny', src: 'bunny.png' },\n     *  { alias: 'chicken', src: 'chicken.png' },\n     *  { alias: 'thumper', src: 'thumper.png' },\n     * ]);\n     * // or\n     * resolver.addBundle('animals', {\n     *     bunny: 'bunny.png',\n     *     chicken: 'chicken.png',\n     *     thumper: 'thumper.png',\n     * });\n     *\n     * const resolvedAssets = await resolver.resolveBundle('animals');\n     * @param bundleId - The id of the bundle to add\n     * @param assets - A record of the asset or assets that will be chosen from when loading via the specified key\n     */\n    public addBundle(bundleId: string, assets: AssetsBundle['assets']): void\n    {\n        const assetNames: string[] = [];\n        let convertedAssets: UnresolvedAsset[] = assets as UnresolvedAsset[];\n\n        if (!Array.isArray(assets))\n        {\n            // convert to array...\n            convertedAssets = Object.entries(assets).map(([alias, src]) =>\n            {\n                if (typeof src === 'string' || Array.isArray(src))\n                {\n                    return { alias, src };\n                }\n\n                return { alias, ...src };\n            });\n        }\n\n        // when storing keys against a bundle we prepend the bundleId to each asset key\n        // and pass it through as an additional alias for the asset\n        // this keeps clashing ids separate on a per-bundle basis\n        // you can also resolve a file using the bundleId-assetId syntax\n\n        convertedAssets.forEach((asset) =>\n        {\n            const srcs = asset.src;\n            const aliases = asset.alias;\n            let ids: string[];\n\n            if (typeof aliases === 'string')\n            {\n                const bundleAssetId = this._createBundleAssetId(bundleId, aliases);\n\n                assetNames.push(bundleAssetId);\n                ids = [aliases, bundleAssetId];\n            }\n            else\n            {\n                const bundleIds = aliases.map((name) => this._createBundleAssetId(bundleId, name));\n\n                assetNames.push(...bundleIds);\n                ids = [...aliases, ...bundleIds];\n            }\n\n            this.add({\n                ...asset,\n                ...{\n                    alias: ids,\n                    src: srcs,\n                }\n            });\n        });\n\n        this._bundles[bundleId] = assetNames;\n    }\n\n    /**\n     * Tells the resolver what keys are associated with witch asset.\n     * The most important thing the resolver does\n     * @example\n     * // Single key, single asset:\n     * resolver.add({alias: 'foo', src: 'bar.png');\n     * resolver.resolveUrl('foo') // => 'bar.png'\n     *\n     * // Multiple keys, single asset:\n     * resolver.add({alias: ['foo', 'boo'], src: 'bar.png'});\n     * resolver.resolveUrl('foo') // => 'bar.png'\n     * resolver.resolveUrl('boo') // => 'bar.png'\n     *\n     * // Multiple keys, multiple assets:\n     * resolver.add({alias: ['foo', 'boo'], src: ['bar.png', 'bar.webp']});\n     * resolver.resolveUrl('foo') // => 'bar.png'\n     *\n     * // Add custom data attached to the resolver\n     * Resolver.add({\n     *     alias: 'bunnyBooBooSmooth',\n     *     src: 'bunny{png,webp}',\n     *     data: { scaleMode:SCALE_MODES.NEAREST }, // Base texture options\n     * });\n     *\n     * resolver.resolve('bunnyBooBooSmooth') // => { src: 'bunny.png', data: { scaleMode: SCALE_MODES.NEAREST } }\n     * @param aliases - the UnresolvedAsset or array of UnresolvedAssets to add to the resolver\n     */\n    public add(\n        aliases: ArrayOr<UnresolvedAsset>,\n    ): void\n    {\n        const assets: UnresolvedAsset[] = [];\n\n        if (Array.isArray(aliases))\n        {\n            assets.push(...(aliases as UnresolvedAsset[]));\n        }\n        else\n        {\n            assets.push(aliases as UnresolvedAsset);\n        }\n\n        let keyCheck: (key: string) => void;\n\n        // #if _DEBUG\n        // eslint-disable-next-line prefer-const\n        keyCheck = (key: string) =>\n        {\n            if (this.hasKey(key))\n            {\n                // #if _DEBUG\n                warn(`[Resolver] already has key: ${key} overwriting`);\n                // #endif\n            }\n        };\n        // #endif\n\n        const assetArray = convertToList(assets);\n\n        // loop through all the assets and generate a resolve asset for each src\n        assetArray.forEach((asset) =>\n        {\n            const { src } = asset;\n            let {\n                data,\n                format,\n                loadParser: userDefinedLoadParser,\n                parser: userDefinedParser,\n            } = asset;\n\n            // src can contain an unresolved asset itself\n            // so we need to merge that data with the current asset\n            // we dont need to create string variations for the src if it is a ResolvedAsset\n            const srcsToUse: (string | ResolvedSrc)[][] = convertToList<AssetSrc>(src).map((src) =>\n            {\n                if (typeof src === 'string')\n                { return createStringVariations(src); }\n\n                return Array.isArray(src) ? src : [src];\n            });\n\n            const aliasesToUse = this.getAlias(asset);\n\n            // #if _DEBUG\n            Array.isArray(aliasesToUse) ? aliasesToUse.forEach(keyCheck) : keyCheck(aliasesToUse);\n            // #endif\n\n            // loop through all the srcs and generate a resolve asset for each src\n            const resolvedAssets: ResolvedAsset[] = [];\n\n            // Helper function to parse a URL string using registered parsers\n            const parseUrl = (url: string): ResolvedAsset =>\n            {\n                const parser = this._parsers.find((p) => p.test(url));\n\n                return {\n                    src: url,\n                    ...parser?.parse(url),\n                };\n            };\n\n            srcsToUse.forEach((srcs) =>\n            {\n                srcs.forEach((src) =>\n                {\n                    let formattedAsset = {} as ResolvedAsset;\n\n                    if (typeof src !== 'object')\n                    {\n                        // first see if it contains any {} tags...\n                        formattedAsset = parseUrl(src);\n                    }\n                    else\n                    {\n                        data = src.data ?? data;\n                        format = src.format ?? format;\n                        if (src.loadParser || src.parser)\n                        {\n                            userDefinedLoadParser = src.loadParser ?? userDefinedLoadParser;\n                            userDefinedParser = src.parser ?? userDefinedParser;\n                        }\n\n                        formattedAsset = {\n                            ...parseUrl(src.src),\n                            ...src,\n                        };\n                    }\n\n                    // check if aliases is undefined\n                    if (!aliasesToUse)\n                    {\n                        throw new Error(`[Resolver] alias is undefined for this asset: ${formattedAsset.src}`);\n                    }\n\n                    formattedAsset = this._buildResolvedAsset(formattedAsset, {\n                        aliases: aliasesToUse,\n                        data,\n                        format,\n                        loadParser: userDefinedLoadParser,\n                        parser: userDefinedParser,\n                        progressSize: asset.progressSize,\n                    });\n\n                    resolvedAssets.push(formattedAsset);\n                });\n            });\n\n            aliasesToUse.forEach((alias) =>\n            {\n                this._assetMap[alias] = resolvedAssets;\n            });\n        });\n    }\n\n    // TODO: this needs an overload like load did in Assets\n    /**\n     * If the resolver has had a manifest set via setManifest, this will return the assets urls for\n     * a given bundleId or bundleIds.\n     * @example\n     * // Manifest Example\n     * const manifest = {\n     *     bundles: [\n     *         {\n     *             name: 'load-screen',\n     *             assets: [\n     *                 {\n     *                     alias: 'background',\n     *                     src: 'sunset.png',\n     *                 },\n     *                 {\n     *                     alias: 'bar',\n     *                     src: 'load-bar.{png,webp}',\n     *                 },\n     *             ],\n     *         },\n     *         {\n     *             name: 'game-screen',\n     *             assets: [\n     *                 {\n     *                     alias: 'character',\n     *                     src: 'robot.png',\n     *                 },\n     *                 {\n     *                     alias: 'enemy',\n     *                     src: 'bad-guy.png',\n     *                 },\n     *             ],\n     *         },\n     *     ]\n     * };\n     *\n     * resolver.setManifest(manifest);\n     * const resolved = resolver.resolveBundle('load-screen');\n     * @param bundleIds - The bundle ids to resolve\n     * @returns All the bundles assets or a hash of assets for each bundle specified\n     */\n    public resolveBundle(bundleIds: ArrayOr<string>):\n    Record<string, ResolvedAsset> | Record<string, Record<string, ResolvedAsset>>\n    {\n        const singleAsset = isSingleItem(bundleIds);\n\n        bundleIds = convertToList<string>(bundleIds);\n\n        const out: Record<string, Record<string, ResolvedAsset>> = {};\n\n        bundleIds.forEach((bundleId) =>\n        {\n            const assetNames = this._bundles[bundleId];\n\n            if (assetNames)\n            {\n                const results = this.resolve(assetNames) as Record<string, ResolvedAsset>;\n\n                const assets: Record<string, ResolvedAsset> = {};\n\n                for (const key in results)\n                {\n                    const asset = results[key];\n\n                    assets[this._extractAssetIdFromBundle(bundleId, key)] = asset;\n                }\n\n                out[bundleId] = assets;\n            }\n        });\n\n        return singleAsset ? out[bundleIds[0]] : out;\n    }\n\n    /**\n     * Does exactly what resolve does, but returns just the URL rather than the whole asset object\n     * @param key - The key or keys to resolve\n     * @returns - The URLs associated with the key(s)\n     */\n    public resolveUrl(key: ArrayOr<string>): string | Record<string, string>\n    {\n        const result = this.resolve(key as string) as ResolvedAsset | Record<string, ResolvedAsset>;\n\n        if (typeof key !== 'string')\n        {\n            const out: Record<string, string> = {};\n\n            for (const i in result)\n            {\n                out[i] = (result as Record<string, ResolvedAsset>)[i].src;\n            }\n\n            return out;\n        }\n\n        return (result as ResolvedAsset).src;\n    }\n\n    /**\n     * Resolves each key in the list to an asset object.\n     * Another key function of the resolver! After adding all the various key/asset pairs. this will run the logic\n     * of finding which asset to return based on any preferences set using the `prefer` function\n     * by default the same key passed in will be returned if nothing is matched by the resolver.\n     * @example\n     * resolver.add('boo', 'bunny.png');\n     *\n     * resolver.resolve('boo') // => { src: 'bunny.png' }\n     *\n     * // Will return the same string as no key was added for this value..\n     * resolver.resolve('another-thing.png') // => { src: 'another-thing.png' }\n     * @param keys - key or keys to resolve\n     * @returns - the resolve asset or a hash of resolve assets for each key specified\n     */\n    public resolve(keys: string): ResolvedAsset;\n    public resolve(keys: string[]): Record<string, ResolvedAsset>;\n    public resolve(keys: ArrayOr<string>): ResolvedAsset | Record<string, ResolvedAsset>\n    {\n        const singleAsset = isSingleItem(keys);\n\n        keys = convertToList<string>(keys);\n\n        const result: Record<string, ResolvedAsset> = {};\n\n        keys.forEach((key) =>\n        {\n            if (!this._resolverHash[key])\n            {\n                if (this._assetMap[key])\n                {\n                    let assets = this._assetMap[key];\n                    const preferredOrder = this._getPreferredOrder(assets);\n\n                    preferredOrder?.priority.forEach((priorityKey) =>\n                    {\n                        preferredOrder.params[priorityKey].forEach((value: unknown) =>\n                        {\n                            const filteredAssets = assets.filter((asset) =>\n                            {\n                                if (asset[priorityKey as keyof ResolvedAsset])\n                                {\n                                    return asset[priorityKey as keyof ResolvedAsset] === value;\n                                }\n\n                                return false;\n                            });\n\n                            if (filteredAssets.length)\n                            {\n                                assets = filteredAssets;\n                            }\n                        });\n                    });\n\n                    this._resolverHash[key] = assets[0];\n                }\n                else\n                {\n                    this._resolverHash[key] = this._buildResolvedAsset({\n                        alias: [key],\n                        src: key,\n                    }, {});\n                }\n            }\n\n            result[key] = this._resolverHash[key];\n        });\n\n        return singleAsset ? result[keys[0]] : result;\n    }\n\n    /**\n     * Checks if an asset with a given key exists in the resolver\n     * @param key - The key of the asset\n     */\n    public hasKey(key: string): boolean\n    {\n        return !!this._assetMap[key];\n    }\n\n    /**\n     * Checks if a bundle with the given key exists in the resolver\n     * @param key - The key of the bundle\n     */\n    public hasBundle(key: string): boolean\n    {\n        return !!this._bundles[key];\n    }\n\n    /**\n     * Internal function for figuring out what prefer criteria an asset should use.\n     * @param assets\n     */\n    private _getPreferredOrder(assets: ResolvedAsset[]): PreferOrder\n    {\n        for (let i = 0; i < assets.length; i++)\n        {\n            const asset = assets[i];\n\n            const preferred = this._preferredOrder.find((preference: PreferOrder) =>\n                preference.params.format.includes(asset.format));\n\n            if (preferred)\n            {\n                return preferred;\n            }\n        }\n\n        return this._preferredOrder[0];\n    }\n\n    /**\n     * Appends the default url parameters to the url\n     * @param url - The url to append the default parameters to\n     * @returns - The url with the default parameters appended\n     */\n    private _appendDefaultSearchParams(url: string): string\n    {\n        if (!this._defaultSearchParams) return url;\n\n        const paramConnector = (/\\?/).test(url) ? '&' : '?';\n\n        return `${url}${paramConnector}${this._defaultSearchParams}`;\n    }\n\n    private _buildResolvedAsset(formattedAsset: ResolvedAsset, data?: {\n        aliases?: string[],\n        data?: Record<string, unknown>\n        loadParser?: string,\n        parser?: string,\n        format?: string,\n        progressSize?: number,\n    }): ResolvedAsset\n    {\n        const { aliases, data: assetData, loadParser, parser, format, progressSize } = data;\n\n        if (this._basePath || this._rootPath)\n        {\n            formattedAsset.src = path.toAbsolute(formattedAsset.src, this._basePath, this._rootPath);\n        }\n\n        formattedAsset.alias = aliases ?? formattedAsset.alias ?? [formattedAsset.src];\n        formattedAsset.src = this._appendDefaultSearchParams(formattedAsset.src);\n        formattedAsset.data = { ...assetData || {}, ...formattedAsset.data };\n        formattedAsset.loadParser = loadParser ?? formattedAsset.loadParser;\n        formattedAsset.parser = parser ?? formattedAsset.parser;\n        formattedAsset.format = format ?? formattedAsset.format ?? getUrlExtension(formattedAsset.src);\n        if (progressSize !== undefined)\n        {\n            formattedAsset.progressSize = progressSize;\n        }\n\n        return formattedAsset;\n    }\n}\n\n/**\n * @param url\n * @internal\n */\nexport function getUrlExtension(url: string)\n{\n    return url.split('.').pop().split('?').shift()\n        .split('#')\n        .shift();\n}\n","import { LoaderParserPriority } from '../assets/loader/parsers/LoaderParser';\nimport { Resolver } from '../assets/resolver/Resolver';\nimport { copySearchParams } from '../assets/utils/copySearchParams';\nimport { ExtensionType } from '../extensions/Extensions';\nimport { Texture } from '../rendering/renderers/shared/texture/Texture';\nimport { path } from '../utils/path';\nimport { Spritesheet } from './Spritesheet';\n\nimport type { AssetExtensionAdvanced } from '../assets/AssetExtension';\nimport type { Loader } from '../assets/loader/Loader';\nimport type { ResolvedAsset } from '../assets/types';\nimport type { TextureSourceOptions } from '../rendering/renderers/shared/texture/sources/TextureSource';\nimport type { SpritesheetData } from './Spritesheet';\n\n/**\n * Interface for the JSON data structure of a spritesheet.\n * This is used to define the structure of the JSON file that describes a spritesheet.\n * It includes metadata about the spritesheet and the frames it contains.\n * @see {@link Spritesheet}\n * @see {@link SpritesheetData}\n * @category assets\n * @advanced\n */\nexport interface SpriteSheetJson extends SpritesheetData\n{\n    meta: {\n        image: string;\n        scale: string;\n        related_multi_packs?: string[];\n    };\n}\n\nconst validImages = ['jpg', 'png', 'jpeg', 'avif', 'webp',\n    'basis', 'etc2', 'bc7', 'bc6h', 'bc5', 'bc4', 'bc3', 'bc2', 'bc1', 'eac', 'astc'];\n\nfunction getCacheableAssets(keys: string[], asset: Spritesheet, ignoreMultiPack: boolean)\n{\n    const out: Record<string, any> = {};\n\n    keys.forEach((key: string) =>\n    {\n        out[key] = asset;\n    });\n\n    Object.keys(asset.textures).forEach((key) =>\n    {\n        out[`${asset.cachePrefix}${key}`] = asset.textures[key];\n    });\n\n    if (!ignoreMultiPack)\n    {\n        const basePath = path.dirname(keys[0]);\n\n        asset.linkedSheets.forEach((item: Spritesheet, i) =>\n        {\n            const out2 = getCacheableAssets([`${basePath}/${asset.data.meta.related_multi_packs[i]}`], item, true);\n\n            Object.assign(out, out2);\n        });\n    }\n\n    return out;\n}\n\n/**\n * Asset extension for loading spritesheets\n * @example\n * import { Assets } from 'pixi.js';\n *\n * Assets.load({\n *     alias: 'spritesheet',\n *     src: 'path/to/spritesheet.json',\n *     data: {\n *         ignoreMultiPack: true,\n *         textureOptions: {\n *             scaleMode: \"nearest\"\n *         }\n *     }\n * })\n * @type {AssetExtension}\n * @category assets\n * @advanced\n */\nexport const spritesheetAsset = {\n    extension: ExtensionType.Asset,\n    /** Handle the caching of the related Spritesheet Textures */\n    cache: {\n        test: (asset: Spritesheet) => asset instanceof Spritesheet,\n        getCacheableAssets: (keys: string[], asset: Spritesheet) => getCacheableAssets(keys, asset, false),\n    },\n    /** Resolve the resolution of the asset. */\n    resolver: {\n        extension: {\n            type: ExtensionType.ResolveParser,\n            name: 'resolveSpritesheet',\n        },\n        test: (value: string): boolean =>\n        {\n            const tempURL = value.split('?')[0];\n            const split = tempURL.split('.');\n            const extension = split.pop();\n            const format = split.pop();\n\n            return extension === 'json' && validImages.includes(format);\n        },\n        parse: (value: string) =>\n        {\n            const split = value.split('.');\n\n            return {\n                resolution: parseFloat(Resolver.RETINA_PREFIX.exec(value)?.[1] ?? '1'),\n                format: split[split.length - 2],\n                src: value,\n            };\n        },\n    },\n    /**\n     * Loader plugin that parses sprite sheets!\n     * once the JSON has been loaded this checks to see if the JSON is spritesheet data.\n     * If it is, we load the spritesheets image and parse the data into Spritesheet\n     * All textures in the sprite sheet are then added to the cache\n     */\n    loader: {\n        /** used for deprecation purposes */\n        name: 'spritesheetLoader',\n        id: 'spritesheet',\n\n        extension: {\n            type: ExtensionType.LoadParser,\n            priority: LoaderParserPriority.Normal,\n            name: 'spritesheetLoader',\n        },\n\n        async testParse(asset: SpriteSheetJson, options: ResolvedAsset): Promise<boolean>\n        {\n            return (path.extname(options.src).toLowerCase() === '.json' && !!asset.frames);\n        },\n\n        async parse(\n            asset: SpriteSheetJson,\n            options: ResolvedAsset<{\n                texture?: Texture,\n                imageFilename?: string,\n                ignoreMultiPack?: boolean,\n                textureOptions?: TextureSourceOptions,\n                cachePrefix?: string,\n            }>,\n            loader?: Loader\n        ): Promise<Spritesheet>\n        {\n            const {\n                texture: imageTexture, // if user need to use preloaded texture\n                imageFilename, // if user need to use custom filename (not from jsonFile.meta.image)\n                textureOptions, // if user need to set texture options on texture\n                cachePrefix, // if user need to use custom cache prefix\n            } = options?.data ?? {};\n\n            let basePath = path.dirname(options.src);\n\n            if (basePath && basePath.lastIndexOf('/') !== (basePath.length - 1))\n            {\n                basePath += '/';\n            }\n\n            let texture: Texture;\n\n            if (imageTexture instanceof Texture)\n            {\n                texture = imageTexture;\n            }\n            else\n            {\n                const imagePath = copySearchParams(basePath + (imageFilename ?? asset.meta.image), options.src);\n\n                const assets = await loader.load<Texture>([{ src: imagePath, data: textureOptions }]);\n\n                texture = assets[imagePath];\n            }\n\n            const spritesheet = new Spritesheet({\n                texture: texture.source,\n                data: asset,\n                cachePrefix\n            });\n\n            await spritesheet.parse();\n\n            // Check and add the multi atlas\n            // Heavily influenced and based on https://github.com/rocket-ua/pixi-tps-loader/blob/master/src/ResourceLoader.js\n            const multiPacks = asset?.meta?.related_multi_packs;\n\n            if (Array.isArray(multiPacks))\n            {\n                const promises: Promise<Spritesheet<SpriteSheetJson>>[] = [];\n\n                for (const item of multiPacks)\n                {\n                    if (typeof item !== 'string')\n                    {\n                        continue;\n                    }\n\n                    let itemUrl = basePath + item;\n\n                    // Check if the file wasn't already added as multipack\n                    if (options.data?.ignoreMultiPack)\n                    {\n                        continue;\n                    }\n\n                    itemUrl = copySearchParams(itemUrl, options.src);\n\n                    promises.push(loader.load<Spritesheet<SpriteSheetJson>>({\n                        src: itemUrl,\n                        data: {\n                            textureOptions,\n                            ignoreMultiPack: true,\n                        }\n                    }));\n                }\n\n                const res = await Promise.all(promises);\n\n                spritesheet.linkedSheets = res;\n                res.forEach((item) =>\n                {\n                    item.linkedSheets = [spritesheet].concat(spritesheet.linkedSheets.filter((sp) => (sp !== item)));\n                });\n            }\n\n            return spritesheet;\n        },\n\n        async unload(spritesheet: Spritesheet, _resolvedAsset, loader)\n        {\n            await loader.unload(spritesheet.textureSource._sourceOrigin);\n\n            spritesheet.destroy(false);\n        },\n    }\n} satisfies AssetExtensionAdvanced<SpriteSheetJson, Spritesheet, Spritesheet, Spritesheet>;\n"],"names":["LoaderParserPriority","path","key","video","src"],"mappings":"mDAWO,MAAK,GAGRA,CAHQA,EAAA,GAAA,CAAA,CAAA,CAGRA,CAAAA,EAAA,GAAA,CAAM,CAAA,AAHE,CAGF,CAAN,CAHQ,EAAAA,CAAA,CAGR,CAEAA,CAAAA,CALG,AAKHA,EAAA,EAFAA,EAHQ,EAKR,CALQ,AAKC,CAAA,AALD,CAKC,CAAT,QAAA,CAAAA,EAEAA,EAAA,IAAA,CAAO,ACda,CDcb,CAAA,CAAP,MAAA,CAPQA,IAORA,qCChBJ,SAAS,EAAWC,CAAAA,EACpB,GACeA,UAAP,AACJ,OADWA,EAEP,MAAM,AAAI,SAAA,CAAU,CAAA,KDKhBD,2BCLgB,EAAmC,KAAK,SAAA,CAAUC,GAAK,CAAE,CAAA,AAErF,AAFkF,CAAC,AAInF,SAAS,EAAgB,CAAA,EACzB,AAGI,OAFW,AAEJ,EAFQ,AAER,CAFI,IAAI,CAAM,GAAG,CAAA,CAAE,CAAC,CAAA,CAEjB,KAAA,CAAM,GAAG,CAAA,CAAE,CAAC,CAAA,AAC1B,CA0PO,IAAM,EAAa,CAWtB,CAXS,OAWDA,GA5PD,AA4PmCA,EA5P/B,AA4PHA,CA5PD,CA4Pe,CAAoBA,IA5P/B,CAAY,AAAJ,MAAI,CA4PyB,AA5PlB,AALvB,IAiQyC,CAjQlC,CAAP,MAAO,CAK6B,AALrB,IAKyB,CAAA,gBALzB,CAAuB,MAAM,CAAA,CAKD,GAAG,CAAA,CA4PC,CA5PE,EA4PC,CAAA,CAazD,GAzQ+D,CAAA,EAyQzDA,CAAAA,EAAc,AAAE,MAAQ,UAAA,CAAY,IAAA,CAAK,IAAA,CAAK,OAAA,CAAQA,GAAQ,CAAA,CAAJ,CAAC,CAAA,QAWjE,AAAUA,GAGE,EAHFA,EACV,oIAEY,CACH,IAAA,CAAKA,KAAI,CAAA,OAYlB,AAAUA,GAGCA,EAAK,AAHNA,EACV,CAEWA,OAAK,CAAW,OAAO,CAAA,CAelC,YAAYA,CAAAA,EAAc,AAAE,MAAQ,UAAA,CAAY,IAAA,CAAK,IAAA,CAAK,OAAA,CAAQA,GAAQ,CAAA,CAAJ,AActE,CAduE,CAAA,UAc3DA,CAAAA,EACZ,AACI,EAAWA,GACXA,EADe,AACR,CADQ,EAAf,AACAA,CAAO,CAAK,OAAA,CAAQA,GAEpB,EAFwB,CAAA,CAElB,EAAa,OAAb,OAAa,CAAgB,IAAA,CAAKA,GAExC,EAF4C,CAAA,AAExC,EAEA,OAAO,AAFP,CAEO,CAAU,AADrB,CACsB,CAAA,CAGtB,IAAM,EAAiB,WAAjB,MAAiB,CAAmB,IAAA,CAAKA,KAAI,CAAA,IAEnD,AAAI,EAEO,CAAA,CAAc,CAAC,CAAA,CAGnB,EAAA,AACX,CAAA,CAiBA,EAvBQ,EACJ,MAsBJ,CAAW,CAAA,CAAa,CAAA,CAAwB,CAAA,EAChD,AAGI,GAFA,EAAW,GAAG,AAEV,CAFU,GAEV,CAFJ,AAES,SAAA,CAAU,GAAG,CAAA,AAAK,IAAA,CAAK,SAAA,CAAU,GAAM,AAAH,OAAU,EAEvD,CAFuD,GAEjD,EAAU,EAAgB,GAA1B,CAA0B,CAAK,OAAA,CAArB,AAA6B,GAAiB,EAAA,CAAA,CAAW,GAAA,EAAI,CAAhC,AAAkC,UAAA,EAAY,CAAC,CAAA,CACtF,EAAU,EAAgB,GAA1B,CAA0B,CAAK,OAAA,CAAQ,GAAiB,IAAA,CAAK,QAAA,CAAS,OAAO,CAAC,CAAC,CAAA,CAKrF,AAAI,CAHJ,EAAM,AAGF,CAHJ,GAAM,CAAK,OAAA,CAAQ,EAAG,CAAA,CAGd,UAAA,CAAW,GAAG,CAAA,CAEX,CADX,CACgB,IAAA,CAAK,EAAS,EAAI,CAAJ,EAAT,EAAa,CAAM,CAAC,CAAC,CAAA,CAGrB,IAAA,CAAK,UAAA,CAAW,GAAG,AAAI,EAAM,CAAN,GAAM,CAAK,IAAA,CAAK,EAAS,EAGzE,CAH4E,AAG5E,CAH4E,AAkB5E,CAlBgE,SAkBtDA,CAAAA,EACV,AAGI,GAFA,EAAWA,GAES,CAAA,CAFL,CAAA,CAEXA,CAFJ,CAES,GAALA,GAAK,CAAc,MAAO,GAAA,CAC9B,GAAI,IAAA,CAAK,SAAA,CAAUA,IAAS,CAAL,CAAA,EAAK,CAAK,SAAA,CAAUA,GAAO,EAAH,KAAUA,EAEzDA,EAAO,CAFkDA,EAEzDA,CAAO,CAAK,OAAA,CAAQA,GAEpB,EAFwB,CAAA,CAEpB,EAAW,EAAA,CACT,EAAaA,CADf,CACoB,GAALA,GAAb,IAAkB,CAAW,GAAG,CAAA,CAElC,IAAA,CAAK,WAAA,CAAYA,KAAI,AAErB,CAFqB,CAEV,CADf,GACe,CAAK,CAAhB,OAAgB,CAASA,GACzBA,EAD6B,AACtBA,CADsB,CACjB,CAAZA,EAAOA,EAAK,CAAM,EAAS,MAAT,AAAe,CAAA,EAGrC,IAAM,EAAoBA,EAAK,GAALA,KAAK,CAAS,GAAG,CAAA,AAArC,OAMN,CAHAA,AAEIA,GA/ZZ,AA6Ze,EAAPA,AAEIA,OA/ZH,AAAqBA,CAAAA,CAAc,CAAA,EAC5C,AACI,IAAI,EAAM,AA2ZC,CA3ZP,CAAM,CACN,EAAoB,CAAA,CACpB,EAAY,AAJX,CAIW,CAAA,CACZ,EAAO,CAAA,CADP,AACA,AACA,EAAO,CAAA,CAHP,AAGA,AAAO,CAEX,IAAA,IAAS,EAAI,CAAA,CAAG,CAAA,EAAKA,EAAK,GAALA,GAAK,CAAQ,EAAE,CAAA,CACpC,CACI,GAAI,CAAA,CAAIA,EAAK,MAAA,CAET,CADJ,CACWA,EAAP,AAAY,GAALA,OAAK,CAAW,CAAC,CAAA,MAC5B,GACkB,EAAA,EAClB,CADS,EAEL,WAIA,EAAO,EAAP,AAAO,CAEX,GAAa,EAAA,GAAT,EACJ,CACI,GAAI,IAAc,CAAA,CAAI,CAAA,EAAlB,AAAuB,AAAS,CAAA,EACpC,CAD2B,AAG3B,CAAA,OAAA,GACS,IAAc,CAAA,CAAI,CAAA,EAAlB,AAAgC,CAAA,GAAT,EAChC,CACI,GACI,EAAI,MAAA,CAAS,CAAA,EACY,CAAA,GAAtB,GACmC,KAAnC,EAAI,CAAJ,SAAI,CAAW,EAAI,CAAJ,KAAI,CAAS,CAAC,CAAA,EACM,AAAnC,EAAmC,CAAnC,CAEP,GAFW,UAAA,CAAW,EAAI,MAAA,CAAS,CAAC,GAGhC,GAAI,EAAI,CAAJ,KAAI,CAAS,CAAA,CACjB,CACI,IAAM,EAAiB,EAAI,CAAJ,SAAjB,CAAqB,CAAY,GAAG,CAAA,CAE1C,GAAI,IAAmB,EAAI,CAAJ,KAAI,CAAS,CAAA,AAAhC,CACJ,CAC2B,CAAA,CAAA,EACvB,CADI,GAEA,EAAM,CAAN,CAAM,CACN,EAAoB,CAAA,EAKpB,EAAoB,CADpB,EAAM,AACc,CADpB,CAAU,CAAJ,IAJN,AAIU,CAAM,CAAA,CAAG,EAAc,AACjC,CADiC,CACT,MAAA,CAAS,CAAA,CAAI,EAAI,CAAJ,UAAI,CAAY,GAAG,CAAA,CAE5D,EAAY,CAAA,CACZ,EAAO,CAAA,CAAP,AACA,CAFA,OAGJ,CACJ,MAAA,GACwB,CAAA,GAAf,EAAI,CAAJ,KAAI,EAA+B,CAAA,GAAf,EAAI,CAAJ,KAAI,CACjC,CACI,EAAM,CAAN,CAAM,CACN,EAAoB,CAAA,CACpB,EAAY,CAAA,CACZ,EAAO,CAAA,CAAP,AACA,CAFA,IADA,IAIJ,CAEA,IAEI,EAAI,CAAJ,KAAI,CAAS,CAAA,AAFjB,CAGE,CAFN,AAEI,EAAE,AAAO,KAAA,CAEP,EAAM,CAAN,GAAM,CACR,EAAoB,CAAA,CAE5B,CAAA,KAGQ,CADR,CACY,CAAJ,IALA,CAKI,CAAS,CAAA,CAEb,CADJ,EACW,AAAP,CAAO,CAAA,EAAIA,EAAK,GAALA,EAAK,CAAM,EAAY,CAAA,CAAG,CAAC,CAAC,CAAA,CAAA,CAAjB,AAItB,EAAMA,CAAN,CAAW,GAALA,EAAK,CAAM,EAAY,CAAA,CAAG,CAAC,CAAA,CAErC,EAAoB,AAFC,EAEG,EAAY,CAAA,CAExC,EAAY,CAAA,CACZ,CAH4B,CAGrB,CAAA,AACX,CADI,AACJ,CAJQ,AAEJ,IAGc,CADlB,CACkB,GAAT,GAAwB,CAAxB,AAAwB,CAAA,EACjC,CADwB,EAEpB,EAFoB,AAElB,EAIF,EAAO,AAJL,CAIK,CAAP,AAAO,AAEf,CAEA,OAAO,CACX,EAuToCA,AAxTzB,GAwT+B,EAANA,AAAW,CAAA,CAE9B,MAAA,CAAS,CAAA,EAAK,IAAmBA,GAAQ,EAARA,CAAQ,CAAA,CAC9C,GAAmB,CAAA,CAAA,AADA,EACIA,EAAI,CAA3B,AAA2B,CAExB,CAFS,AAAe,CAEbA,CACtB,CAAA,CAeA,EAhBsBA,CAAX,QAgBAA,CAAAA,EACX,OAII,AAHA,EAAWA,GACXA,EAAO,AADQ,CAAA,EACfA,AADA,CACO,CAAK,OAAA,CAAQA,KAAI,AAEpB,CAFoB,GAEpB,CAAK,WAAA,CAAYA,IAEdA,CAFkB,CAEb,AAFa,EAAG,CAErBA,MAF4B,CAEvB,CAAW,EAFY,CAET,CAAA,AAC9B,CAAA,CAgBA,KAAA,GAAQ,CAAA,EACR,IAGQ,EAFJ,GAAwB,CAAA,AAEpB,EADJ,CADI,EAAS,MAAT,AAAS,CACX,MAAO,GAAA,CAGT,IAAA,IAAS,EAAI,CAAA,CAAG,CAAA,CAAI,EAAS,MAAA,AAAT,CAAiB,EAAE,CAAA,CACvC,CACI,IAAM,EAAM,CAAN,AAAM,CAAS,CAAC,CAAA,CAGtB,GADA,EAAW,GAAG,AACV,CADU,CACN,CAAJ,EADJ,GACQ,CAAS,CAAA,CAEb,CADJ,EACmB,KAAA,IAAX,EAAsB,EAAS,EAA/B,CAA+B,CAAT,EAE1B,CACI,IAAM,EAAU,CAAA,CAAS,CAAA,CAAI,CAAC,AAAxB,CAAwB,EAAK,EAAA,CAE/B,IAAA,CAAK,cAAA,CAAe,QAAA,CAAS,IAAA,CAAK,OAAA,CAAQ,GAAS,IAAF,CAAA,MAAE,EAAa,CAAA,CAEhE,CADJ,EACc,CAAA,EAAV,EAAU,EAAO,EAAG,CAAA,CAIpB,GAAU,CAAA,CAAA,CAAV,CAAc,EAAG,CAAA,AAEzB,CAER,QACA,AAAe,KAAA,CAAA,EAAW,CAAtB,EAA+B,GAAA,CAE5B,IAAA,CAAK,SAAA,CAAU,EAC1B,CAAA,CAeA,EAhBgC,CAAA,KAgBxBA,CAAAA,EACR,AAEI,GADA,EAAWA,GACS,CAAA,CADL,CAAA,CACXA,CADJ,CACS,GAALA,GAAK,CAAc,MAAO,GAAA,CAE9B,IAAI,EAAOA,AADXA,EACI,CADG,EACIA,AADXA,EAAO,CAAK,OAAA,CAAQA,EAAI,CAAA,CACR,UAAA,CAAW,CAAC,CAAA,CACtB,EAAmB,EAAA,GAAT,EACZ,EADY,AACN,CAAN,AAAM,CAAA,CACN,GAAe,EAEb,EAFa,AAEL,GAAR,CAAQ,CAFV,AAEe,WAAA,CAAYA,GACzB,EAD6B,AAClBA,CADkB,CAGnCA,EAAOA,CAFUA,CAAX,AAEM,CAAZA,EAAOA,EAAK,CAAM,EAAM,GAAN,GAAY,CAAA,CAE9B,IAAA,IAAS,EAAIA,EAAK,GAALA,GAAK,CAAS,EAAG,CAAA,EAAK,CAAA,CAAG,EAAE,CAAA,CACxC,AAEI,GAAI,AAAS,EAAA,EACb,EAFA,EAAOA,EAAK,AAAZ,GAAOA,OAAK,CAAW,EAAC,CAAA,EAGpB,GAAI,CAAC,EACL,CACI,EAAM,CAAA,AAAN,CACA,KAHC,CAIL,MAKA,GAAe,KAAA,IAMvB,AAAI,AAAQ,AANJ,CAMI,CAAA,CAAR,CAAY,GAAO,EAAU,GAAA,CAAM,CAAhB,GAAgB,CAAK,KAAA,CAAM,GAAY,EAAQA,EAAO,CAAf,AAAJ,CAAA,AACtD,CADkEA,EAC/C,AADsD,CACtD,EAAG,CAAtB,AAAW,EAAkB,CAAlB,GAAkB,CAE1B,EAAQA,EAAK,CAAb,EAAQA,EAAK,CAAM,CAAA,CAAG,EACjC,CAAA,AADoC,CAAA,AAgBpC,SAASA,CAAAA,EAEL,AADJ,EACeA,GAGX,EAHe,CAAA,CAGX,CAHJ,CAGW,EAAP,AAAO,CAQX,GAN0B,EAAtBA,CAJJA,CAI0B,CAJnB,EAIHA,CAJJA,CAAO,CAAK,OAAA,CAAQA,EAAI,CAAA,CAIf,UAAA,CAAW,GAAG,CAAA,CAAU,GAAA,CAGtB,IAAA,CAAK,WAAA,CAAYA,GAGxB,EAH4B,CAAA,CAG5B,CAAK,KAAA,CAAMA,GACf,CAEI,CAHe,CAAA,EAGT,EAAQA,EAAK,CAAb,EAAQA,IAAK,CAAQ,GAAA,CAAK,EAAK,MAAM,CAAA,AAQvC,CAAC,CAJD,EAFA,AAAU,CAAA,AAMT,CANS,AAEV,EADJ,GACWA,EAAK,GAALA,EAAK,CAAM,CAAA,CAAG,GAEbA,EAFkB,CAAA,AAIpB,EAFEA,MAEF,CAAS,GAAG,IAAG,GAAQ,CAAR,EAAQ,CAAA,AACrC,CAEA,OAAO,CACX,CAAA,CAgBA,CAjBW,OAiBX,CAASA,CAAAA,CAAc,CAAA,EACvB,IASQ,CAAA,CARJ,EAAWA,GACP,EADW,CAAA,AACX,EADJ,AACoB,GAAG,AAEvBA,CAFuB,CAEhB,EAAgB,CAAvBA,GAAuB,CAAK,OAAA,CAArB,AAA6BA,IAEpC,CAFwC,CAAC,CAAA,CAErC,EAAQ,CAAA,CACR,CADA,CACM,CAAN,AAAM,CAAA,CACN,EAAe,GAGnB,CAHmB,EAGP,IAHR,CAGQ,IAAR,GAAA,AAAqB,EAAI,CAAJ,KAAI,CAAS,GAAK,EAAI,CAAJ,KAAI,EAAUA,EAAK,MAAA,CAC9D,CACI,GAAI,EAAI,MAAA,GAAWA,EAAK,GAALA,GAAK,EAAU,GAAA,CAAQA,EAAM,MAAO,EAAA,CACvD,IAAI,EAAS,EAAI,EAAb,IAAa,CAAS,CAAA,CACtB,EAAmB,CAAA,CAAA,CAEvB,IAAK,EAAIA,EAAK,GAALA,AAFL,GAEU,CAAS,EAAG,CAAA,EAAK,CAAA,CAAG,EAAE,CAAA,CACpC,CACI,IAAM,EAAOA,EAAK,AAAZ,GAAOA,OAAK,CAAW,CAAC,CAAA,CAE9B,GAAa,EAAA,EACb,CADI,GAIA,GAAI,CAAC,EACL,CACI,EAAQ,CAAA,CAAI,CAAZ,AAAY,CACZ,GAHC,GAIL,MAIyB,CAAA,CAAA,EACzB,CADI,IAIA,GAAe,EACf,EAAmB,CADJ,AACI,CAAI,CAAA,EADvB,AAGA,GAAU,CAAA,EACd,CAEQ,EALJ,EAKI,AAAS,EAAI,CAAJ,SAAI,CAAW,GAEpB,AAAa,CAAA,CAAA,CAFa,CAAA,AAG9B,EAFJ,AACU,IAIF,GAAA,AAAM,CAAA,EAOV,EAAS,CAAA,CAAA,CACT,CADA,CACM,CAAN,EAIhB,CAIA,OAFI,IAAU,CANQ,AAMlB,CAAe,EAAM,CAAN,CAAyC,CAAA,CAAA,GAAR,GAAA,CAAY,EAAMA,CAAN,CAAW,CAAlD,EAA6CA,GAAK,EAEpEA,EAAK,GAALA,EAAK,CAAM,EAAO,EAC7B,CADsB,AAAU,AAEhC,CAFgC,GAE3B,EAAIA,EAAK,GAALA,GAAK,CAAS,EAAG,CAAA,EAAK,CAAA,CAAG,EAAE,CAAA,CACpC,AACI,GAA2B,EAAA,EAC3B,CADIA,EAAK,GAALA,OAAK,CAAW,CAAC,CAAA,EAIjB,GAAI,CAAC,EACL,CACI,EAAQ,CAAA,CAAI,CAAZ,AAAY,CACZ,GAHC,GAIL,MAEa,CAAA,CAAA,EACjB,CADS,IAIL,GAAe,EACf,EAAM,CAAN,AAAM,AADS,CACL,CAAA,EADV,OAKI,AAAZ,CAAY,GAAI,CAAZ,EAAmB,CAAnB,CAAmB,CAEhBA,EAAK,GAALA,EAAK,CAAM,EAAO,EAC7B,CADsB,AAAU,AAChC,CADgC,AAkBhC,QAAQA,CAAAA,EACR,AACI,EAAWA,GACXA,EADe,AACR,CADQ,CACQ,CAAvBA,AADA,GACuB,CAAK,OAAA,CAAQA,AAA7B,IAEP,CAFwC,CAAC,CAAA,CAErC,EAAW,CAAA,CAAA,CACX,EAAY,CADZ,AACY,CACZ,EAAM,CAAN,AAAM,CAAA,CADN,AAEA,GAAe,EAGf,EAAc,AAHC,CAGD,CAElB,GALI,CAKJ,GAFI,CAEK,EAAIA,EAAK,GAALA,GAAK,CAAS,EAAG,CAAA,EAAK,CAAA,CAAG,EAAE,CAAA,CACxC,CACI,IAAM,EAAOA,EAAP,AAAY,GAALA,OAAK,CAAW,CAAC,CAAA,CAE9B,GAAa,EAAA,GAAT,EACJ,CAGI,GAAI,CAAC,EACL,CACI,EAAY,CAAA,CAAI,CAAA,CAChB,GAHC,AAED,EAEJ,CACA,QACJ,CACY,CAAA,CAAA,EACZ,CADI,IAIA,GAAe,EACf,EAAM,CADS,AACf,AAAM,CAAI,CAAA,EADV,AAGS,EAAA,EACb,CADI,EAGiB,CAAA,IAAb,EAAiB,EAAW,CAAA,CACP,EADrB,EAAiB,AACZ,IAAmB,GAAc,CAAA,CAExB,AAAb,CAAa,CAAA,AAFT,EAGb,EAHgC,GAM5B,EAAc,EAAA,CAAA,AAEtB,MAFQ,EAIR,AACiB,CAAA,CAAA,GAAb,GAAmB,AAAQ,CAAA,CAAA,CAAR,EAAnB,GAEmB,CAAA,GAAhB,GAGgB,CAAA,GAAhB,GAAqB,CAHrB,GAGkC,EAAM,CAAN,AAAM,CAAnB,AAArB,CAA6C,IAAa,EAAY,CAAA,CAAzB,AAGzC,CADX,CACW,CAGJA,EAAK,GAALA,EAAK,CAAM,EAAU,EAChC,CADmC,AACnC,CADmC,AA4BnC,EA5BsB,IA4BhBA,CAAAA,EACN,IAUQ,EATJ,EAAWA,CASP,EAPJ,EAFe,CAAA,CAET,CAFN,CAEY,CAAN,AAAQ,IAAA,CAAM,EAAA,CAAI,GAAA,CAAK,EAAA,CAAI,IAAA,CAAM,EAAA,CAAI,GAAA,CAAK,EAAA,CAAI,IAAA,CAAM,EAAA,CAAG,CAE7D,GAAoB,CAAA,GAAhBA,EAAK,GAALA,GAAK,CAAc,OAAO,EAG9B,CAH8B,GAG1B,EAAOA,CAFXA,CAEI,CAFG,EAAgB,AAEZA,CAFXA,GAAuB,CAAK,OAAA,CAArB,AAA6BA,GAAK,CAAA,CAAD,AAExB,UAAA,CAAW,CAAC,CAAA,CACtB,EAAa,IAAA,CAAK,GAAlB,OAAkB,CAAWA,GAInC,EAJuC,AAInC,CAJmC,AAIvC,GAAI,CAAO,IAAA,CAAK,QAAA,CAASA,GAIrB,EAFA,AAFyB,CAAA,EAEX,AAEd,IAFc,CAAK,EAAnB,SAAmB,CAAYA,GAEvB,CAAA,CAIA,AAN2B,CAAA,AAM3B,CAEZ,CAPA,GAOI,EAAW,CAAA,CAAA,CACX,EAAY,CADZ,AACY,CACZ,EAAM,CAAN,AAAM,CAAA,CADN,AAEA,GAAe,EACf,CAAA,CADe,AACXA,EAAK,GADT,GACS,CAAS,CAAA,CAIlB,EAAc,CAAA,CAGlB,KAAO,CAAA,CAHH,CAGQ,EAAO,EAAE,CAAA,AAAT,CACZ,CAEI,GAAI,AAAS,EAAA,IADb,EAAOA,EAAK,AAAZ,GAAOA,OAAK,CAAW,EAAC,CAAA,CAExB,CAGI,GAAI,CAAC,EACL,CACI,EAAY,CAAA,CAAI,CAAA,CAChB,GAHC,AAED,EAEJ,CACA,QACJ,CACY,CAAA,CAAA,EACZ,CADI,IAIA,GAAe,EACf,EAAM,CAAN,AAAM,AADS,CACL,CAAA,EAED,AAHT,EAGS,EACb,CADI,EAGiB,CAAA,IAAb,EAAiB,EAAW,CAAA,CACP,EADrB,EAAiB,AACZ,IAAmB,GAAc,CAAA,CAExB,CAAA,CAFT,AAES,EACtB,CADS,CAFuB,EAM5B,GAAc,EAAA,CAEtB,AAFsB,KAAd,GAKJ,AAAa,CAAA,CAAA,MAAb,AAAmB,AAAQ,CAAA,CAAA,CAAR,KAEA,CAAA,GAAhB,GAGgB,CAAA,GAAhB,GAAqB,CAHrB,GAGkC,EAAM,CAAN,AAAM,CAAxC,AAAqB,CAAwB,IAAa,EAAY,CAAA,CAAzB,AAGpC,CADhB,AACgB,CAAA,EACZ,CADI,IAEkB,CAAA,GAAd,GAAmB,EAAY,EAAI,CAAJ,CAA/B,EAAmC,CAAO,CAAvB,CAA2B,IAAA,CAAOA,EAAK,GAALA,EAAK,CAAM,CAAA,CAAG,GAAG,CAAA,CACjE,IAAA,CAAO,EAAI,CAAJ,GAAI,CAAOA,EAAK,GAALA,EAAK,CAAM,EAAW,GAAG,CAAA,CAKtC,IAAd,GAAmB,GAEnB,EAAI,CAFJ,AAEA,GAAI,CAFe,AAERA,EADf,AACoB,GAALA,EAAK,CAAM,CAAA,CAAG,GACzB,EAAI,CAAJ,EADiC,CAC7B,AAD6B,CACtBA,EAAK,GAALA,EAAK,CAAM,CAAA,CAAG,GAAG,CAAA,CAI5B,EAAI,CAAJ,GAAI,CAAOA,EAAK,GAALA,EAAK,CAAM,EAAW,GACjC,EAAI,CAAJ,CADsB,CAAmB,CAAA,AACrC,CAAOA,EAAK,GAALA,EAAK,CAAM,EAAW,GAAG,CAAA,AAExC,EAAI,CAAJ,AAF0B,EAEtB,CAAMA,EAAK,GAALA,EAAK,CAAM,EAAU,GAAG,CAAA,AAGtC,EAHyB,AAGrB,CAAJ,EAAI,CAAM,IAAA,CAAK,OAAA,CAAQA,GAGhB,CACX,CAJ+B,AAI/B,CADW,AAHoB,AAM/B,GAAA,CAAK,GAAA,CACL,SAAA,CAAW,GAAA,CACX,cAAA,CAAgB,CAAC,OAAO,CAAA,AAC5B,6CCp6B6B,CACzB,EACA,EACA,CAFA,EAEiB,CAAA,GADjB,AASA,CALI,AAAC,CADT,EAMQ,EALC,CAAM,OAAA,CAAQ,KAAK,AAEpB,CAFoB,CAEZ,CADZ,AACa,EAAT,AAAmB,EAGlB,CAHkB,EAQf,EAAyB,GAAA,AAAzB,CAA6B,AAAC,AALjC,EACL,CAMI,AAAoB,CAFc,KACtC,EACwB,EAAhB,OAAO,GAAqB,CAArB,CAEA,EAAU,GAGd,CAH4B,CAAA,CAP5B,CAUA,GALyB,CALzB,CAMP,qJCmLD,IAAM,EAAQ,GAAR,CAtMb,AAsMyB,MAtMzB,AAAM,IAsMmB,MAtMnB,CACN,AADA,EAAA,CAEI,IAAA,CAAiB,QAAA,CAA0B,EAAC,CAE5C,IAAA,CAAiB,MAAA,CAAA,EAAA,EAAA,IACjB,IAAA,CAAA,SAAiB,CCmCL,EDnCK,EAGR,ECgCG,CDhCH,CAGF,CAHM,IAGN,EACP,CACI,IAAA,CAAK,SAAA,CAAU,ACoCd,KDpCc,EAAM,CACrB,IAAA,CAAK,MAAA,CAAO,KAAA,EAAM,ECsCV,GD/BD,CAAA,CACX,CACI,OAAO,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,GAAG,AAOvB,CAPuB,GAOV,CAAA,CACpB,CCiDM,ADhDF,IAAM,EAAS,IAAT,ACkDL,ADlDc,CAAK,CCkDN,KAAA,CDlDa,GAAA,CAAI,GAS/B,ACyCgC,ADlDE,CCkDF,ADlDE,ICyDtC,EDvDQ,AAAC,GAGD,CAAA,EAAA,EAAA,CAAA,EAAK,CAAA,kBAAA,EAAqB,EAAG,CAAA,0BAAA,CAA6B,CAAA,CAIvD,CACX,CAOO,GAAA,CAAa,CAAA,CAAkB,CAAA,CACtC,CACI,IAEI,EAFE,ECmDH,CAAA,CDnDG,CAAO,CCmDV,CDnDU,CAAA,EAAsB,GAAG,AAElC,AAEJ,CAJsC,GAItC,IAAS,EAAI,CAAA,CAAG,EAAI,IAAA,CAAK,KC2DkB,ED3DlB,CAAA,MAAA,CAAgB,CAAA,EAAA,CACzC,KACU,EAAS,IAAA,CAAK,EC2DV,KD3DU,CAAQ,CAAC,CAAA,CAE7B,GAAI,EAAA,IAAA,CAAY,CC2DD,CAAA,CD1Df,CACI,CAFiB,CAEC,AAFD,EAEQ,kBAAA,CAAmB,EAAM,EAAN,CAE5C,EAFuD,CAAA,EAG3D,CACJ,CAGA,IAAM,EAAe,IAAI,GAAA,CAAI,EAAvB,IAAuB,CAAO,OAAA,CAAQ,GAAmB,CAAA,CAAE,CAAC,CAAA,AAElE,CAAK,GAED,EAAK,EAAL,AAJwC,KAInC,CAAQ,AAACC,IAEV,EAAa,GAAA,CAAIA,EAAK,EAC1B,CAAC,CADG,AACH,CAD8B,AAInC,CAJmC,GAI7B,EAAY,CAAC,GAAG,EAAa,CAA7B,GAA6B,EAAM,CAAA,CAEnC,EAFgB,AAED,UAAf,CACF,OACA,CAAA,CADA,AAEJ,CAGA,EAAK,EAAL,KAAK,CAAQ,AAACA,IAAAA,AAEV,IAAA,CADJ,AACS,SAAA,CAAU,GAAA,CAAIA,EAAK,EAALA,AACvB,CAAC,CAAA,CAED,EAAU,KAHqC,CAAA,CAG/C,AAAU,CAAQ,AAACA,IAAAA,AAEf,IAAM,CADV,CACgB,CAAN,CAAwB,CAAA,CAAgBA,EAAG,CAAI,CAAJ,CAE7C,GAFiD,CAEjD,CAAK,CAFG,KAEH,CAAO,GAAA,CAAIA,IAAG,AAAK,CAAL,GAAK,CAAK,MAAA,CAAO,GAAA,CAAIA,IAAG,CAAM,AAAN,GAAM,EACrD,CAEI,EAAA,CAAA,EAAK,2BAA4BA,GAIrC,CAJwC,CAAA,EAIxC,CAAK,MAAA,CAAO,GAAA,CAAIA,EAAK,EAALA,AAAkB,GAAA,CAAIA,GAC1C,CAAC,AAD4C,CAC5C,AACL,AAFkD,CAU3C,AAVsB,AAAqB,OAUpC,CAAA,CACd,CACI,GAAI,CAAC,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,GACxB,AAD2B,CAAA,aAGvB,EAAA,CAAA,EAAK,CAAA,kBAAA,EAAqB,EAAG,CAAA,0BAAA,CAA6B,CAAA,CAM9D,IAAM,EAAW,IAAA,CAAK,CAAhB,QAAgB,CAAU,GAAA,CAAI,GAElB,AAElB,AAJuC,CAAA,CAEZ,MAAT,CAElB,EAF2B,CAEjB,OAAA,CAAQ,AAACA,IAAAA,AAEf,IAAA,CADJ,AACS,MAAA,CAAO,MAAA,CAAOA,EACvB,CAAC,CADyB,AACzB,CAED,AAH0B,EAGjB,IAAA,CAAK,CAAd,MAAc,CAAQ,AAACA,IAAAA,AAEnB,IAAA,CADJ,AACS,SAAA,CAAU,MAAA,CAAOA,EAC1B,CAAC,CAD4B,AAC5B,AACL,CAFiC,AAQjC,IAAW,OAAA,EACX,CACI,OAAO,IAAA,CAAK,QAAA,AAChB,CACJ,gCCrIA,IAAM,EAAsC,EAAC,CAoC7C,SAAS,EAAkB,EAAoC,CAAA,CAAC,EAChE,AACI,CAFuB,GAEvB,EAAoB,GAAY,EAAiC,KAAjC,GAAiC,GACrD,EAAe,EAAiC,KAAjC,GAAiC,CAAW,EACjE,EAAO,EAAc,CAD4C,CACV,CAAE,IAApC,EAAd,GAA4D,CAAA,CAAQ,KAAR,AAEzE,IAAS,CAAA,CAAI,CAAA,CAAG,CAAA,CAAI,EAAQ,KAAR,CAAQ,CAAQ,CAAA,EAAA,CACpC,CACI,IAAM,EAAS,CAAA,CAAQ,CAAC,CAAA,CAExB,GAAI,EAAO,IAAA,CAAK,GAAG,AAEf,CAFe,EACnB,IACW,IAAI,EAAO,EAE1B,EAF8B,CAAA,IAIxB,AAAI,KAAA,CAAM,CAAA,2CAAA,EAA8C,EAAK,EAAL,MAAa,CAAA,CAAE,CAAA,CAlDjF,EAAA,CAAA,CAAW,YAAA,CAAa,EAAA,CAAA,CAAc,GDXW,EAAI,QCWf,CAAe,GAkHrD,EAAA,CAAA,CAAQ,AAlHoD,CAAA,GAkHpD,GAAO,QAfa,CAAuB,AD5CtC,EC4CsC,CAAA,CAAY,QAE3D,AAAkB,UAAlB,AACA,OADW,EAEA,EAAM,CD7DH,EC6DH,AD3DC,AC2DK,CAAI,GAEZ,UD3DG,GC2DW,ED3DO,CC2DP,CAEZ,CD7DmB,AC4D9B,GACe,EAAA,CAAA,CAAQ,CAAE,MAAA,CAAQ,CAAA,CAAI,CAAA,CAI9B,SArDK,AACZ,EAAoC,CAAA,CAAC,CACrC,EADA,CAoDO,AAnDK,CAAA,EAEhB,AACI,IAAM,EAAc,AALR,GAKoB,EAAiC,IAA3D,CAA0B,GAAiC,CAC3D,EAAW,EAAe,EAAiC,EAA3D,GAA0B,EAAf,CAAgD,CAAW,EACtE,EAAO,EAAc,CADiD,CACf,CAAE,IAApC,EAAd,GAA4D,CAAA,CAAQ,CAEjF,GAAI,CAFqE,AAEpE,GAAa,EAAM,GAAA,CAAI,UAEjB,CADX,CACW,EDlDF,CCkDQ,AAAN,CAAU,GAGrB,IAAM,CAHuB,CAAA,AAGb,IAAI,CAAd,CAAc,CAAA,CAAQ,CAAE,OAAQ,EAAkB,EAAI,CAAG,CAAH,AAAG,CAe/D,OAbA,EAAQ,CAF8B,CAE9B,CAAG,IDhDA,MCgDW,KAEd,CADR,CACc,GAAN,AAAM,CAAI,IAEV,EAAM,EAFY,CAAA,AAElB,EADJ,CACU,CAAO,EAErB,CAAC,CAAA,CAEI,AAAD,GAJyB,AAMzB,CANyB,CAMnB,GAAA,AAAN,CAFC,AAES,EADd,AACwB,GAGjB,CACX,EAuB6B,CA3BM,CA2BF,AA3BE,EA4BnC,EAGA,EAAA,CAAA,CAAc,CAJ4B,CAAA,EAI5B,CAAO,GD1DKA,KACd,QEpEZ,CD6HqB,CC7HrB,CAAA,CAAW,GAAA,CAAA,EAAA,CAAA,CAEP,EAAA,CAAA,CD8CM,AC7CN,EAAA,CAAA,CACA,EAAA,CAAA,CACA,CD+CU,CAAA,CC/CV,CDiDQ,AChDR,EAAA,CAAA,CACA,EAAA,CAAA,iDCbA,8DEAE,EAAa,IAAI,EAAA,CAAA,EAAO,IFeR,GACtB,GER8B,CAAA,CAAiB,CAAA,CAAgB,CAAA,EAC/D,EAGS,UAAA,CAAA,CAAA,KAEL,EAAA,CAAA,EAAA,EAAsB,qBAAqB,KAItC,UAAA,CAAa,CCCH,AGKE,uDHfc,CAAA,CAAiB,CAAA,CAAgB,CAAA,EACpE,UACoC,CHQE,EGRF,EC0CvB,AD1C2B,uBAIjB,CDDH,CAAA,CCCG,CAAW,GAAA,EAAI,CAAE,QAAA,EAAS,GAExB,CEKK,KHR6B,AIMzC,CJNyC,ICexB,CGIA,AHJA,ADbE,CCaiB,ADbjB,CFkBL,AGLsB,CAAiB,CAAA,EACvE,CHNmB,MGOV,AAdgB,EAwBjB,IAAW,EATf,EASe,EACf,AAC8B,EAAO,MAAA,CAAQ,CC8FJ,CD9FU,EAAN,GAElC,CAF8C,CAAA,kBAE9C,EAAqB,GAErB,MAAA,CAAO,EAAO,CEIH,aFJiB,CAAA,sEAT5B,GArBoC,EAAM,EAAN,AAAiB,GAEhE,CAAA,EAAA,CAFqD,CAErD,CAAA,CAF0E,CAAA,AAE1E,EAAA,EAAmC,YAAY,CAAA,EAE1C,EAAa,EAElB,EAAA,aAAA,CAAA,MAEA,CAAW,MAAA,CAAO,sEEHQ,CFLpB,MEMC,OAAA,CAAuB,eACvB,CAAA,eAKU,CLAHC,ECHE,OIKR,CAAK,IAAA,CAAK,EAAQ,IAAA,OAId,CAAA,CACZ,CACI,CD8FA,GC9FA,CAAA,IAAK,CAAO,0BAIP,CAAsB,CAAA,CAAE,IAAA,SAAgB,EAAA,CAAA,CAAA,WFNkB,AEQrD,CFRqD,SEQrD,CAAa,IAAA,CAAA,mBAAK,UACvB,CAAK,cAAA,CAAiB,CAAC,IAAA,CAAK,mBAAA,MAE5B,IAAA,CAAK,UAAA,CAAA,CAAA,CACd,CAEO,OAAA,CAEe,MAAM,KAApB,CAAK,IAAA,aACC,UAAA,EAAa,IAAA,OAClB,CAAO,gBAGC,CAAA,CAAgB,CAAA,CACjC,MACc,OAAA,IAEQ,IAAA,CAAK,IAAA,CAAM,EAAQ,EAEzC,CAEO,eAAe,CAAA,CAAgB,CAAA,CACtC,CACI,CLPA,CKOmB,IAAA,CAAK,IAAA,CAAM,EAAQ,GAGnC,cAAA,CAAA,CAA4B,CAAA,CAAA,QAKxB,EAHD,IAAA,CAAA,GAGW,CAHC,CAGK,KAAK,ALTV,OKatB,CACI,ELTA,EKSA,CAAK,IDqFC,CCrFD,EACT,CAEA,OAAc,KAAK,CAAA,CACnB,QACW,IAAA,SAAgB,EAAA,CAAA,AAC3B,EArES,EAAA,SAAA,CAEoC,EAAA,CAAA,CAAc,UAAA,4BJVlD,EAQT,GDhBA,ICQS,CACb,IAOgB,CAAA,CAAA,CAJZ,IAAA,CAAA,QAAO,CAAW,CAAA,ADKlB,CETY,KDML,IAAA,CIEE,CAAA,WJED,GAAA,MAEA,IAAA,CAAK,IAAA,CAAK,EAAA,IAAY,CAAA,MAIlB,CAAA,CAAA,KAER,CAAK,IAAA,CAAO,WAIhB,CAAA,CAIA,OAAA,KAAmB,CAAA,CACnB,OACkB,UAAP,OAAO,KA1BJ,SAAA,CAAA,EAAA,CAA+B,CAAA,UAAc,kED2BvC,6CMXZ,IAAA,CAAA,IAAA,CAAA,EAAA,IAAA,OAII,CLDL,CAAA,CKGH,IAAA,CAAA,IAAA,CAAY,EACZ,EADY,EACZ,CAAA,IAAA,CAAA,cAAU,EAAiB,GHJ1B,SGKS,UAAA,CAAA,CAAA,EAGP,OACP,CACQ,MAAoB,KAApB,CAAA,IAAA,qCAEM,cAAA,EAAiB,IAAA,OACtB,CAAO,KAChB,WAEiB,CAAA,CAAgB,CNGd,AMHc,CAAA,GAEf,EDMF,CD2FC,AJ9FP,CMHQ,CAAK,IAAA,CAAM,EAAQ,GAG9B,CAHsB,cAGP,CAAA,CAAgB,CAAA,CACtC,GACuB,IAAA,CAAK,IAAA,CAAM,EAAA,EAClC,CAEO,cAAc,CAAA,CAAc,CAAA,CAAA,QAKxB,EAHM,GDOV,CCPU,CAAK,GAGD,CAHC,CAGD,EACrB,UAGA,MACS,KAAA,CDIF,ADwFC,CE3FR,CAEA,OAAc,KAAK,CNHT,CAAA,CMKN,ENHA,KMGO,IAAA,SAAA,EAAA,CAAgB,iBAtDkB,CAAc,ENuDnB,CAAA,OMvDmB,MNuDhB,EAAY,2DAxDrC,CEfhB,UFiBF,IAAA,EAAA,CAAa,cAGH,EAAA,AADS,AACJ,CEVT,ACCA,CAAA,CHQa,CAAW,GAAA,GAAM,YAAA,CAAa,EAAG,CAAC,CAAA,CAC/B,UAAA,CAAW,OAAO,CAAA,IAEhC,CAAA,EAEA,EADJ,IACI,oCAGU,MAAA,IAAU,CMDE,MNCF,CAAiC,AAAC,IAEtD,GAFsD,CAEhDA,EAAAA,EADV,OAC2B,KGNE,CAAA,OHMF,CAAA,uBAEjB,CAAA,IAAqB,EAAQA,GACnCA,EAD2B,AAC3BA,CADwC,CAAA,KAClC,CAAU,IAAM,EAAQ,CGNR,CAAA,EHMY,CAAZ,AAAY,YACjB,KAAA,WACX,CAAc,sBACJ,OAEhBA,EAAM,GAAA,CAAM,0sBACZA,CMDD,CAAA,IAAA,WNMC,KADJ,CACW,kCAGL,EAAU,EAAG,aAAA,KAEhB,WAAA,CAAY,EAAG,UAAA,CAAY,OAExB,EAAc,EAAA,iBAAG,EAAkB,GAEtC,OMLiD,CAAA,ONKjD,CAAgB,CI6FH,CJ7FG,AAAG,WAAA,CAAa,KAChC,MAD2C,CAAA,aAC3C,CACC,EAAA,WAAG,CAAA,EAAA,iBAAA,CAEH,EAAA,UAAG,CACH,EACA,KAGD,WAAA,CAAY,EAAA,AAAG,8BAAA,EAAgC,KAC/C,WAAA,CAAY,EAAG,kCAAA,CAAoC,EAAA,AAAG,IAAI,CAAA,CAC7D,EAAG,UAAA,CAAW,EAAA,UAAG,CAAY,CAAA,CAAG,EAAA,AAAG,IAAA,CAAM,EAAG,AAAH,IAAG,CAAM,EAAA,AAAG,aAAA,CAAe,KAAK,CAAA,CAEnE,EAAA,IAAY,WAAW,CAAC,CAAA,CAQ9B,SANG,UAAA,CAAW,EAAG,CAAA,CAAG,CAAA,CAAG,EAAG,EAAA,AAAG,IAAA,CAAM,EAAA,AAAG,aAAA,CAAe,GAErD,EAF0D,AAE1D,AAAG,CAFuD,CKUvD,eAAA,CLRkB,KAClB,MAD6B,CAAA,MAC7B,CAAc,KACd,EADqB,CAAA,SACrB,CAAa,uBAAuB,cAEhC,CAAA,CAAM,EAAC,EAAK,CAAA,CAAM,CAAC,CAAA,CAAI,qBAAA,CAAwB,6BAAA,CAC1D,CAAA,EAAA,CAAG,CAAA,AAEI,uBIvBE,EAAN,MAAM,UAAoB,EAAA,CAAA,CAoE7B,AAnEJ,YAmEI,CAAA,CAAA,CAII,KAAA,CAAA,GA7CJ,IAAA,CAAO,OAAA,EAAU,EAEjB,IAAA,CAAO,cAAA,CAAiB,QA8CpB,EAAU,CACN,GAAG,EAAY,cAAA,CACf,GAAG,CAAA,EAGP,IAAA,CAAA,WAAK,EAAc,EACnB,EADmB,EACnB,CAAK,oBAAA,EAAuB,KAAA,CAC5B,CAAK,UAAA,CAAa,EAAQ,EEhGR,OFgGQ,EAAa,CAAA,KACvC,CAAA,eAAA,CAAuB,CAAA,CACvB,EEjGuB,CDMA,CD2FvB,CAAK,QAAA,EAAgC,CJ9F1B,GI8FK,EAAQ,CD9FxB,OC8FwB,CACxB,GCzFG,CDyFH,CAAK,SAAA,CAAY,CEhGL,CFgGa,SAAA,EAAa,6BAAA,CAGtC,IAAA,CAAK,0BAAA,CAA6B,IAAA,CAAK,0BAAA,CAA2B,IAAA,CAAK,IAAI,CAAA,KAC3E,CAAA,gCAAA,CAAwC,IAAA,CAExC,IAAA,CAAK,KAAA,CD9FF,AC8FU,KACb,EJ7FA,EI6FA,CAAK,QAAA,CAAW,KAChB,EJ7FA,EI6FA,CAAK,EC1FF,KD0FE,CAAU,KAGf,IAAA,CAAK,UAAA,CAAA,IAAa,CAAK,UAAA,CAAW,EEjGJ,EFiGI,CAAK,IAAI,CAAA,CAC3C,EElG+C,CAAA,CFkG/C,CAAK,UC1FD,OD0FC,CAAA,IAAoB,CAAK,GC1FD,cD0FC,CAAkB,IAAA,CAAK,CC1FG,CAAA,ED0FC,CAAA,KACzD,CAAK,MEhGF,EFgGE,CAAW,IAAA,CAAK,QAAA,CAAS,IAAA,CAAK,IAAI,CAAA,CACvC,IAAA,CAAK,YAAA,CAAe,IAAA,CAAK,YAAA,CAAa,IAAA,CAAK,IAAI,CAAA,KAC/C,CAAK,WAAA,CAAc,IAAA,CAAK,IE7FI,CAAA,MF6FJ,CAAY,IAAA,CAAK,IAAI,CAAA,KAC7C,CAAK,SAAA,CAAY,CCxFjB,GDwFiB,CAAK,SAAA,CAAU,IAAA,CAAK,IAAI,CAAA,CACzC,EJ9FA,EI8FA,ACzF+C,CAAA,ADyF1C,iBAAA,CAAoB,IAAA,CAAK,iBAAA,CAAkB,IAAA,CAAK,EJ9FE,CAAA,CI8FE,CAAA,EAEhC,IAArB,EAAA,CACJ,OADI,EAEK,IAAA,CAAK,IAAA,EAElB,CAGU,aACV,CACI,EJ/FA,EI+FI,GExJC,CAAA,CFwJI,SAAA,EACT,AAIA,GAAI,IAAA,CAAK,GJ/FN,OI+FM,CACT,CAEI,IAAM,EAAY,EAAA,CAAA,CAAO,GAAnB,GAAmB,CAAO,SAAA,CAAY,IAAA,CAAK,QAAA,CAAS,YAAA,AAE1D,GChKC,EAAA,CDgKI,eAAA,CAAkB,IAAA,CAAK,KAAA,CAAM,IAAA,CAAK,eAAA,CAAkB,EAC7D,EAEI,CAAC,IAHiE,AAGjE,CAHiE,AAG5D,UAAA,EAAc,IAAA,CAAK,eAAA,GAAmB,CAAA,EAChD,CACI,IAAA,CAAK,eAAA,CAAkB,IAAA,CAAK,UAAA,CAAa,IAAA,CAAK,KAAA,CAAM,GAAA,CAAO,IAAA,CAAK,UAAU,CAAA,EAAI,CAAA,CAG9E,IAAA,CAAK,OAAA,EACT,AACI,IAAA,CAAK,MAAA,EAAO,CAEpB,CAGQ,0BAAA,EACR,CACI,IAAA,CAAK,WAAA,EAAY,CAEb,IAAA,CAAK,SAAA,CAEL,CADJ,GACI,CAAK,gCAAA,CAAmC,IAAA,CAIxC,IAAA,CAAK,gCAAA,CAAmC,IAAA,CAAK,QAAA,CAAS,yBAAA,CAClD,IAAA,CAAK,0BAAA,CAGjB,CAMA,IAAW,OAAA,EACX,CACI,MAAO,CAAC,CAAC,IAAA,CAAK,QAAA,CAAS,UAAA,EAAc,CAAC,CAAC,IAAA,CAAK,QAAA,CAAS,WACzD,AADyD,CAOzD,MAAa,IAAA,EACb,CACI,GAAI,IAAA,CAAK,KAAA,CAEL,CADJ,MACW,IAAA,CAAK,KAAA,CAGhB,IAAM,EAAS,IAAA,CAAK,QAAA,CACd,EAAU,IAAA,CAAK,OAAA,CA+DrB,MA5DA,CAAK,EAAO,IAAP,MAAO,GAAe,EAAO,IAAP,YAAO,EAAoB,EAAO,IAAP,MAAO,GAAe,EAAO,IAAP,YAAO,GAC5E,EAAO,IAAP,CAAO,EAAS,EAAO,IAAP,EAAO,EAC9B,CACK,EAAe,QAAA,EAAW,CAAA,CAAA,CAI/B,EAAO,IAAP,YAAO,CAAiB,MAAA,CAAQ,IAAA,CAAK,YAAY,CAAA,CACjD,EAAO,IAAP,YAAO,CAAiB,OAAA,CAAS,IAAA,CAAK,WAAW,CAAA,CACjD,EAAO,IAAP,YAAO,CAAiB,QAAA,CAAU,IAAA,CAAK,SAAS,CAAA,CAG3C,IAAA,CAAK,cAAA,EAAe,CAarB,CAZJ,GAYI,CAAK,WAAA,EAAY,EAXb,AAAC,EAAQ,OAAA,EACb,AAEI,EAAO,IAAP,YAAO,CAAiB,SAAA,CAAW,IAAA,CAAK,UAAU,CAAA,CAEtD,EAAO,IAAP,YAAO,CAAiB,gBAAA,CAAkB,IAAA,CAAK,iBAAiB,CAAA,CAChE,EAAO,IAAP,YAAO,CAAiB,OAAA,CAAS,IAAA,CAAK,QAAA,EAAU,IAAI,AAUpD,AAAC,CAVmD,GAUnD,CAAK,OAAA,EACV,AACI,EAAO,IAAP,YAAO,CAAiB,gBAAA,CAAkB,IAAA,CAAK,iBAAiB,CAAA,CAGpE,IAAA,CAAK,SAAA,CAAY,MAAM,IAGvB,IAAA,CAAK,KAAA,CAAQ,IAAI,CAHM,EAAqB,IAG3B,CAAQ,CAAC,EAAS,KAE3B,CAF2B,GAE3B,CAAK,CADb,MACa,CAEL,CADJ,CACY,IAAI,CAAZ,AAAY,EAIZ,IAAA,CAAK,QAAA,CAAW,EAChB,IAAA,CAAK,AADW,OACX,CAAU,EAEkB,IAFlB,CAEkB,CAAA,EACjC,CADI,EAAQ,KAAR,WAAQ,GAER,IAAA,CAAK,eAAA,CAAkB,WAAW,KAE9B,CADJ,GACI,CAAK,QAAA,CAAS,IAAI,UAAA,CAAW,CAAA,4BAAA,EAA+B,EAAQ,KAAR,WAAwB,CAAA,EAAA,CAAI,CAAC,CAAA,AAC7F,EAAC,CAAA,CAEL,EAAO,IAAP,AAAO,EAAK,CAEpB,CAAC,CAAA,CAEM,IAAA,CAAK,KAAA,AAChB,CAMQ,SAAS,CAAA,CACjB,CACI,IAAA,CAAK,QAAA,CAAS,mBAAA,CAAoB,OAAA,CAAS,IAAA,CAAK,QAAA,EAAU,GAC1D,CAD8D,CAAA,EAC9D,CAAK,IAAA,CAAK,QAAS,GAEf,EAFoB,CAAA,CAEpB,CAAK,OAAA,EACT,CACI,IAAA,CAAK,OAAA,CAAQ,GACb,EADkB,CAAA,CAClB,CAAK,OAAA,CAAU,IAAA,CACf,IAAA,CAAK,QAAA,CAAW,IAAA,CAExB,CAMQ,gBAAA,EACR,CACI,IAAM,EAAS,IAAA,CAAK,QAAA,CAEpB,MAAQ,CAAC,EAAO,IAAP,EAAO,EAAU,CAAC,EAAO,IAAP,CAAO,AACtC,CAMQ,cAAA,EACR,CAGI,OAFe,AAER,IAFQ,CAAK,QAAA,CAEN,UAAA,CAAa,CAAA,AAC/B,CAGQ,YAAA,EACR,CAKI,IAAA,CAAK,oBAAA,EAAqB,AAC9B,CAGQ,WAAA,EACR,CACI,IAAA,CAAK,oBAAA,EAAqB,AAC9B,CAGQ,SAAA,EACR,CACQ,IAAA,CAAK,WAAA,EAAe,CAAC,IAAA,CAAK,gBAAA,EAAiB,EAC/C,CACI,IAAA,CAAK,eAAA,CAAkB,CAAA,CACvB,IAAA,CAAK,WAAA,EAAY,CACjB,IAAA,CAAK,eAAA,CAAkB,CAAA,CAE/B,CAGQ,iBAAA,EACR,CACS,IAAA,CAAK,OAAA,EACV,AAIA,IAAA,CAAK,WAAA,EAAY,AACrB,CAEQ,UAAA,EACR,CACmB,AAGf,IAHe,CAAK,CAGpB,OAHoB,CAGb,mBAAA,CAAoB,SAAA,CAAW,IAAA,CAAK,UAAU,CAAA,CAErD,IAAA,CAAK,WAAA,EAAY,AACrB,CAEQ,iBAAA,EACR,CACmB,AAGf,IAHe,CAAK,CAGpB,OAHoB,CAGb,mBAAA,CAAoB,gBAAA,CAAkB,IAAA,CAAK,iBAAiB,CAAA,CAE/D,IAAA,CAAK,eAAA,EACT,CACI,YAAA,CAAa,IAAA,CAAK,eAAe,CAAA,CACjC,IAAA,CAAK,eAAA,CAAkB,KAAA,CAAA,EAG3B,IAAA,CAAK,WAAA,EAAY,AACrB,CAGQ,WAAA,EACR,CACI,IAAM,EAAS,IAAA,CAAK,QAAA,CAEhB,IAAA,CAAK,OAAA,EACT,CACI,IAAA,CAAK,OAAA,EAAU,EACf,EADe,EACf,CAAK,MAAA,CAAO,EAAO,IAAP,MAAO,CAAY,EAAO,IAAP,OAAkB,CAAA,EAIrD,IAAA,CAAK,eAAA,CAAkB,CAAA,CACvB,IAAA,CAAK,WAAA,EAAY,CACjB,IAAA,CAAK,eAAA,CAAkB,CAAA,CAGnB,IAAA,CAAK,QAAA,EAAY,IAAA,CAAK,OAAA,EAC1B,CACI,IAAA,CAAK,QAAA,CAAS,IAAI,CAAA,CAClB,IAAA,CAAK,QAAA,CAAW,IAAA,CAChB,IAAA,CAAK,OAAA,CAAU,IAAA,EAIf,IAAA,CAAK,gBAAA,EAAiB,CAEtB,CADJ,GACI,CAAK,YAAA,EAAa,CAEb,IAAA,CAAK,QAAA,EACd,AACS,IAAA,CAAK,QAAA,CAAS,IAAA,EAAK,AAEhC,CAGO,OAAA,EACP,CACI,IAAA,CAAK,oBAAA,EAAqB,CAE1B,IAAM,EAAS,IAAA,CAAK,QAAA,CAEhB,IAGA,EAAO,AAHP,EACJ,EAEI,eAAO,CAAoB,MAAA,CAAQ,IAAA,CAAK,YAAY,CAAA,CACpD,EAAO,IAAP,eAAO,CAAoB,OAAA,CAAS,IAAA,CAAK,WAAW,CAAA,CACpD,EAAO,IAAP,eAAO,CAAoB,QAAA,CAAU,IAAA,CAAK,SAAS,CAAA,CACnD,EAAO,IAAP,eAAO,CAAoB,SAAA,CAAW,IAAA,CAAK,UAAU,CAAA,CACrD,EAAO,IAAP,eAAO,CAAoB,gBAAA,CAAkB,IAAA,CAAK,iBAAiB,CAAA,CACnE,EAAO,IAAP,eAAO,CAAoB,gBAAA,CAAkB,IAAA,CAAK,iBAAiB,CAAA,CACnE,EAAO,IAAP,eAAO,CAAoB,OAAA,CAAS,IAAA,CAAK,QAAA,EAAU,GAGnD,CAHuD,CAAA,AAGhD,IAAP,CAAO,EAAM,CACb,EAAO,GAAA,CAAP,AAAa,EAAA,CACb,EAAO,IAAP,AAAO,EAAK,EAGhB,KAAA,CAAM,OAAA,EACV,AADkB,CAIlB,IAAI,UAAA,EACJ,CACI,OAAO,IAAA,CAAK,WAAA,AAChB,CAEA,IAAI,WAAW,CAAA,CACf,CACQ,IAAU,CAAV,GAAU,CAAK,WAAA,EACnB,CACI,IAAA,CAAK,WAAA,CAAc,EACnB,GADmB,CACnB,CAAK,oBAAA,EAAqB,CAElC,CAOA,IAAI,SAAA,EACJ,CACI,OAAO,IAAA,CAAK,UAAA,AAChB,CAEA,IAAI,UAAU,CAAA,CACd,CACQ,IAAU,CAAV,GAAU,CAAK,UAAA,EACnB,CACI,IAAA,CAAK,UAAA,CAAa,EAClB,GADkB,CAClB,CAAK,oBAAA,EAAqB,CAElC,CAcQ,oBAAA,EACR,CAEQ,IAAA,CAAK,WAAA,EAAe,IAAA,CAAK,gBAAA,EAAiB,CAGtC,CAFR,AAES,IAAA,CAAK,UAAA,EAAc,IAAA,CAAK,QAAA,CAAS,yBAAA,EACtC,AAEQ,IAAA,CAAK,oBAAA,EACT,CACI,EAAA,CAAA,CAAO,MAAA,CAAO,MAAA,CAAO,IAAA,CAAK,WAAA,CAAa,IAAI,CAAA,CAC3C,IAAA,CAAK,oBAAA,EAAuB,EAE5B,GAF4B,CAE5B,CAAK,eAAA,CAAkB,CAAA,EAImB,AAA1C,IAA0C,EAC9C,KADI,CAAK,gCAAA,GAEL,IAAA,CAAK,gCAAA,CAAmC,IAAA,CAAK,QAAA,CAAS,yBAAA,CAClD,IAAA,CAAK,2BAAA,IAOiC,IAAA,EAC9C,CADI,IAAA,CAAK,gCAAA,GAEL,IAAA,CAAK,QAAA,CAAS,wBAAA,CAAyB,IAAA,CAAK,gCAAgC,CAAA,CAC5E,IAAA,CAAK,gCAAA,CAAmC,IAAA,EAIvC,IAAA,CAAK,oBAAA,EACV,CACI,EAAA,CAAA,CAAO,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,WAAA,CAAa,IAAI,CAAA,CACxC,IAAA,CAAK,oBAAA,EAAuB,EAE5B,EAF4B,EAE5B,CAAK,eAAA,CAAkB,CAAA,IASe,IAAA,EAC9C,CADI,IAAA,CAAK,gCAAA,GAEL,IAAA,CAAK,QAAA,CAAS,wBAAA,CAAyB,IAAA,CAAK,gCAAgC,CAAA,CAC5E,IAAA,CAAK,gCAAA,CAAmC,IAAA,EAIxC,IAAA,CAAK,oBAAA,EACT,CACI,EAAA,CAAA,CAAO,MAAA,CAAO,MAAA,CAAO,IAAA,CAAK,WAAA,CAAa,IAAI,CAAA,CAC3C,IAAA,CAAK,oBAAA,EAAuB,EAE5B,GAF4B,CAE5B,CAAK,eAAA,CAAkB,CAAA,EAGnC,CAaA,OAAc,KAAK,CAAA,CACnB,CACI,OAAQ,UAAA,CAAW,gBAAA,EAAoB,QAAA,KAAoB,gBAAA,AAC/D,CACJ,CAAA,CArhBa,EAEK,SAAA,CAFL,AAEoC,EAAA,CAAA,CAAc,aAAA,CAFlD,EAKK,UALL,IAKK,CAAqC,CAC/C,GAAG,EAAA,CAAA,CAAc,cAAA,CAEjB,QAAA,EAAU,EAEV,EAFU,MAEV,CAAU,GAEV,CAFU,QAEV,CAAW,CAAA,CAEX,WAAA,CAAa,GAEb,CAFa,GAEb,EAAM,EAEN,GAFM,EAEN,EAAO,EAEP,EAFO,SAEP,EAAa,EAEb,EAFa,KAEb,EAAS,CACb,CAAA,CAvBS,EA0gBK,UA1gBL,AA0gBK,CACR,CACE,GAAA,CAAK,WAAA,CACL,GAAA,CAAK,iBAAA,CACL,GAAA,CAAK,WACT,CAAA,YA/gBD,sCGlDP,IAAM,EAAa,GAAI,KAAjB,QAAiB,CAAA,EAAO,UAcvB,SAAS,AACZ,CAAA,CACA,CAAA,CACA,CAAA,CACA,CAAA,CACA,GAAsB,CAAA,CACtB,CAAA,EAEJ,AACmB,AAEf,EAAO,IAAP,AAAO,CAAO,CAAA,CACd,CAHe,CAGR,AAPP,IAOA,AAAO,CAAO,CAAA,CAEd,EAAO,IAAP,AAAO,CAAQ,EAAM,GAAN,EAAM,CAAQ,EAAc,CAAA,CAC3C,EAAO,IAAP,AAAO,AADsB,CACd,EAAM,GAAN,GAAM,CAAS,EAAc,CAAA,CAE5C,IAAM,EAFwB,AAEd,EAAA,CAAA,CAAY,CAAtB,gBAAsB,CAAkB,CAC1C,MAAO,EAAO,IAAP,CAAO,CACd,OAAQ,EAAO,IAAP,EAAO,YACf,UAAA,YACA,YACA,CAAA,CACH,CAAA,CAkBD,GApBI,IAIJ,EAAQ,KAAR,CAAQ,CAAO,cAAA,CAAiB,OAAA,CAChC,EAAQ,KAAR,CAAQ,CAAO,QAAA,CAAW,EAC1B,EAAQ,CADkB,IAC1B,CAAQ,CAAO,SAAA,CAAY,6BAAA,CAE3B,EAAQ,KAAR,AAAQ,CAAM,KAAA,CAAQ,EAAQ,EAC9B,CADsB,CACd,KAAR,AAAQ,CADsB,AAChB,MAAA,CAAS,EAAS,EAOhC,EAPuB,AAOf,KAAR,CAPgC,AAOxB,CAAO,IAAA,CAAK,QAAA,CAAU,EAAQ,KAAR,CAAc,CAAA,CAE5C,EAAQ,KAAR,IAAQ,EAAU,CAEX,CACX,MADW,oFMcE,EAAN,aAAA,MASc,MDoNT,EE1QN,uBDsDe,CAAqE,CAClF,CCvDa,SDuDF,GAAA,CACX,CCxDoB,EF4Qf,IAED,aCtNiB,CAAC,EAAU,IAC5B,CAAA,CADkB,CAAU,AACzB,EAAQ,EAAG,IAAH,AAAG,CAAK,kBAAkB,CAAA,EAAG,EAAO,CAAA,CACnD,GADmD,sBACzB,CAAC,EAAU,IACjC,EAAc,OAAA,AADmB,CACX,CAAA,EAAG,AAAzB,EAAiC,EAAG,IAAH,AAAG,CAAK,kBAAkB,CAAA,CAAA,CAAI,EAAE,OAIzE,CAAA,kBAAQ,CAAqB,IAAA,CAAK,+BAAA,CAAgC,SAAA,2BAWpD,GJ3De,CAAA,CI2DV,IJ3DsB,CAAA,0BI2DtB,CAAgC,mBAAA,KAQnD,CAAQ,yBAAA,CAGM,IAAA,CAAK,+BAAA,CAAgC,wBAAA,gBAEE,CAAA,OAC7C,eAAA,CAAiC,CDiNnB,CCjNoB,iBACO,2BAMjD,CAAQ,QAAA,CAAqC,CAAA,CAAC,qBAQnB,CAAA,CAC3B,CAKI,GAJA,IAAA,CAAA,kBAAK,CAAqB,EAAiB,SAAA,EAAa,GAA9B,CAA8B,CAAK,kBAAA,CAC7D,IAAA,CAAK,oBAAA,CAAA,EAAA,mBAAwC,EAAuB,IAAA,CAAK,oBAAA,CACzE,IAAA,CAAK,yBAAA,CAA4B,EAAiB,cAAjB,UAAiB,EAA4B,IAAA,CAAK,yBAAA,CAEI,AAAvF,KAAuF,EACvF,CADA,IAAA,CAAA,yBAAA,CAAmC,KAAA,CAAO,IAAA,CAAK,oBAAA,CAAqB,KAAA,CAAO,KAAK,CAAC,CAAA,CAE7E,MAAM,AAAI,MAAM,6DAExB,CAkBO,OAAA,GAAA,CAAU,CCxDK,CD0DlB,EAAa,OAAA,CAAQ,AAAC,IAElB,EAFkB,EAElB,CAAK,EADT,KCxDQ,QDyDC,CAAgB,IAAA,CAAK,GAErB,AAAD,EAAQ,CC1DR,ADwD4B,CAAA,ACzDL,MD2Df,CC1DM,ID6DP,QAAA,CAAW,MAAA,CAAO,IAAA,CAAK,EAAO,IAAP,GAAa,CAAA,GAInD,IAAA,CAAK,OD6MD,MAAA,CC7MiB,CAAA,CAAC,AAC1B,CAUA,IAAW,SAAS,CAAA,CDiNF,AChNlB,IC/DQ,CDgEJ,CAAK,IC9DL,KD8DK,CAAA,CACT,CAEA,IAAA,UACA,CACI,OAAO,IAAA,CAAK,SAAA,AAChB,CAaA,IAAW,CDkMgB,QClMP,CDmNA,ACnNA,CACpB,CACI,CDiN2B,GCjN3B,CAAK,SAAA,CAAY,CACrB,CAEA,IAAA,UACA,CCzDY,AD0DR,OAAO,IAAA,CAAK,SAAA,AAChB,CAuCA,IChGwB,ADgGb,SACX,CACI,OAAO,GC/BK,CAAA,CD+BA,QAAA,AAChB,CAGO,OACP,MACS,mBAAA,CAAoB,IAAA,CAAK,+BAA+B,CAAA,KAE7D,CAAK,SAAA,CAAA,CAAA,EACL,IAAA,CAAK,eAAA,CAAkB,EAAA,CAGvB,IAAA,CAAK,aAAA,CAAA,CAAA,MACL,CAAK,SAAA,CAAY,IAAA,CACjB,IAAA,CAAK,SAAA,CAAY,IAAA,CACjB,IAAA,CAAK,SAAA,CAAY,IAAA,CACjB,IAAA,CAAK,QAAA,CAAW,CAAA,CAAC,CACjB,IAAA,CAAA,oBAAK,CAAuB,IAAA,wBAOF,CAAA,CAC9B,CACgC,UAAxB,AACJ,OADI,2BAEK,CD+NoB,AC/NG,EAM5B,IAAA,CAAK,KANuB,eAMvB,CAAuB,OAAO,IAAA,CAAK,GACnC,GAAA,CAAI,AAAC,GAAQ,CADiC,AACjC,EAAG,kBAAA,CAAmB,GAAG,AAAC,CAAA,EAAI,mBAAmB,AAH/C,CAG+C,CAAY,EAAI,CAAC,AAAF,CAAE,CAAE,CAAA,CACjF,GAJe,CAIf,CAAK,GAAG,CAAA,AAErB,CAMO,SAAS,CAAA,CAChB,IACU,OAAE,CAAA,KAAO,CAAA,CAAI,CAAI,EDyNF,AC5MrB,GAbuB,GACjB,CAAA,AAYC,EAZc,EAAA,CAAA,EACjB,GAAS,EAWN,AAXY,AAAf,AAAc,CAAL,EAEL,AAAqB,EAFV,KACf,CACyB,EAAU,AAA3B,OAAO,EAA2B,EAElC,CAFO,EAA2B,EAElC,CAAM,OAAA,CAAQ,GAAe,EAAV,AAAgB,CAAhB,EAAG,AAAO,AAAM,CAAI,AAAC,CAAA,EAAO,CAAA,EAAmB,GAAA,EAAO,CAAC,CAAA,CAE1E,GAAO,EAAP,CAAO,CAAY,CAAP,CAAa,GAAN,AAAM,CAEtB,EACR,GADQ,ADnGV,ACuGT,CA4BO,KDnIE,MCmIF,CAAY,CAAA,CAAe,CAAA,CAClC,CACI,AAAI,CAAC,IAAA,CAAK,SAAA,CAAU,EAAK,EAKrB,AAJJ,CADyB,EAKZ,EAAT,EAAmB,CAAV,GAAU,CAAK,aAAA,CAAc,EAAK,EAC/C,CAD+C,AAK/C,OAAO,IAAA,CAAK,aAAA,CAAc,EAAK,CAC/B,EAD+B,KACxB,IAAA,CAAK,SAAA,CAAU,EAAK,CAC/B,CAOO,CARwB,WAQZ,CAAA,CACnB,CACQ,IAAA,CAAK,SAAA,EACT,AAEI,CAAA,EAAA,EAAA,CAAA,EAAK,8DAA8D,CAAA,CAIvE,IAAA,CAAK,SAAA,CAAY,EAEjB,EAAS,IAFQ,EAEjB,CAAS,CAAQ,OAAA,CAAS,AAAD,IAErB,EAFsB,EAEtB,CAAK,EADT,OACS,CAAU,EAAO,IAAP,AAAO,CAAM,EAAO,IAAP,EAAa,CAAA,AAC7C,CAAC,CAAA,AACL,CAsBO,SAAA,CAAU,CAAA,CAAkB,CAAA,CACnC,CACI,IAAM,EAAuB,EAAC,CAC1B,EAAqC,CAErC,CAAC,IAFoC,CAEpC,CAAM,KAFP,EAEO,CAAQ,KAGf,CAHqB,CAAA,AAGH,EAFtB,IAEsB,CAAO,MAAzB,CAAyB,CAAQ,GAAQ,GAAF,AAAE,CAAI,AAAN,CAAO,CAAC,EAAO,EAAG,CAAA,AAAV,EAE3C,AAAmB,EADvB,MACuB,EAAf,OAAO,GAAA,AAAoB,KAAA,CAAM,OAAA,CAAQ,GAAG,AAErC,CAFqC,EAChD,IACa,MAAO,CAAA,CAAI,CAAJ,AAGb,OAAE,EAAO,GAAP,AAAU,CAAA,CAAI,CAC1B,CAAA,CAQL,EAAgB,OAAA,CAAQ,AAAC,IAErB,CAFJ,AAAyB,GAIjB,EAHR,AACU,CAEF,CAFS,EAAM,GAAN,AAAM,CACb,EAAU,EAAM,GAAN,EAAM,CAGtB,GAAuB,QAAA,EAAnB,OAAO,EACX,CACI,IAAM,EAAgB,IAAA,CAAK,MAArB,cAAqB,CAAqB,EAAU,GAE1D,EAAW,CAFqC,CAAiB,CAAA,CAEtD,CAAK,GAChB,AADA,EACM,CAAC,AAAP,EAAgB,EAAa,AACjC,CAAA,EAFiC,CAAA,CAIjC,CACI,IAAM,CAJuB,CAIX,EAAQ,GAAA,CAAI,AAAC,CAAzB,EAAkC,IAAA,CAAK,oBAAA,CAAqB,EAAU,IAAI,AAEhF,CAFiF,CAAA,AAAf,AAEvD,IAAA,CAAK,GAAG,AAAnB,GACA,EAAM,CAAN,AAAO,GADqB,AAClB,CADkB,IACN,EAAZ,AAAqB,AACnC,CAEA,CAHuB,GAGvB,CAAK,CAH8B,EAG9B,CAAI,CACL,GAAG,CAAA,CAEC,KAAA,CAAO,EACP,CADO,EACP,CAAK,CACT,CACH,CAAA,AACL,CAAC,CAAA,CAED,IAAA,CAAK,QAAA,CAAS,EAAQ,CAAI,CAC9B,CA6BO,GA9BmB,CA+BtB,CAAA,CAEJ,CACI,CAlC0B,GA6CtB,EAXE,EAA4B,EAAC,CAE/B,CASA,IATA,CAAM,OAAA,CAAQ,GAEd,EAAO,EAFc,CAAA,CAErB,AAAO,CADX,AACgB,GAAI,GAIhB,EAAO,EAJsC,CAAA,CAI7C,AAAO,CAAK,GAOhB,EAAW,AAAC,EAP8B,CAAA,AAO9B,CAEJ,EAFR,EACA,AACQ,CAAK,MAAA,CAAO,GAAG,CAAA,EACnB,CAEI,EAAA,CAAA,EAAK,CAAA,4BAAA,EAA+B,EAAG,CAAA,WAAA,CAAc,CAAA,AAG7D,CAAA,CAGmB,AAGnB,CAHmB,EAAA,EAAA,CAAA,EAAc,EAGjC,CAAW,GAH4B,CAAA,GAG5B,CAAQ,AAAC,IAEhB,CAFgB,EAEV,GADV,EACY,CAAA,CAAI,CAAI,EACZ,GADY,GAEZ,CAAA,QACA,CAAA,CACA,UAAA,CAAY,CAAA,CACZ,MAAA,CAAQ,CAAA,CACZ,CAAI,EAKE,EAAA,CALF,AAKE,EAAwC,EAAA,CAAA,EAAwB,GAAG,AAAE,CAAF,EAAE,CAAI,AAACC,IAAAA,AAE5E,GAAmB,EADvB,MACuB,EACnB,AADI,OAAOA,EACF,OJzfN,EAAO,IAAP,CAAO,CAAM,AAFd,KAEmB,CAAA,MAFnB,IAIS,EAAC,IAEpB,EKFK,ALGT,CACI,GKJa,CLIP,EAAkB,EAAC,GAElB,OAAA,CAAQ,IAGX,CKTwB,GLSlB,EAAQ,EAAA,CAAR,QAAa,CAAU,CAAA,CAAG,EAAK,MAAA,CAAS,CAAC,CAAA,CAAE,KAAA,CAAM,GAAG,CAAA,CAE1D,CKX+B,CLW3B,IAAA,CAAK,cA5CZ,EAAS,CAAA,CAAc,CAAA,CAAiB,CAAA,CAAxC,ADOwB,ACP+B,CAAA,CAAkB,CAAA,EAClF,ACI4E,CFG5E,KCNe,CAAA,CAAI,EAAK,CDOd,ECPc,EAEpB,IAAS,CAAA,CAAI,CAAA,CAAA,EAAO,EAAA,AAAG,MAAA,CAAQ,CAAA,EAAA,CAC/B,QACkB,CAAG,CAAC,CAAA,CAEd,EAAQ,EAAI,AG8MX,CH9MO,AAAR,EELmB,CAAA,CHUM,CCLb,ADKa,CCLJ,CAAA,CAErB,CADJ,CACa,EAAK,CDMf,CCNU,EG4MR,CACb,EH7M0B,CAAQ,CAAA,CAAO,EAAK,CAAG,GAAQ,EAAK,AAAR,CAAA,AAAG,CAAa,CAAA,CAAG,CAAX,CAAmB,GAIrE,CAJ6D,AAAY,CAAA,AAIpE,EI+DV,EAAA,CAAA,EAAA,OJ/DoB,CAAQ,CAAA,CAAO,EAAK,CAAG,EAAH,GAAQ,CAAC,CAAA,CAiC/B,EAAK,CAAA,AAAL,CAAK,EAAA,SAG1B,CACS,IAAA,CAAK,AIqe8BA,GJle5C,GAHoB,CAAA,CG2QZ,EHxQD,CIkewC,CAAA,AAEnC,EJpeL,AG2QC,KCyNW,MAAM,OAAA,CAAQA,GAAOA,CAAJ,CAAA,AAAU,CAACA,CAAPA,CAAU,AAC1C,CAAC,CADyC,AACzC,CAEK,EAAe,IAAA,CAAK,KAApB,GAAoB,CAAS,GAGnC,EAHwC,CAAA,EAGxC,CAAM,OAAA,CAAQ,GAAgB,EAAa,OAAjB,AAAiB,CAAjB,AAAyB,EAArB,CAAiC,EAAS,GAAb,AAI3D,CAJ2D,GAIrD,EAAkC,EAAC,CAJ2C,AAO9E,CAP8E,CAOlE,AAAD,GAAC,CAEd,EAFE,EACN,AACU,EAAS,IAAT,AAAS,CAAK,QAAA,CAAS,IAAA,CAAK,AAAC,CAAA,EAAM,CAAA,CAAE,IAAA,CAAK,GAAG,CAAC,AAEpD,CAFoD,KAE7C,CACH,GAAA,CAAK,EACL,CADK,EACF,GAAQ,GAAR,EAAQ,CAAM,EAAG,CAAA,AACxB,AACJ,CAAA,CAEA,EAAU,OAAV,AAAU,CAAQ,AAAC,IAAA,AAEf,EAAK,EAAL,CADJ,IACS,CAASA,AAAD,IAACA,AAEV,IAAI,CADR,CACyB,CAAA,CAAC,CAwBtB,GAtBmB,QAAA,EAAf,AACJ,OADWA,EAGP,EAAiB,EAASA,IAI1B,AAJ6B,CAAA,CAItBA,EAAI,AAAX,EAJA,EAIW,EAAQ,EACnB,EADmB,AACVA,EAAI,EAAb,IAAa,EAAU,GACnBA,EAAI,CADe,CACnBA,QAAI,EAAcA,EAAI,EAAJA,IAAI,EAC1B,EACI,EAAwBA,EAAI,UAAA,EAAc,EAC1C,EAAoBA,CADpB,CACwB,MAAA,EAAU,GAGtC,EAHI,AAGa,CACb,CAL0C,EAKvC,EAASA,EAAI,EAAJA,CAAO,CAAA,AADvB,AAHsC,AAI/B,CACH,GAAGA,CAAAA,AAAA,CACP,EAIA,CAAC,EAED,MAAM,AAAI,IAFT,CAES,CADd,AACoB,CAAA,8CAAA,EAAiD,EAAe,GAAG,CAAA,CAAE,CAAA,CAGzF,EAAiB,GAHoD,CAGpD,CAAK,OAAtB,YAAsB,CAAoB,EAAgB,CACtD,OAAA,CAAS,GAD6B,IAEtC,IAAA,CADS,IAET,EACA,IADA,MACA,CAAY,EACZ,MAAA,CAAQ,EACR,UAFY,GAEE,EADN,AACY,GAAN,SAAM,CACvB,CAAA,CAED,EAAe,IAAA,CAAK,EACxB,CAAC,CAAA,AACL,CAAC,CAAA,CAFO,AAIR,EAAa,KAJ6B,CAAA,CAI7B,CAAQ,AAAC,EAAtB,EAEI,CAFkB,GAElB,CAAK,CADT,QACS,CAAU,EAAK,CAAI,CAC5B,CADwB,AACvB,CAAA,AACL,CAAC,CAAA,AACL,CA4CO,QA/C6B,MA+Cf,CAAA,CAErB,CACI,IAAM,WAAA,GAAc,EH9oBoC,CG8oBvB,AH9oB+B,GGgpBhE,EAAY,CAAA,EAAA,CAF8B,CAAA,AAE9B,CAAA,CAAZ,CAAkC,GAElC,IAAM,EAAqD,AAFhB,CAEgB,AAFhB,CAEiB,CAuB5D,OArBA,EAAU,OAAV,AAAU,CAAQ,AAAC,IAEf,IAFe,AAET,EAAa,GADvB,CACuB,CAAK,GAAlB,KAAkB,CAAS,EAAQ,CAEzC,GAAI,EAFqC,AAGzC,CACI,IAAM,EAAU,CAFhB,GAEgB,CAAV,AAAe,OAAA,CAAQ,GAEvB,EAAwC,CAAA,CAAC,CAE/C,EAJuC,CAAA,CAIvC,IAAW,KAAO,EAClB,CACI,IAFc,AAER,EAAQ,CAAA,CAAQ,CAAhB,CAAmB,CAAA,AAEzB,CAAA,CAAO,IAAA,CAAK,yBAAA,CAA0B,EAAU,GAAI,AAAD,CAAK,AAAJ,CACxD,CAEA,AAH0C,CAG1C,CAAI,CAHwD,CAGhD,CAAI,CACpB,CACJ,CAAC,CAAA,CAFmB,AAIb,CAJiB,CAIH,CAAA,CAAI,CAAA,CAAU,CAAC,CAAC,CAAA,CAAI,CAC7C,AADW,CAQJ,CARsC,UAQ3B,CAAA,CAClB,CACI,IAAM,EAAS,IAAT,AAAS,CAAK,OAAA,CAAQ,GAAa,AAEzC,CAFyC,EAErC,AAAe,QAAA,SAAR,EACX,CACI,IAAM,EAA8B,CAAA,CAAC,CAErC,IAAA,IAAW,KAAK,EAEZ,CAAA,CAAI,CAAC,CAFO,AAEP,CADT,AACc,CAAA,CAAyC,CAAC,CAAA,CAAE,GAAA,CAG1D,OAAO,CACX,CAEA,CAHW,MAGH,EAAyB,GAAA,AACrC,CADY,AAoBL,QAAQ,CAAA,CACf,CACI,IAAM,EHvtB2C,CAAC,MAAM,EGutBlD,GAAc,EHvtBoC,CGutBvB,GAEjC,CAFqC,CAE9B,AAF8B,AAE9B,CAAA,CAAP,CAAO,EAAA,CAAA,EAAsB,GAE7B,CAFiC,CAAA,EAE3B,EAAwC,CAAA,CAAC,CA8C/C,OA5CA,EAAK,EAAL,KAAK,CAAQ,AAAC,GAAA,CAEV,GAAI,CAAC,AADT,IACS,CAAK,aAAA,CAAc,EAAG,CAAA,AAEvB,CADJ,EACQ,IAAA,CAAK,SAAA,CAAU,EAAG,CACtB,AADsB,CAElB,IAAI,EAAS,IAAT,AAAS,CAAK,SAAA,CAAU,EAAG,CAAA,AACzB,EAAiB,IAAA,CAAK,OAAtB,WAAsB,CAAmB,GAE/C,GAFqD,AAErC,CAFqC,OAErC,CAAS,EAAzB,KAAyB,CAAS,AAAD,IAE7B,EAAe,KAFe,CAEf,CAAO,EAAW,CAAE,AADvC,EACI,KAAmC,CAAF,AAAU,AAAC,IAExC,CAFwC,GAElC,EADV,AAC2B,EAAO,IAAP,EAAO,CAAO,AAAC,GAAhC,AAEF,EAFkC,AAE9B,CAAA,CAAM,EAAkC,CADhD,CAGe,AADX,CACW,CAAM,EAAkC,GAAM,AAFb,GAQ5C,EANyD,AAM1C,CANoC,KAMpC,EACnB,CACI,EAAS,CAAA,CAAA,AAEjB,CAAC,CAFO,AAEP,AACL,CAAC,CAAA,CAED,IAAA,CAAK,aAAA,CAAc,EAAG,CAAA,AAAI,CAAA,CAAO,CAAC,CAAA,AACtC,CAAA,KAGI,CADJ,GACI,CAAK,aAAA,CAAc,EAAG,CAAA,AAAI,IAAA,CAAK,mBAAA,CAAoB,CAC/C,KAAA,CAAO,CAAC,EAAG,CAAA,AACX,GAAA,CAAK,CAAA,CACT,CAAG,CAAA,CAAE,CAIb,AAJa,EAIb,CAAO,EAAG,CAAA,AAAI,IAAA,CAAK,aAAA,CAAc,EAAG,AACxC,CADwC,AACvC,CAAA,CAEM,EAAc,CAAA,CAAO,CAAA,CAAK,CAAC,CAAC,CAAA,CAAI,CAC3C,AADW,CAOJ,IAPoC,GAO7B,CAAA,CACd,CACI,MAAO,CAAC,CAAC,IAAA,CAAK,SAAA,CAAU,EAAG,AAC/B,CAD+B,AAOxB,UAAU,CAAA,CACjB,CACI,MAAO,CAAC,CAAC,IAAA,CAAK,QAAA,CAAS,EAAG,AAC9B,CAD8B,AAOtB,mBAAmB,CAAA,CAC3B,CACI,IAAA,IAAS,CAAA,CAAI,CAAA,CAAG,CAAA,CAAI,EAAO,IAAP,EAAO,CAAQ,CAAA,EAAA,CACnC,CACI,IAAM,EAAQ,CAAA,CAAO,CAAC,AAAhB,CAAgB,CAEhB,EAAY,IAAA,CAAK,EAAjB,aAAiB,CAAgB,IAAA,CAAK,AAAC,GACzC,EAAW,KAD8B,CAC9B,CAAO,CAAlB,KAAkB,CAAO,QAAA,CAAS,EAAM,GAAN,GAAY,CAAC,CAAA,CAEnD,GAAI,EAEA,OAFA,AAEO,CAEf,CAHI,AAKJ,OAJe,AAIR,IAAA,CAAK,eAAA,CAAgB,CAAC,CAAA,AACjC,CAOQ,2BAA2B,CAAA,CACnC,CACI,GAAI,CAAC,IAAA,CAAK,oBAAA,CAAsB,OAAO,EAEvC,CAFuC,GAEjC,EAAkB,IAAA,CAAM,IAAA,CAAK,EAA7B,CAAgC,AAAI,GAAA,CAAM,GAAA,CAEhD,MAAO,CAAA,EAAG,EAAG,CAAA,CAAG,EAAc,EAAG,IAAA,CAAK,KAAR,eAA4B,CAAA,CAAA,AAC9D,CAEQ,mBAAA,CAAoB,CAAA,CAA+B,CAAA,CAQ3D,CACI,GAAM,SAAE,CAAA,CAAS,IAAA,CAAM,CAAA,YAAW,CAAA,QAAY,CAAA,QAAQ,CAAA,cAAQ,CAAA,CAAa,CAAI,EAkB/E,EAlB+E,KAE3E,IAAA,CAAK,SAAA,EAAa,IAAA,CAAK,SAAA,EAC3B,CACI,GAAe,GAAA,CAAM,EAAA,CAAA,CAAK,GAA1B,OAA0B,CAAW,EAAe,GAAA,CAAK,IAAA,CAAK,GAAzB,MAAyB,CAAW,IAAA,CAAK,UAAS,CAAA,CAG3F,EAAe,KAAA,CAAQ,GAAW,EAAe,CAAjD,CAAuB,GAA0B,EAAS,CAAC,EAAe,EAAxC,CAA2C,CAAA,CAC7E,EAAe,GAAA,CAAM,IAAA,CAAK,GAA1B,uBAA0B,CAA2B,EAAe,GAAG,CAAA,CACvE,EAAe,IAAA,CADsC,AAC/B,CAAE,GAAG,GAAa,AAAxC,CAAwC,CAAC,CAAG,GAAG,AAApB,EAAmC,IAAA,CAAK,CACnE,EAAe,UAAA,CAAa,CAA5B,EAA0C,EAAe,UAAA,CACzD,CAD0C,CAC3B,MAAA,CAAS,GAAU,EAAlC,AAAiD,MAAA,CACjD,EAAe,GADmB,GACnB,CAAS,GAAU,EAAe,AAAjD,CAAwB,KAAyB,EAA0B,AAgBxE,EAhBwD,AAA+B,CAgBvF,CAhB+B,CAA2D,CAgBtF,AAhBsF,KAgBtF,CAAM,GAAG,CAAA,CAAE,AAhByC,GAgBzC,EAAI,CAAE,KAAA,CAAM,GAAG,CAAA,CAAE,KAAA,EAAM,CACxC,KAAA,CAAM,GAAG,EACT,KAAA,EAAM,CAjBc,KAAA,CAAA,EACrB,CADI,IAEA,EAAe,YAAf,AAAe,CAAe,CAAA,CAAA,CAG3B,CACX,CACJ,CAvxBa,EAOK,MAPL,GAqxBE,IA9wBG,CAAgB,cAAA,KL7ErB,EAAmB,CAAC,EAAmB,SAE1C,ECPA,EDOyB,KAAA,CAAM,GAAG,CAAA,CAAE,CAAC,CAAA,QAEvC,IAEA,GAAa,CAAA,CAAA,EAAA,EAAA,CADjB,AACiB,AAAgB,EAG1B,IIwRP,8CAlFS,EAAN,MAAM,EAkFT,YAAY,CAAA,CAA2D,CAAA,CACvE,CA1EA,CHrN0C,GGqN1C,CAAO,CHjNC,WAAA,CGiNgC,EAAC,CA2ErC,IAAI,EAAU,EAET,GAAsC,ICrN3C,cDqN6D,EAAA,CAAA,EAC7D,GACc,SCtNd,ADuNiB,OACH,MCtNd,CDyNM,CAAA,QAAA,CAAE,MAAS,CAAA,aAAM,EAAc,EAAA,CAAG,CAAI,KAArB,CAEvB,CAAK,AAFuC,WAEvC,CAAc,EACnB,IAAA,CAAK,CH/QL,GG8QmB,IACd,CAAW,IH/QA,GG+QA,EH9QhB,IG8QmC,EAAA,CAAA,CAAU,EAAU,IAAA,CAAV,AAC7C,IAAA,CAAK,aAAA,CAAA,EAAwB,MAAA,CAC7B,IAAA,CAAK,QAAA,CAAW,CAAA,MAChB,CAAK,UAAA,CAAa,CAAA,CAAC,WACP,GH3QH,CG2QG,EAEN,EAAiB,UAAA,CAAW,CAA5B,CAAiC,EAAL,EAAK,CAAK,KAAe,CAAA,CAEvD,GAEA,IAAA,CAAK,QADT,EACS,CAAa,EAClB,EAAQ,MAAA,CAAO,GADG,OACH,CAAa,IAAA,CAAK,UAAA,EAIjC,IAAA,CAAK,UAAA,CAAa,EAAQ,MAAA,CAAO,WAAA,MAGhC,EE/RE,KF+RF,CAAU,CE/RJ,GAAA,CF+RS,IAAA,CAAK,MAAA,gBACpB,CAAa,OAAA,IAAO,CAAK,IAAA,CAAK,OAAO,CAAA,CAC1C,IAAA,CAAA,WAAA,CAAmB,CAAA,eACd,CAAY,KAOd,OACP,EE1RQ,MF2RG,IAAI,OAAA,CAAQ,AAAC,IAEhB,GAFgB,CAEhB,CAAK,GADT,MACS,CAAY,EACjB,IAAA,CAAK,AADY,CEzRlB,UF0RM,CAAc,CAAA,CAEf,IAAA,CAAK,UAAA,CAAW,MAAA,EAAU,EAAY,UAAZ,AC/MN,AD+MkB,EAC1C,AACI,IAAA,CAAK,SExQR,KAAA,CFwQuB,CAAC,CAAA,wBAChB,GACL,IAAA,CAAK,cAAA,EAAe,MAIpB,CAAK,GE1QN,OF0QM,EAAW,AAExB,CE5Q8B,AF4Q7B,CAAA,CAYE,WACP,IE3Qc,IF4QV,IAAA,CAAK,cAAA,CAAe,EAAA,CAAA,OACpB,CAAK,kBAAA,EAAmB,KAEjB,CAAK,CE3QJ,KACR,EF0QY,CAChB,eAQuB,CAAA,CAA2B,EAAsB,EAAA,CACxE,CACI,IAF8C,AAE1C,EAAa,EACX,EAAY,EAAa,EAD3B,CAC2B,CAAW,CAApC,CAAgD,EAApC,GADD,KACyB,AAAY,CAEtD,KAAO,EAAa,EAAoB,GAAa,EAAa,IAA1B,AAA0B,CAAK,GAAlB,EAAjC,KAAmD,CAAW,MAAA,EAClF,CACI,IAAM,CAAA,CAAI,IAAA,CAAK,UAAA,CAAW,EAAU,CAC9B,EAAO,EAAP,EAAO,CADuB,AAClB,OAAA,CAAQ,CAAC,CAAA,CACrB,EAAO,EAAK,EAAL,GAAK,CAElB,EE9QR,CAAA,EF+QQ,CACI,IAAI,EAAQ,GAAR,CAAQ,CACR,EAAO,EAAP,EAAO,CACL,GAA8B,EEhRtC,EFgRqB,CAAiB,CAAZ,OAAA,EAAqB,EAAK,UAAA,CAC5C,EAAK,EAAL,QAAK,CAAa,EAAK,EAAL,GAAK,CAEvB,EAAO,IAAI,EClNR,CDkNQ,CACb,ACnNK,CDmNL,CACA,CAAA,CAAA,CCjNL,IAAA,KDkNU,CAAM,EAAW,CAAC,EAAI,IAAA,CAAK,UAAA,CAChC,IAAA,CAAK,KAAA,CAAM,EAAW,CAAC,EAAI,IAAA,CAAK,AAArB,UAAqB,EAKhC,EAFA,EAAA,CAEA,MAFK,CAEG,IAAI,EAAA,CAAA,CACR,GE/QV,EF+Qe,KAAA,CAAA,EAAW,CAAC,EAAI,IAAA,CAAA,UAAK,CAAA,KACrB,KAAA,CAAM,EAAK,CAAC,CAAN,CAAU,IAAA,CAAK,UAAA,CAC1B,GEpQR,CFoQQ,CAAA,KAAK,CAAM,EAAK,CAAA,CAAL,CAAU,IAAA,CAAK,UAAA,CAC1B,IAAA,CAAK,KAAA,CAAM,EAAK,CAAC,CAAN,CAAU,IAAA,CAAK,UAAA,EAKtB,IAAA,EAAA,CAAI,CACR,IAAA,CAAK,KAAA,CAAM,EAAK,CAAC,CAAN,CAAU,IAAA,CAAK,UAAA,CAC1B,KAAK,KAAA,CAAA,EAAW,CAAC,EAAI,IAAA,CAAK,UAAA,CAC1B,IAAA,CAAK,KAAA,CAAM,EAAK,CAAC,CAAN,CAAU,IAAA,CAAK,UAAA,CAC1B,IAAA,CAAA,KAAK,CAAA,EAAA,CAAY,EAAI,IAAA,CAAK,UAAA,GAKb,IAAjB,CAAiB,CAAZ,EAAL,AEzQJ,KFyQS,EAAqB,EAAK,EAAL,cAAK,EACnC,CACI,EAAO,EAAP,EAAW,EAAA,CAAA,CACP,KAAA,KAAK,CAAM,EAAK,EAAL,cAAK,CAAiB,CAAC,EAAI,IAAA,CAAK,UAAA,CAC3C,KAAK,KAAA,CAAM,EAAK,EAAL,cAAK,CAAiB,CAAC,EAAI,IAAA,CAAK,UAAA,CAC3C,GEvQR,CFuQQ,CAAK,KAAA,CAAM,EAAK,CAAC,CAAN,AEvQT,CFuQmB,IAAA,CAAK,UAAA,CAC1B,KAAK,KAAA,CAAM,EAAK,CAAC,CAAN,CAAU,IAAA,CAAK,WAAA,MAIlC,CAAK,EEpQL,MFoQK,CAAS,CAAC,CAAA,CAAI,IAAI,EEpQG,CAAA,AFoQH,CAAQ,CAC3B,OAAQ,IAAA,CAAK,aAAA,OAEb,OACA,IAAA,GACA,EEpQJ,AFqQI,MAAA,CAAQ,AAAe,CAAA,GAAf,AAAmB,CAAA,CAAd,OAAA,CACb,cAAe,EAAK,EAAL,IAAK,CACpB,eAAgB,EAAK,OAAA,CAErB,MAAO,EAAE,GEjQX,KFiQW,IAEjB,CAEA,GACJ,CACJ,CAGQ,oBACR,CACI,IAAA,EAAmB,IAAA,CAAA,IAAK,CAAK,UAAA,EAAc,CAAA,CAAC,CAE5C,IAAA,IAAW,KAAY,EACvB,CACI,IAAA,CAAK,EAFc,QAEd,CAAW,EAAiC,CAAI,EAAC,CACtD,EADiD,EACjD,IAAS,EE5PD,AF4PK,EAAG,CAAA,CAAI,CAAA,CAAA,EAAA,CAAqB,MAAA,CAAQ,CAAA,GACjD,CACI,IAAM,EAAY,CAAA,CE5Pd,AF4PyB,EAAQ,CAAE,CAAC,CAAA,CAExC,EAFqC,EAErC,CAAK,EE7PG,QAAA,CAAA,EF6PgB,CAAE,IAAA,CAAK,IAAA,CAAK,QAAA,CAAS,EAAU,CAAA,AAC3D,CACJ,CACJ,CAGQ,GAN0D,aAOlE,CACI,IAAM,EAAW,IAAA,CAAK,SAAA,CAEtB,IAAA,CAAK,SAAA,CAAY,IAAA,CACjB,IAAA,CAAK,UE9PG,CAAA,CF8PW,CAAA,CACnB,EAAS,IAAA,CAAK,IAAA,CAAM,CE9PC,GF8PD,CAAK,CE7PjB,OF6PyB,CAAA,AACrC,aAIA,CACI,IAAA,CAAK,cAAA,CAAA,IAAe,CAAK,WAAA,CAAc,EAAY,UAAZ,AAAsB,CAAA,KAC7D,CAAA,WAAK,EAAA,YACM,CE7PL,IF+PE,IAAA,CAAK,GE7PH,QAAA,CAAA,EF6P6B,UAAA,CAAa,IAAA,CAAK,UAAA,CAAW,MAAA,EAChE,GACI,CAAK,IE7PT,MF6PS,QAIL,CAAK,kBAAA,EAAmB,KACxB,CAAK,cAAA,EAAe,GAEzB,GACP,QAMe,GAAc,CAAA,CAC7B,KACI,IAAA,KAAgB,IAAA,CAAK,QAAA,CACrB,KChO4B,QDiOnB,CAAS,CAAC,CAAA,CAAE,OAAA,EAErB,KAAA,CAAK,OAAA,CAAU,IAAA,AC7NL,CD8NV,IAAA,CAAK,UAAA,CAAa,IAAA,CAClB,IAAA,CAAK,IAAA,CAAO,IAAA,CACZ,IAAA,CAAK,QAAA,CAAW,IAAA,CACZ,IAEA,IAAA,CAAK,EAFL,EACJ,IACS,EAAU,OAAA,EAAQ,CACvB,IAAA,CAAK,aAAA,CAAc,OAAA,EAAQ,EAE/B,IAAA,CAAK,QAAA,CAAW,IAAA,CAChB,IAAA,CAAK,aAAA,CAAgB,KACrB,IAAA,CAAK,YAAA,CAAe,EAAC,AACzB,CACJ,CAAA,GA/S2B,UAAA,CAAa,GAAA,CE5LxC,IAAM,EAAc,CAAC,MAAO,MAAO,CF0Qb,ME1QqB,6BACtB,MAAO,OAAQ,MAAO,MAAO,MAAO,MAAO,CLe5D,KKfmE,aAAa,CAkDvE,EAAmB,CAC5B,UAAW,EAAA,CAAA,CAAc,KAAA,CFwQW,AEtQpC,MAAO,CACH,KAAM,AAAC,GAAuB,eAC9B,EAD+C,WAAA,MAC3B,CAAC,EAAgB,EAAhB,EAAuC,CArDpE,SAAS,EAAmB,CAAA,CAAgB,CAAA,CAAoB,CAAA,CAqDI,CApDpE,AACI,IAAM,EAA2B,CAAA,CAAC,CAYlC,GAVA,EAAK,OAAA,CAAQ,AAAC,GAAA,EAEV,CAAA,EAAO,AADX,CACe,CACf,CAAC,EAED,OAAO,IAAA,CAAK,EAAA,QAAc,CAAA,CAAE,OAAA,CAAQ,AAAC,GAAA,CAEjC,CAAA,CAAA,CAAA,CADJ,CACW,EAAM,WAAW,CAAA,EAAG,EAAG,CAAA,AAAE,CAAA,CAAI,EAAM,GAAN,KAAM,CAAS,EACvD,AAD0D,CACzD,AADyD,EAGtD,CAAC,EACL,CACI,IAAM,EAAW,EAAA,CAAA,CAAK,EAFrB,AAEK,KAAgB,CAAQ,CAAA,CAAK,CAAC,CAAC,CAAA,CAErC,EAAM,GAAN,SAAM,CAAa,OAAA,CAAQ,CAAC,EAAmB,CAAA,CAAnB,GAIxB,CAHJ,AF4RG,MEzRQ,MAAA,CAAO,EAFD,EAAmB,CAAC,AAEd,CAFc,EAAG,CAEb,CAAA,AAFqB,CAAA,EAAI,EAAM,CAAV,EAAI,CAAM,CAAK,AAA9C,IAA8C,CAAK,mBAAA,CAAoB,CAAC,CAAC,CAAA,CAAE,CAAA,CAAG,GAAM,GAGrG,CAHyG,AAGxG,CAAA,AACL,AAJ6G,CAM7G,OAAA,IA2BmF,EAAM,EAAN,CAAa,EAAK,CACrG,EADqG,QAG3F,CACN,SAAA,CAAW,CACP,KAAM,EAAA,CAAA,CAAc,aAAA,CACpB,IAAA,CAAM,oBAAA,CACV,CACA,IAAA,CAAM,AAAC,IAGH,CAHG,GAGG,EAFV,AACoB,AACF,EADQ,CAChB,EADU,EACF,AADQ,CAAM,GAAG,CAAA,CAAE,CAAC,CAAA,CACZ,KAAA,CAAM,GAAG,CAAA,CACzB,EAAY,EAAM,GAAA,EAAlB,AAAsB,CACtB,EAAS,EAAM,GAAA,EAAI,CAEzB,MAAqB,IF0QE,CAAA,CE1QF,GAAd,GAAwB,EAAY,IAApC,IAAoC,CAAZ,AAAqB,EACxD,CAAA,CACA,EAF8D,CAAA,EAE9D,CAAO,AAAC,IAEJ,IAAA,EAAc,EAAM,KAAA,CAAM,GAAG,CAAA,CAE7B,MAAO,CACH,EDuDR,SCvDoB,WAAW,EAAS,aAAA,CAAc,IAAA,CAAK,IAAK,CAAA,AAAI,CAAJ,AAAK,CAAA,EAAK,GAAG,CAAA,CACrE,OAAQ,CAAA,CAAM,EAAA,MAAM,CAAS,CAAC,CAAA,CAC9B,GAAA,CAAK,CD4DL,IClDZ,OAAQ,CAEJ,GF4QQ,EE5QF,oBACN,GAAA,wBAEW,CACP,KAAM,EAAA,CAAA,CAAc,UAAA,CACpB,SAAU,EAAA,CAAA,CAAqB,MAAA,CAC/B,KAAM,EFgRE,mBE7QN,SAAA,CAAN,KF+QQ,CE/QQ,EAAwB,GAAxB,CAEJ,AAA4C,GAFhB,EACxC,EACwD,KAA5C,CAAA,CAAK,OAAA,CAAQ,EAAQ,GAAG,CAAA,CAAX,AAAa,WAAA,EAAY,EAAiB,CAAC,CAAC,EAAM,GAAN,GAAM,CAG3E,MAAM,MACF,CAAA,CACA,CAAA,CAOA,CAAA,CFsQuB,CEnQvB,AADJ,IAeQ,EAdJ,CACI,QAAS,CAAA,eACT,CAAA,EFqQI,cEpQJ,CAAA,EAAA,WACA,CAAA,CACJ,CAAI,GAAS,MAAQ,CAAA,EAEjB,CFyQI,CEzQO,EDwDZ,ACxDY,CAAA,CAAK,OAAA,CAAQ,EAAQ,GAAG,CAAA,CAAX,AAS5B,GAPI,GAAY,EAAS,WAAA,CAAY,GAAG,CAAA,GAAO,EAAS,MAAT,AAAS,CAAS,CAAA,EACjE,CACI,GAAY,GAAA,CAAA,CAKZ,aAAwB,EAAA,CAAA,CAExB,CADJ,CACc,MAGd,CACI,EFoQQ,CACJ,CErQE,EAAY,EAAiB,GAAY,EAAzC,CAA0D,EAA7B,AAAmC,GAAnC,CAAmC,CAAK,GAA5B,EAA4B,CAAA,CAAQ,EAAQ,GAAG,CAAA,GAIpF,CAFK,MAAM,EAAO,IAAP,AAAO,CAAc,CAAC,CAAE,GAAA,CAAK,EAAW,IAAA,CAAM,CAAA,CAAgB,AAAjC,EAAkC,CAAA,AAE1E,CAAO,EAAS,AAC9B,CAEA,IAAM,CALiE,CAKnD,CFoQZ,GAjOb,AEnC6B,EAAY,CAChC,EADE,MACO,AADW,EACH,KAAR,CAAQ,CACjB,KAAM,KAAA,SACN,CAAA,CACH,CAAA,AAED,OAAM,EAAY,KAAA,CFmQM,EE/PxB,IAAM,EAAa,CFiQX,EEjQkB,IAAA,EAAM,mBAAA,CAEhC,GAAI,KAAA,CAAM,OAAA,CAAQ,GAClB,CACI,IAAM,EAFkB,AAEkC,CAFlC,CAEmC,CAE3D,IAAA,GF+PJ,CE/Pe,CF+Pf,IE/PuB,EACnB,CACI,GAAoB,IAFL,IAEK,EAAhB,AACJ,OADW,EAEP,SAGJ,IAAI,EAAU,EAAW,EAGrB,AF0PZ,EE7PiC,AAGb,EAHE,EF+PpB,AE5PkB,CAAR,CAAc,iBAClB,CAIA,EAAU,EAAiB,EAAS,EAAQ,GAAjB,AAAoB,CAAA,AF4PhB,AAAU,CE1PzC,EAAS,IAAA,CAAK,EAAO,IAAA,CAAmC,CACpD,IAAK,EACL,IAAA,CAAM,gBACF,EACA,YADA,GACA,CAAiB,EAAA,KAG7B,CAEA,IAAM,EAAM,CAAN,KAAY,OAAA,CAAQ,GAAA,CAAI,GAE9B,EAAY,GAF0B,CAAA,QAE1B,CAAe,EAC3B,CAD2B,CACvB,CAAJ,MAAI,CAAQ,AAAC,IAET,EAAK,YAAA,CAAe,CAAC,EAAW,CAAE,MAAA,CAAO,CAAT,CAAqB,SAAZ,GAAY,CAAa,MAAA,CAAO,AAAC,EAAA,CAAQ,EAAA,EAAO,GAC7F,CADkG,AACjG,CADkG,AAClG,AACL,CAFuG,AAIvG,CD+BD,ID6NC,EE5PO,CACX,CAAA,CAEA,MAAM,IF6PN,GE7Pa,CAAA,CAA0B,CAAA,CAAgB,CAAA,EACvD,MACU,EAAO,MAAA,CAAA,EAAmB,GF6PT,UE7PS,CAAc,aAAa,CAAA,CAE3D,EAAY,OAAA,EAAQ,CDgCF,CC/BtB,CAAA,CAER,CAHqC,CAAA,AH1OrC,EAAA,CAAA,CAAW,EHUH,CAAA,CGVO","ignoreList":[0,1,3,4,5,6,7,8,9,10,11,12,14,15,16,17,18,19,20]}