@luma.gl/shadertools 9.1.0-alpha.1 → 9.1.0-alpha.12

package/dist/dist.dev.js

@@ -54,8 +54,6 @@ var __exports__ = (() => {
   var bundle_exports = {};
   __export(bundle_exports, {
     ShaderAssembler: () => ShaderAssembler,
-    ShaderModuleInstance: () => ShaderModuleInstance,
-    _ShaderModuleInstance: () => ShaderModuleInstance,
     _getDependencyGraph: () => getDependencyGraph,
     _resolveModules: () => resolveModules,
     _warp: () => warp,
@@ -63,6 +61,7 @@ var __exports__ = (() => {
     brightnessContrast: () => brightnessContrast,
     bulgePinch: () => bulgePinch,
     capitalize: () => capitalize,
+    checkShaderModuleDeprecations: () => checkShaderModuleDeprecations,
     colorHalftone: () => colorHalftone,
     combineInjects: () => combineInjects,
     convertToVec4: () => convertToVec4,
@@ -85,17 +84,20 @@ var __exports__ = (() => {
     getQualifierDetails: () => getQualifierDetails,
     getShaderInfo: () => getShaderInfo,
     getShaderLayoutFromWGSL: () => getShaderLayoutFromWGSL,
-    glsl: () => glsl,
+    getShaderModuleDependencies: () => getShaderModuleDependencies,
+    getShaderModuleSource: () => getShaderModuleSource,
+    getShaderModuleUniforms: () => getShaderModuleUniforms,
     gouraudLighting: () => gouraudLighting,
     gouraudMaterial: () => gouraudMaterial,
     hexagonalPixelate: () => hexagonalPixelate,
     hueSaturation: () => hueSaturation,
+    initializeShaderModule: () => initializeShaderModule,
+    initializeShaderModules: () => initializeShaderModules,
     ink: () => ink,
     lighting: () => lighting,
     lights1: () => lights,
     magnify: () => magnify,
     noise: () => noise,
-    normalizeShaderModule: () => normalizeShaderModule,
     pbr: () => pbr,
     pbrMaterial: () => pbrMaterial,
     phongLighting: () => phongLighting,
@@ -117,9 +119,6 @@ var __exports__ = (() => {
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
-  // src/lib/glsl-utils/highlight.ts
-  var glsl = (x) => `${x}`;
-
   // src/lib/utils/assert.ts
   function assert(condition, message) {
     if (!condition) {
@@ -194,13 +193,16 @@ var __exports__ = (() => {
   }
 
   // src/module-injectors.ts
-  var MODULE_INJECTORS_VS = glsl`\
-#ifdef MODULE_LOGDEPTH
+  var MODULE_INJECTORS_VS = (
+    /* glsl */
+    `#ifdef MODULE_LOGDEPTH
   logdepth_adjustPosition(gl_Position);
 #endif
-`;
-  var MODULE_INJECTORS_FS = glsl`\
-#ifdef MODULE_MATERIAL
+`
+  );
+  var MODULE_INJECTORS_FS = (
+    /* glsl */
+    `#ifdef MODULE_MATERIAL
   gl_FragColor = material_filterColor(gl_FragColor);
 #endif
 
@@ -220,7 +222,8 @@ var __exports__ = (() => {
 #ifdef MODULE_LOGDEPTH
   logdepth_setFragDepth();
 #endif
-`;
+`
+  );
 
   // src/lib/shader-assembly/shader-injections.ts
   var MODULE_INJECTORS = {
@@ -321,148 +324,71 @@ ${inject[key]}` : inject[key];
     return result;
   }
 
-  // src/lib/shader-module/shader-module-instance.ts
-  var index = 1;
-  var ShaderModuleInstance = class {
-    name;
-    vs;
-    fs;
-    getModuleUniforms;
-    dependencies;
-    deprecations;
-    defines;
-    injections;
-    uniforms = {};
-    uniformTypes = {};
-    static instantiateModules(modules) {
-      return modules.map((module) => {
-        if (module instanceof ShaderModuleInstance) {
-          return module;
-        }
-        assert(
-          typeof module !== "string",
-          `Shader module use by name is deprecated. Import shader module '${JSON.stringify(
-            module
-          )}' and use it directly.`
-        );
-        if (!module.name) {
-          console.warn("shader module has no name");
-          module.name = `shader-module-${index++}`;
-        }
-        const moduleObject = new ShaderModuleInstance(module);
-        moduleObject.dependencies = ShaderModuleInstance.instantiateModules(
-          module.dependencies || []
-        );
-        return moduleObject;
-      });
-    }
-    constructor(props) {
-      const {
-        name,
-        vs: vs6,
-        fs: fs28,
-        dependencies = [],
-        uniformPropTypes = {},
-        getUniforms: getUniforms9,
-        deprecations = [],
-        defines = {},
-        inject = {}
-      } = props;
-      assert(typeof name === "string");
-      this.name = name;
-      this.vs = vs6;
-      this.fs = fs28;
-      this.getModuleUniforms = getUniforms9;
-      this.dependencies = ShaderModuleInstance.instantiateModules(dependencies);
-      this.deprecations = this._parseDeprecationDefinitions(deprecations);
-      this.defines = defines;
-      this.injections = normalizeInjections(inject);
-      if (uniformPropTypes) {
-        this.uniforms = makePropValidators(uniformPropTypes);
-      }
-    }
-    // Extracts the source code chunk for the specified shader type from the named shader module
-    getModuleSource(stage) {
-      let moduleSource;
-      switch (stage) {
-        case "vertex":
-          moduleSource = this.vs || "";
-          break;
-        case "fragment":
-          moduleSource = this.fs || "";
-          break;
-        default:
-          assert(false);
-      }
-      const moduleName = this.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
-      return `// ----- MODULE ${this.name} ---------------
-
-#define MODULE_${moduleName}
-${moduleSource}
-
-`;
-    }
-    getUniforms(userProps, uniforms) {
-      if (this.getModuleUniforms) {
-        return this.getModuleUniforms(userProps, uniforms);
-      }
-      return getValidatedProperties(userProps, this.uniforms, this.name);
-    }
-    getDefines() {
-      return this.defines;
+  // src/lib/shader-module/shader-module.ts
+  function initializeShaderModules(modules) {
+    modules.map((module) => initializeShaderModule(module));
+  }
+  function initializeShaderModule(module) {
+    if (module.instance) {
+      return;
     }
-    // Warn about deprecated uniforms or functions
-    checkDeprecations(shaderSource, log2) {
-      this.deprecations.forEach((def) => {
-        if (def.regex?.test(shaderSource)) {
-          if (def.deprecated) {
-            log2.deprecated(def.old, def.new)();
-          } else {
-            log2.removed(def.old, def.new)();
-          }
-        }
-      });
+    initializeShaderModules(module.dependencies || []);
+    const {
+      uniformPropTypes = {},
+      deprecations = [],
+      // defines = {},
+      inject = {}
+    } = module;
+    const instance = {
+      normalizedInjections: normalizeInjections(inject),
+      parsedDeprecations: parseDeprecationDefinitions(deprecations)
+    };
+    if (uniformPropTypes) {
+      instance.propValidators = makePropValidators(uniformPropTypes);
     }
-    _parseDeprecationDefinitions(deprecations) {
-      deprecations.forEach((def) => {
-        switch (def.type) {
-          case "function":
-            def.regex = new RegExp(`\\b${def.old}\\(`);
-            break;
-          default:
-            def.regex = new RegExp(`${def.type} ${def.old};`);
-        }
-      });
-      return deprecations;
+    module.instance = instance;
+  }
+  function getShaderModuleUniforms(module, props, oldUniforms) {
+    initializeShaderModule(module);
+    const uniforms = oldUniforms || { ...module.defaultUniforms };
+    if (module.getUniforms) {
+      return module.getUniforms(props, uniforms);
     }
-    _defaultGetUniforms(opts = {}) {
-      const uniforms = {};
-      const propTypes = this.uniforms;
-      for (const key in propTypes) {
-        const propDef = propTypes[key];
-        if (key in opts && !propDef.private) {
-          if (propDef.validate) {
-            assert(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`);
-          }
-          uniforms[key] = opts[key];
+    return getValidatedProperties(props, module.instance?.propValidators, module.name);
+  }
+  function checkShaderModuleDeprecations(shaderModule, shaderSource, log2) {
+    shaderModule.deprecations?.forEach((def) => {
+      if (def.regex?.test(shaderSource)) {
+        if (def.deprecated) {
+          log2.deprecated(def.old, def.new)();
         } else {
-          uniforms[key] = propDef.value;
+          log2.removed(def.old, def.new)();
         }
       }
-      return uniforms;
-    }
-  };
-
-  // src/lib/shader-assembly/resolve-modules.ts
-  function resolveModules(modules) {
-    const instances = ShaderModuleInstance.instantiateModules(modules);
-    return getShaderDependencies(instances);
+    });
   }
-  function getShaderDependencies(modules) {
+  function parseDeprecationDefinitions(deprecations) {
+    deprecations.forEach((def) => {
+      switch (def.type) {
+        case "function":
+          def.regex = new RegExp(`\\b${def.old}\\(`);
+          break;
+        default:
+          def.regex = new RegExp(`${def.type} ${def.old};`);
+      }
+    });
+    return deprecations;
+  }
+
+  // src/lib/shader-module/shader-module-dependencies.ts
+  function getShaderModuleDependencies(modules) {
+    initializeShaderModules(modules);
     const moduleMap = {};
     const moduleDepth = {};
     getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });
-    return Object.keys(moduleDepth).sort((a, b) => moduleDepth[b] - moduleDepth[a]).map((name) => moduleMap[name]);
+    const dependencies = Object.keys(moduleDepth).sort((a, b) => moduleDepth[b] - moduleDepth[a]).map((name) => moduleMap[name]);
+    initializeShaderModules(dependencies);
+    return dependencies;
   }
   function getDependencyGraph(options) {
     const { modules, level, moduleMap, moduleDepth } = options;
@@ -481,49 +407,71 @@ ${moduleSource}
       }
     }
   }
+  function getShaderDependencies(modules) {
+    initializeShaderModules(modules);
+    const moduleMap = {};
+    const moduleDepth = {};
+    getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });
+    modules = Object.keys(moduleDepth).sort((a, b) => moduleDepth[b] - moduleDepth[a]).map((name) => moduleMap[name]);
+    initializeShaderModules(modules);
+    return modules;
+  }
+  function resolveModules(modules) {
+    return getShaderDependencies(modules);
+  }
 
   // src/lib/shader-assembly/platform-defines.ts
   function getPlatformShaderDefines(platformInfo) {
     switch (platformInfo?.gpu.toLowerCase()) {
       case "apple":
-        return glsl`\
-#define APPLE_GPU
+        return (
+          /* glsl */
+          `#define APPLE_GPU
 // Apple optimizes away the calculation necessary for emulated fp64
 #define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
 #define LUMA_FP32_TAN_PRECISION_WORKAROUND 1
 // Intel GPU doesn't have full 32 bits precision in same cases, causes overflow
 #define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1
-`;
+`
+        );
       case "nvidia":
-        return glsl`\
-#define NVIDIA_GPU
+        return (
+          /* glsl */
+          `#define NVIDIA_GPU
 // Nvidia optimizes away the calculation necessary for emulated fp64
 #define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
-`;
+`
+        );
       case "intel":
-        return glsl`\
-#define INTEL_GPU
+        return (
+          /* glsl */
+          `#define INTEL_GPU
 // Intel optimizes away the calculation necessary for emulated fp64
 #define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
 // Intel's built-in 'tan' function doesn't have acceptable precision
 #define LUMA_FP32_TAN_PRECISION_WORKAROUND 1
 // Intel GPU doesn't have full 32 bits precision in same cases, causes overflow
 #define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1
-`;
+`
+        );
       case "amd":
-        return glsl`\
-#define AMD_GPU
-`;
+        return (
+          /* glsl */
+          `#define AMD_GPU
+`
+        );
       default:
-        return glsl`\
-#define DEFAULT_GPU
+        return (
+          /* glsl */
+          `#define DEFAULT_GPU
 // Prevent driver from optimizing away the calculation necessary for emulated fp64
 #define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
 // Headless Chrome's software shader 'tan' function doesn't have acceptable precision
 #define LUMA_FP32_TAN_PRECISION_WORKAROUND 1
 // If the GPU doesn't have full 32 bits precision, will causes overflow
 #define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1
-`;
+`
+        );
     }
   }
 
@@ -661,11 +609,13 @@ ${moduleSource}
 
 ${DECLARATION_INJECT_MARKER}
 `;
-  var FRAGMENT_SHADER_PROLOGUE = glsl`\
-precision highp float;
-`;
+  var FRAGMENT_SHADER_PROLOGUE = (
+    /* glsl */
+    `precision highp float;
+`
+  );
   function assembleWGSLShader(options) {
-    const modules = resolveModules(options.modules || []);
+    const modules = getShaderModuleDependencies(options.modules || []);
     return {
       source: assembleShaderWGSL(options.platformInfo, {
         ...options,
@@ -678,7 +628,7 @@ precision highp float;
   }
   function assembleGLSLShaderPair(options) {
     const { vs: vs6, fs: fs28 } = options;
-    const modules = resolveModules(options.modules || []);
+    const modules = getShaderModuleDependencies(options.modules || []);
     return {
       vs: assembleShaderGLSL(options.platformInfo, {
         ...options,
@@ -733,14 +683,14 @@ precision highp float;
         mainInjections[key] = [injection];
       }
     }
-    const modulesToInject = platformInfo.type !== "webgpu" ? modules : [];
+    const modulesToInject = modules;
     for (const module of modulesToInject) {
       if (log2) {
-        module.checkDeprecations(coreSource, log2);
+        checkShaderModuleDeprecations(module, coreSource, log2);
       }
-      const moduleSource = module.getModuleSource(stage, "wgsl");
+      const moduleSource = getShaderModuleSource(module, "wgsl");
       assembledSource += moduleSource;
-      const injections = module.injections[stage];
+      const injections = module.injections?.[stage] || {};
       for (const key in injections) {
         const match = /^(v|f)s:#([\w-]+)$/.exec(key);
         if (match) {
@@ -782,7 +732,7 @@ precision highp float;
     const coreSource = sourceLines.slice(1).join("\n");
     const allDefines = {};
     modules.forEach((module) => {
-      Object.assign(allDefines, module.getDefines());
+      Object.assign(allDefines, module.defines);
     });
     Object.assign(allDefines, defines);
     let assembledSource = "";
@@ -795,6 +745,7 @@ precision highp float;
 // ----- PROLOGUE -------------------------
 ${getShaderNameDefine({ id, source, stage })}
 ${`#define SHADER_TYPE_${stage.toUpperCase()}`}
+
 ${getPlatformShaderDefines(platformInfo)}
 ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
 
@@ -831,11 +782,11 @@ ${getApplicationDefines(allDefines)}
     }
     for (const module of modules) {
       if (log2) {
-        module.checkDeprecations(coreSource, log2);
+        checkShaderModuleDeprecations(module, coreSource, log2);
       }
-      const moduleSource = module.getModuleSource(stage);
+      const moduleSource = getShaderModuleSource(module, stage);
       assembledSource += moduleSource;
-      const injections = module.injections[stage];
+      const injections = module.instance?.normalizedInjections[stage] || {};
       for (const key in injections) {
         const match = /^(v|f)s:#([\w-]+)$/.exec(key);
         if (match) {
@@ -864,7 +815,7 @@ ${getApplicationDefines(allDefines)}
     return function getUniforms9(opts) {
       const uniforms = {};
       for (const module of modules) {
-        const moduleUniforms = module.getUniforms(opts, uniforms);
+        const moduleUniforms = module.getUniforms?.(opts, uniforms);
         Object.assign(uniforms, moduleUniforms);
       }
       return uniforms;
@@ -874,9 +825,7 @@ ${getApplicationDefines(allDefines)}
     const { id, source, stage } = options;
     const injectShaderName = id && source.indexOf("SHADER_NAME") === -1;
     return injectShaderName ? `
-#define SHADER_NAME ${id}_${stage}
-
-` : "";
+#define SHADER_NAME ${id}_${stage}` : "";
   }
   function getApplicationDefines(defines = {}) {
     let sourceText = "";
@@ -889,6 +838,36 @@ ${getApplicationDefines(allDefines)}
     }
     return sourceText;
   }
+  function getShaderModuleSource(module, stage) {
+    let moduleSource;
+    switch (stage) {
+      case "vertex":
+        moduleSource = module.vs || "";
+        break;
+      case "fragment":
+        moduleSource = module.fs || "";
+        break;
+      case "wgsl":
+        moduleSource = module.source || "";
+        break;
+      default:
+        assert(false);
+    }
+    if (!module.name) {
+      throw new Error("Shader module must have a name");
+    }
+    const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
+    let source = `// ----- MODULE ${module.name} ---------------
+
+`;
+    if (stage !== "wgsl") {
+      source += `#define MODULE_${moduleName}
+`;
+    }
+    source += `${moduleSource}
+`;
+    return source;
+  }
 
   // src/lib/preprocessor/preprocessor.ts
   var IFDEF_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*$/;
@@ -998,9 +977,7 @@ ${getApplicationDefines(allDefines)}
      * Dedupe and combine with default modules
      */
     _getModuleList(appModules = []) {
-      const modules = new Array(
-        this._defaultModules.length + appModules.length
-      );
+      const modules = new Array(this._defaultModules.length + appModules.length);
       const seen = {};
       let count = 0;
       for (let i = 0, len = this._defaultModules.length; i < len; ++i) {
@@ -1018,31 +995,22 @@ ${getApplicationDefines(allDefines)}
         }
       }
       modules.length = count;
-      return ShaderModuleInstance.instantiateModules(modules);
+      initializeShaderModules(modules);
+      return modules;
     }
   };
   var ShaderAssembler = _ShaderAssembler;
   /** Default ShaderAssembler instance */
   __publicField(ShaderAssembler, "defaultShaderAssembler");
 
-  // src/lib/shader-module/normalize-shader-module.ts
-  function normalizeShaderModule(module) {
-    if (!module.normalized) {
-      module.normalized = true;
-      if (module.uniformPropTypes && !module.getUniforms) {
-        const shaderModule = new ShaderModuleInstance(module);
-        module.getUniforms = shaderModule.getUniforms.bind(shaderModule);
-      }
-    }
-    return module;
-  }
-
   // src/lib/glsl-utils/shader-utils.ts
-  var FS_GLES = glsl`\
-out vec4 transform_output;
+  var FS_GLES = (
+    /* glsl */
+    `out vec4 transform_output;
 void main() {
   transform_output = vec4(0);
-}`;
+}`
+  );
   var FS300 = `#version 300 es
 ${FS_GLES}`;
   function getQualifierDetails(line, qualifiers) {
@@ -1139,11 +1107,11 @@ void main() {
     return generateGLSLUniformDeclarations(module, options);
   }
   function generateGLSLUniformDeclarations(module, options) {
-    const glsl2 = [];
+    const glsl = [];
     switch (options.uniforms) {
       case "scoped-interface-blocks":
       case "unscoped-interface-blocks":
-        glsl2.push(`uniform ${capitalize(module.name)} {`);
+        glsl.push(`uniform ${capitalize(module.name)} {`);
         break;
       case "uniforms":
     }
@@ -1151,26 +1119,26 @@ void main() {
       const glslUniformType = getGLSLUniformType(uniformFormat);
       switch (options.uniforms) {
         case "scoped-interface-blocks":
-          glsl2.push(`  ${glslUniformType} ${uniformName};`);
+          glsl.push(`  ${glslUniformType} ${uniformName};`);
           break;
         case "unscoped-interface-blocks":
-          glsl2.push(`  ${glslUniformType} ${module.name}_${uniformName};`);
+          glsl.push(`  ${glslUniformType} ${module.name}_${uniformName};`);
           break;
         case "uniforms":
-          glsl2.push(`uniform ${glslUniformType} ${module.name}_${uniformName};`);
+          glsl.push(`uniform ${glslUniformType} ${module.name}_${uniformName};`);
       }
     }
     switch (options.uniforms) {
       case "scoped-interface-blocks":
-        glsl2.push(`} ${module.name};`);
+        glsl.push(`} ${module.name};`);
         break;
       case "unscoped-interface-blocks":
-        glsl2.push("};");
+        glsl.push("};");
         break;
       case "uniforms":
     }
-    glsl2.push("");
-    return glsl2.join("\n");
+    glsl.push("");
+    return glsl.join("\n");
   }
   function getGLSLUniformType(uniformFormat) {
     const UNIFORM_TYPE_TO_GLSL = {
@@ -1196,8 +1164,8 @@ void main() {
       "mat4x3<f32>": "mat4x3",
       "mat4x4<f32>": "mat4"
     };
-    const glsl2 = UNIFORM_TYPE_TO_GLSL[uniformFormat];
-    return glsl2;
+    const glsl = UNIFORM_TYPE_TO_GLSL[uniformFormat];
+    return glsl;
   }
 
   // src/lib/shader-generator/wgsl/generate-wgsl.ts
@@ -1488,6 +1456,7 @@ void main() {
       return "assign";
     }
     search(callback) {
+      this.variable.search(callback);
       this.value.search(callback);
     }
   };
@@ -1567,6 +1536,15 @@ void main() {
       return "enable";
     }
   };
+  var Requires = class extends Statement {
+    constructor(extensions) {
+      super();
+      this.extensions = extensions;
+    }
+    get astNodeType() {
+      return "requires";
+    }
+  };
   var Diagnostic = class extends Statement {
     constructor(severity, rule) {
       super();
@@ -1838,6 +1816,9 @@ void main() {
     }
     search(callback) {
       callback(this);
+      if (this.postfix) {
+        this.postfix.search(callback);
+      }
     }
     evaluate(context) {
       const constant = context.constants.get(this.name);
@@ -1931,6 +1912,15 @@ void main() {
       this.searchBlock(this.contents, callback);
     }
   };
+  var ArrayIndex = class extends Expression {
+    constructor(index) {
+      super();
+      this.index = index;
+    }
+    search(callback) {
+      this.index.search(callback);
+    }
+  };
   var Operator = class extends Expression {
     constructor() {
       super();
@@ -2178,10 +2168,10 @@ void main() {
     continue: new TokenType("continue", TokenClass.keyword, "continue"),
     continuing: new TokenType("continuing", TokenClass.keyword, "continuing"),
     default: new TokenType("default", TokenClass.keyword, "default"),
+    diagnostic: new TokenType("diagnostic", TokenClass.keyword, "diagnostic"),
     discard: new TokenType("discard", TokenClass.keyword, "discard"),
     else: new TokenType("else", TokenClass.keyword, "else"),
     enable: new TokenType("enable", TokenClass.keyword, "enable"),
-    diagnostic: new TokenType("diagnostic", TokenClass.keyword, "diagnostic"),
     fallthrough: new TokenType("fallthrough", TokenClass.keyword, "fallthrough"),
     false: new TokenType("false", TokenClass.keyword, "false"),
     fn: new TokenType("fn", TokenClass.keyword, "fn"),
@@ -2196,6 +2186,7 @@ void main() {
     read: new TokenType("read", TokenClass.keyword, "read"),
     read_write: new TokenType("read_write", TokenClass.keyword, "read_write"),
     return: new TokenType("return", TokenClass.keyword, "return"),
+    requires: new TokenType("requires", TokenClass.keyword, "requires"),
     storage: new TokenType("storage", TokenClass.keyword, "storage"),
     switch: new TokenType("switch", TokenClass.keyword, "switch"),
     true: new TokenType("true", TokenClass.keyword, "true"),
@@ -2259,8 +2250,6 @@ void main() {
     and_and: new TokenType("and_and", TokenClass.token, "&&"),
     arrow: new TokenType("arrow ", TokenClass.token, "->"),
     attr: new TokenType("attr", TokenClass.token, "@"),
-    attr_left: new TokenType("attr_left", TokenClass.token, "[["),
-    attr_right: new TokenType("attr_right", TokenClass.token, "]]"),
     forward_slash: new TokenType("forward_slash", TokenClass.token, "/"),
     bang: new TokenType("bang", TokenClass.token, "!"),
     bracket_left: new TokenType("bracket_left", TokenClass.token, "["),
@@ -2304,6 +2293,63 @@ void main() {
     shift_right_equal: new TokenType("shift_right_equal", TokenClass.token, ">>="),
     shift_left_equal: new TokenType("shift_left_equal", TokenClass.token, "<<=")
   };
+  TokenTypes.simpleTokens = {
+    "@": _a.tokens.attr,
+    "{": _a.tokens.brace_left,
+    "}": _a.tokens.brace_right,
+    ":": _a.tokens.colon,
+    ",": _a.tokens.comma,
+    "(": _a.tokens.paren_left,
+    ")": _a.tokens.paren_right,
+    ";": _a.tokens.semicolon
+  };
+  TokenTypes.literalTokens = {
+    "&": _a.tokens.and,
+    "&&": _a.tokens.and_and,
+    "->": _a.tokens.arrow,
+    "/": _a.tokens.forward_slash,
+    "!": _a.tokens.bang,
+    "[": _a.tokens.bracket_left,
+    "]": _a.tokens.bracket_right,
+    "=": _a.tokens.equal,
+    "==": _a.tokens.equal_equal,
+    "!=": _a.tokens.not_equal,
+    ">": _a.tokens.greater_than,
+    ">=": _a.tokens.greater_than_equal,
+    ">>": _a.tokens.shift_right,
+    "<": _a.tokens.less_than,
+    "<=": _a.tokens.less_than_equal,
+    "<<": _a.tokens.shift_left,
+    "%": _a.tokens.modulo,
+    "-": _a.tokens.minus,
+    "--": _a.tokens.minus_minus,
+    ".": _a.tokens.period,
+    "+": _a.tokens.plus,
+    "++": _a.tokens.plus_plus,
+    "|": _a.tokens.or,
+    "||": _a.tokens.or_or,
+    "*": _a.tokens.star,
+    "~": _a.tokens.tilde,
+    "_": _a.tokens.underscore,
+    "^": _a.tokens.xor,
+    "+=": _a.tokens.plus_equal,
+    "-=": _a.tokens.minus_equal,
+    "*=": _a.tokens.times_equal,
+    "/=": _a.tokens.division_equal,
+    "%=": _a.tokens.modulo_equal,
+    "&=": _a.tokens.and_equal,
+    "|=": _a.tokens.or_equal,
+    "^=": _a.tokens.xor_equal,
+    ">>=": _a.tokens.shift_right_equal,
+    "<<=": _a.tokens.shift_left_equal
+  };
+  TokenTypes.regexTokens = {
+    decimal_float_literal: _a.tokens.decimal_float_literal,
+    hex_float_literal: _a.tokens.hex_float_literal,
+    int_literal: _a.tokens.int_literal,
+    uint_literal: _a.tokens.uint_literal,
+    ident: _a.tokens.ident
+  };
   TokenTypes.storage_class = [
     _a.keywords.function,
     _a.keywords.private,
@@ -2426,7 +2472,7 @@ void main() {
     _a.keywords.bitcast,
     ..._a.any_texture_type
   ];
-  TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block];
+  TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block, _a.keywords.diagnostic];
   TokenTypes.assignment_operators = [
     _a.tokens.equal,
     _a.tokens.plus_equal,
@@ -2530,7 +2576,32 @@ void main() {
           return true;
         }
       }
+      const simpleToken = TokenTypes.simpleTokens[lexeme];
+      if (simpleToken) {
+        this._addToken(simpleToken);
+        return true;
+      }
       let matchType = TokenTypes.none;
+      const isAlpha = this._isAlpha(lexeme);
+      const isUnderscore = lexeme === "_";
+      if (this._isAlphaNumeric(lexeme)) {
+        let nextChar = this._peekAhead();
+        while (this._isAlphaNumeric(nextChar)) {
+          lexeme += this._advance();
+          nextChar = this._peekAhead();
+        }
+      }
+      if (isAlpha) {
+        const matchedType = TokenTypes.keywords[lexeme];
+        if (matchedType) {
+          this._addToken(matchedType);
+          return true;
+        }
+      }
+      if (isAlpha || isUnderscore) {
+        this._addToken(TokenTypes.tokens.ident);
+        return true;
+      }
       for (; ; ) {
         let matchedType = this._findType(lexeme);
         const nextLexeme = this._peekAhead();
@@ -2586,36 +2657,31 @@ void main() {
       return true;
     }
     _findType(lexeme) {
-      for (const name in TokenTypes.keywords) {
-        const type = TokenTypes.keywords[name];
-        if (this._match(lexeme, type.rule)) {
-          return type;
+      for (const name in TokenTypes.regexTokens) {
+        const type2 = TokenTypes.regexTokens[name];
+        if (this._match(lexeme, type2.rule)) {
+          return type2;
         }
       }
-      for (const name in TokenTypes.tokens) {
-        const type = TokenTypes.tokens[name];
-        if (this._match(lexeme, type.rule)) {
-          return type;
-        }
+      const type = TokenTypes.literalTokens[lexeme];
+      if (type) {
+        return type;
       }
       return TokenTypes.none;
     }
     _match(lexeme, rule) {
-      if (typeof rule === "string") {
-        if (rule == lexeme) {
-          return true;
-        }
-      } else {
-        const match = rule.exec(lexeme);
-        if (match && match.index == 0 && match[0] == lexeme) {
-          return true;
-        }
-      }
-      return false;
+      const match = rule.exec(lexeme);
+      return match && match.index == 0 && match[0] == lexeme;
     }
     _isAtEnd() {
       return this._current >= this._source.length;
     }
+    _isAlpha(c) {
+      return c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+    }
+    _isAlphaNumeric(c) {
+      return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c == "_" || c >= "0" && c <= "9";
+    }
     _isWhitespace(c) {
       return c == " " || c == "	" || c == "\r";
     }
@@ -2733,8 +2799,8 @@ void main() {
       const tk = this._peek();
       if (types instanceof Array) {
         const t = tk.type;
-        const index2 = types.indexOf(t);
-        return index2 != -1;
+        const index = types.indexOf(t);
+        return index != -1;
       }
       return tk.type == types;
     }
@@ -2765,6 +2831,11 @@ void main() {
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
         return directive;
       }
+      if (this._match(TokenTypes.keywords.requires)) {
+        const requires = this._requires_directive();
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
+        return requires;
+      }
       if (this._match(TokenTypes.keywords.enable)) {
         const enable = this._enable_directive();
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
@@ -2871,6 +2942,9 @@ void main() {
     _statement() {
       while (this._match(TokenTypes.tokens.semicolon) && !this._isAtEnd())
         ;
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       if (this._check(TokenTypes.keywords.if)) {
         return this._if_statement();
       }
@@ -2930,6 +3004,9 @@ void main() {
         return null;
       }
       const condition = this._optional_paren_expression();
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       const block = this._compound_statement();
       return new While(condition, block);
     }
@@ -2951,6 +3028,9 @@ void main() {
       this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
       const increment = !this._check(TokenTypes.tokens.paren_right) ? this._for_increment() : null;
       this._consume(TokenTypes.tokens.paren_right, "Expected ')'.");
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       const body = this._compound_statement();
       return new For(init, condition, increment, body);
     }
@@ -3048,6 +3128,9 @@ void main() {
       if (!this._match(TokenTypes.keywords.loop)) {
         return null;
       }
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for loop.");
       const statements = [];
       let statement = this._statement();
@@ -3073,6 +3156,9 @@ void main() {
         return null;
       }
       const condition = this._optional_paren_expression();
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for switch.");
       const body = this._switch_body();
       if (body == null || body.length == 0) {
@@ -3086,6 +3172,9 @@ void main() {
       if (this._match(TokenTypes.keywords.case)) {
         const selector = this._case_selectors();
         this._match(TokenTypes.tokens.colon);
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         this._consume(TokenTypes.tokens.brace_left, "Exected '{' for switch case.");
         const body = this._case_body();
         this._consume(TokenTypes.tokens.brace_right, "Exected '}' for switch case.");
@@ -3093,6 +3182,9 @@ void main() {
       }
       if (this._match(TokenTypes.keywords.default)) {
         this._match(TokenTypes.tokens.colon);
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         this._consume(TokenTypes.tokens.brace_left, "Exected '{' for switch default.");
         const body = this._case_body();
         this._consume(TokenTypes.tokens.brace_right, "Exected '}' for switch default.");
@@ -3137,13 +3229,22 @@ void main() {
         return null;
       }
       const condition = this._optional_paren_expression();
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       const block = this._compound_statement();
       let elseif = [];
       if (this._match_elseif()) {
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         elseif = this._elseif_statement(elseif);
       }
       let _else = null;
       if (this._match(TokenTypes.keywords.else)) {
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         _else = this._compound_statement();
       }
       return new If(condition, block, elseif, _else);
@@ -3161,6 +3262,9 @@ void main() {
       const block = this._compound_statement();
       elseif.push(new ElseIf(condition, block));
       if (this._match_elseif()) {
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         this._elseif_statement(elseif);
       }
       return elseif;
@@ -3266,25 +3370,29 @@ void main() {
     _singular_expression() {
       const expr = this._primary_expression();
       const p = this._postfix_expression();
-      if (p)
+      if (p) {
         expr.postfix = p;
+      }
       return expr;
     }
     _postfix_expression() {
       if (this._match(TokenTypes.tokens.bracket_left)) {
         const expr = this._short_circuit_or_expression();
         this._consume(TokenTypes.tokens.bracket_right, "Expected ']'.");
+        const arrayIndex = new ArrayIndex(expr);
         const p = this._postfix_expression();
-        if (p)
-          expr.postfix = p;
-        return expr;
+        if (p) {
+          arrayIndex.postfix = p;
+        }
+        return arrayIndex;
       }
       if (this._match(TokenTypes.tokens.period)) {
         const name = this._consume(TokenTypes.tokens.ident, "Expected member name.");
         const p = this._postfix_expression();
         const expr = new StringExpr(name.lexeme);
-        if (p)
+        if (p) {
           expr.postfix = p;
+        }
         return expr;
       }
       return null;
@@ -3523,6 +3631,14 @@ void main() {
       const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
       return new Enable(name.toString());
     }
+    _requires_directive() {
+      const extensions = [this._consume(TokenTypes.tokens.ident, "identity expected.").toString()];
+      while (this._match(TokenTypes.tokens.comma)) {
+        const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
+        extensions.push(name.toString());
+      }
+      return new Requires(extensions);
+    }
     _type_alias() {
       const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
       this._consume(TokenTypes.tokens.equal, "Expected '=' for type alias.");
@@ -3665,29 +3781,6 @@ void main() {
         }
         attributes.push(attr);
       }
-      while (this._match(TokenTypes.tokens.attr_left)) {
-        if (!this._check(TokenTypes.tokens.attr_right)) {
-          do {
-            const name = this._consume(TokenTypes.attribute_name, "Expected attribute name");
-            const attr = new Attribute(name.toString(), null);
-            if (this._match(TokenTypes.tokens.paren_left)) {
-              attr.value = [
-                this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString()
-              ];
-              if (this._check(TokenTypes.tokens.comma)) {
-                this._advance();
-                do {
-                  const v = this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString();
-                  attr.value.push(v);
-                } while (this._match(TokenTypes.tokens.comma));
-              }
-              this._consume(TokenTypes.tokens.paren_right, "Expected ')'");
-            }
-            attributes.push(attr);
-          } while (this._match(TokenTypes.tokens.comma));
-        }
-        this._consume(TokenTypes.tokens.attr_right, "Expected ']]' after attribute declarations");
-      }
       if (attributes.length == 0) {
         return null;
       }
@@ -4607,17 +4700,11 @@ void main() {
     printRowMajor: true,
     _cartographicRadians: false
   };
-  globalThis.mathgl = globalThis.mathgl || {
-    config: {
-      ...DEFAULT_CONFIG
-    }
-  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
   var config = globalThis.mathgl.config;
-  function formatValue(value, {
-    precision = config.precision
-  } = {}) {
+  function formatValue(value, { precision = config.precision } = {}) {
     value = round(value);
-    return "".concat(parseFloat(value.toPrecision(precision)));
+    return `${parseFloat(value.toPrecision(precision))}`;
   }
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
@@ -4679,28 +4766,12 @@ void main() {
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  function _extendableBuiltin(cls) {
-    function ExtendableBuiltin() {
-      var instance = Reflect.construct(cls, Array.from(arguments));
-      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-      return instance;
-    }
-    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-      constructor: {
-        value: cls,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(ExtendableBuiltin, cls);
-    } else {
-      ExtendableBuiltin.__proto__ = cls;
-    }
-    return ExtendableBuiltin;
-  }
-  var MathArray = class extends _extendableBuiltin(Array) {
+  var MathArray = class extends Array {
+    // Common methods
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
     clone() {
       return new this.constructor().copy(this);
     }
@@ -4720,7 +4791,10 @@ void main() {
       return targetObject;
     }
     from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
+        // @ts-ignore
+        this.fromObject(arrayOrObject)
+      );
     }
     to(arrayOrObject) {
       if (arrayOrObject === this) {
@@ -4731,18 +4805,20 @@ void main() {
     toTarget(target) {
       return target ? this.to(target) : this;
     }
+    /** @deprecated */
     toFloat32Array() {
       return new Float32Array(this);
     }
     toString() {
       return this.formatString(config);
     }
+    /** Formats string according to options */
     formatString(opts) {
       let string = "";
       for (let i = 0; i < this.ELEMENTS; ++i) {
         string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
       }
-      return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
+      return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
     }
     equals(array) {
       if (!array || this.length !== array.length) {
@@ -4766,6 +4842,8 @@ void main() {
       }
       return true;
     }
+    // Modifiers
+    /** Negates all values in this object */
     negate() {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = -this[i];
@@ -4783,12 +4861,14 @@ void main() {
       }
       return this.check();
     }
+    /** Minimal */
     min(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(vector[i], this[i]);
       }
       return this.check();
     }
+    /** Maximal */
     max(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.max(vector[i], this[i]);
@@ -4829,18 +4909,25 @@ void main() {
       }
       return this.check();
     }
+    /**
+     * Multiplies all elements by `scale`
+     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+     */
     multiplyByScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
+    // Debug checks
+    /** Throws an error if array length is incorrect or contains illegal values */
     check() {
       if (config.debug && !this.validate()) {
-        throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
+        throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
       }
       return this;
     }
+    /** Returns false if the array length is incorrect or contains illegal values */
     validate() {
       let valid = this.length === this.ELEMENTS;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -4848,39 +4935,48 @@ void main() {
       }
       return valid;
     }
+    // three.js compatibility
+    /** @deprecated */
     sub(a) {
       return this.subtract(a);
     }
+    /** @deprecated */
     setScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = a;
       }
       return this.check();
     }
+    /** @deprecated */
     addScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] += a;
       }
       return this.check();
     }
+    /** @deprecated */
     subScalar(a) {
       return this.addScalar(-a);
     }
+    /** @deprecated */
     multiplyScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
+    /** @deprecated */
     divideScalar(a) {
       return this.multiplyByScalar(1 / a);
     }
+    /** @deprecated */
     clampScalar(min, max) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(Math.max(this[i], min), max);
       }
       return this.check();
     }
+    /** @deprecated */
     get elements() {
       return this;
     }
@@ -4900,13 +4996,13 @@ void main() {
   }
   function checkNumber(value) {
     if (!Number.isFinite(value)) {
-      throw new Error("Invalid number ".concat(JSON.stringify(value)));
+      throw new Error(`Invalid number ${JSON.stringify(value)}`);
     }
     return value;
   }
   function checkVector(v, length, callerName = "") {
     if (config.debug && !validateVector(v, length)) {
-      throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
+      throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
     }
     return v;
   }
@@ -5031,19 +5127,29 @@ void main() {
 
   // ../../node_modules/@math.gl/core/dist/classes/base/matrix.js
   var Matrix = class extends MathArray {
+    // fromObject(object) {
+    //   const array = object.elements;
+    //   return this.fromRowMajor(array);
+    // }
+    // toObject(object) {
+    //   const array = object.elements;
+    //   this.toRowMajor(array);
+    //   return object;
+    // }
+    // TODO better override formatString?
     toString() {
       let string = "[";
       if (config.printRowMajor) {
         string += "row-major:";
         for (let row = 0; row < this.RANK; ++row) {
           for (let col = 0; col < this.RANK; ++col) {
-            string += " ".concat(this[col * this.RANK + row]);
+            string += ` ${this[col * this.RANK + row]}`;
           }
         }
       } else {
         string += "column-major:";
         for (let i = 0; i < this.ELEMENTS; ++i) {
-          string += " ".concat(this[i]);
+          string += ` ${this[i]}`;
         }
       }
       string += "]";
@@ -5052,9 +5158,11 @@ void main() {
     getElementIndex(row, col) {
       return col * this.RANK + row;
     }
+    // By default assumes row major indices
     getElement(row, col) {
       return this[col * this.RANK + row];
     }
+    // By default assumes row major indices
     setElement(row, col, value) {
       this[col * this.RANK + row] = checkNumber(value);
       return this;
@@ -5820,6 +5928,7 @@ void main() {
       this[15] = array[15];
       return this.check();
     }
+    // eslint-disable-next-line max-params
     set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {
       this[0] = m00;
       this[1] = m10;
@@ -5839,6 +5948,8 @@ void main() {
       this[15] = m33;
       return this.check();
     }
+    // accepts row major order, stores as column major
+    // eslint-disable-next-line max-params
     setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
       this[0] = m00;
       this[1] = m10;
@@ -5877,25 +5988,41 @@ void main() {
       result[15] = this[15];
       return result;
     }
+    // Constructors
+    /** Set to identity matrix */
     identity() {
       return this.copy(IDENTITY_MATRIX);
     }
+    /**
+     *
+     * @param object
+     * @returns self
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     fromObject(object) {
       return this.check();
     }
+    /**
+     * Calculates a 4x4 matrix from the given quaternion
+     * @param quaternion Quaternion to create matrix from
+     * @returns self
+     */
     fromQuaternion(quaternion) {
       fromQuat(this, quaternion);
       return this.check();
     }
+    /**
+     * Generates a frustum matrix with the given bounds
+     * @param view.left - Left bound of the frustum
+     * @param view.right - Right bound of the frustum
+     * @param view.bottom - Bottom bound of the frustum
+     * @param view.top - Top bound of the frustum
+     * @param view.near - Near bound of the frustum
+     * @param view.far - Far bound of the frustum. Can be set to Infinity.
+     * @returns self
+     */
     frustum(view) {
-      const {
-        left,
-        right,
-        bottom,
-        top,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       if (far === Infinity) {
         computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
       } else {
@@ -5903,35 +6030,47 @@ void main() {
       }
       return this.check();
     }
+    /**
+     * Generates a look-at matrix with the given eye position, focal point,
+     * and up axis
+     * @param view.eye - (vector) Position of the viewer
+     * @param view.center - (vector) Point the viewer is looking at
+     * @param view.up - (vector) Up axis
+     * @returns self
+     */
     lookAt(view) {
-      const {
-        eye,
-        center = [0, 0, 0],
-        up = [0, 1, 0]
-      } = view;
+      const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
       lookAt(this, eye, center, up);
       return this.check();
     }
+    /**
+     * Generates a orthogonal projection matrix with the given bounds
+     * from "traditional" view space parameters
+     * @param view.left - Left bound of the frustum
+     * @param view.right number  Right bound of the frustum
+     * @param view.bottom - Bottom bound of the frustum
+     * @param view.top number  Top bound of the frustum
+     * @param view.near - Near bound of the frustum
+     * @param view.far number  Far bound of the frustum
+     * @returns self
+     */
     ortho(view) {
-      const {
-        left,
-        right,
-        bottom,
-        top,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       ortho(this, left, right, bottom, top, near, far);
       return this.check();
     }
+    /**
+     * Generates an orthogonal projection matrix with the same parameters
+     * as a perspective matrix (plus focalDistance)
+     * @param view.fovy Vertical field of view in radians
+     * @param view.aspect Aspect ratio. Typically viewport width / viewport height
+     * @param view.focalDistance Distance in the view frustum used for extent calculations
+     * @param view.near Near bound of the frustum
+     * @param view.far Far bound of the frustum
+     * @returns self
+     */
     orthographic(view) {
-      const {
-        fovy = DEFAULT_FOVY,
-        aspect = DEFAULT_ASPECT,
-        focalDistance = 1,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { fovy = DEFAULT_FOVY, aspect = DEFAULT_ASPECT, focalDistance = 1, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       checkRadians(fovy);
       const halfY = fovy / 2;
       const top = focalDistance * Math.tan(halfY);
@@ -5945,32 +6084,53 @@ void main() {
         far
       });
     }
+    /**
+     * Generates a perspective projection matrix with the given bounds
+     * @param view.fovy Vertical field of view in radians
+     * @param view.aspect Aspect ratio. typically viewport width/height
+     * @param view.near Near bound of the frustum
+     * @param view.far Far bound of the frustum
+     * @returns self
+     */
     perspective(view) {
-      const {
-        fovy = 45 * Math.PI / 180,
-        aspect = 1,
-        near = 0.1,
-        far = 500
-      } = view;
+      const { fovy = 45 * Math.PI / 180, aspect = 1, near = 0.1, far = 500 } = view;
       checkRadians(fovy);
       perspective(this, fovy, aspect, near, far);
       return this.check();
     }
+    // Accessors
     determinant() {
       return determinant(this);
     }
+    /**
+     * Extracts the non-uniform scale assuming the matrix is an affine transformation.
+     * The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix.
+     * @param result
+     * @returns self
+     */
     getScale(result = [-0, -0, -0]) {
       result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);
       result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]);
       result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]);
       return result;
     }
+    /**
+     * Gets the translation portion, assuming the matrix is a affine transformation matrix.
+     * @param result
+     * @returns self
+     */
     getTranslation(result = [-0, -0, -0]) {
       result[0] = this[12];
       result[1] = this[13];
       result[2] = this[14];
       return result;
     }
+    /**
+     * Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix
+     * @param result
+     * @param scaleResult
+     * @returns self
+     */
     getRotation(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
@@ -5996,6 +6156,12 @@ void main() {
       result[15] = 1;
       return result;
     }
+    /**
+     *
+     * @param result
+     * @param scaleResult
+     * @returns self
+     */
     getRotationMatrix3(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
@@ -6014,6 +6180,7 @@ void main() {
       result[8] = this[10] * inverseScale2;
       return result;
     }
+    // Modifiers
     transpose() {
       transpose(this, this);
       return this.check();
@@ -6022,6 +6189,7 @@ void main() {
       invert(this, this);
       return this.check();
     }
+    // Operations
     multiplyLeft(a) {
       multiply(this, a, this);
       return this.check();
@@ -6030,33 +6198,68 @@ void main() {
       multiply(this, this, a);
       return this.check();
     }
+    // Rotates a matrix by the given angle around the X axis
     rotateX(radians2) {
       rotateX(this, this, radians2);
       return this.check();
     }
+    // Rotates a matrix by the given angle around the Y axis.
     rotateY(radians2) {
       rotateY(this, this, radians2);
       return this.check();
     }
+    /**
+     * Rotates a matrix by the given angle around the Z axis.
+     * @param radians
+     * @returns self
+     */
     rotateZ(radians2) {
       rotateZ(this, this, radians2);
       return this.check();
     }
+    /**
+     *
+     * @param param0
+     * @returns self
+     */
     rotateXYZ(angleXYZ) {
       return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
     }
+    /**
+     *
+     * @param radians
+     * @param axis
+     * @returns self
+     */
     rotateAxis(radians2, axis) {
       rotate(this, this, radians2, axis);
       return this.check();
     }
+    /**
+     *
+     * @param factor
+     * @returns self
+     */
     scale(factor) {
       scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
       return this.check();
     }
+    /**
+     *
+     * @param vec
+     * @returns self
+     */
     translate(vector) {
       translate(this, this, vector);
       return this.check();
     }
+    // Transforms
+    /**
+     * Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transform(vector, result) {
       if (vector.length === 4) {
         result = transformMat43(result || [-0, -0, -0, -0], vector, this);
@@ -6065,10 +6268,14 @@ void main() {
       }
       return this.transformAsPoint(vector, result);
     }
+    /**
+     * Transforms any 2 or 3 element array as point (w implicitly 1)
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transformAsPoint(vector, result) {
-      const {
-        length
-      } = vector;
+      const { length } = vector;
       let out;
       switch (length) {
         case 2:
@@ -6083,6 +6290,12 @@ void main() {
       checkVector(out, vector.length);
       return out;
     }
+    /**
+     * Transforms any 2 or 3 element array as vector (w implicitly 0)
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transformAsVector(vector, result) {
       let out;
       switch (vector.length) {
@@ -6098,15 +6311,19 @@ void main() {
       checkVector(out, vector.length);
       return out;
     }
+    /** @deprecated */
     transformPoint(vector, result) {
       return this.transformAsPoint(vector, result);
     }
+    /** @deprecated */
     transformVector(vector, result) {
       return this.transformAsPoint(vector, result);
     }
+    /** @deprecated */
     transformDirection(vector, result) {
       return this.transformAsVector(vector, result);
     }
+    // three.js math API compatibility
     makeRotationX(radians2) {
       return this.identity().rotateX(radians2);
     }
@@ -6262,28 +6479,31 @@ void main() {
     const matrixFP64 = new Float32Array(32);
     for (let i = 0; i < 4; ++i) {
       for (let j = 0; j < 4; ++j) {
-        const index2 = i * 4 + j;
-        fp64ify(matrix[j * 4 + i], matrixFP64, index2 * 2);
+        const index = i * 4 + j;
+        fp64ify(matrix[j * 4 + i], matrixFP64, index * 2);
       }
     }
     return matrixFP64;
   }
 
   // src/modules/math/random/random.ts
-  var fs = glsl`\
-float random(vec3 scale, float seed) {
+  var fs = (
+    /* glsl */
+    `float random(vec3 scale, float seed) {
   /* use the fragment position for a different seed per-pixel */
   return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
 }
-`;
+`
+  );
   var random = {
     name: "random",
     fs
   };
 
   // src/modules/math/fp32/fp32.ts
-  var fp32shader = glsl`\
-#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND
+  var fp32shader = (
+    /* glsl */
+    `#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND
 
 // All these functions are for substituting tan() function from Intel GPU only
 const float TWO_PI = 6.2831854820251465;
@@ -6433,7 +6653,8 @@ float tan_fp32(float a) {
   return tan(a);
 #endif
 }
-`;
+`
+  );
   var fp32 = {
     name: "fp32",
     vs: fp32shader
@@ -6441,8 +6662,9 @@ float tan_fp32(float a) {
 
   // src/modules/engine/picking/picking.ts
   var DEFAULT_HIGHLIGHT_COLOR = new Float32Array([0, 1, 1, 1]);
-  var vs = glsl`\
-uniform pickingUniforms {
+  var vs = (
+    /* glsl */
+    `uniform pickingUniforms {
   float isActive;
   float isAttribute;
   float isHighlightActive;
@@ -6513,9 +6735,11 @@ void picking_setPickingAttribute(vec3 value) {
     picking_vRGBcolor_Avalid.rgb = value;
   }
 }
-`;
-  var fs2 = glsl`\
-uniform pickingUniforms {
+`
+  );
+  var fs2 = (
+    /* glsl */
+    `uniform pickingUniforms {
   float isActive;
   float isAttribute;
   float isHighlightActive;
@@ -6571,8 +6795,11 @@ vec4 picking_filterColor(vec4 color) {
   vec4 highlightColor = picking_filterHighlightColor(color);
   return picking_filterPickingColor(highlightColor);
 }
-`;
+`
+  );
   var picking = {
+    props: {},
+    uniforms: {},
     name: "picking",
     uniformTypes: {
       isActive: "f32",
@@ -6592,8 +6819,6 @@ vec4 picking_filterColor(vec4 color) {
     },
     vs,
     fs: fs2,
-    props: {},
-    uniforms: {},
     getUniforms
   };
   function getUniforms(opts = {}, prevUniforms) {
@@ -6624,8 +6849,9 @@ vec4 picking_filterColor(vec4 color) {
   }
 
   // src/modules/lighting/lights/lighting-uniforms-glsl.ts
-  var lightingUniforms = glsl`\
-precision highp int;
+  var lightingUniformsGLSL = (
+    /* glsl */
+    `precision highp int;
 
 // #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
 struct AmbientLight {
@@ -6676,12 +6902,72 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 }
 
 // #endif
-`;
+`
+  );
+
+  // src/modules/lighting/lights/lighting-uniforms-wgsl.ts
+  var lightingUniformsWGSL = (
+    /* wgsl */
+    `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+struct AmbientLight {
+  color: vec3<f32>,
+};
+
+struct PointLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
+};
+
+struct DirectionalLight {
+  color: vec3<f32>,
+  direction: vec3<f32>,
+};
+
+struct lightingUniforms {
+  enabled: i32,
+  poightCount: i32,
+  directionalLightCount: i32,
+
+  ambientColor: vec3<f32>,
+
+  // TODO - support multiple lights by uncommenting arrays below
+  lightType: i32,
+  lightColor: vec3<f32>,
+  lightDirection: vec3<f32>,
+  lightPosition: vec3<f32>,
+  lightAttenuation: vec3<f32>,
+
+  // AmbientLight ambientLight;
+  // PointLight pointLight[MAX_LIGHTS];
+  // DirectionalLight directionalLight[MAX_LIGHTS];
+};
+
+// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
+@binding(1) @group(0) var<uniform> lighting : lightingUniforms;
+
+fn lighting_getPointLight(index: i32) -> PointLight {
+  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+}
+
+fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
+  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
+} 
+
+fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
+  return pointLight.attenuation.x
+       + pointLight.attenuation.y * distance
+       + pointLight.attenuation.z * distance * distance;
+}
+`
+  );
 
   // src/modules/lighting/lights/lighting.ts
   var MAX_LIGHTS = 5;
   var COLOR_FACTOR = 255;
   var lighting = {
+    props: {},
+    uniforms: {},
     name: "lighting",
     defines: {
       MAX_LIGHTS
@@ -6714,10 +7000,9 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
       lightDirection: [1, 1, 1],
       lightAttenuation: [1, 1, 1]
     },
-    vs: lightingUniforms,
-    fs: lightingUniforms,
-    props: {},
-    uniforms: {},
+    source: lightingUniformsWGSL,
+    vs: lightingUniformsGLSL,
+    fs: lightingUniformsGLSL,
     getUniforms: getUniforms2
   };
   function getUniforms2(props, prevUniforms = {}) {
@@ -6798,15 +7083,48 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
   }
 
   // src/modules/lighting/no-material/dirlight.ts
-  var VS_GLSL = glsl`\
-out vec3 dirlight_vNormal;
+  var SOURCE_WGSL = (
+    /* WGSL */
+    `  
+struct dirlightUniforms {
+  lightDirection: vec3<f32>,
+};
+
+alias DirlightNormal = vec3<f32>;
+
+struct DirlightInputs {
+  normal: DirlightNormal,
+};
+
+@binding(1) @group(0) var<uniform> dirlight : dirlightUniforms;
+
+// For vertex
+fn dirlight_setNormal(normal: vec3<f32>) -> DirlightNormal {
+  return normalize(normal);
+}
+
+// Returns color attenuated by angle from light source
+fn dirlight_filterColor(color: vec4<f32>, inputs: DirlightInputs) -> vec4<f32> {
+  // TODO - fix default light direction
+  // let lightDirection = dirlight.lightDirection;
+  let lightDirection = vec3<f32>(1, 1, 1);
+  let d: f32 = abs(dot(inputs.normal, normalize(lightDirection)));
+  return vec4<f32>(color.rgb * d, color.a);
+}
+`
+  );
+  var VS_GLSL = (
+    /* glsl */
+    `out vec3 dirlight_vNormal;
 
 void dirlight_setNormal(vec3 normal) {
   dirlight_vNormal = normalize(normal);
 }
-`;
-  var FS_GLSL = glsl`\
-uniform dirlightUniforms {
+`
+  );
+  var FS_GLSL = (
+    /* glsl */
+    `uniform dirlightUniforms {
   vec3 lightDirection;
 } dirlight;
 
@@ -6817,10 +7135,14 @@ vec4 dirlight_filterColor(vec4 color) {
   float d = abs(dot(dirlight_vNormal, normalize(dirlight.lightDirection)));
   return vec4(color.rgb * d, color.a);
 }
-`;
+`
+  );
   var dirlight = {
+    props: {},
+    uniforms: {},
     name: "dirlight",
     dependencies: [],
+    source: SOURCE_WGSL,
     vs: VS_GLSL,
     fs: FS_GLSL,
     // fragmentInputs: [
@@ -6835,8 +7157,6 @@ vec4 dirlight_filterColor(vec4 color) {
     defaultUniforms: {
       lightDirection: new Float32Array([1, 1, 2])
     },
-    props: {},
-    uniforms: {},
     getUniforms: getUniforms3
   };
   function getUniforms3(opts = dirlight.defaultUniforms) {
@@ -6848,16 +7168,19 @@ vec4 dirlight_filterColor(vec4 color) {
   }
 
   // src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts
-  var GOURAUD_VS = glsl`\
-uniform materialUniforms {
+  var GOURAUD_VS = (
+    /* glsl */
+    `uniform materialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
   uniform vec3  specularColor;
 } material;
-`;
-  var GOURAUD_FS = glsl`\
-uniform materialUniforms {
+`
+  );
+  var GOURAUD_FS = (
+    /* glsl */
+    `uniform materialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -6938,10 +7261,13 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   }
   return lightColor;
 }
-`;
+`
+  );
 
   // src/modules/lighting/gouraud-material/gouraud-material.ts
   var gouraudMaterial = {
+    props: {},
+    uniforms: {},
     name: "gouraud-lighting",
     // Note these are switched between phong and gouraud
     vs: GOURAUD_VS,
@@ -6967,17 +7293,111 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
     }
   };
 
+  // src/modules/lighting/phong-material/phong-shaders-wgsl.ts
+  var PHONG_WGSL = (
+    /* wgsl */
+    `struct phongMaterialUniforms {
+  ambient: f32,
+  diffuse: f32,
+  shininess: f32,
+  specularColor: vec3<f32>,
+};
+
+@binding(2) @group(0) var<uniform> material : phongMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
+  var lambertian: f32 = dot(light_direction, normal_worldspace);
+  var specular: f32 = 0.0;
+  if (lambertian > 0.0) {
+    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, material.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  if (lighting.lightType == 0) {
+    let pointLight: PointLight  = lighting_getPointLight(0);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  } else if (lighting.lightType == 1) {
+    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  return lightColor;
+  /*
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.pointLightCount) {
+      break;
+    }
+    PointLight pointLight = lighting.pointLight[i];
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  }
+
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.directionalLightCount) {
+      break;
+    }
+    DirectionalLight directionalLight = lighting.directionalLight[i];
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  */
+}
+
+fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{
+  var lightColor = vec3<f32>(0, 0, 0);
+  let surfaceColor = vec3<f32>(0, 0, 0);
+
+  if (lighting.enabled == 0) {
+    let view_direction = normalize(cameraPosition - position_worldspace);
+
+    switch (lighting.lightType) {
+      case 0, default: {
+        let pointLight: PointLight = lighting_getPointLight(0);
+        let light_position_worldspace: vec3<f32> = pointLight.position;
+        let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+      }
+      case 1: {
+        let directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+      }
+    }
+  }
+  return lightColor;
+}
+`
+  );
+
   // src/modules/lighting/phong-material/phong-shaders-glsl.ts
-  var PHONG_VS = glsl`\
-uniform phongMaterialUniforms {
+  var PHONG_VS = (
+    /* glsl */
+    `uniform phongMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
   uniform vec3  specularColor;
 } material;
-`;
-  var PHONG_FS = glsl`\
-uniform phongMaterialUniforms {
+`
+  );
+  var PHONG_FS = (
+    /* glsl */
+    `uniform phongMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -7061,18 +7481,22 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   }
   return lightColor;
 }
-`;
+`
+  );
 
   // src/modules/lighting/phong-material/phong-material.ts
   var phongMaterial = {
+    props: {},
+    uniforms: {},
     name: "phong-lighting",
+    dependencies: [lighting],
     // Note these are switched between phong and gouraud
+    source: PHONG_WGSL,
     vs: PHONG_VS,
     fs: PHONG_FS,
     defines: {
       LIGHTING_FRAGMENT: 1
     },
-    dependencies: [lighting],
     uniformTypes: {
       ambient: "f32",
       diffuse: "f32",
@@ -7085,16 +7509,15 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
       shininess: 32,
       specularColor: [0.15, 0.15, 0.15]
     },
-    props: {},
-    uniforms: {},
     getUniforms(props) {
       return { ...phongMaterial.defaultUniforms, ...props };
     }
   };
 
   // src/modules/lighting/pbr-material/pbr-vertex-glsl.ts
-  var vs2 = glsl`\
-uniform projection {
+  var vs2 = (
+    /* glsl */
+    `uniform projection {
   mat4 u_MVPMatrix;
   mat4 u_ModelMatrix;
   mat4 u_NormalMatrix;
@@ -7135,11 +7558,13 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
   pbr_vUV = vec2(0.,0.);
 #endif
 }
-`;
+`
+  );
 
   // src/modules/lighting/pbr-material/pbr-fragment-glsl.ts
-  var fs3 = glsl`\
-precision highp float;
+  var fs3 = (
+    /* glsl */
+    `precision highp float;
 
 uniform Projection {
   // Projection
@@ -7544,11 +7969,15 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
   return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
 }
-`;
+`
+  );
 
   // src/modules/lighting/pbr-material/pbr-material.ts
   var pbrMaterial = {
+    props: {},
+    uniforms: {},
     name: "pbr",
+    dependencies: [lighting],
     vs: vs2,
     fs: fs3,
     defines: {
@@ -7609,13 +8038,13 @@ vec4 pbr_filterColor(vec4 colorUnused)
       // #ifdef USE_IBL (samplerCube)
       brdfLUT: { type: "texture", location: 15 }
       // #ifdef USE_IBL
-    },
-    dependencies: [lighting]
+    }
   };
 
   // src/modules/postprocessing/image-adjust-filters/brightnesscontrast.ts
-  var fs4 = glsl`\
-
+  var fs4 = (
+    /* glsl */
+    `
 uniform brightnessContrastUniforms {
   float brightness;
   float contrast;
@@ -7634,8 +8063,11 @@ vec4 brightnessContrast_filterColor(vec4 color) {
 vec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {
   return brightnessContrast_filterColor(color);
 }
-`;
+`
+  );
   var brightnessContrast = {
+    props: {},
+    uniforms: {},
     name: "brightnessContrast",
     uniformTypes: {
       brightness: "f32",
@@ -7650,8 +8082,9 @@ vec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {
   };
 
   // src/modules/postprocessing/image-adjust-filters/denoise.ts
-  var fs5 = glsl`\
-uniform denoiseUniforms {
+  var fs5 = (
+    /* glsl */
+    `uniform denoiseUniforms {
   float strength;
 } noise;
 
@@ -7673,8 +8106,11 @@ vec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 
   return color / total;
 }
-`;
+`
+  );
   var denoise = {
+    props: {},
+    uniforms: {},
     name: "denoise",
     uniformTypes: {
       strength: "f32"
@@ -7688,8 +8124,9 @@ vec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-adjust-filters/huesaturation.ts
-  var fs6 = glsl`\
-uniform hueSaturationUniforms {
+  var fs6 = (
+    /* glsl */
+    `uniform hueSaturationUniforms {
   float hue;
   float saturation;
 } hueSaturation;
@@ -7720,9 +8157,13 @@ vec4 hueSaturation_filterColor(vec4 color) {
 vec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   return hueSaturation_filterColor(color);
 }
-`;
+`
+  );
   var hueSaturation = {
+    props: {},
+    uniforms: {},
     name: "hueSaturation",
+    fs: fs6,
     uniformTypes: {
       hue: "f32",
       saturation: "f32"
@@ -7731,13 +8172,13 @@ vec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
       hue: { value: 0, min: -1, max: 1 },
       saturation: { value: 0, min: -1, max: 1 }
     },
-    fs: fs6,
     passes: [{ filter: true }]
   };
 
   // src/modules/postprocessing/image-adjust-filters/noise.ts
-  var fs7 = glsl`\
-uniform noiseUniforms {
+  var fs7 = (
+    /* glsl */
+    `uniform noiseUniforms {
   float amount;
 } noise;
 
@@ -7756,8 +8197,11 @@ vec4 noise_filterColor(vec4 color, vec2 texCoord) {
 vec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   return noise_filterColor(color, texCoord);
 }
-`;
+`
+  );
   var noise = {
+    props: {},
+    uniforms: {},
     name: "noise",
     uniformTypes: {
       amount: "f32"
@@ -7770,8 +8214,9 @@ vec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-adjust-filters/sepia.ts
-  var fs8 = glsl`\
-uniform sepiaUniforms {
+  var fs8 = (
+    /* glsl */
+    `uniform sepiaUniforms {
   float amount;
 } sepia;
 
@@ -7791,8 +8236,11 @@ vec4 sepia_filterColor(vec4 color) {
 vec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   return sepia_filterColor(color);
 }
-`;
+`
+  );
   var sepia = {
+    props: {},
+    uniforms: {},
     name: "sepia",
     uniformTypes: {
       amount: "f32"
@@ -7805,8 +8253,9 @@ vec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-adjust-filters/vibrance.ts
-  var fs9 = glsl`\
-uniform vibranceUniforms {
+  var fs9 = (
+    /* glsl */
+    `uniform vibranceUniforms {
   float amount;
 } vibrance;
 
@@ -7821,8 +8270,11 @@ vec4 vibrance_filterColor(vec4 color) {
 vec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   return vibrance_filterColor(color);
 }
-`;
+`
+  );
   var vibrance = {
+    props: {},
+    uniforms: {},
     name: "vibrance",
     uniformPropTypes: {
       amount: { value: 0, min: -1, max: 1 }
@@ -7832,8 +8284,9 @@ vec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-adjust-filters/vignette.ts
-  var fs10 = glsl`\
-uniform vignetteUniforms {
+  var fs10 = (
+    /* glsl */
+    `uniform vignetteUniforms {
   float radius;
   float amount;
 } vignette;
@@ -7847,10 +8300,12 @@ vec4 vignette_filterColor(vec4 color, vec2 texCoord) {
 vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   return vignette_filterColor(color, texCoord);
 }
-`;
+`
+  );
   var vignette = {
+    props: {},
+    uniforms: {},
     name: "vignette",
-    fs: fs10,
     uniformTypes: {
       radius: "f32",
       amount: "f32"
@@ -7859,12 +8314,14 @@ vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
       radius: { value: 0.5, min: 0, max: 1 },
       amount: { value: 0.5, min: 0, max: 1 }
     },
-    passes: [{ filter: true }]
+    passes: [{ filter: true }],
+    fs: fs10
   };
 
   // src/modules/postprocessing/image-blur-filters/tiltshift.ts
-  var fs11 = glsl`\
-uniform tiltShiftUniforms {
+  var fs11 = (
+    /* glsl */
+    `uniform tiltShiftUniforms {
   float blurRadius;
   float gradientRadius;
   vec2 start;
@@ -7907,8 +8364,11 @@ vec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 
   return color;
 }
-`;
+`
+  );
   var tiltShift = {
+    props: {},
+    uniforms: {},
     name: "tiltShift",
     dependencies: [random],
     uniformTypes: {
@@ -7933,8 +8393,9 @@ vec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-blur-filters/triangleblur.ts
-  var fs12 = glsl`\
-uniform triangleBlurUniforms {
+  var fs12 = (
+    /* glsl */
+    `uniform triangleBlurUniforms {
   float radius;
   vec2 delta;
 } triangleBlur;
@@ -7967,8 +8428,11 @@ vec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 
   return color;
 }
-`;
+`
+  );
   var triangleBlur = {
+    props: {},
+    uniforms: {},
     name: "triangleBlur",
     uniformTypes: {
       radius: "f32",
@@ -8022,6 +8486,8 @@ vec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 }
 `;
   var zoomBlur = {
+    props: {},
+    uniforms: {},
     name: "zoomBlur",
     uniformTypes: {
       center: "vec2<f32>",
@@ -8037,8 +8503,9 @@ vec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-fun-filters/colorhalftone.ts
-  var fs14 = glsl`\
-uniform colorHalftoneUniforms {
+  var fs14 = (
+    /* glsl */
+    `uniform colorHalftoneUniforms {
   vec2 center;
   float angle;
   float size;
@@ -8072,8 +8539,11 @@ vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);
   return vec4(1.0 - cmy - k, color.a);
 }
-`;
+`
+  );
   var colorHalftone = {
+    props: {},
+    uniforms: {},
     name: "colorHalftone",
     uniformTypes: {
       center: "vec2<f32>",
@@ -8090,8 +8560,9 @@ vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-fun-filters/dotscreen.ts
-  var fs15 = glsl`\
-uniform dotScreenUniforms {
+  var fs15 = (
+    /* glsl */
+    `uniform dotScreenUniforms {
   vec2 center;
   float angle;
   float size;
@@ -8113,8 +8584,11 @@ vec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   float average = (color.r + color.g + color.b) / 3.0;
   return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);
 }
-`;
+`
+  );
   var dotScreen = {
+    props: {},
+    uniforms: {},
     name: "dotScreen",
     uniformTypes: {
       center: "vec2<f32>",
@@ -8131,8 +8605,9 @@ vec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-fun-filters/edgework.ts
-  var fs16 = glsl`\
-uniform edgeWorkUniforms {
+  var fs16 = (
+    /* glsl */
+    `uniform edgeWorkUniforms {
   float radius;
   vec2 delta;
 } edgeWork;
@@ -8186,15 +8661,18 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);
   return vec4(c, c, c, 1.0);
 }
-`;
+`
+  );
   var edgeWork = {
+    props: {},
+    uniforms: {},
     name: "edgeWork",
+    dependencies: [random],
+    fs: fs16,
     uniformPropTypes: {
       radius: { value: 2, min: 1, softMax: 50 },
       delta: { value: [1, 0], private: true }
     },
-    fs: fs16,
-    dependencies: [random],
     passes: [
       {
         // @ts-expect-error
@@ -8210,8 +8688,9 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-fun-filters/hexagonalpixelate.ts
-  var fs17 = glsl`\
-uniform hexagonalPixelateUniforms {
+  var fs17 = (
+    /* glsl */
+    `uniform hexagonalPixelateUniforms {
   vec2 center;
   float scale;
 } hexagonalPixelate;
@@ -8253,8 +8732,11 @@ vec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord
 
   return texture(source, choice + hexagonalPixelate.center);
 }
-`;
+`
+  );
   var hexagonalPixelate = {
+    props: {},
+    uniforms: {},
     name: "hexagonalPixelate",
     uniformTypes: {
       center: "vec2<f32>",
@@ -8269,8 +8751,9 @@ vec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord
   };
 
   // src/modules/postprocessing/image-fun-filters/ink.ts
-  var fs18 = glsl`\
-uniform inkUniforms {
+  var fs18 = (
+    /* glsl */
+    `uniform inkUniforms {
   float strength;
 } ink;
 
@@ -8297,22 +8780,26 @@ vec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;
   return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);
 }
-`;
+`
+  );
   var ink = {
+    props: {},
+    uniforms: {},
     name: "ink",
+    fs: fs18,
     uniformTypes: {
       strength: "f32"
     },
     uniformPropTypes: {
       strength: { value: 0.25, min: 0, softMax: 1 }
     },
-    fs: fs18,
     passes: [{ sampler: true }]
   };
 
   // src/modules/postprocessing/image-fun-filters/magnify.ts
-  var fs19 = glsl`\
-uniform magnifyUniforms {
+  var fs19 = (
+    /* glsl */
+    `uniform magnifyUniforms {
   vec2 screenXY;
   float radiusPixels;
   float zoom;
@@ -8332,7 +8819,8 @@ vec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   }
   return texture(source, texCoord);
 }
-`;
+`
+  );
   var magnify = {
     name: "magnify",
     uniformTypes: {
@@ -8355,8 +8843,9 @@ vec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-warp-filters/warp.ts
-  var fs20 = glsl`\
-vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {
+  var fs20 = (
+    /* glsl */
+    `vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {
   vec4 color = texture(source, coord / texSize);
   vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);
   if (coord != clampedCoord) {
@@ -8366,7 +8855,8 @@ vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {
 
   return color;
 }
-`;
+`
+  );
   var warp = {
     name: "warp",
     passes: [],
@@ -8374,8 +8864,9 @@ vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {
   };
 
   // src/modules/postprocessing/image-warp-filters/bulgepinch.ts
-  var fs21 = glsl`\
-uniform bulgePinchUniforms {
+  var fs21 = (
+    /* glsl */
+    `uniform bulgePinchUniforms {
   float radius;
   float strength;
   vec2 center;
@@ -8402,8 +8893,11 @@ vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 
   return warp_sampleColor(source, texSize, coord);
 }
-`;
+`
+  );
   var bulgePinch = {
+    props: {},
+    uniforms: {},
     name: "bulgePinch",
     dependencies: [warp],
     fs: fs21,
@@ -8421,8 +8915,9 @@ vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules/postprocessing/image-warp-filters/swirl.ts
-  var fs22 = glsl`\
-uniform swirlUniforms {
+  var fs22 = (
+    /* glsl */
+    `uniform swirlUniforms {
   float radius;
   float angle;
   vec2 center;
@@ -8451,8 +8946,11 @@ vec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 
   return warp_sampleColor(source, texSize, coord);
 }
-`;
+`
+  );
   var swirl = {
+    props: {},
+    uniforms: {},
     name: "swirl",
     dependencies: [warp],
     fs: fs22,
@@ -9060,8 +9558,9 @@ vec4 fxaa_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/modules-webgl1/math/fp64/fp64-arithmetic-glsl.ts
-  var fp64arithmeticShader = glsl`\
-uniform float ONE;
+  var fp64arithmeticShader = (
+    /* glsl */
+    `uniform float ONE;
 
 /*
 About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
@@ -9226,11 +9725,13 @@ vec2 sqrt_fp64(vec2 a) {
   return sum_fp64(vec2(yn, 0.0), prod);
 #endif
 }
-`;
+`
+  );
 
   // src/modules-webgl1/math/fp64/fp64-functions-glsl.ts
-  var fp64functionShader = glsl`\
-const vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);
+  var fp64functionShader = (
+    /* glsl */
+    `const vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);
 const vec2 LOG2_FP64 = vec2(0.6931471824645996e+00, -1.9046542121259336e-09);
 const vec2 PI_FP64 = vec2(3.1415927410125732, -8.742278012618954e-8);
 const vec2 TWO_PI_FP64 = vec2(6.2831854820251465, -1.7484556025237907e-7);
@@ -9899,7 +10400,8 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
     vec4_dot_fp64(a, tmp, out_val[i]);
   }
 }
-`;
+`
+  );
 
   // src/modules-webgl1/math/fp64/fp64.ts
   var CONST_UNIFORMS = {
@@ -9928,8 +10430,9 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
   };
 
   // src/modules-webgl1/geometry/geometry.ts
-  var vs3 = glsl`\
-varying vec4 geometry_vPosition;
+  var vs3 = (
+    /* glsl */
+    `varying vec4 geometry_vPosition;
 varying vec3 geometry_vNormal;
 
 void geometry_setNormal(vec3 normal) {
@@ -9943,9 +10446,11 @@ void geometry_setPosition(vec4 position) {
 void geometry_setPosition(vec3 position) {
   geometry_vPosition = vec4(position, 1.);
 }
-`;
-  var fs24 = glsl`\
-varying vec4 geometry_vPosition;
+`
+  );
+  var fs24 = (
+    /* glsl */
+    `varying vec4 geometry_vPosition;
 varying vec3 geometry_vNormal;
 
 vec4 geometry_getPosition() {
@@ -9955,7 +10460,8 @@ vec4 geometry_getPosition() {
 vec3 geometry_getNormal() {
   return geometry_vNormal;
 }
-`;
+`
+  );
   var geometry = {
     name: "geometry",
     vs: vs3,
@@ -9991,8 +10497,9 @@ vec3 geometry_getNormal() {
     }
     return uniforms;
   }
-  var common = glsl`\
-varying vec4 project_vPositionWorld;
+  var common = (
+    /* glsl */
+    `varying vec4 project_vPositionWorld;
 varying vec3 project_vNormalWorld;
 
 vec4 project_getPosition_World() {
@@ -10002,7 +10509,8 @@ vec4 project_getPosition_World() {
 vec3 project_getNormal_World() {
   return project_vNormalWorld;
 }
-`;
+`
+  );
   var vs4 = `${common}
 
 // Unprefixed uniforms
@@ -10067,8 +10575,9 @@ ${common}`;
   };
 
   // src/modules-webgl1/lighting/lights/lights-glsl.ts
-  var lightingShader = glsl`\
-#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+  var lightingShader = (
+    /* glsl */
+    `#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
 
 struct AmbientLight {
  vec3 color;
@@ -10102,7 +10611,8 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 }
 
 #endif
-`;
+`
+  );
 
   // src/modules-webgl1/lighting/lights/lights.ts
   var INITIAL_MODULE_OPTIONS = {
@@ -10123,19 +10633,19 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     } else {
       lightSourceUniforms["lighting_uAmbientLight.color"] = [0, 0, 0];
     }
-    pointLights.forEach((pointLight, index2) => {
-      lightSourceUniforms[`lighting_uPointLight[${index2}].color`] = convertColor2(pointLight);
-      lightSourceUniforms[`lighting_uPointLight[${index2}].position`] = pointLight.position;
-      lightSourceUniforms[`lighting_uPointLight[${index2}].attenuation`] = pointLight.attenuation || [
+    pointLights.forEach((pointLight, index) => {
+      lightSourceUniforms[`lighting_uPointLight[${index}].color`] = convertColor2(pointLight);
+      lightSourceUniforms[`lighting_uPointLight[${index}].position`] = pointLight.position;
+      lightSourceUniforms[`lighting_uPointLight[${index}].attenuation`] = pointLight.attenuation || [
         1,
         0,
         0
       ];
     });
     lightSourceUniforms.lighting_uPointLightCount = pointLights.length;
-    directionalLights.forEach((directionalLight, index2) => {
-      lightSourceUniforms[`lighting_uDirectionalLight[${index2}].color`] = convertColor2(directionalLight);
-      lightSourceUniforms[`lighting_uDirectionalLight[${index2}].direction`] = directionalLight.direction;
+    directionalLights.forEach((directionalLight, index) => {
+      lightSourceUniforms[`lighting_uDirectionalLight[${index}].color`] = convertColor2(directionalLight);
+      lightSourceUniforms[`lighting_uDirectionalLight[${index}].direction`] = directionalLight.direction;
     });
     lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;
     return lightSourceUniforms;
@@ -10196,8 +10706,9 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     }
     return uniforms;
   }
-  var fs26 = glsl`\
-uniform vec3 dirlight_uLightDirection;
+  var fs26 = (
+    /* glsl */
+    `uniform vec3 dirlight_uLightDirection;
 
 /*
  * Returns color attenuated by angle from light source
@@ -10207,7 +10718,8 @@ vec4 dirlight_filterColor(vec4 color) {
   float d = abs(dot(normalize(normal), normalize(dirlight_uLightDirection)));
   return vec4(color.rgb * d, color.a);
 }
-`;
+`
+  );
   var dirlight2 = {
     name: "dirlight",
     // vs // TODO - reuse normal from geometry module
@@ -10217,8 +10729,9 @@ vec4 dirlight_filterColor(vec4 color) {
   };
 
   // src/modules-webgl1/lighting/phong-lighting/phong-lighting-glsl.ts
-  var lightingShader2 = glsl`\
-
+  var lightingShader2 = (
+    /* glsl */
+    `
 uniform float lighting_uAmbient;
 uniform float lighting_uDiffuse;
 uniform float lighting_uShininess;
@@ -10291,7 +10804,8 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   }
   return lightColor;
 }
-`;
+`
+  );
 
   // src/modules-webgl1/lighting/phong-lighting/phong-lighting.ts
   var INITIAL_MODULE_OPTIONS2 = {};
@@ -10334,8 +10848,9 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   };
 
   // src/modules-webgl1/lighting/pbr/pbr-vertex-glsl.ts
-  var vs5 = glsl`\
-uniform mat4 u_MVPMatrix;
+  var vs5 = (
+    /* glsl */
+    `uniform mat4 u_MVPMatrix;
 uniform mat4 u_ModelMatrix;
 uniform mat4 u_NormalMatrix;
 
@@ -10372,11 +10887,13 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
   pbr_vUV = vec2(0.,0.);
 #endif
 }
-`;
+`
+  );
 
   // src/modules-webgl1/lighting/pbr/pbr-fragment-glsl.ts
-  var fs27 = glsl`\
-precision highp float;
+  var fs27 = (
+    /* glsl */
+    `precision highp float;
 
 uniform bool pbr_uUnlit;
 
@@ -10757,7 +11274,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
   return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
 }
-`;
+`
+  );
 
   // src/modules-webgl1/lighting/pbr/pbr.ts
   var pbr = {