tangram-core 0.2.0__cp313-cp313-win_amd64.whl

tangram_core/dist-frontend/assets/project-CrvReKGW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-CrvReKGW.js","sources":["../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/utils/assert.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/filters/prop-types.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/module-injectors.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/shader-injections.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/shader-module/shader-module.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/shader-module/shader-module-dependencies.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/platform-defines.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/shader-transpiler/transpile-glsl-shader.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/shader-hooks.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/get-shader-info.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/assemble-shaders.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/preprocessor/preprocessor.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/lib/shader-assembler.js","../../../../../../node_modules/.pnpm/@luma.gl+shadertools@9.2.4_@luma.gl+core@9.2.4/node_modules/@luma.gl/shadertools/dist/modules/math/fp32/fp32.js","../../../../../../node_modules/.pnpm/@deck.gl+core@9.2.2/node_modules/@deck.gl/core/dist/shaderlib/misc/geometry.js","../../../../../../node_modules/.pnpm/@deck.gl+core@9.2.2/node_modules/@deck.gl/core/dist/utils/memoize.js","../../../../../../node_modules/.pnpm/@deck.gl+core@9.2.2/node_modules/@deck.gl/core/dist/shaderlib/project/viewport-uniforms.js","../../../../../../node_modules/.pnpm/@deck.gl+core@9.2.2/node_modules/@deck.gl/core/dist/shaderlib/project/project.wgsl.js","../../../../../../node_modules/.pnpm/@deck.gl+core@9.2.2/node_modules/@deck.gl/core/dist/shaderlib/project/project.glsl.js","../../../../../../node_modules/.pnpm/@deck.gl+core@9.2.2/node_modules/@deck.gl/core/dist/shaderlib/project/project.js"],"sourcesContent":["// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Recommendation is to ignore message but current test suite checks agains the\n// message so keep it for now.\nexport function assert(condition, message) {\n    if (!condition) {\n        throw new Error(message || 'shadertools: assertion failed.');\n    }\n}\n//# sourceMappingURL=assert.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { assert } from \"../utils/assert.js\";\n/** Minimal validators for number and array types */\nconst DEFAULT_PROP_VALIDATORS = {\n    number: {\n        type: 'number',\n        validate(value, propType) {\n            return (Number.isFinite(value) &&\n                typeof propType === 'object' &&\n                (propType.max === undefined || value <= propType.max) &&\n                (propType.min === undefined || value >= propType.min));\n        }\n    },\n    array: {\n        type: 'array',\n        validate(value, propType) {\n            return Array.isArray(value) || ArrayBuffer.isView(value);\n        }\n    }\n};\n/**\n * Parse a list of property types into property definitions that can be used to validate\n * values passed in by applications.\n * @param propTypes\n * @returns\n */\nexport function makePropValidators(propTypes) {\n    const propValidators = {};\n    for (const [name, propType] of Object.entries(propTypes)) {\n        propValidators[name] = makePropValidator(propType);\n    }\n    return propValidators;\n}\n/**\n * Validate a map of user supplied properties against a map of validators\n * Inject default values when user doesn't supply a property\n * @param properties\n * @param propValidators\n * @returns\n */\nexport function getValidatedProperties(properties, propValidators, errorMessage) {\n    const validated = {};\n    for (const [key, propsValidator] of Object.entries(propValidators)) {\n        if (properties && key in properties && !propsValidator.private) {\n            if (propsValidator.validate) {\n                assert(propsValidator.validate(properties[key], propsValidator), `${errorMessage}: invalid ${key}`);\n            }\n            validated[key] = properties[key];\n        }\n        else {\n            // property not supplied - use default value\n            validated[key] = propsValidator.value;\n        }\n    }\n    // TODO - warn for unused properties that don't match a validator?\n    return validated;\n}\n/**\n * Creates a property validator for a prop type. Either contains:\n * - a valid prop type object ({type, ...})\n * - or just a default value, in which case type and name inference is used\n */\nfunction makePropValidator(propType) {\n    let type = getTypeOf(propType);\n    if (type !== 'object') {\n        return { value: propType, ...DEFAULT_PROP_VALIDATORS[type], type };\n    }\n    // Special handling for objects\n    if (typeof propType === 'object') {\n        if (!propType) {\n            return { type: 'object', value: null };\n        }\n        if (propType.type !== undefined) {\n            return { ...propType, ...DEFAULT_PROP_VALIDATORS[propType.type], type: propType.type };\n        }\n        // If no type and value this object is likely the value\n        if (propType.value === undefined) {\n            return { type: 'object', value: propType };\n        }\n        type = getTypeOf(propType.value);\n        return { ...propType, ...DEFAULT_PROP_VALIDATORS[type], type };\n    }\n    throw new Error('props');\n}\n/**\n * \"improved\" version of javascript typeof that can distinguish arrays and null values\n */\nfunction getTypeOf(value) {\n    if (Array.isArray(value) || ArrayBuffer.isView(value)) {\n        return 'array';\n    }\n    return typeof value;\n}\n//# sourceMappingURL=prop-types.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const MODULE_INJECTORS_VS = /* glsl */ `\\\n#ifdef MODULE_LOGDEPTH\n  logdepth_adjustPosition(gl_Position);\n#endif\n`;\nexport const MODULE_INJECTORS_FS = /* glsl */ `\\\n#ifdef MODULE_MATERIAL\n  fragColor = material_filterColor(fragColor);\n#endif\n\n#ifdef MODULE_LIGHTING\n  fragColor = lighting_filterColor(fragColor);\n#endif\n\n#ifdef MODULE_FOG\n  fragColor = fog_filterColor(fragColor);\n#endif\n\n#ifdef MODULE_PICKING\n  fragColor = picking_filterHighlightColor(fragColor);\n  fragColor = picking_filterPickingColor(fragColor);\n#endif\n\n#ifdef MODULE_LOGDEPTH\n  logdepth_setFragDepth();\n#endif\n`;\n//# sourceMappingURL=module-injectors.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { MODULE_INJECTORS_VS, MODULE_INJECTORS_FS } from \"../../module-injectors.js\";\nimport { assert } from \"../utils/assert.js\";\n// TODO - experimental\nconst MODULE_INJECTORS = {\n    vertex: MODULE_INJECTORS_VS,\n    fragment: MODULE_INJECTORS_FS\n};\nconst REGEX_START_OF_MAIN = /void\\s+main\\s*\\([^)]*\\)\\s*\\{\\n?/; // Beginning of main\nconst REGEX_END_OF_MAIN = /}\\n?[^{}]*$/; // End of main, assumes main is last function\nconst fragments = [];\nexport const DECLARATION_INJECT_MARKER = '__LUMA_INJECT_DECLARATIONS__';\n/**\n *\n */\nexport function normalizeInjections(injections) {\n    const result = { vertex: {}, fragment: {} };\n    for (const hook in injections) {\n        let injection = injections[hook];\n        const stage = getHookStage(hook);\n        if (typeof injection === 'string') {\n            injection = {\n                order: 0,\n                injection\n            };\n        }\n        result[stage][hook] = injection;\n    }\n    return result;\n}\nfunction getHookStage(hook) {\n    const type = hook.slice(0, 2);\n    switch (type) {\n        case 'vs':\n            return 'vertex';\n        case 'fs':\n            return 'fragment';\n        default:\n            throw new Error(type);\n    }\n}\n/**\n// A minimal shader injection/templating system.\n// RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/shader-injection-rfc.md\n * @param source\n * @param type\n * @param inject\n * @param injectStandardStubs\n * @returns\n */\n// eslint-disable-next-line complexity\nexport function injectShader(source, stage, inject, injectStandardStubs = false) {\n    const isVertex = stage === 'vertex';\n    for (const key in inject) {\n        const fragmentData = inject[key];\n        fragmentData.sort((a, b) => a.order - b.order);\n        fragments.length = fragmentData.length;\n        for (let i = 0, len = fragmentData.length; i < len; ++i) {\n            fragments[i] = fragmentData[i].injection;\n        }\n        const fragmentString = `${fragments.join('\\n')}\\n`;\n        switch (key) {\n            // declarations are injected before the main function\n            case 'vs:#decl':\n                if (isVertex) {\n                    source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);\n                }\n                break;\n            // inject code at the beginning of the main function\n            case 'vs:#main-start':\n                if (isVertex) {\n                    source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);\n                }\n                break;\n            // inject code at the end of main function\n            case 'vs:#main-end':\n                if (isVertex) {\n                    source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);\n                }\n                break;\n            // declarations are injected before the main function\n            case 'fs:#decl':\n                if (!isVertex) {\n                    source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);\n                }\n                break;\n            // inject code at the beginning of the main function\n            case 'fs:#main-start':\n                if (!isVertex) {\n                    source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);\n                }\n                break;\n            // inject code at the end of main function\n            case 'fs:#main-end':\n                if (!isVertex) {\n                    source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);\n                }\n                break;\n            default:\n                // TODO(Tarek): I think this usage should be deprecated.\n                // inject code after key, leaving key in place\n                source = source.replace(key, (match) => match + fragmentString);\n        }\n    }\n    // Remove if it hasn't already been replaced\n    source = source.replace(DECLARATION_INJECT_MARKER, '');\n    // Finally, if requested, insert an automatic module injector chunk\n    if (injectStandardStubs) {\n        source = source.replace(/\\}\\s*$/, (match) => match + MODULE_INJECTORS[stage]);\n    }\n    return source;\n}\n// Takes an array of inject objects and combines them into one\nexport function combineInjects(injects) {\n    const result = {};\n    assert(Array.isArray(injects) && injects.length > 1);\n    injects.forEach(inject => {\n        for (const key in inject) {\n            result[key] = result[key] ? `${result[key]}\\n${inject[key]}` : inject[key];\n        }\n    });\n    return result;\n}\n//# sourceMappingURL=shader-injections.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { makePropValidators, getValidatedProperties } from \"../filters/prop-types.js\";\nimport { normalizeInjections } from \"../shader-assembly/shader-injections.js\";\n// SHNDER MODULE API\nexport function initializeShaderModules(modules) {\n    modules.map((module) => initializeShaderModule(module));\n}\nexport function initializeShaderModule(module) {\n    if (module.instance) {\n        return;\n    }\n    initializeShaderModules(module.dependencies || []);\n    const { propTypes = {}, deprecations = [], \n    // defines = {},\n    inject = {} } = module;\n    const instance = {\n        normalizedInjections: normalizeInjections(inject),\n        parsedDeprecations: parseDeprecationDefinitions(deprecations)\n    };\n    if (propTypes) {\n        instance.propValidators = makePropValidators(propTypes);\n    }\n    module.instance = instance;\n    // TODO(ib) - we need to apply the original prop types to the default uniforms\n    let defaultProps = {};\n    if (propTypes) {\n        defaultProps = Object.entries(propTypes).reduce((obj, [key, propType]) => {\n            // @ts-expect-error\n            const value = propType?.value;\n            if (value) {\n                // @ts-expect-error\n                obj[key] = value;\n            }\n            return obj;\n        }, {});\n    }\n    module.defaultUniforms = { ...module.defaultUniforms, ...defaultProps };\n}\n/** Convert module props to uniforms */\nexport function getShaderModuleUniforms(module, props, oldUniforms) {\n    initializeShaderModule(module);\n    const uniforms = oldUniforms || { ...module.defaultUniforms };\n    // If module has a getUniforms function, use it\n    if (props && module.getUniforms) {\n        return module.getUniforms(props, uniforms);\n    }\n    // Build uniforms from the uniforms array\n    // @ts-expect-error\n    return getValidatedProperties(props, module.instance?.propValidators, module.name);\n}\n/* TODO this looks like it was unused code\n  _defaultGetUniforms(opts: Record<string, any> = {}): Record<string, any> {\n    const uniforms: Record<string, any> = {};\n    const propTypes = this.uniforms;\n\n    for (const key in propTypes) {\n      const propDef = propTypes[key];\n      if (key in opts && !propDef.private) {\n        if (propDef.validate) {\n          assert(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`);\n        }\n        uniforms[key] = opts[key];\n      } else {\n        uniforms[key] = propDef.value;\n      }\n    }\n\n    return uniforms;\n  }\n}\n*/\n// Warn about deprecated uniforms or functions\nexport function checkShaderModuleDeprecations(shaderModule, shaderSource, log) {\n    shaderModule.deprecations?.forEach(def => {\n        if (def.regex?.test(shaderSource)) {\n            if (def.deprecated) {\n                log.deprecated(def.old, def.new)();\n            }\n            else {\n                log.removed(def.old, def.new)();\n            }\n        }\n    });\n}\n// HELPERS\nfunction parseDeprecationDefinitions(deprecations) {\n    deprecations.forEach(def => {\n        switch (def.type) {\n            case 'function':\n                def.regex = new RegExp(`\\\\b${def.old}\\\\(`);\n                break;\n            default:\n                def.regex = new RegExp(`${def.type} ${def.old};`);\n        }\n    });\n    return deprecations;\n}\n//# sourceMappingURL=shader-module.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { initializeShaderModules } from \"./shader-module.js\";\n/**\n * Takes a list of shader module names and returns a new list of\n * shader module names that includes all dependencies, sorted so\n * that modules that are dependencies of other modules come first.\n *\n * If the shader glsl code from the returned modules is concatenated\n * in the reverse order, it is guaranteed that all functions be resolved and\n * that all function and variable definitions come before use.\n *\n * @param modules - Array of modules (inline modules or module names)\n * @return - Array of modules\n */\nexport function getShaderModuleDependencies(modules) {\n    initializeShaderModules(modules);\n    const moduleMap = {};\n    const moduleDepth = {};\n    getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });\n    // Return a reverse sort so that dependencies come before the modules that use them\n    const dependencies = Object.keys(moduleDepth)\n        .sort((a, b) => moduleDepth[b] - moduleDepth[a])\n        .map(name => moduleMap[name]);\n    initializeShaderModules(dependencies);\n    return dependencies;\n}\n/**\n * Recursively checks module dependencies to calculate dependency level of each module.\n *\n * @param options.modules - Array of modules\n * @param options.level - Current level\n * @param options.moduleMap -\n * @param options.moduleDepth - Current level\n * @return - Map of module name to its level\n */\n// Adds another level of dependencies to the result map\nexport function getDependencyGraph(options) {\n    const { modules, level, moduleMap, moduleDepth } = options;\n    if (level >= 5) {\n        throw new Error('Possible loop in shader dependency graph');\n    }\n    // Update level on all current modules\n    for (const module of modules) {\n        moduleMap[module.name] = module;\n        if (moduleDepth[module.name] === undefined || moduleDepth[module.name] < level) {\n            moduleDepth[module.name] = level;\n        }\n    }\n    // Recurse\n    for (const module of modules) {\n        if (module.dependencies) {\n            getDependencyGraph({ modules: module.dependencies, level: level + 1, moduleMap, moduleDepth });\n        }\n    }\n}\n/**\n * Takes a list of shader module names and returns a new list of\n * shader module names that includes all dependencies, sorted so\n * that modules that are dependencies of other modules come first.\n *\n * If the shader glsl code from the returned modules is concatenated\n * in the reverse order, it is guaranteed that all functions be resolved and\n * that all function and variable definitions come before use.\n *\n * @param modules - Array of modules (inline modules or module names)\n * @return - Array of modules\n */\nexport function getShaderDependencies(modules) {\n    initializeShaderModules(modules);\n    const moduleMap = {};\n    const moduleDepth = {};\n    getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });\n    // Return a reverse sort so that dependencies come before the modules that use them\n    modules = Object.keys(moduleDepth)\n        .sort((a, b) => moduleDepth[b] - moduleDepth[a])\n        .map(name => moduleMap[name]);\n    initializeShaderModules(modules);\n    return modules;\n}\n// DEPRECATED\n/**\n * Instantiate shader modules and resolve any dependencies\n * @deprecated Use getShaderDpendencies\n */\nexport function resolveModules(modules) {\n    return getShaderDependencies(modules);\n}\n//# sourceMappingURL=shader-module-dependencies.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/** Adds defines to help identify GPU architecture / platform */\nexport function getPlatformShaderDefines(platformInfo) {\n    switch (platformInfo?.gpu.toLowerCase()) {\n        case 'apple':\n            return /* glsl */ `\\\n#define APPLE_GPU\n// Apple optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n        case 'nvidia':\n            return /* glsl */ `\\\n#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n`;\n        case 'intel':\n            return /* glsl */ `\\\n#define INTEL_GPU\n// Intel optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Intel's built-in 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n        case 'amd':\n            // AMD Does not eliminate fp64 code\n            return /* glsl */ `\\\n#define AMD_GPU\n`;\n        default:\n            // We don't know what GPU it is, could be that the GPU driver or\n            // browser is not implementing UNMASKED_RENDERER constant and not\n            // reporting a correct name\n            return /* glsl */ `\\\n#define DEFAULT_GPU\n// Prevent driver from optimizing away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Headless Chrome's software shader 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// If the GPU doesn't have full 32 bits precision, will causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n    }\n}\n//# sourceMappingURL=platform-defines.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// TRANSPILATION TABLES\n/**\n * Transpiles GLSL 3.00 shader source code to target GLSL version (3.00 or 1.00)\n *\n * @note We always run transpiler even if same version e.g. 3.00 => 3.00\n * @note For texture sampling transpilation, apps need to use non-standard texture* calls in GLSL 3.00 source\n * RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/portable-glsl-300-rfc.md\n */\nexport function transpileGLSLShader(source, stage) {\n    const sourceGLSLVersion = Number(source.match(/^#version[ \\t]+(\\d+)/m)?.[1] || 100);\n    if (sourceGLSLVersion !== 300) {\n        // TODO - we splurge on a longer error message to help deck.gl custom layer developers\n        throw new Error('luma.gl v9 only supports GLSL 3.00 shader sources');\n    }\n    switch (stage) {\n        case 'vertex':\n            source = convertShader(source, ES300_VERTEX_REPLACEMENTS);\n            return source;\n        case 'fragment':\n            source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);\n            return source;\n        default:\n            // Unknown shader stage\n            throw new Error(stage);\n    }\n}\n/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */\nconst ES300_REPLACEMENTS = [\n    // Fix poorly formatted version directive\n    [/^(#version[ \\t]+(100|300[ \\t]+es))?[ \\t]*\\n/, '#version 300 es\\n'],\n    // The individual `texture...()` functions were replaced with `texture()` overloads\n    [/\\btexture(2D|2DProj|Cube)Lod(EXT)?\\(/g, 'textureLod('],\n    [/\\btexture(2D|2DProj|Cube)(EXT)?\\(/g, 'texture(']\n];\nconst ES300_VERTEX_REPLACEMENTS = [\n    ...ES300_REPLACEMENTS,\n    // `attribute` keyword replaced with `in`\n    [makeVariableTextRegExp('attribute'), 'in $1'],\n    // `varying` keyword replaced with `out`\n    [makeVariableTextRegExp('varying'), 'out $1']\n];\n/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */\nconst ES300_FRAGMENT_REPLACEMENTS = [\n    ...ES300_REPLACEMENTS,\n    // `varying` keyword replaced with `in`\n    [makeVariableTextRegExp('varying'), 'in $1']\n];\nfunction convertShader(source, replacements) {\n    for (const [pattern, replacement] of replacements) {\n        source = source.replace(pattern, replacement);\n    }\n    return source;\n}\n/**\n * Creates a regexp that tests for a specific variable type\n * @example\n *   should match:\n *     in float weight;\n *     out vec4 positions[2];\n *   should not match:\n *     void f(out float a, in float b) {}\n */\nfunction makeVariableTextRegExp(qualifier) {\n    return new RegExp(`\\\\b${qualifier}[ \\\\t]+(\\\\w+[ \\\\t]+\\\\w+(\\\\[\\\\w+\\\\])?;)`, 'g');\n}\n//# sourceMappingURL=transpile-glsl-shader.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/** Generate hook source code */\nexport function getShaderHooks(hookFunctions, hookInjections) {\n    let result = '';\n    for (const hookName in hookFunctions) {\n        const hookFunction = hookFunctions[hookName];\n        result += `void ${hookFunction.signature} {\\n`;\n        if (hookFunction.header) {\n            result += `  ${hookFunction.header}`;\n        }\n        if (hookInjections[hookName]) {\n            const injections = hookInjections[hookName];\n            injections.sort((a, b) => a.order - b.order);\n            for (const injection of injections) {\n                result += `  ${injection.injection}\\n`;\n            }\n        }\n        if (hookFunction.footer) {\n            result += `  ${hookFunction.footer}`;\n        }\n        result += '}\\n';\n    }\n    return result;\n}\n/**\n * Parse string based hook functions\n * And split per shader\n */\nexport function normalizeShaderHooks(hookFunctions) {\n    const result = { vertex: {}, fragment: {} };\n    for (const hookFunction of hookFunctions) {\n        let opts;\n        let hook;\n        if (typeof hookFunction !== 'string') {\n            opts = hookFunction;\n            hook = opts.hook;\n        }\n        else {\n            opts = {};\n            hook = hookFunction;\n        }\n        hook = hook.trim();\n        const [shaderStage, signature] = hook.split(':');\n        const name = hook.replace(/\\(.+/, '');\n        const normalizedHook = Object.assign(opts, { signature });\n        switch (shaderStage) {\n            case 'vs':\n                result.vertex[name] = normalizedHook;\n                break;\n            case 'fs':\n                result.fragment[name] = normalizedHook;\n                break;\n            default:\n                throw new Error(shaderStage);\n        }\n    }\n    return result;\n}\n//# sourceMappingURL=shader-hooks.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/** Extracts information from shader source code */\nexport function getShaderInfo(source, defaultName) {\n    return {\n        name: getShaderName(source, defaultName),\n        language: 'glsl',\n        version: getShaderVersion(source)\n    };\n}\n/** Extracts GLSLIFY style naming of shaders: `#define SHADER_NAME ...` */\nfunction getShaderName(shader, defaultName = 'unnamed') {\n    const SHADER_NAME_REGEXP = /#define[^\\S\\r\\n]*SHADER_NAME[^\\S\\r\\n]*([A-Za-z0-9_-]+)\\s*/;\n    const match = SHADER_NAME_REGEXP.exec(shader);\n    return match ? match[1] : defaultName;\n}\n/** returns GLSL shader version of given shader string */\nfunction getShaderVersion(source) {\n    let version = 100;\n    const words = source.match(/[^\\s]+/g);\n    if (words && words.length >= 2 && words[0] === '#version') {\n        const parsedVersion = parseInt(words[1], 10);\n        if (Number.isFinite(parsedVersion)) {\n            version = parsedVersion;\n        }\n    }\n    if (version !== 100 && version !== 300) {\n        throw new Error(`Invalid GLSL version ${version}`);\n    }\n    return version;\n}\n//# sourceMappingURL=get-shader-info.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { getShaderModuleDependencies } from \"../shader-module/shader-module-dependencies.js\";\nimport { getPlatformShaderDefines } from \"./platform-defines.js\";\nimport { injectShader, DECLARATION_INJECT_MARKER } from \"./shader-injections.js\";\nimport { transpileGLSLShader } from \"../shader-transpiler/transpile-glsl-shader.js\";\nimport { checkShaderModuleDeprecations } from \"../shader-module/shader-module.js\";\nimport { normalizeShaderHooks, getShaderHooks } from \"./shader-hooks.js\";\nimport { assert } from \"../utils/assert.js\";\nimport { getShaderInfo } from \"../glsl-utils/get-shader-info.js\";\nconst INJECT_SHADER_DECLARATIONS = `\\n\\n${DECLARATION_INJECT_MARKER}\\n`;\n/**\n * Precision prologue to inject before functions are injected in shader\n * TODO - extract any existing prologue in the fragment source and move it up...\n */\nconst FRAGMENT_SHADER_PROLOGUE = /* glsl */ `\\\nprecision highp float;\n`;\n/**\n * Inject a list of shader modules into a single shader source for WGSL\n */\nexport function assembleWGSLShader(options) {\n    const modules = getShaderModuleDependencies(options.modules || []);\n    return {\n        source: assembleShaderWGSL(options.platformInfo, {\n            ...options,\n            source: options.source,\n            stage: 'vertex',\n            modules\n        }),\n        getUniforms: assembleGetUniforms(modules)\n    };\n}\n/**\n * Injects dependent shader module sources into pair of main vertex/fragment shader sources for GLSL\n */\nexport function assembleGLSLShaderPair(options) {\n    const { vs, fs } = options;\n    const modules = getShaderModuleDependencies(options.modules || []);\n    return {\n        vs: assembleShaderGLSL(options.platformInfo, {\n            ...options,\n            source: vs,\n            stage: 'vertex',\n            modules\n        }),\n        fs: assembleShaderGLSL(options.platformInfo, {\n            ...options,\n            // @ts-expect-error\n            source: fs,\n            stage: 'fragment',\n            modules\n        }),\n        getUniforms: assembleGetUniforms(modules)\n    };\n}\n/**\n * Pulls together complete source code for either a vertex or a fragment shader\n * adding prologues, requested module chunks, and any final injections.\n * @param gl\n * @param options\n * @returns\n */\nexport function assembleShaderWGSL(platformInfo, options) {\n    const { \n    // id,\n    source, stage, modules, \n    // defines = {},\n    hookFunctions = [], inject = {}, log } = options;\n    assert(typeof source === 'string', 'shader source must be a string');\n    // const isVertex = type === 'vs';\n    // const sourceLines = source.split('\\n');\n    const coreSource = source;\n    // Combine Module and Application Defines\n    // const allDefines = {};\n    // modules.forEach(module => {\n    //   Object.assign(allDefines, module.getDefines());\n    // });\n    // Object.assign(allDefines, defines);\n    // Add platform defines (use these to work around platform-specific bugs and limitations)\n    // Add common defines (GLSL version compatibility, feature detection)\n    // Add precision declaration for fragment shaders\n    let assembledSource = '';\n    //   prologue\n    //     ? `\\\n    // ${getShaderNameDefine({id, source, type})}\n    // ${getShaderType(type)}\n    // ${getPlatformShaderDefines(platformInfo)}\n    // ${getApplicationDefines(allDefines)}\n    // ${isVertex ? '' : FRAGMENT_SHADER_PROLOGUE}\n    // `\n    // `;\n    const hookFunctionMap = normalizeShaderHooks(hookFunctions);\n    // Add source of dependent modules in resolved order\n    const hookInjections = {};\n    const declInjections = {};\n    const mainInjections = {};\n    for (const key in inject) {\n        const injection = typeof inject[key] === 'string' ? { injection: inject[key], order: 0 } : inject[key];\n        const match = /^(v|f)s:(#)?([\\w-]+)$/.exec(key);\n        if (match) {\n            const hash = match[2];\n            const name = match[3];\n            if (hash) {\n                if (name === 'decl') {\n                    declInjections[key] = [injection];\n                }\n                else {\n                    mainInjections[key] = [injection];\n                }\n            }\n            else {\n                hookInjections[key] = [injection];\n            }\n        }\n        else {\n            // Regex injection\n            mainInjections[key] = [injection];\n        }\n    }\n    // TODO - hack until shadertool modules support WebGPU\n    const modulesToInject = modules;\n    for (const module of modulesToInject) {\n        if (log) {\n            checkShaderModuleDeprecations(module, coreSource, log);\n        }\n        const moduleSource = getShaderModuleSource(module, 'wgsl');\n        // Add the module source, and a #define that declares it presence\n        assembledSource += moduleSource;\n        const injections = module.injections?.[stage] || {};\n        for (const key in injections) {\n            const match = /^(v|f)s:#([\\w-]+)$/.exec(key);\n            if (match) {\n                const name = match[2];\n                const injectionType = name === 'decl' ? declInjections : mainInjections;\n                injectionType[key] = injectionType[key] || [];\n                injectionType[key].push(injections[key]);\n            }\n            else {\n                hookInjections[key] = hookInjections[key] || [];\n                hookInjections[key].push(injections[key]);\n            }\n        }\n    }\n    // For injectShader\n    assembledSource += INJECT_SHADER_DECLARATIONS;\n    assembledSource = injectShader(assembledSource, stage, declInjections);\n    assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);\n    // Add the version directive and actual source of this shader\n    assembledSource += coreSource;\n    // Apply any requested shader injections\n    assembledSource = injectShader(assembledSource, stage, mainInjections);\n    return assembledSource;\n}\n/**\n * Pulls together complete source code for either a vertex or a fragment shader\n * adding prologues, requested module chunks, and any final injections.\n * @param gl\n * @param options\n * @returns\n */\nfunction assembleShaderGLSL(platformInfo, options) {\n    const { source, stage, language = 'glsl', modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log } = options;\n    assert(typeof source === 'string', 'shader source must be a string');\n    const sourceVersion = language === 'glsl' ? getShaderInfo(source).version : -1;\n    const targetVersion = platformInfo.shaderLanguageVersion;\n    const sourceVersionDirective = sourceVersion === 100 ? '#version 100' : '#version 300 es';\n    const sourceLines = source.split('\\n');\n    // TODO : keep all pre-processor statements at the beginning of the shader.\n    const coreSource = sourceLines.slice(1).join('\\n');\n    // Combine Module and Application Defines\n    const allDefines = {};\n    modules.forEach(module => {\n        Object.assign(allDefines, module.defines);\n    });\n    Object.assign(allDefines, defines);\n    // Add platform defines (use these to work around platform-specific bugs and limitations)\n    // Add common defines (GLSL version compatibility, feature detection)\n    // Add precision declaration for fragment shaders\n    let assembledSource = '';\n    switch (language) {\n        case 'wgsl':\n            break;\n        case 'glsl':\n            assembledSource = prologue\n                ? `\\\n${sourceVersionDirective}\n\n// ----- PROLOGUE -------------------------\n${`#define SHADER_TYPE_${stage.toUpperCase()}`}\n\n${getPlatformShaderDefines(platformInfo)}\n${stage === 'fragment' ? FRAGMENT_SHADER_PROLOGUE : ''}\n\n// ----- APPLICATION DEFINES -------------------------\n\n${getApplicationDefines(allDefines)}\n\n`\n                : `${sourceVersionDirective}\n`;\n            break;\n    }\n    const hookFunctionMap = normalizeShaderHooks(hookFunctions);\n    // Add source of dependent modules in resolved order\n    const hookInjections = {};\n    const declInjections = {};\n    const mainInjections = {};\n    for (const key in inject) {\n        const injection = typeof inject[key] === 'string' ? { injection: inject[key], order: 0 } : inject[key];\n        const match = /^(v|f)s:(#)?([\\w-]+)$/.exec(key);\n        if (match) {\n            const hash = match[2];\n            const name = match[3];\n            if (hash) {\n                if (name === 'decl') {\n                    declInjections[key] = [injection];\n                }\n                else {\n                    mainInjections[key] = [injection];\n                }\n            }\n            else {\n                hookInjections[key] = [injection];\n            }\n        }\n        else {\n            // Regex injection\n            mainInjections[key] = [injection];\n        }\n    }\n    for (const module of modules) {\n        if (log) {\n            checkShaderModuleDeprecations(module, coreSource, log);\n        }\n        const moduleSource = getShaderModuleSource(module, stage);\n        // Add the module source, and a #define that declares it presence\n        assembledSource += moduleSource;\n        const injections = module.instance?.normalizedInjections[stage] || {};\n        for (const key in injections) {\n            const match = /^(v|f)s:#([\\w-]+)$/.exec(key);\n            if (match) {\n                const name = match[2];\n                const injectionType = name === 'decl' ? declInjections : mainInjections;\n                injectionType[key] = injectionType[key] || [];\n                injectionType[key].push(injections[key]);\n            }\n            else {\n                hookInjections[key] = hookInjections[key] || [];\n                hookInjections[key].push(injections[key]);\n            }\n        }\n    }\n    assembledSource += '// ----- MAIN SHADER SOURCE -------------------------';\n    // For injectShader\n    assembledSource += INJECT_SHADER_DECLARATIONS;\n    assembledSource = injectShader(assembledSource, stage, declInjections);\n    assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);\n    // Add the version directive and actual source of this shader\n    assembledSource += coreSource;\n    // Apply any requested shader injections\n    assembledSource = injectShader(assembledSource, stage, mainInjections);\n    if (language === 'glsl' && sourceVersion !== targetVersion) {\n        assembledSource = transpileGLSLShader(assembledSource, stage);\n    }\n    return assembledSource.trim();\n}\n/**\n * Returns a combined `getUniforms` covering the options for all the modules,\n * the created function will pass on options to the inidividual `getUniforms`\n * function of each shader module and combine the results into one object that\n * can be passed to setUniforms.\n * @param modules\n * @returns\n */\nexport function assembleGetUniforms(modules) {\n    return function getUniforms(opts) {\n        const uniforms = {};\n        for (const module of modules) {\n            // `modules` is already sorted by dependency level. This guarantees that\n            // modules have access to the uniforms that are generated by their dependencies.\n            const moduleUniforms = module.getUniforms?.(opts, uniforms);\n            Object.assign(uniforms, moduleUniforms);\n        }\n        return uniforms;\n    };\n}\n/**\n * NOTE: Removed as id injection defeated caching of shaders\n *\n * Generate \"glslify-compatible\" SHADER_NAME defines\n * These are understood by the GLSL error parsing function\n * If id is provided and no SHADER_NAME constant is present in source, create one\n unction getShaderNameDefine(options: {\n  id?: string;\n  source: string;\n  stage: 'vertex' | 'fragment';\n}): string {\n  const {id, source, stage} = options;\n  const injectShaderName = id && source.indexOf('SHADER_NAME') === -1;\n  return injectShaderName\n    ? `\n#define SHADER_NAME ${id}_${stage}`\n    : '';\n}\n*/\n/** Generates application defines from an object of key value pairs */\nfunction getApplicationDefines(defines = {}) {\n    let sourceText = '';\n    for (const define in defines) {\n        const value = defines[define];\n        if (value || Number.isFinite(value)) {\n            sourceText += `#define ${define.toUpperCase()} ${defines[define]}\\n`;\n        }\n    }\n    return sourceText;\n}\n/** Extracts the source code chunk for the specified shader type from the named shader module */\nexport function getShaderModuleSource(module, stage) {\n    let moduleSource;\n    switch (stage) {\n        case 'vertex':\n            moduleSource = module.vs || '';\n            break;\n        case 'fragment':\n            moduleSource = module.fs || '';\n            break;\n        case 'wgsl':\n            moduleSource = module.source || '';\n            break;\n        default:\n            assert(false);\n    }\n    if (!module.name) {\n        throw new Error('Shader module must have a name');\n    }\n    const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, '_');\n    let source = `\\\n// ----- MODULE ${module.name} ---------------\n\n`;\n    if (stage !== 'wgsl') {\n        source += `#define MODULE_${moduleName}\\n`;\n    }\n    source += `${moduleSource}\\n`;\n    return source;\n}\n/*\nfunction getHookFunctions(\n  hookFunctions: Record<string, HookFunction>,\n  hookInjections: Record<string, Injection[]>\n): string {\n  let result = '';\n  for (const hookName in hookFunctions) {\n    const hookFunction = hookFunctions[hookName];\n    result += `void ${hookFunction.signature} {\\n`;\n    if (hookFunction.header) {\n      result += `  ${hookFunction.header}`;\n    }\n    if (hookInjections[hookName]) {\n      const injections = hookInjections[hookName];\n      injections.sort((a: {order: number}, b: {order: number}): number => a.order - b.order);\n      for (const injection of injections) {\n        result += `  ${injection.injection}\\n`;\n      }\n    }\n    if (hookFunction.footer) {\n      result += `  ${hookFunction.footer}`;\n    }\n    result += '}\\n';\n  }\n\n  return result;\n}\n\nfunction normalizeHookFunctions(hookFunctions: (string | HookFunction)[]): {\n  vs: Record<string, HookFunction>;\n  fs: Record<string, HookFunction>;\n} {\n  const result: {vs: Record<string, any>; fs: Record<string, any>} = {\n    vs: {},\n    fs: {}\n  };\n\n  hookFunctions.forEach((hookFunction: string | HookFunction) => {\n    let opts: HookFunction;\n    let hook: string;\n    if (typeof hookFunction !== 'string') {\n      opts = hookFunction;\n      hook = opts.hook;\n    } else {\n      opts = {} as HookFunction;\n      hook = hookFunction;\n    }\n    hook = hook.trim();\n    const [stage, signature] = hook.split(':');\n    const name = hook.replace(/\\(.+/, '');\n    if (stage !== 'vs' && stage !== 'fs') {\n      throw new Error(stage);\n    }\n    result[stage][name] = Object.assign(opts, {signature});\n  });\n\n  return result;\n}\n*/\n//# sourceMappingURL=assemble-shaders.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst IFDEF_REGEXP = /^\\s*\\#\\s*ifdef\\s*([a-zA-Z_]+)\\s*$/;\nconst ENDIF_REGEXP = /^\\s*\\#\\s*endif\\s*$/;\nexport function preprocess(source, options) {\n    const lines = source.split('\\n');\n    const output = [];\n    let conditional = true;\n    let currentDefine = null;\n    for (const line of lines) {\n        const matchIf = line.match(IFDEF_REGEXP);\n        const matchEnd = line.match(ENDIF_REGEXP);\n        if (matchIf) {\n            currentDefine = matchIf[1];\n            conditional = Boolean(options?.defines?.[currentDefine]);\n        }\n        else if (matchEnd) {\n            conditional = true;\n        }\n        else if (conditional) {\n            output.push(line);\n        }\n    }\n    return output.join('\\n');\n}\n//# sourceMappingURL=preprocessor.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { initializeShaderModules } from \"./shader-module/shader-module.js\";\nimport { assembleWGSLShader, assembleGLSLShaderPair } from \"./shader-assembly/assemble-shaders.js\";\nimport { preprocess } from \"./preprocessor/preprocessor.js\";\n/**\n * A stateful version of `assembleShaders` that can be used to assemble shaders.\n * Supports setting of default modules and hooks.\n */\nexport class ShaderAssembler {\n    /** Default ShaderAssembler instance */\n    static defaultShaderAssembler;\n    /** Hook functions */\n    _hookFunctions = [];\n    /** Shader modules */\n    _defaultModules = [];\n    /**\n     * A default shader assembler instance - the natural place to register default modules and hooks\n     * @returns\n     */\n    static getDefaultShaderAssembler() {\n        ShaderAssembler.defaultShaderAssembler =\n            ShaderAssembler.defaultShaderAssembler || new ShaderAssembler();\n        return ShaderAssembler.defaultShaderAssembler;\n    }\n    /**\n     * Add a default module that does not have to be provided with every call to assembleShaders()\n     */\n    addDefaultModule(module) {\n        if (!this._defaultModules.find(m => m.name === (typeof module === 'string' ? module : module.name))) {\n            this._defaultModules.push(module);\n        }\n    }\n    /**\n     * Remove a default module\n     */\n    removeDefaultModule(module) {\n        const moduleName = typeof module === 'string' ? module : module.name;\n        this._defaultModules = this._defaultModules.filter(m => m.name !== moduleName);\n    }\n    /**\n     * Register a shader hook\n     * @param hook\n     * @param opts\n     */\n    addShaderHook(hook, opts) {\n        if (opts) {\n            hook = Object.assign(opts, { hook });\n        }\n        this._hookFunctions.push(hook);\n    }\n    /**\n     * Assemble a WGSL unified shader\n     * @param platformInfo\n     * @param props\n     * @returns\n     */\n    assembleWGSLShader(props) {\n        const modules = this._getModuleList(props.modules); // Combine with default modules\n        const hookFunctions = this._hookFunctions; // TODO - combine with default hook functions\n        const { source, getUniforms } = assembleWGSLShader({\n            ...props,\n            // @ts-expect-error\n            source: props.source,\n            modules,\n            hookFunctions\n        });\n        // WGSL does not have built-in preprocessing support (just compile time constants)\n        const preprocessedSource = props.platformInfo.shaderLanguage === 'wgsl' ? preprocess(source) : source;\n        return { source: preprocessedSource, getUniforms, modules };\n    }\n    /**\n     * Assemble a pair of shaders into a single shader program\n     * @param platformInfo\n     * @param props\n     * @returns\n     */\n    assembleGLSLShaderPair(props) {\n        const modules = this._getModuleList(props.modules); // Combine with default modules\n        const hookFunctions = this._hookFunctions; // TODO - combine with default hook functions\n        const assembled = assembleGLSLShaderPair({\n            ...props,\n            // @ts-expect-error\n            vs: props.vs,\n            // @ts-expect-error\n            fs: props.fs,\n            modules,\n            hookFunctions\n        });\n        return { ...assembled, modules };\n    }\n    /**\n     * Dedupe and combine with default modules\n     */\n    _getModuleList(appModules = []) {\n        const modules = new Array(this._defaultModules.length + appModules.length);\n        const seen = {};\n        let count = 0;\n        for (let i = 0, len = this._defaultModules.length; i < len; ++i) {\n            const module = this._defaultModules[i];\n            const name = module.name;\n            modules[count++] = module;\n            seen[name] = true;\n        }\n        for (let i = 0, len = appModules.length; i < len; ++i) {\n            const module = appModules[i];\n            const name = module.name;\n            if (!seen[name]) {\n                modules[count++] = module;\n                seen[name] = true;\n            }\n        }\n        modules.length = count;\n        initializeShaderModules(modules);\n        return modules;\n    }\n}\n//# sourceMappingURL=shader-assembler.js.map","// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// import {ShaderModule} from '../../types';\nconst fp32shader = /* glsl */ `\\\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n\n// All these functions are for substituting tan() function from Intel GPU only\nconst float TWO_PI = 6.2831854820251465;\nconst float PI_2 = 1.5707963705062866;\nconst float PI_16 = 0.1963495463132858;\n\nconst float SIN_TABLE_0 = 0.19509032368659973;\nconst float SIN_TABLE_1 = 0.3826834261417389;\nconst float SIN_TABLE_2 = 0.5555702447891235;\nconst float SIN_TABLE_3 = 0.7071067690849304;\n\nconst float COS_TABLE_0 = 0.9807852506637573;\nconst float COS_TABLE_1 = 0.9238795042037964;\nconst float COS_TABLE_2 = 0.8314695954322815;\nconst float COS_TABLE_3 = 0.7071067690849304;\n\nconst float INVERSE_FACTORIAL_3 = 1.666666716337204e-01; // 1/3!\nconst float INVERSE_FACTORIAL_5 = 8.333333767950535e-03; // 1/5!\nconst float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04; // 1/7!\nconst float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06; // 1/9!\n\nfloat sin_taylor_fp32(float a) {\n  float r, s, t, x;\n\n  if (a == 0.0) {\n    return 0.0;\n  }\n\n  x = -a * a;\n  s = a;\n  r = a;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_3;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_5;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_7;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_9;\n  s = s + t;\n\n  return s;\n}\n\nvoid sincos_taylor_fp32(float a, out float sin_t, out float cos_t) {\n  if (a == 0.0) {\n    sin_t = 0.0;\n    cos_t = 1.0;\n  }\n  sin_t = sin_taylor_fp32(a);\n  cos_t = sqrt(1.0 - sin_t * sin_t);\n}\n\nfloat tan_taylor_fp32(float a) {\n    float sin_a;\n    float cos_a;\n\n    if (a == 0.0) {\n        return 0.0;\n    }\n\n    // 2pi range reduction\n    float z = floor(a / TWO_PI);\n    float r = a - TWO_PI * z;\n\n    float t;\n    float q = floor(r / PI_2 + 0.5);\n    int j = int(q);\n\n    if (j < -2 || j > 2) {\n        return 1.0 / 0.0;\n    }\n\n    t = r - PI_2 * q;\n\n    q = floor(t / PI_16 + 0.5);\n    int k = int(q);\n    int abs_k = int(abs(float(k)));\n\n    if (abs_k > 4) {\n        return 1.0 / 0.0;\n    } else {\n        t = t - PI_16 * q;\n    }\n\n    float u = 0.0;\n    float v = 0.0;\n\n    float sin_t, cos_t;\n    float s, c;\n    sincos_taylor_fp32(t, sin_t, cos_t);\n\n    if (k == 0) {\n        s = sin_t;\n        c = cos_t;\n    } else {\n        if (abs(float(abs_k) - 1.0) < 0.5) {\n            u = COS_TABLE_0;\n            v = SIN_TABLE_0;\n        } else if (abs(float(abs_k) - 2.0) < 0.5) {\n            u = COS_TABLE_1;\n            v = SIN_TABLE_1;\n        } else if (abs(float(abs_k) - 3.0) < 0.5) {\n            u = COS_TABLE_2;\n            v = SIN_TABLE_2;\n        } else if (abs(float(abs_k) - 4.0) < 0.5) {\n            u = COS_TABLE_3;\n            v = SIN_TABLE_3;\n        }\n        if (k > 0) {\n            s = u * sin_t + v * cos_t;\n            c = u * cos_t - v * sin_t;\n        } else {\n            s = u * sin_t - v * cos_t;\n            c = u * cos_t + v * sin_t;\n        }\n    }\n\n    if (j == 0) {\n        sin_a = s;\n        cos_a = c;\n    } else if (j == 1) {\n        sin_a = c;\n        cos_a = -s;\n    } else if (j == -1) {\n        sin_a = -c;\n        cos_a = s;\n    } else {\n        sin_a = -s;\n        cos_a = -c;\n    }\n    return sin_a / cos_a;\n}\n#endif\n\nfloat tan_fp32(float a) {\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n  return tan_taylor_fp32(a);\n#else\n  return tan(a);\n#endif\n}\n`;\n/**\n * 32 bit math library (fixups for GPUs)\n */\nexport const fp32 = {\n    name: 'fp32',\n    vs: fp32shader\n};\n//# sourceMappingURL=fp32.js.map","// deck.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst source = /* wgsl */ `\\\nconst SMOOTH_EDGE_RADIUS: f32 = 0.5;\n\nstruct VertexGeometry {\n  position: vec4<f32>,\n  worldPosition: vec3<f32>,\n  worldPositionAlt: vec3<f32>,\n  normal: vec3<f32>,\n  uv: vec2<f32>,\n  pickingColor: vec3<f32>,\n};\n\nvar<private> geometry_: VertexGeometry = VertexGeometry(\n  vec4<f32>(0.0, 0.0, 1.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec2<f32>(0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0)\n);\n\nstruct FragmentGeometry {\n  uv: vec2<f32>,\n};\n\nvar<private> fragmentGeometry: FragmentGeometry;\n\nfn smoothedge(edge: f32, x: f32) -> f32 {\n  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n`;\nconst defines = '#define SMOOTH_EDGE_RADIUS 0.5';\nconst vs = /* glsl */ `\\\n${defines}\n\nstruct VertexGeometry {\n  vec4 position;\n  vec3 worldPosition;\n  vec3 worldPositionAlt;\n  vec3 normal;\n  vec2 uv;\n  vec3 pickingColor;\n} geometry = VertexGeometry(\n  vec4(0.0, 0.0, 1.0, 0.0),\n  vec3(0.0),\n  vec3(0.0),\n  vec3(0.0),\n  vec2(0.0),\n  vec3(0.0)\n);\n`;\nconst fs = /* glsl */ `\\\n${defines}\n\nstruct FragmentGeometry {\n  vec2 uv;\n} geometry;\n\nfloat smoothedge(float edge, float x) {\n  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n`;\nexport default {\n    name: 'geometry',\n    source,\n    vs,\n    fs\n};\n//# sourceMappingURL=geometry.js.map","// deck.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nfunction isEqual(a, b) {\n    if (a === b) {\n        return true;\n    }\n    if (Array.isArray(a)) {\n        // Special treatment for arrays: compare 1-level deep\n        // This is to support equality of matrix/coordinate props\n        const len = a.length;\n        if (!b || b.length !== len) {\n            return false;\n        }\n        for (let i = 0; i < len; i++) {\n            if (a[i] !== b[i]) {\n                return false;\n            }\n        }\n        return true;\n    }\n    return false;\n}\n/**\n * Speed up consecutive function calls by caching the result of calls with identical input\n * https://en.wikipedia.org/wiki/Memoization\n * @param {function} compute - the function to be memoized\n */\nexport default function memoize(compute) {\n    let cachedArgs = {};\n    let cachedResult;\n    return (args) => {\n        for (const key in args) {\n            if (!isEqual(args[key], cachedArgs[key])) {\n                cachedResult = compute(args);\n                cachedArgs = args;\n                break;\n            }\n        }\n        return cachedResult;\n    };\n}\n//# sourceMappingURL=memoize.js.map","// deck.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/* eslint-disable complexity, camelcase */\nimport { mat4, vec4 } from '@math.gl/core';\nimport { COORDINATE_SYSTEM, PROJECTION_MODE } from \"../../lib/constants.js\";\nimport memoize from \"../../utils/memoize.js\";\n// To quickly set a vector to zero\nconst ZERO_VECTOR = [0, 0, 0, 0];\n// 4x4 matrix that drops 4th component of vector\nconst VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];\nconst IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\nconst DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0];\nconst DEFAULT_COORDINATE_ORIGIN = [0, 0, 0];\nconst getMemoizedViewportUniforms = memoize(calculateViewportUniforms);\nexport function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_COORDINATE_ORIGIN) {\n    if (coordinateOrigin.length < 3) {\n        coordinateOrigin = [coordinateOrigin[0], coordinateOrigin[1], 0];\n    }\n    let shaderCoordinateOrigin = coordinateOrigin;\n    let geospatialOrigin;\n    let offsetMode = true;\n    if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT_OFFSETS ||\n        coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) {\n        geospatialOrigin = coordinateOrigin;\n    }\n    else {\n        geospatialOrigin = viewport.isGeospatial\n            ? // @ts-expect-error longitude and latitude are not defined on the base Viewport, but is expected on geospatial viewports\n                [Math.fround(viewport.longitude), Math.fround(viewport.latitude), 0]\n            : null;\n    }\n    switch (viewport.projectionMode) {\n        case PROJECTION_MODE.WEB_MERCATOR:\n            if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT ||\n                coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) {\n                geospatialOrigin = [0, 0, 0];\n                offsetMode = false;\n            }\n            break;\n        case PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET:\n            if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) {\n                // viewport center in world space\n                // @ts-expect-error when using LNGLAT coordinates, we expect the viewport to be geospatial, in which case geospatialOrigin is defined\n                shaderCoordinateOrigin = geospatialOrigin;\n            }\n            else if (coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) {\n                // viewport center in common space\n                shaderCoordinateOrigin = [\n                    Math.fround(viewport.center[0]),\n                    Math.fround(viewport.center[1]),\n                    0\n                ];\n                // Geospatial origin (wgs84) must match shaderCoordinateOrigin (common)\n                geospatialOrigin = viewport.unprojectPosition(shaderCoordinateOrigin);\n                shaderCoordinateOrigin[0] -= coordinateOrigin[0];\n                shaderCoordinateOrigin[1] -= coordinateOrigin[1];\n                shaderCoordinateOrigin[2] -= coordinateOrigin[2];\n            }\n            break;\n        case PROJECTION_MODE.IDENTITY:\n            shaderCoordinateOrigin = viewport.position.map(Math.fround);\n            shaderCoordinateOrigin[2] = shaderCoordinateOrigin[2] || 0;\n            break;\n        case PROJECTION_MODE.GLOBE:\n            offsetMode = false;\n            geospatialOrigin = null;\n            break;\n        default:\n            // Unknown projection mode\n            offsetMode = false;\n    }\n    return { geospatialOrigin, shaderCoordinateOrigin, offsetMode };\n}\n// The code that utilizes Matrix4 does the same calculation as their mat4 counterparts,\n// has lower performance but provides error checking.\nfunction calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin) {\n    const { viewMatrixUncentered, projectionMatrix } = viewport;\n    let { viewMatrix, viewProjectionMatrix } = viewport;\n    let projectionCenter = ZERO_VECTOR;\n    let originCommon = ZERO_VECTOR;\n    let cameraPosCommon = viewport.cameraPosition;\n    const { geospatialOrigin, shaderCoordinateOrigin, offsetMode } = getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin);\n    if (offsetMode) {\n        // Calculate transformed projectionCenter (using 64 bit precision JS)\n        // This is the key to offset mode precision\n        // (avoids doing this addition in 32 bit precision in GLSL)\n        // @ts-expect-error the 4th component is assigned below\n        originCommon = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin);\n        cameraPosCommon = [\n            cameraPosCommon[0] - originCommon[0],\n            cameraPosCommon[1] - originCommon[1],\n            cameraPosCommon[2] - originCommon[2]\n        ];\n        originCommon[3] = 1;\n        // projectionCenter = new Matrix4(viewProjectionMatrix)\n        //   .transformVector([positionPixels[0], positionPixels[1], 0.0, 1.0]);\n        projectionCenter = vec4.transformMat4([], originCommon, viewProjectionMatrix);\n        // Always apply uncentered projection matrix if available (shader adds center)\n        viewMatrix = viewMatrixUncentered || viewMatrix;\n        // Zero out 4th coordinate (\"after\" model matrix) - avoids further translations\n        // viewMatrix = new Matrix4(viewMatrixUncentered || viewMatrix)\n        //   .multiplyRight(VECTOR_TO_POINT_MATRIX);\n        viewProjectionMatrix = mat4.multiply([], projectionMatrix, viewMatrix);\n        viewProjectionMatrix = mat4.multiply([], viewProjectionMatrix, VECTOR_TO_POINT_MATRIX);\n    }\n    return {\n        viewMatrix: viewMatrix,\n        viewProjectionMatrix: viewProjectionMatrix,\n        projectionCenter,\n        originCommon,\n        cameraPosCommon,\n        shaderCoordinateOrigin,\n        geospatialOrigin\n    };\n}\n/**\n * Returns uniforms for shaders based on current projection\n * includes: projection matrix suitable for shaders\n *\n * TODO - Ensure this works with any viewport, not just WebMercatorViewports\n *\n * @param {WebMercatorViewport} viewport -\n * @return {Float32Array} - 4x4 projection matrix that can be used in shaders\n */\nexport function getUniformsFromViewport({ viewport, devicePixelRatio = 1, modelMatrix = null, \n// Match Layer.defaultProps\ncoordinateSystem = COORDINATE_SYSTEM.DEFAULT, coordinateOrigin = DEFAULT_COORDINATE_ORIGIN, autoWrapLongitude = false }) {\n    if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) {\n        coordinateSystem = viewport.isGeospatial\n            ? COORDINATE_SYSTEM.LNGLAT\n            : COORDINATE_SYSTEM.CARTESIAN;\n    }\n    const uniforms = getMemoizedViewportUniforms({\n        viewport,\n        devicePixelRatio,\n        coordinateSystem,\n        coordinateOrigin\n    });\n    uniforms.wrapLongitude = autoWrapLongitude;\n    uniforms.modelMatrix = modelMatrix || IDENTITY_MATRIX;\n    return uniforms;\n}\nfunction calculateViewportUniforms({ viewport, devicePixelRatio, coordinateSystem, coordinateOrigin }) {\n    const { projectionCenter, viewProjectionMatrix, originCommon, cameraPosCommon, shaderCoordinateOrigin, geospatialOrigin } = calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin);\n    // Calculate projection pixels per unit\n    const distanceScales = viewport.getDistanceScales();\n    const viewportSize = [\n        viewport.width * devicePixelRatio,\n        viewport.height * devicePixelRatio\n    ];\n    // Distance at which screen pixels are projected.\n    // Used to scale sizes in clipspace to match screen pixels.\n    // When using Viewport class's default projection matrix, this yields 1 for orthographic\n    // and `viewport.focalDistance` for perspective views\n    const focalDistance = vec4.transformMat4([], [0, 0, -viewport.focalDistance, 1], viewport.projectionMatrix)[3] || 1;\n    const uniforms = {\n        // Projection mode values\n        coordinateSystem,\n        projectionMode: viewport.projectionMode,\n        coordinateOrigin: shaderCoordinateOrigin,\n        commonOrigin: originCommon.slice(0, 3),\n        center: projectionCenter,\n        // Backward compatibility\n        // TODO: remove in v9\n        // @ts-expect-error _pseudoMeters is only defined on WebMercator viewport\n        pseudoMeters: Boolean(viewport._pseudoMeters),\n        // Screen size\n        viewportSize,\n        devicePixelRatio,\n        focalDistance,\n        commonUnitsPerMeter: distanceScales.unitsPerMeter,\n        commonUnitsPerWorldUnit: distanceScales.unitsPerMeter,\n        commonUnitsPerWorldUnit2: DEFAULT_PIXELS_PER_UNIT2,\n        scale: viewport.scale, // This is the mercator scale (2 ** zoom)\n        wrapLongitude: false,\n        viewProjectionMatrix,\n        modelMatrix: IDENTITY_MATRIX,\n        // This is for lighting calculations\n        cameraPosition: cameraPosCommon\n    };\n    if (geospatialOrigin) {\n        // Get high-precision DistanceScales from geospatial viewport\n        // TODO: stricter types in Viewport classes\n        const distanceScalesAtOrigin = viewport.getDistanceScales(geospatialOrigin);\n        switch (coordinateSystem) {\n            case COORDINATE_SYSTEM.METER_OFFSETS:\n                uniforms.commonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerMeter;\n                uniforms.commonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerMeter2;\n                break;\n            case COORDINATE_SYSTEM.LNGLAT:\n            case COORDINATE_SYSTEM.LNGLAT_OFFSETS:\n                // @ts-expect-error _pseudoMeters only exists on WebMercatorView\n                if (!viewport._pseudoMeters) {\n                    uniforms.commonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter;\n                }\n                uniforms.commonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerDegree;\n                uniforms.commonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerDegree2;\n                break;\n            // a.k.a \"preprojected\" positions\n            case COORDINATE_SYSTEM.CARTESIAN:\n                uniforms.commonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]];\n                uniforms.commonUnitsPerWorldUnit2 = [0, 0, distanceScalesAtOrigin.unitsPerMeter2[2]];\n                break;\n            default:\n                break;\n        }\n    }\n    return uniforms;\n}\n//# sourceMappingURL=viewport-uniforms.js.map","// deck.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { COORDINATE_SYSTEM, PROJECTION_MODE, UNIT } from \"../../lib/constants.js\";\n// We are generating these from the js code in constants.js\nconst COORDINATE_SYSTEM_WGSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM)\n    .map(key => `const COORDINATE_SYSTEM_${key}: i32 = ${COORDINATE_SYSTEM[key]};`)\n    .join('');\nconst PROJECTION_MODE_WGSL_CONSTANTS = Object.keys(PROJECTION_MODE)\n    .map(key => `const PROJECTION_MODE_${key}: i32 = ${PROJECTION_MODE[key]};`)\n    .join('');\nconst UNIT_WGSL_CONSTANTS = Object.keys(UNIT)\n    .map(key => `const UNIT_${key.toUpperCase()}: i32 = ${UNIT[key]};`)\n    .join('');\nexport const projectWGSLHeader = /* wgsl */ `\\\n${COORDINATE_SYSTEM_WGSL_CONSTANTS}\n${PROJECTION_MODE_WGSL_CONSTANTS}\n${UNIT_WGSL_CONSTANTS}\n\nconst TILE_SIZE: f32 = 512.0;\nconst PI: f32 = 3.1415926536;\nconst WORLD_SCALE: f32 = TILE_SIZE / (PI * 2.0);\nconst ZERO_64_LOW: vec3<f32> = vec3<f32>(0.0, 0.0, 0.0);\nconst EARTH_RADIUS: f32 = 6370972.0; // meters\nconst GLOBE_RADIUS: f32 = 256.0;\n\n// -----------------------------------------------------------------------------\n// Uniform block (converted from GLSL uniform block)\n// -----------------------------------------------------------------------------\nstruct ProjectUniforms {\n  wrapLongitude: i32,\n  coordinateSystem: i32,\n  commonUnitsPerMeter: vec3<f32>,\n  projectionMode: i32,\n  scale: f32,\n  commonUnitsPerWorldUnit: vec3<f32>,\n  commonUnitsPerWorldUnit2: vec3<f32>,\n  center: vec4<f32>,\n  modelMatrix: mat4x4<f32>,\n  viewProjectionMatrix: mat4x4<f32>,\n  viewportSize: vec2<f32>,\n  devicePixelRatio: f32,\n  focalDistance: f32,\n  cameraPosition: vec3<f32>,\n  coordinateOrigin: vec3<f32>,\n  commonOrigin: vec3<f32>,\n  pseudoMeters: i32,\n};\n\n@group(0) @binding(0)\nvar<uniform> project: ProjectUniforms;\n\n// -----------------------------------------------------------------------------\n// Geometry data\n// (In your GLSL code, \"geometry\" was assumed to be available globally. In WGSL,\n// you might supply this via vertex attributes or a uniform. Here we define a\n// uniform struct for demonstration.)\n// -----------------------------------------------------------------------------\n\n// Structure to carry additional geometry data used by deck.gl filters.\nstruct Geometry {\n  worldPosition: vec3<f32>,\n  worldPositionAlt: vec3<f32>,\n  position: vec4<f32>,\n  normal: vec3<f32>,\n  uv: vec2<f32>,\n  pickingColor: vec3<f32>,\n};\n\n// @group(0) @binding(1)\nvar<private> geometry: Geometry;\n`;\nexport const projectWGSL = /* wgsl */ `\\\n${projectWGSLHeader}\n\n// -----------------------------------------------------------------------------\n// Functions\n// -----------------------------------------------------------------------------\n\n// Returns an adjustment factor for commonUnitsPerMeter\nfn _project_size_at_latitude(lat: f32) -> f32 {\n  let y = clamp(lat, -89.9, 89.9);\n  return 1.0 / cos(radians(y));\n}\n\n// Overloaded version: scales a value in meters at a given latitude.\nfn _project_size_at_latitude_m(meters: f32, lat: f32) -> f32 {\n  return meters * project.commonUnitsPerMeter.z * _project_size_at_latitude(lat);\n}\n\n// Computes a non-linear scale factor based on geometry.\n// (Note: This function relies on \"geometry\" being provided.)\nfn project_size() -> f32 {\n  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR &&\n      project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT &&\n      project.pseudoMeters == 0) {\n    if (geometry.position.w == 0.0) {\n      return _project_size_at_latitude(geometry.worldPosition.y);\n    }\n    let y: f32 = geometry.position.y / TILE_SIZE * 2.0 - 1.0;\n    let y2 = y * y;\n    let y4 = y2 * y2;\n    let y6 = y4 * y2;\n    return 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6;\n  }\n  return 1.0;\n}\n\n// Overloads to scale offsets (meters to world units)\nfn project_size_float(meters: f32) -> f32 {\n  return meters * project.commonUnitsPerMeter.z * project_size();\n}\n\nfn project_size_vec2(meters: vec2<f32>) -> vec2<f32> {\n  return meters * project.commonUnitsPerMeter.xy * project_size();\n}\n\nfn project_size_vec3(meters: vec3<f32>) -> vec3<f32> {\n  return meters * project.commonUnitsPerMeter * project_size();\n}\n\nfn project_size_vec4(meters: vec4<f32>) -> vec4<f32> {\n  return vec4<f32>(meters.xyz * project.commonUnitsPerMeter, meters.w);\n}\n\n// Returns a rotation matrix aligning the z‑axis with the given up vector.\nfn project_get_orientation_matrix(up: vec3<f32>) -> mat3x3<f32> {\n  let uz = normalize(up);\n  let ux = select(\n    vec3<f32>(1.0, 0.0, 0.0),\n    normalize(vec3<f32>(uz.y, -uz.x, 0.0)),\n    abs(uz.z) == 1.0\n  );\n  let uy = cross(uz, ux);\n  return mat3x3<f32>(ux, uy, uz);\n}\n\n// Since WGSL does not support \"out\" parameters, we return a struct.\nstruct RotationResult {\n  needsRotation: bool,\n  transform: mat3x3<f32>,\n};\n\nfn project_needs_rotation(commonPosition: vec3<f32>) -> RotationResult {\n  if (project.projectionMode == PROJECTION_MODE_GLOBE) {\n    return RotationResult(true, project_get_orientation_matrix(commonPosition));\n  } else {\n    return RotationResult(false, mat3x3<f32>());  // identity alternative if needed\n  };\n}\n\n// Projects a normal vector from the current coordinate system to world space.\nfn project_normal(vector: vec3<f32>) -> vec3<f32> {\n  let normal_modelspace = project.modelMatrix * vec4<f32>(vector, 0.0);\n  var n = normalize(normal_modelspace.xyz * project.commonUnitsPerMeter);\n  let rotResult = project_needs_rotation(geometry.position.xyz);\n  if (rotResult.needsRotation) {\n    n = rotResult.transform * n;\n  }\n  return n;\n}\n\n// Applies a scale offset based on y-offset (dy)\nfn project_offset_(offset: vec4<f32>) -> vec4<f32> {\n  let dy: f32 = offset.y;\n  let commonUnitsPerWorldUnit = project.commonUnitsPerWorldUnit + project.commonUnitsPerWorldUnit2 * dy;\n  return vec4<f32>(offset.xyz * commonUnitsPerWorldUnit, offset.w);\n}\n\n// Projects lng/lat coordinates to a unit tile [0,1]\nfn project_mercator_(lnglat: vec2<f32>) -> vec2<f32> {\n  var x = lnglat.x;\n  if (project.wrapLongitude != 0) {\n    x = ((x + 180.0) % 360.0) - 180.0;\n  }\n  let y = clamp(lnglat.y, -89.9, 89.9);\n  return vec2<f32>(\n    radians(x) + PI,\n    PI + log(tan(PI * 0.25 + radians(y) * 0.5))\n  ) * WORLD_SCALE;\n}\n\n// Projects lng/lat/z coordinates for a globe projection.\nfn project_globe_(lnglatz: vec3<f32>) -> vec3<f32> {\n  let lambda = radians(lnglatz.x);\n  let phi = radians(lnglatz.y);\n  let cosPhi = cos(phi);\n  let D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS;\n  return vec3<f32>(\n    sin(lambda) * cosPhi,\n    -cos(lambda) * cosPhi,\n    sin(phi)\n  ) * D;\n}\n\n// Projects positions (with an optional 64-bit low part) from the input\n// coordinate system to the common space.\nfn project_position_vec4_f64(position: vec4<f32>, position64Low: vec3<f32>) -> vec4<f32> {\n  var position_world = project.modelMatrix * position;\n\n  // Work around for a Mac+NVIDIA bug:\n  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR) {\n    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n      return vec4<f32>(\n        project_mercator_(position_world.xy),\n        _project_size_at_latitude_m(position_world.z, position_world.y),\n        position_world.w\n      );\n    }\n    if (project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {\n      position_world = vec4f(position_world.xyz + project.coordinateOrigin, position_world.w);\n    }\n  }\n  if (project.projectionMode == PROJECTION_MODE_GLOBE) {\n    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n      return vec4<f32>(\n        project_globe_(position_world.xyz),\n        position_world.w\n      );\n    }\n  }\n  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {\n    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n      if (abs(position_world.y - project.coordinateOrigin.y) > 0.25) {\n        return vec4<f32>(\n          project_mercator_(position_world.xy) - project.commonOrigin.xy,\n          project_size_float(position_world.z),\n          position_world.w\n        );\n      }\n    }\n  }\n  if (project.projectionMode == PROJECTION_MODE_IDENTITY ||\n      (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&\n       (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT ||\n        project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {\n    position_world = vec4f(position_world.xyz - project.coordinateOrigin, position_world.w);\n  }\n\n  return project_offset_(position_world) +\n         project_offset_(project.modelMatrix * vec4<f32>(position64Low, 0.0));\n}\n\n// Overloaded versions for different input types.\nfn project_position_vec4_f32(position: vec4<f32>) -> vec4<f32> {\n  return project_position_vec4_f64(position, ZERO_64_LOW);\n}\n\nfn project_position_vec3_f64(position: vec3<f32>, position64Low: vec3<f32>) -> vec3<f32> {\n  let projected_position = project_position_vec4_f64(vec4<f32>(position, 1.0), position64Low);\n  return projected_position.xyz;\n}\n\nfn project_position_vec3_f32(position: vec3<f32>) -> vec3<f32> {\n  let projected_position = project_position_vec4_f64(vec4<f32>(position, 1.0), ZERO_64_LOW);\n  return projected_position.xyz;\n}\n\nfn project_position_vec2_f32(position: vec2<f32>) -> vec2<f32> {\n  let projected_position = project_position_vec4_f64(vec4<f32>(position, 0.0, 1.0), ZERO_64_LOW);\n  return projected_position.xy;\n}\n\n// Transforms a common space position to clip space.\nfn project_common_position_to_clipspace_with_projection(position: vec4<f32>, viewProjectionMatrix: mat4x4<f32>, center: vec4<f32>) -> vec4<f32> {\n  return viewProjectionMatrix * position + center;\n}\n\n// Uses the project viewProjectionMatrix and center.\nfn project_common_position_to_clipspace(position: vec4<f32>) -> vec4<f32> {\n  return project_common_position_to_clipspace_with_projection(position, project.viewProjectionMatrix, project.center);\n}\n\n// Returns a clip space offset corresponding to a given number of screen pixels.\nfn project_pixel_size_to_clipspace(pixels: vec2<f32>) -> vec2<f32> {\n  let offset = pixels / project.viewportSize * project.devicePixelRatio * 2.0;\n  return offset * project.focalDistance;\n}\n\nfn project_meter_size_to_pixel(meters: f32) -> f32 {\n  return project_size_float(meters) * project.scale;\n}\n\nfn project_unit_size_to_pixel(size: f32, unit: i32) -> f32 {\n  if (unit == UNIT_METERS) {\n    return project_meter_size_to_pixel(size);\n  } else if (unit == UNIT_COMMON) {\n    return size * project.scale;\n  }\n  // UNIT_PIXELS: no scaling applied.\n  return size;\n}\n\nfn project_pixel_size_float(pixels: f32) -> f32 {\n  return pixels / project.scale;\n}\n\nfn project_pixel_size_vec2(pixels: vec2<f32>) -> vec2<f32> {\n  return pixels / project.scale;\n}\n`;\n//# sourceMappingURL=project.wgsl.js.map","// deck.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { COORDINATE_SYSTEM, PROJECTION_MODE, UNIT } from \"../../lib/constants.js\";\n// We are generating these from the js code in constants.js\nconst COORDINATE_SYSTEM_GLSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM)\n    .map(key => `const int COORDINATE_SYSTEM_${key} = ${COORDINATE_SYSTEM[key]};`)\n    .join('');\nconst PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE)\n    .map(key => `const int PROJECTION_MODE_${key} = ${PROJECTION_MODE[key]};`)\n    .join('');\nconst UNIT_GLSL_CONSTANTS = Object.keys(UNIT)\n    .map(key => `const int UNIT_${key.toUpperCase()} = ${UNIT[key]};`)\n    .join('');\nexport const projectGLSL = /* glsl */ `\\\n${COORDINATE_SYSTEM_GLSL_CONSTANTS}\n${PROJECTION_MODE_GLSL_CONSTANTS}\n${UNIT_GLSL_CONSTANTS}\nuniform projectUniforms {\nbool wrapLongitude;\nint coordinateSystem;\nvec3 commonUnitsPerMeter;\nint projectionMode;\nfloat scale;\nvec3 commonUnitsPerWorldUnit;\nvec3 commonUnitsPerWorldUnit2;\nvec4 center;\nmat4 modelMatrix;\nmat4 viewProjectionMatrix;\nvec2 viewportSize;\nfloat devicePixelRatio;\nfloat focalDistance;\nvec3 cameraPosition;\nvec3 coordinateOrigin;\nvec3 commonOrigin;\nbool pseudoMeters;\n} project;\nconst float TILE_SIZE = 512.0;\nconst float PI = 3.1415926536;\nconst float WORLD_SCALE = TILE_SIZE / (PI * 2.0);\nconst vec3 ZERO_64_LOW = vec3(0.0);\nconst float EARTH_RADIUS = 6370972.0;\nconst float GLOBE_RADIUS = 256.0;\nfloat project_size_at_latitude(float lat) {\nfloat y = clamp(lat, -89.9, 89.9);\nreturn 1.0 / cos(radians(y));\n}\nfloat project_size() {\nif (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR &&\nproject.coordinateSystem == COORDINATE_SYSTEM_LNGLAT &&\nproject.pseudoMeters == false) {\nif (geometry.position.w == 0.0) {\nreturn project_size_at_latitude(geometry.worldPosition.y);\n}\nfloat y = geometry.position.y / TILE_SIZE * 2.0 - 1.0;\nfloat y2 = y * y;\nfloat y4 = y2 * y2;\nfloat y6 = y4 * y2;\nreturn 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6;\n}\nreturn 1.0;\n}\nfloat project_size_at_latitude(float meters, float lat) {\nreturn meters * project.commonUnitsPerMeter.z * project_size_at_latitude(lat);\n}\nfloat project_size(float meters) {\nreturn meters * project.commonUnitsPerMeter.z * project_size();\n}\nvec2 project_size(vec2 meters) {\nreturn meters * project.commonUnitsPerMeter.xy * project_size();\n}\nvec3 project_size(vec3 meters) {\nreturn meters * project.commonUnitsPerMeter * project_size();\n}\nvec4 project_size(vec4 meters) {\nreturn vec4(meters.xyz * project.commonUnitsPerMeter, meters.w);\n}\nmat3 project_get_orientation_matrix(vec3 up) {\nvec3 uz = normalize(up);\nvec3 ux = abs(uz.z) == 1.0 ? vec3(1.0, 0.0, 0.0) : normalize(vec3(uz.y, -uz.x, 0));\nvec3 uy = cross(uz, ux);\nreturn mat3(ux, uy, uz);\n}\nbool project_needs_rotation(vec3 commonPosition, out mat3 transform) {\nif (project.projectionMode == PROJECTION_MODE_GLOBE) {\ntransform = project_get_orientation_matrix(commonPosition);\nreturn true;\n}\nreturn false;\n}\nvec3 project_normal(vec3 vector) {\nvec4 normal_modelspace = project.modelMatrix * vec4(vector, 0.0);\nvec3 n = normalize(normal_modelspace.xyz * project.commonUnitsPerMeter);\nmat3 rotation;\nif (project_needs_rotation(geometry.position.xyz, rotation)) {\nn = rotation * n;\n}\nreturn n;\n}\nvec4 project_offset_(vec4 offset) {\nfloat dy = offset.y;\nvec3 commonUnitsPerWorldUnit = project.commonUnitsPerWorldUnit + project.commonUnitsPerWorldUnit2 * dy;\nreturn vec4(offset.xyz * commonUnitsPerWorldUnit, offset.w);\n}\nvec2 project_mercator_(vec2 lnglat) {\nfloat x = lnglat.x;\nif (project.wrapLongitude) {\nx = mod(x + 180., 360.0) - 180.;\n}\nfloat y = clamp(lnglat.y, -89.9, 89.9);\nreturn vec2(\nradians(x) + PI,\nPI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5))\n) * WORLD_SCALE;\n}\nvec3 project_globe_(vec3 lnglatz) {\nfloat lambda = radians(lnglatz.x);\nfloat phi = radians(lnglatz.y);\nfloat cosPhi = cos(phi);\nfloat D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS;\nreturn vec3(\nsin(lambda) * cosPhi,\n-cos(lambda) * cosPhi,\nsin(phi)\n) * D;\n}\nvec4 project_position(vec4 position, vec3 position64Low) {\nvec4 position_world = project.modelMatrix * position;\nif (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR) {\nif (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\nreturn vec4(\nproject_mercator_(position_world.xy),\nproject_size_at_latitude(position_world.z, position_world.y),\nposition_world.w\n);\n}\nif (project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {\nposition_world.xyz += project.coordinateOrigin;\n}\n}\nif (project.projectionMode == PROJECTION_MODE_GLOBE) {\nif (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\nreturn vec4(\nproject_globe_(position_world.xyz),\nposition_world.w\n);\n}\n}\nif (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {\nif (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\nif (abs(position_world.y - project.coordinateOrigin.y) > 0.25) {\nreturn vec4(\nproject_mercator_(position_world.xy) - project.commonOrigin.xy,\nproject_size(position_world.z),\nposition_world.w\n);\n}\n}\n}\nif (project.projectionMode == PROJECTION_MODE_IDENTITY ||\n(project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&\n(project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT ||\nproject.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {\nposition_world.xyz -= project.coordinateOrigin;\n}\nreturn project_offset_(position_world) + project_offset_(project.modelMatrix * vec4(position64Low, 0.0));\n}\nvec4 project_position(vec4 position) {\nreturn project_position(position, ZERO_64_LOW);\n}\nvec3 project_position(vec3 position, vec3 position64Low) {\nvec4 projected_position = project_position(vec4(position, 1.0), position64Low);\nreturn projected_position.xyz;\n}\nvec3 project_position(vec3 position) {\nvec4 projected_position = project_position(vec4(position, 1.0), ZERO_64_LOW);\nreturn projected_position.xyz;\n}\nvec2 project_position(vec2 position) {\nvec4 projected_position = project_position(vec4(position, 0.0, 1.0), ZERO_64_LOW);\nreturn projected_position.xy;\n}\nvec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatrix, vec4 center) {\nreturn viewProjectionMatrix * position + center;\n}\nvec4 project_common_position_to_clipspace(vec4 position) {\nreturn project_common_position_to_clipspace(position, project.viewProjectionMatrix, project.center);\n}\nvec2 project_pixel_size_to_clipspace(vec2 pixels) {\nvec2 offset = pixels / project.viewportSize * project.devicePixelRatio * 2.0;\nreturn offset * project.focalDistance;\n}\nfloat project_size_to_pixel(float meters) {\nreturn project_size(meters) * project.scale;\n}\nfloat project_size_to_pixel(float size, int unit) {\nif (unit == UNIT_METERS) return project_size_to_pixel(size);\nif (unit == UNIT_COMMON) return size * project.scale;\nreturn size;\n}\nfloat project_pixel_size(float pixels) {\nreturn pixels / project.scale;\n}\nvec2 project_pixel_size(vec2 pixels) {\nreturn pixels / project.scale;\n}\n`;\n//# sourceMappingURL=project.glsl.js.map","// deck.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { fp32 } from '@luma.gl/shadertools';\nimport geometry from \"../misc/geometry.js\";\nimport { getUniformsFromViewport } from \"./viewport-uniforms.js\";\nimport { projectWGSL } from \"./project.wgsl.js\";\nimport { projectGLSL } from \"./project.glsl.js\";\nconst INITIAL_MODULE_OPTIONS = {};\nfunction getUniforms(opts = INITIAL_MODULE_OPTIONS) {\n    if ('viewport' in opts) {\n        return getUniformsFromViewport(opts);\n    }\n    return {};\n}\nexport default {\n    name: 'project',\n    dependencies: [fp32, geometry],\n    source: projectWGSL,\n    vs: projectGLSL,\n    getUniforms,\n    uniformTypes: {\n        wrapLongitude: 'f32',\n        coordinateSystem: 'i32',\n        commonUnitsPerMeter: 'vec3<f32>',\n        projectionMode: 'i32',\n        scale: 'f32',\n        commonUnitsPerWorldUnit: 'vec3<f32>',\n        commonUnitsPerWorldUnit2: 'vec3<f32>',\n        center: 'vec4<f32>',\n        modelMatrix: 'mat4x4<f32>',\n        viewProjectionMatrix: 'mat4x4<f32>',\n        viewportSize: 'vec2<f32>',\n        devicePixelRatio: 'f32',\n        focalDistance: 'f32',\n        cameraPosition: 'vec3<f32>',\n        coordinateOrigin: 'vec3<f32>',\n        commonOrigin: 'vec3<f32>',\n        pseudoMeters: 'f32'\n    }\n    // @ts-ignore TODO v9.1\n};\n//# sourceMappingURL=project.js.map"],"names":["assert","condition","message","DEFAULT_PROP_VALIDATORS","value","propType","makePropValidators","propTypes","propValidators","name","makePropValidator","type","getTypeOf","MODULE_INJECTORS_VS","MODULE_INJECTORS_FS","MODULE_INJECTORS","REGEX_START_OF_MAIN","REGEX_END_OF_MAIN","fragments","DECLARATION_INJECT_MARKER","normalizeInjections","injections","result","hook","injection","stage","getHookStage","injectShader","source","inject","injectStandardStubs","isVertex","key","fragmentData","a","b","i","len","fragmentString","match","initializeShaderModules","modules","module","initializeShaderModule","deprecations","instance","parseDeprecationDefinitions","defaultProps","obj","checkShaderModuleDeprecations","shaderModule","shaderSource","log","def","getShaderModuleDependencies","moduleMap","moduleDepth","getDependencyGraph","dependencies","options","level","getPlatformShaderDefines","platformInfo","transpileGLSLShader","convertShader","ES300_VERTEX_REPLACEMENTS","ES300_FRAGMENT_REPLACEMENTS","ES300_REPLACEMENTS","makeVariableTextRegExp","replacements","pattern","replacement","qualifier","getShaderHooks","hookFunctions","hookInjections","hookName","hookFunction","normalizeShaderHooks","opts","shaderStage","signature","normalizedHook","getShaderInfo","defaultName","getShaderName","getShaderVersion","shader","version","words","parsedVersion","INJECT_SHADER_DECLARATIONS","FRAGMENT_SHADER_PROLOGUE","assembleWGSLShader","assembleShaderWGSL","assembleGetUniforms","assembleGLSLShaderPair","vs","fs","assembleShaderGLSL","coreSource","assembledSource","hookFunctionMap","declInjections","mainInjections","hash","modulesToInject","moduleSource","getShaderModuleSource","injectionType","language","defines","prologue","sourceVersion","targetVersion","sourceVersionDirective","allDefines","getApplicationDefines","uniforms","moduleUniforms","sourceText","define","moduleName","IFDEF_REGEXP","ENDIF_REGEXP","preprocess","lines","output","conditional","currentDefine","line","matchIf","matchEnd","ShaderAssembler","m","props","getUniforms","appModules","seen","count","fp32shader","fp32","geometry","isEqual","memoize","compute","cachedArgs","cachedResult","args","ZERO_VECTOR","VECTOR_TO_POINT_MATRIX","IDENTITY_MATRIX","DEFAULT_PIXELS_PER_UNIT2","DEFAULT_COORDINATE_ORIGIN","getMemoizedViewportUniforms","calculateViewportUniforms","getOffsetOrigin","viewport","coordinateSystem","coordinateOrigin","shaderCoordinateOrigin","geospatialOrigin","offsetMode","COORDINATE_SYSTEM","PROJECTION_MODE","calculateMatrixAndOffset","viewMatrixUncentered","projectionMatrix","viewMatrix","viewProjectionMatrix","projectionCenter","originCommon","cameraPosCommon","vec4.transformMat4","mat4.multiply","getUniformsFromViewport","devicePixelRatio","modelMatrix","autoWrapLongitude","distanceScales","viewportSize","focalDistance","distanceScalesAtOrigin","COORDINATE_SYSTEM_WGSL_CONSTANTS","PROJECTION_MODE_WGSL_CONSTANTS","UNIT_WGSL_CONSTANTS","UNIT","projectWGSLHeader","projectWGSL","COORDINATE_SYSTEM_GLSL_CONSTANTS","PROJECTION_MODE_GLSL_CONSTANTS","UNIT_GLSL_CONSTANTS","projectGLSL","INITIAL_MODULE_OPTIONS","project"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]}