@deck.gl/geo-layers 9.0.0-alpha.7 → 9.0.0-beta.2

package/dist/dist.dev.js

@@ -4408,13 +4408,13 @@ var __exports__ = (() => {
         return image;
       case "image":
       case "imagebitmap":
-        const canvas = document.createElement("canvas");
-        const context = canvas.getContext("2d");
+        const canvas2 = document.createElement("canvas");
+        const context = canvas2.getContext("2d");
         if (!context) {
           throw new Error("getImageData");
         }
-        canvas.width = image.width;
-        canvas.height = image.height;
+        canvas2.width = image.width;
+        canvas2.height = image.height;
         context.drawImage(image, 0, 0);
         return context.getImageData(0, 0, image.width, image.height);
       default:
@@ -12814,7 +12814,7 @@ ${moduleSource}
   }
   function getShaderName(shader) {
     let defaultName = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "unnamed";
-    const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
+    const SHADER_NAME_REGEXP = /#define[^\S\r\n]*SHADER_NAME[^\S\r\n]*([A-Za-z0-9_-]+)\s*/;
     const match = SHADER_NAME_REGEXP.exec(shader);
     return match ? match[1] : defaultName;
   }
@@ -13196,6 +13196,2779 @@ ${getApplicationDefines(allDefines)}
   };
   ShaderAssembler.defaultShaderAssembler = void 0;
 
+  // ../../node_modules/@luma.gl/shadertools/dist/libs/wgsl-reflect/wgsl_reflect.module.js
+  var ParseContext = class {
+    constructor() {
+      this.constants = /* @__PURE__ */ new Map();
+      this.aliases = /* @__PURE__ */ new Map();
+      this.structs = /* @__PURE__ */ new Map();
+    }
+  };
+  var Node = class {
+    constructor() {
+    }
+    get isAstNode() {
+      return true;
+    }
+    get astNodeType() {
+      return "";
+    }
+    evaluate(context) {
+      throw new Error("Cannot evaluate node");
+    }
+    evaluateString(context) {
+      return this.evaluate(context).toString();
+    }
+  };
+  var Statement = class extends Node {
+    constructor() {
+      super();
+    }
+  };
+  var Function = class extends Statement {
+    constructor(name12, args, returnType, body) {
+      super();
+      this.name = name12;
+      this.args = args;
+      this.returnType = returnType;
+      this.body = body;
+    }
+    get astNodeType() {
+      return "function";
+    }
+  };
+  var StaticAssert = class extends Statement {
+    constructor(expression) {
+      super();
+      this.expression = expression;
+    }
+    get astNodeType() {
+      return "staticAssert";
+    }
+  };
+  var While = class extends Statement {
+    constructor(condition, body) {
+      super();
+      this.condition = condition;
+      this.body = body;
+    }
+    get astNodeType() {
+      return "while";
+    }
+  };
+  var Continuing = class extends Statement {
+    constructor(body) {
+      super();
+      this.body = body;
+    }
+    get astNodeType() {
+      return "continuing";
+    }
+  };
+  var For = class extends Statement {
+    constructor(init, condition, increment, body) {
+      super();
+      this.init = init;
+      this.condition = condition;
+      this.increment = increment;
+      this.body = body;
+    }
+    get astNodeType() {
+      return "for";
+    }
+  };
+  var Var = class extends Statement {
+    constructor(name12, type, storage, access, value) {
+      super();
+      this.name = name12;
+      this.type = type;
+      this.storage = storage;
+      this.access = access;
+      this.value = value;
+    }
+    get astNodeType() {
+      return "var";
+    }
+  };
+  var Override = class extends Statement {
+    constructor(name12, type, value) {
+      super();
+      this.name = name12;
+      this.type = type;
+      this.value = value;
+    }
+    get astNodeType() {
+      return "override";
+    }
+  };
+  var Let = class extends Statement {
+    constructor(name12, type, storage, access, value) {
+      super();
+      this.name = name12;
+      this.type = type;
+      this.storage = storage;
+      this.access = access;
+      this.value = value;
+    }
+    get astNodeType() {
+      return "let";
+    }
+  };
+  var Const = class extends Statement {
+    constructor(name12, type, storage, access, value) {
+      super();
+      this.name = name12;
+      this.type = type;
+      this.storage = storage;
+      this.access = access;
+      this.value = value;
+    }
+    get astNodeType() {
+      return "const";
+    }
+    evaluate(context) {
+      return this.value.evaluate(context);
+    }
+  };
+  var IncrementOperator;
+  (function(IncrementOperator2) {
+    IncrementOperator2["increment"] = "++";
+    IncrementOperator2["decrement"] = "--";
+  })(IncrementOperator || (IncrementOperator = {}));
+  (function(IncrementOperator2) {
+    function parse4(val2) {
+      const key = val2;
+      if (key == "parse")
+        throw new Error("Invalid value for IncrementOperator");
+      return IncrementOperator2[key];
+    }
+    IncrementOperator2.parse = parse4;
+  })(IncrementOperator || (IncrementOperator = {}));
+  var Increment = class extends Statement {
+    constructor(operator, variable) {
+      super();
+      this.operator = operator;
+      this.variable = variable;
+    }
+    get astNodeType() {
+      return "increment";
+    }
+  };
+  var AssignOperator;
+  (function(AssignOperator2) {
+    AssignOperator2["assign"] = "=";
+    AssignOperator2["addAssign"] = "+=";
+    AssignOperator2["subtractAssin"] = "-=";
+    AssignOperator2["multiplyAssign"] = "*=";
+    AssignOperator2["divideAssign"] = "/=";
+    AssignOperator2["moduloAssign"] = "%=";
+    AssignOperator2["andAssign"] = "&=";
+    AssignOperator2["orAssign"] = "|=";
+    AssignOperator2["xorAssign"] = "^=";
+    AssignOperator2["shiftLeftAssign"] = "<<=";
+    AssignOperator2["shiftRightAssign"] = ">>=";
+  })(AssignOperator || (AssignOperator = {}));
+  (function(AssignOperator2) {
+    function parse4(val2) {
+      const key = val2;
+      if (key == "parse")
+        throw new Error("Invalid value for AssignOperator");
+      return AssignOperator2[key];
+    }
+    AssignOperator2.parse = parse4;
+  })(AssignOperator || (AssignOperator = {}));
+  var Assign = class extends Statement {
+    constructor(operator, variable, value) {
+      super();
+      this.operator = operator;
+      this.variable = variable;
+      this.value = value;
+    }
+    get astNodeType() {
+      return "assign";
+    }
+  };
+  var Call = class extends Statement {
+    constructor(name12, args) {
+      super();
+      this.name = name12;
+      this.args = args;
+    }
+    get astNodeType() {
+      return "call";
+    }
+  };
+  var Loop = class extends Statement {
+    constructor(body, continuing) {
+      super();
+      this.body = body;
+      this.continuing = continuing;
+    }
+    get astNodeType() {
+      return "loop";
+    }
+  };
+  var Switch = class extends Statement {
+    constructor(condition, body) {
+      super();
+      this.condition = condition;
+      this.body = body;
+    }
+    get astNodeType() {
+      return "body";
+    }
+  };
+  var If = class extends Statement {
+    constructor(condition, body, elseif, _else) {
+      super();
+      this.condition = condition;
+      this.body = body;
+      this.elseif = elseif;
+      this.else = _else;
+    }
+    get astNodeType() {
+      return "if";
+    }
+  };
+  var Return = class extends Statement {
+    constructor(value) {
+      super();
+      this.value = value;
+    }
+    get astNodeType() {
+      return "return";
+    }
+  };
+  var Enable = class extends Statement {
+    constructor(name12) {
+      super();
+      this.name = name12;
+    }
+    get astNodeType() {
+      return "enable";
+    }
+  };
+  var Alias = class extends Statement {
+    constructor(name12, type) {
+      super();
+      this.name = name12;
+      this.type = type;
+    }
+    get astNodeType() {
+      return "alias";
+    }
+  };
+  var Discard = class extends Statement {
+    constructor() {
+      super();
+    }
+    get astNodeType() {
+      return "discard";
+    }
+  };
+  var Break = class extends Statement {
+    constructor() {
+      super();
+    }
+    get astNodeType() {
+      return "break";
+    }
+  };
+  var Continue = class extends Statement {
+    constructor() {
+      super();
+    }
+    get astNodeType() {
+      return "continue";
+    }
+  };
+  var Type = class extends Statement {
+    constructor(name12) {
+      super();
+      this.name = name12;
+    }
+    get astNodeType() {
+      return "type";
+    }
+    get isStruct() {
+      return false;
+    }
+    get isArray() {
+      return false;
+    }
+  };
+  var Struct = class extends Type {
+    constructor(name12, members) {
+      super(name12);
+      this.members = members;
+    }
+    get astNodeType() {
+      return "struct";
+    }
+    get isStruct() {
+      return true;
+    }
+    getMemberIndex(name12) {
+      for (let i3 = 0; i3 < this.members.length; i3++) {
+        if (this.members[i3].name == name12)
+          return i3;
+      }
+      return -1;
+    }
+  };
+  var TemplateType = class extends Type {
+    constructor(name12, format, access) {
+      super(name12);
+      this.format = format;
+      this.access = access;
+    }
+    get astNodeType() {
+      return "template";
+    }
+  };
+  var PointerType = class extends Type {
+    constructor(name12, storage, type, access) {
+      super(name12);
+      this.storage = storage;
+      this.type = type;
+      this.access = access;
+    }
+    get astNodeType() {
+      return "pointer";
+    }
+  };
+  var ArrayType = class extends Type {
+    constructor(name12, attributes, format, count) {
+      super(name12);
+      this.attributes = attributes;
+      this.format = format;
+      this.count = count;
+    }
+    get astNodeType() {
+      return "array";
+    }
+    get isArray() {
+      return true;
+    }
+  };
+  var SamplerType = class extends Type {
+    constructor(name12, format, access) {
+      super(name12);
+      this.format = format;
+      this.access = access;
+    }
+    get astNodeType() {
+      return "sampler";
+    }
+  };
+  var Expression = class extends Node {
+    constructor() {
+      super();
+    }
+  };
+  var StringExpr = class extends Expression {
+    constructor(value) {
+      super();
+      this.value = value;
+    }
+    get astNodeType() {
+      return "stringExpr";
+    }
+    toString() {
+      return this.value;
+    }
+    evaluateString() {
+      return this.value;
+    }
+  };
+  var CreateExpr = class extends Expression {
+    constructor(type, args) {
+      super();
+      this.type = type;
+      this.args = args;
+    }
+    get astNodeType() {
+      return "createExpr";
+    }
+  };
+  var CallExpr = class extends Expression {
+    constructor(name12, args) {
+      super();
+      this.name = name12;
+      this.args = args;
+    }
+    get astNodeType() {
+      return "callExpr";
+    }
+    evaluate(context) {
+      switch (this.name) {
+        case "abs":
+          return Math.abs(this.args[0].evaluate(context));
+        case "acos":
+          return Math.acos(this.args[0].evaluate(context));
+        case "acosh":
+          return Math.acosh(this.args[0].evaluate(context));
+        case "asin":
+          return Math.asin(this.args[0].evaluate(context));
+        case "asinh":
+          return Math.asinh(this.args[0].evaluate(context));
+        case "atan":
+          return Math.atan(this.args[0].evaluate(context));
+        case "atan2":
+          return Math.atan2(this.args[0].evaluate(context), this.args[1].evaluate(context));
+        case "atanh":
+          return Math.atanh(this.args[0].evaluate(context));
+        case "ceil":
+          return Math.ceil(this.args[0].evaluate(context));
+        case "clamp":
+          return Math.min(Math.max(this.args[0].evaluate(context), this.args[1].evaluate(context)), this.args[2].evaluate(context));
+        case "cos":
+          return Math.cos(this.args[0].evaluate(context));
+        case "degrees":
+          return this.args[0].evaluate(context) * 180 / Math.PI;
+        case "distance":
+          return Math.sqrt(Math.pow(this.args[0].evaluate(context) - this.args[1].evaluate(context), 2));
+        case "dot":
+        case "exp":
+          return Math.exp(this.args[0].evaluate(context));
+        case "exp2":
+          return Math.pow(2, this.args[0].evaluate(context));
+        case "floor":
+          return Math.floor(this.args[0].evaluate(context));
+        case "fma":
+          return this.args[0].evaluate(context) * this.args[1].evaluate(context) + this.args[2].evaluate(context);
+        case "fract":
+          return this.args[0].evaluate(context) - Math.floor(this.args[0].evaluate(context));
+        case "inverseSqrt":
+          return 1 / Math.sqrt(this.args[0].evaluate(context));
+        case "log":
+          return Math.log(this.args[0].evaluate(context));
+        case "log2":
+          return Math.log2(this.args[0].evaluate(context));
+        case "max":
+          return Math.max(this.args[0].evaluate(context), this.args[1].evaluate(context));
+        case "min":
+          return Math.min(this.args[0].evaluate(context), this.args[1].evaluate(context));
+        case "mix":
+          return this.args[0].evaluate(context) * (1 - this.args[2].evaluate(context)) + this.args[1].evaluate(context) * this.args[2].evaluate(context);
+        case "modf":
+          return this.args[0].evaluate(context) - Math.floor(this.args[0].evaluate(context));
+        case "pow":
+          return Math.pow(this.args[0].evaluate(context), this.args[1].evaluate(context));
+        case "radians":
+          return this.args[0].evaluate(context) * Math.PI / 180;
+        case "round":
+          return Math.round(this.args[0].evaluate(context));
+        case "sign":
+          return Math.sign(this.args[0].evaluate(context));
+        case "sin":
+          return Math.sin(this.args[0].evaluate(context));
+        case "sinh":
+          return Math.sinh(this.args[0].evaluate(context));
+        case "saturate":
+          return Math.min(Math.max(this.args[0].evaluate(context), 0), 1);
+        case "smoothstep":
+          return this.args[0].evaluate(context) * this.args[0].evaluate(context) * (3 - 2 * this.args[0].evaluate(context));
+        case "sqrt":
+          return Math.sqrt(this.args[0].evaluate(context));
+        case "step":
+          return this.args[0].evaluate(context) < this.args[1].evaluate(context) ? 0 : 1;
+        case "tan":
+          return Math.tan(this.args[0].evaluate(context));
+        case "tanh":
+          return Math.tanh(this.args[0].evaluate(context));
+        case "trunc":
+          return Math.trunc(this.args[0].evaluate(context));
+        default:
+          throw new Error("Non const function: " + this.name);
+      }
+    }
+  };
+  var VariableExpr = class extends Expression {
+    constructor(name12) {
+      super();
+      this.name = name12;
+    }
+    get astNodeType() {
+      return "varExpr";
+    }
+  };
+  var ConstExpr = class extends Expression {
+    constructor(name12, initializer) {
+      super();
+      this.name = name12;
+      this.initializer = initializer;
+    }
+    get astNodeType() {
+      return "constExpr";
+    }
+    evaluate(context) {
+      var _a2, _b;
+      if (this.initializer instanceof CreateExpr) {
+        const property = (_a2 = this.postfix) === null || _a2 === void 0 ? void 0 : _a2.evaluateString(context);
+        const type = (_b = this.initializer.type) === null || _b === void 0 ? void 0 : _b.name;
+        const struct = context.structs.get(type);
+        const memberIndex = struct === null || struct === void 0 ? void 0 : struct.getMemberIndex(property);
+        if (memberIndex != -1) {
+          const value = this.initializer.args[memberIndex].evaluate(context);
+          return value;
+        }
+        console.log(memberIndex);
+      }
+      return this.initializer.evaluate(context);
+    }
+  };
+  var LiteralExpr = class extends Expression {
+    constructor(value) {
+      super();
+      this.value = value;
+    }
+    get astNodeType() {
+      return "literalExpr";
+    }
+    evaluate() {
+      return this.value;
+    }
+  };
+  var BitcastExpr = class extends Expression {
+    constructor(type, value) {
+      super();
+      this.type = type;
+      this.value = value;
+    }
+    get astNodeType() {
+      return "bitcastExpr";
+    }
+  };
+  var TypecastExpr = class extends Expression {
+    constructor(type, args) {
+      super();
+      this.type = type;
+      this.args = args;
+    }
+    get astNodeType() {
+      return "typecastExpr";
+    }
+    evaluate(context) {
+      return this.args[0].evaluate(context);
+    }
+  };
+  var GroupingExpr = class extends Expression {
+    constructor(contents) {
+      super();
+      this.contents = contents;
+    }
+    get astNodeType() {
+      return "groupExpr";
+    }
+    evaluate(context) {
+      return this.contents[0].evaluate(context);
+    }
+  };
+  var Operator = class extends Expression {
+    constructor() {
+      super();
+    }
+  };
+  var UnaryOperator = class extends Operator {
+    constructor(operator, right) {
+      super();
+      this.operator = operator;
+      this.right = right;
+    }
+    get astNodeType() {
+      return "unaryOp";
+    }
+    evaluate(context) {
+      switch (this.operator) {
+        case "+":
+          return this.right.evaluate(context);
+        case "-":
+          return -this.right.evaluate(context);
+        case "!":
+          return this.right.evaluate(context) ? 0 : 1;
+        case "~":
+          return ~this.right.evaluate(context);
+        default:
+          throw new Error("Unknown unary operator: " + this.operator);
+      }
+    }
+  };
+  var BinaryOperator = class extends Operator {
+    constructor(operator, left, right) {
+      super();
+      this.operator = operator;
+      this.left = left;
+      this.right = right;
+    }
+    get astNodeType() {
+      return "binaryOp";
+    }
+    evaluate(context) {
+      switch (this.operator) {
+        case "+":
+          return this.left.evaluate(context) + this.right.evaluate(context);
+        case "-":
+          return this.left.evaluate(context) - this.right.evaluate(context);
+        case "*":
+          return this.left.evaluate(context) * this.right.evaluate(context);
+        case "/":
+          return this.left.evaluate(context) / this.right.evaluate(context);
+        case "%":
+          return this.left.evaluate(context) % this.right.evaluate(context);
+        case "==":
+          return this.left.evaluate(context) == this.right.evaluate(context) ? 1 : 0;
+        case "!=":
+          return this.left.evaluate(context) != this.right.evaluate(context) ? 1 : 0;
+        case "<":
+          return this.left.evaluate(context) < this.right.evaluate(context) ? 1 : 0;
+        case ">":
+          return this.left.evaluate(context) > this.right.evaluate(context) ? 1 : 0;
+        case "<=":
+          return this.left.evaluate(context) <= this.right.evaluate(context) ? 1 : 0;
+        case ">=":
+          return this.left.evaluate(context) >= this.right.evaluate(context) ? 1 : 0;
+        case "&&":
+          return this.left.evaluate(context) && this.right.evaluate(context) ? 1 : 0;
+        case "||":
+          return this.left.evaluate(context) || this.right.evaluate(context) ? 1 : 0;
+        default:
+          throw new Error(`Unknown operator ${this.operator}`);
+      }
+    }
+  };
+  var SwitchCase = class extends Node {
+    constructor() {
+      super();
+    }
+  };
+  var Case = class extends SwitchCase {
+    constructor(selector, body) {
+      super();
+      this.selector = selector;
+      this.body = body;
+    }
+    get astNodeType() {
+      return "case";
+    }
+  };
+  var Default = class extends SwitchCase {
+    constructor(body) {
+      super();
+      this.body = body;
+    }
+    get astNodeType() {
+      return "default";
+    }
+  };
+  var Argument = class extends Node {
+    constructor(name12, type, attributes) {
+      super();
+      this.name = name12;
+      this.type = type;
+      this.attributes = attributes;
+    }
+    get astNodeType() {
+      return "argument";
+    }
+  };
+  var ElseIf = class extends Node {
+    constructor(condition, body) {
+      super();
+      this.condition = condition;
+      this.body = body;
+    }
+    get astNodeType() {
+      return "elseif";
+    }
+  };
+  var Member = class extends Node {
+    constructor(name12, type, attributes) {
+      super();
+      this.name = name12;
+      this.type = type;
+      this.attributes = attributes;
+    }
+    get astNodeType() {
+      return "member";
+    }
+  };
+  var Attribute = class extends Node {
+    constructor(name12, value) {
+      super();
+      this.name = name12;
+      this.value = value;
+    }
+    get astNodeType() {
+      return "attribute";
+    }
+  };
+  var _a;
+  var TokenClass;
+  (function(TokenClass2) {
+    TokenClass2[TokenClass2["token"] = 0] = "token";
+    TokenClass2[TokenClass2["keyword"] = 1] = "keyword";
+    TokenClass2[TokenClass2["reserved"] = 2] = "reserved";
+  })(TokenClass || (TokenClass = {}));
+  var TokenType = class {
+    constructor(name12, type, rule) {
+      this.name = name12;
+      this.type = type;
+      this.rule = rule;
+    }
+    toString() {
+      return this.name;
+    }
+  };
+  var TokenTypes = class {
+  };
+  _a = TokenTypes;
+  TokenTypes.none = new TokenType("", TokenClass.reserved, "");
+  TokenTypes.eof = new TokenType("EOF", TokenClass.token, "");
+  TokenTypes.reserved = {
+    asm: new TokenType("asm", TokenClass.reserved, "asm"),
+    bf16: new TokenType("bf16", TokenClass.reserved, "bf16"),
+    do: new TokenType("do", TokenClass.reserved, "do"),
+    enum: new TokenType("enum", TokenClass.reserved, "enum"),
+    f16: new TokenType("f16", TokenClass.reserved, "f16"),
+    f64: new TokenType("f64", TokenClass.reserved, "f64"),
+    handle: new TokenType("handle", TokenClass.reserved, "handle"),
+    i8: new TokenType("i8", TokenClass.reserved, "i8"),
+    i16: new TokenType("i16", TokenClass.reserved, "i16"),
+    i64: new TokenType("i64", TokenClass.reserved, "i64"),
+    mat: new TokenType("mat", TokenClass.reserved, "mat"),
+    premerge: new TokenType("premerge", TokenClass.reserved, "premerge"),
+    regardless: new TokenType("regardless", TokenClass.reserved, "regardless"),
+    typedef: new TokenType("typedef", TokenClass.reserved, "typedef"),
+    u8: new TokenType("u8", TokenClass.reserved, "u8"),
+    u16: new TokenType("u16", TokenClass.reserved, "u16"),
+    u64: new TokenType("u64", TokenClass.reserved, "u64"),
+    unless: new TokenType("unless", TokenClass.reserved, "unless"),
+    using: new TokenType("using", TokenClass.reserved, "using"),
+    vec: new TokenType("vec", TokenClass.reserved, "vec"),
+    void: new TokenType("void", TokenClass.reserved, "void")
+  };
+  TokenTypes.keywords = {
+    array: new TokenType("array", TokenClass.keyword, "array"),
+    atomic: new TokenType("atomic", TokenClass.keyword, "atomic"),
+    bool: new TokenType("bool", TokenClass.keyword, "bool"),
+    f32: new TokenType("f32", TokenClass.keyword, "f32"),
+    i32: new TokenType("i32", TokenClass.keyword, "i32"),
+    mat2x2: new TokenType("mat2x2", TokenClass.keyword, "mat2x2"),
+    mat2x3: new TokenType("mat2x3", TokenClass.keyword, "mat2x3"),
+    mat2x4: new TokenType("mat2x4", TokenClass.keyword, "mat2x4"),
+    mat3x2: new TokenType("mat3x2", TokenClass.keyword, "mat3x2"),
+    mat3x3: new TokenType("mat3x3", TokenClass.keyword, "mat3x3"),
+    mat3x4: new TokenType("mat3x4", TokenClass.keyword, "mat3x4"),
+    mat4x2: new TokenType("mat4x2", TokenClass.keyword, "mat4x2"),
+    mat4x3: new TokenType("mat4x3", TokenClass.keyword, "mat4x3"),
+    mat4x4: new TokenType("mat4x4", TokenClass.keyword, "mat4x4"),
+    ptr: new TokenType("ptr", TokenClass.keyword, "ptr"),
+    sampler: new TokenType("sampler", TokenClass.keyword, "sampler"),
+    sampler_comparison: new TokenType("sampler_comparison", TokenClass.keyword, "sampler_comparison"),
+    struct: new TokenType("struct", TokenClass.keyword, "struct"),
+    texture_1d: new TokenType("texture_1d", TokenClass.keyword, "texture_1d"),
+    texture_2d: new TokenType("texture_2d", TokenClass.keyword, "texture_2d"),
+    texture_2d_array: new TokenType("texture_2d_array", TokenClass.keyword, "texture_2d_array"),
+    texture_3d: new TokenType("texture_3d", TokenClass.keyword, "texture_3d"),
+    texture_cube: new TokenType("texture_cube", TokenClass.keyword, "texture_cube"),
+    texture_cube_array: new TokenType("texture_cube_array", TokenClass.keyword, "texture_cube_array"),
+    texture_multisampled_2d: new TokenType("texture_multisampled_2d", TokenClass.keyword, "texture_multisampled_2d"),
+    texture_storage_1d: new TokenType("texture_storage_1d", TokenClass.keyword, "texture_storage_1d"),
+    texture_storage_2d: new TokenType("texture_storage_2d", TokenClass.keyword, "texture_storage_2d"),
+    texture_storage_2d_array: new TokenType("texture_storage_2d_array", TokenClass.keyword, "texture_storage_2d_array"),
+    texture_storage_3d: new TokenType("texture_storage_3d", TokenClass.keyword, "texture_storage_3d"),
+    texture_depth_2d: new TokenType("texture_depth_2d", TokenClass.keyword, "texture_depth_2d"),
+    texture_depth_2d_array: new TokenType("texture_depth_2d_array", TokenClass.keyword, "texture_depth_2d_array"),
+    texture_depth_cube: new TokenType("texture_depth_cube", TokenClass.keyword, "texture_depth_cube"),
+    texture_depth_cube_array: new TokenType("texture_depth_cube_array", TokenClass.keyword, "texture_depth_cube_array"),
+    texture_depth_multisampled_2d: new TokenType("texture_depth_multisampled_2d", TokenClass.keyword, "texture_depth_multisampled_2d"),
+    texture_external: new TokenType("texture_external", TokenClass.keyword, "texture_external"),
+    u32: new TokenType("u32", TokenClass.keyword, "u32"),
+    vec2: new TokenType("vec2", TokenClass.keyword, "vec2"),
+    vec3: new TokenType("vec3", TokenClass.keyword, "vec3"),
+    vec4: new TokenType("vec4", TokenClass.keyword, "vec4"),
+    bitcast: new TokenType("bitcast", TokenClass.keyword, "bitcast"),
+    block: new TokenType("block", TokenClass.keyword, "block"),
+    break: new TokenType("break", TokenClass.keyword, "break"),
+    case: new TokenType("case", TokenClass.keyword, "case"),
+    continue: new TokenType("continue", TokenClass.keyword, "continue"),
+    continuing: new TokenType("continuing", TokenClass.keyword, "continuing"),
+    default: new TokenType("default", TokenClass.keyword, "default"),
+    discard: new TokenType("discard", TokenClass.keyword, "discard"),
+    else: new TokenType("else", TokenClass.keyword, "else"),
+    enable: new TokenType("enable", TokenClass.keyword, "enable"),
+    fallthrough: new TokenType("fallthrough", TokenClass.keyword, "fallthrough"),
+    false: new TokenType("false", TokenClass.keyword, "false"),
+    fn: new TokenType("fn", TokenClass.keyword, "fn"),
+    for: new TokenType("for", TokenClass.keyword, "for"),
+    function: new TokenType("function", TokenClass.keyword, "function"),
+    if: new TokenType("if", TokenClass.keyword, "if"),
+    let: new TokenType("let", TokenClass.keyword, "let"),
+    const: new TokenType("const", TokenClass.keyword, "const"),
+    loop: new TokenType("loop", TokenClass.keyword, "loop"),
+    while: new TokenType("while", TokenClass.keyword, "while"),
+    private: new TokenType("private", TokenClass.keyword, "private"),
+    read: new TokenType("read", TokenClass.keyword, "read"),
+    read_write: new TokenType("read_write", TokenClass.keyword, "read_write"),
+    return: new TokenType("return", TokenClass.keyword, "return"),
+    storage: new TokenType("storage", TokenClass.keyword, "storage"),
+    switch: new TokenType("switch", TokenClass.keyword, "switch"),
+    true: new TokenType("true", TokenClass.keyword, "true"),
+    alias: new TokenType("alias", TokenClass.keyword, "alias"),
+    type: new TokenType("type", TokenClass.keyword, "type"),
+    uniform: new TokenType("uniform", TokenClass.keyword, "uniform"),
+    var: new TokenType("var", TokenClass.keyword, "var"),
+    override: new TokenType("override", TokenClass.keyword, "override"),
+    workgroup: new TokenType("workgroup", TokenClass.keyword, "workgroup"),
+    write: new TokenType("write", TokenClass.keyword, "write"),
+    r8unorm: new TokenType("r8unorm", TokenClass.keyword, "r8unorm"),
+    r8snorm: new TokenType("r8snorm", TokenClass.keyword, "r8snorm"),
+    r8uint: new TokenType("r8uint", TokenClass.keyword, "r8uint"),
+    r8sint: new TokenType("r8sint", TokenClass.keyword, "r8sint"),
+    r16uint: new TokenType("r16uint", TokenClass.keyword, "r16uint"),
+    r16sint: new TokenType("r16sint", TokenClass.keyword, "r16sint"),
+    r16float: new TokenType("r16float", TokenClass.keyword, "r16float"),
+    rg8unorm: new TokenType("rg8unorm", TokenClass.keyword, "rg8unorm"),
+    rg8snorm: new TokenType("rg8snorm", TokenClass.keyword, "rg8snorm"),
+    rg8uint: new TokenType("rg8uint", TokenClass.keyword, "rg8uint"),
+    rg8sint: new TokenType("rg8sint", TokenClass.keyword, "rg8sint"),
+    r32uint: new TokenType("r32uint", TokenClass.keyword, "r32uint"),
+    r32sint: new TokenType("r32sint", TokenClass.keyword, "r32sint"),
+    r32float: new TokenType("r32float", TokenClass.keyword, "r32float"),
+    rg16uint: new TokenType("rg16uint", TokenClass.keyword, "rg16uint"),
+    rg16sint: new TokenType("rg16sint", TokenClass.keyword, "rg16sint"),
+    rg16float: new TokenType("rg16float", TokenClass.keyword, "rg16float"),
+    rgba8unorm: new TokenType("rgba8unorm", TokenClass.keyword, "rgba8unorm"),
+    rgba8unorm_srgb: new TokenType("rgba8unorm_srgb", TokenClass.keyword, "rgba8unorm_srgb"),
+    rgba8snorm: new TokenType("rgba8snorm", TokenClass.keyword, "rgba8snorm"),
+    rgba8uint: new TokenType("rgba8uint", TokenClass.keyword, "rgba8uint"),
+    rgba8sint: new TokenType("rgba8sint", TokenClass.keyword, "rgba8sint"),
+    bgra8unorm: new TokenType("bgra8unorm", TokenClass.keyword, "bgra8unorm"),
+    bgra8unorm_srgb: new TokenType("bgra8unorm_srgb", TokenClass.keyword, "bgra8unorm_srgb"),
+    rgb10a2unorm: new TokenType("rgb10a2unorm", TokenClass.keyword, "rgb10a2unorm"),
+    rg11b10float: new TokenType("rg11b10float", TokenClass.keyword, "rg11b10float"),
+    rg32uint: new TokenType("rg32uint", TokenClass.keyword, "rg32uint"),
+    rg32sint: new TokenType("rg32sint", TokenClass.keyword, "rg32sint"),
+    rg32float: new TokenType("rg32float", TokenClass.keyword, "rg32float"),
+    rgba16uint: new TokenType("rgba16uint", TokenClass.keyword, "rgba16uint"),
+    rgba16sint: new TokenType("rgba16sint", TokenClass.keyword, "rgba16sint"),
+    rgba16float: new TokenType("rgba16float", TokenClass.keyword, "rgba16float"),
+    rgba32uint: new TokenType("rgba32uint", TokenClass.keyword, "rgba32uint"),
+    rgba32sint: new TokenType("rgba32sint", TokenClass.keyword, "rgba32sint"),
+    rgba32float: new TokenType("rgba32float", TokenClass.keyword, "rgba32float"),
+    static_assert: new TokenType("static_assert", TokenClass.keyword, "static_assert")
+  };
+  TokenTypes.tokens = {
+    decimal_float_literal: new TokenType("decimal_float_literal", TokenClass.token, /((-?[0-9]*\.[0-9]+|-?[0-9]+\.[0-9]*)((e|E)(\+|-)?[0-9]+)?f?)|(-?[0-9]+(e|E)(\+|-)?[0-9]+f?)|([0-9]+f)/),
+    hex_float_literal: new TokenType("hex_float_literal", TokenClass.token, /-?0x((([0-9a-fA-F]*\.[0-9a-fA-F]+|[0-9a-fA-F]+\.[0-9a-fA-F]*)((p|P)(\+|-)?[0-9]+f?)?)|([0-9a-fA-F]+(p|P)(\+|-)?[0-9]+f?))/),
+    int_literal: new TokenType("int_literal", TokenClass.token, /-?0x[0-9a-fA-F]+|0i?|-?[1-9][0-9]*i?/),
+    uint_literal: new TokenType("uint_literal", TokenClass.token, /0x[0-9a-fA-F]+u|0u|[1-9][0-9]*u/),
+    ident: new TokenType("ident", TokenClass.token, /[a-zA-Z][0-9a-zA-Z_]*/),
+    and: new TokenType("and", TokenClass.token, "&"),
+    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, "["),
+    bracket_right: new TokenType("bracket_right", TokenClass.token, "]"),
+    brace_left: new TokenType("brace_left", TokenClass.token, "{"),
+    brace_right: new TokenType("brace_right", TokenClass.token, "}"),
+    colon: new TokenType("colon", TokenClass.token, ":"),
+    comma: new TokenType("comma", TokenClass.token, ","),
+    equal: new TokenType("equal", TokenClass.token, "="),
+    equal_equal: new TokenType("equal_equal", TokenClass.token, "=="),
+    not_equal: new TokenType("not_equal", TokenClass.token, "!="),
+    greater_than: new TokenType("greater_than", TokenClass.token, ">"),
+    greater_than_equal: new TokenType("greater_than_equal", TokenClass.token, ">="),
+    shift_right: new TokenType("shift_right", TokenClass.token, ">>"),
+    less_than: new TokenType("less_than", TokenClass.token, "<"),
+    less_than_equal: new TokenType("less_than_equal", TokenClass.token, "<="),
+    shift_left: new TokenType("shift_left", TokenClass.token, "<<"),
+    modulo: new TokenType("modulo", TokenClass.token, "%"),
+    minus: new TokenType("minus", TokenClass.token, "-"),
+    minus_minus: new TokenType("minus_minus", TokenClass.token, "--"),
+    period: new TokenType("period", TokenClass.token, "."),
+    plus: new TokenType("plus", TokenClass.token, "+"),
+    plus_plus: new TokenType("plus_plus", TokenClass.token, "++"),
+    or: new TokenType("or", TokenClass.token, "|"),
+    or_or: new TokenType("or_or", TokenClass.token, "||"),
+    paren_left: new TokenType("paren_left", TokenClass.token, "("),
+    paren_right: new TokenType("paren_right", TokenClass.token, ")"),
+    semicolon: new TokenType("semicolon", TokenClass.token, ";"),
+    star: new TokenType("star", TokenClass.token, "*"),
+    tilde: new TokenType("tilde", TokenClass.token, "~"),
+    underscore: new TokenType("underscore", TokenClass.token, "_"),
+    xor: new TokenType("xor", TokenClass.token, "^"),
+    plus_equal: new TokenType("plus_equal", TokenClass.token, "+="),
+    minus_equal: new TokenType("minus_equal", TokenClass.token, "-="),
+    times_equal: new TokenType("times_equal", TokenClass.token, "*="),
+    division_equal: new TokenType("division_equal", TokenClass.token, "/="),
+    modulo_equal: new TokenType("modulo_equal", TokenClass.token, "%="),
+    and_equal: new TokenType("and_equal", TokenClass.token, "&="),
+    or_equal: new TokenType("or_equal", TokenClass.token, "|="),
+    xor_equal: new TokenType("xor_equal", TokenClass.token, "^="),
+    shift_right_equal: new TokenType("shift_right_equal", TokenClass.token, ">>="),
+    shift_left_equal: new TokenType("shift_left_equal", TokenClass.token, "<<=")
+  };
+  TokenTypes.storage_class = [_a.keywords.function, _a.keywords.private, _a.keywords.workgroup, _a.keywords.uniform, _a.keywords.storage];
+  TokenTypes.access_mode = [_a.keywords.read, _a.keywords.write, _a.keywords.read_write];
+  TokenTypes.sampler_type = [_a.keywords.sampler, _a.keywords.sampler_comparison];
+  TokenTypes.sampled_texture_type = [_a.keywords.texture_1d, _a.keywords.texture_2d, _a.keywords.texture_2d_array, _a.keywords.texture_3d, _a.keywords.texture_cube, _a.keywords.texture_cube_array];
+  TokenTypes.multisampled_texture_type = [_a.keywords.texture_multisampled_2d];
+  TokenTypes.storage_texture_type = [_a.keywords.texture_storage_1d, _a.keywords.texture_storage_2d, _a.keywords.texture_storage_2d_array, _a.keywords.texture_storage_3d];
+  TokenTypes.depth_texture_type = [_a.keywords.texture_depth_2d, _a.keywords.texture_depth_2d_array, _a.keywords.texture_depth_cube, _a.keywords.texture_depth_cube_array, _a.keywords.texture_depth_multisampled_2d];
+  TokenTypes.texture_external_type = [_a.keywords.texture_external];
+  TokenTypes.any_texture_type = [..._a.sampled_texture_type, ..._a.multisampled_texture_type, ..._a.storage_texture_type, ..._a.depth_texture_type, ..._a.texture_external_type];
+  TokenTypes.texel_format = [_a.keywords.r8unorm, _a.keywords.r8snorm, _a.keywords.r8uint, _a.keywords.r8sint, _a.keywords.r16uint, _a.keywords.r16sint, _a.keywords.r16float, _a.keywords.rg8unorm, _a.keywords.rg8snorm, _a.keywords.rg8uint, _a.keywords.rg8sint, _a.keywords.r32uint, _a.keywords.r32sint, _a.keywords.r32float, _a.keywords.rg16uint, _a.keywords.rg16sint, _a.keywords.rg16float, _a.keywords.rgba8unorm, _a.keywords.rgba8unorm_srgb, _a.keywords.rgba8snorm, _a.keywords.rgba8uint, _a.keywords.rgba8sint, _a.keywords.bgra8unorm, _a.keywords.bgra8unorm_srgb, _a.keywords.rgb10a2unorm, _a.keywords.rg11b10float, _a.keywords.rg32uint, _a.keywords.rg32sint, _a.keywords.rg32float, _a.keywords.rgba16uint, _a.keywords.rgba16sint, _a.keywords.rgba16float, _a.keywords.rgba32uint, _a.keywords.rgba32sint, _a.keywords.rgba32float];
+  TokenTypes.const_literal = [_a.tokens.int_literal, _a.tokens.uint_literal, _a.tokens.decimal_float_literal, _a.tokens.hex_float_literal, _a.keywords.true, _a.keywords.false];
+  TokenTypes.literal_or_ident = [_a.tokens.ident, _a.tokens.int_literal, _a.tokens.uint_literal, _a.tokens.decimal_float_literal, _a.tokens.hex_float_literal];
+  TokenTypes.element_count_expression = [_a.tokens.int_literal, _a.tokens.uint_literal, _a.tokens.ident];
+  TokenTypes.template_types = [_a.keywords.vec2, _a.keywords.vec3, _a.keywords.vec4, _a.keywords.mat2x2, _a.keywords.mat2x3, _a.keywords.mat2x4, _a.keywords.mat3x2, _a.keywords.mat3x3, _a.keywords.mat3x4, _a.keywords.mat4x2, _a.keywords.mat4x3, _a.keywords.mat4x4, _a.keywords.atomic, _a.keywords.bitcast, ..._a.any_texture_type];
+  TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block];
+  TokenTypes.assignment_operators = [_a.tokens.equal, _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.increment_operators = [_a.tokens.plus_plus, _a.tokens.minus_minus];
+  var Token = class {
+    constructor(type, lexeme, line) {
+      this.type = type;
+      this.lexeme = lexeme;
+      this.line = line;
+    }
+    toString() {
+      return this.lexeme;
+    }
+    isTemplateType() {
+      return TokenTypes.template_types.indexOf(this.type) != -1;
+    }
+    isArrayType() {
+      return this.type == TokenTypes.keywords.array;
+    }
+    isArrayOrTemplateType() {
+      return this.isArrayType() || this.isTemplateType();
+    }
+  };
+  var WgslScanner = class {
+    constructor(source) {
+      this._tokens = [];
+      this._start = 0;
+      this._current = 0;
+      this._line = 1;
+      this._source = source !== null && source !== void 0 ? source : "";
+    }
+    scanTokens() {
+      while (!this._isAtEnd()) {
+        this._start = this._current;
+        if (!this.scanToken())
+          throw `Invalid syntax at line ${this._line}`;
+      }
+      this._tokens.push(new Token(TokenTypes.eof, "", this._line));
+      return this._tokens;
+    }
+    scanToken() {
+      let lexeme = this._advance();
+      if (lexeme == "\n") {
+        this._line++;
+        return true;
+      }
+      if (this._isWhitespace(lexeme)) {
+        return true;
+      }
+      if (lexeme == "/") {
+        if (this._peekAhead() == "/") {
+          while (lexeme != "\n") {
+            if (this._isAtEnd())
+              return true;
+            lexeme = this._advance();
+          }
+          this._line++;
+          return true;
+        } else if (this._peekAhead() == "*") {
+          this._advance();
+          let commentLevel = 1;
+          while (commentLevel > 0) {
+            if (this._isAtEnd())
+              return true;
+            lexeme = this._advance();
+            if (lexeme == "\n") {
+              this._line++;
+            } else if (lexeme == "*") {
+              if (this._peekAhead() == "/") {
+                this._advance();
+                commentLevel--;
+                if (commentLevel == 0) {
+                  return true;
+                }
+              }
+            } else if (lexeme == "/") {
+              if (this._peekAhead() == "*") {
+                this._advance();
+                commentLevel++;
+              }
+            }
+          }
+          return true;
+        }
+      }
+      let matchType = TokenTypes.none;
+      for (; ; ) {
+        let matchedType = this._findType(lexeme);
+        const nextLexeme = this._peekAhead();
+        if (lexeme == ">" && (nextLexeme == ">" || nextLexeme == "=")) {
+          let foundLessThan = false;
+          let ti = this._tokens.length - 1;
+          for (let count = 0; count < 5 && ti >= 0; ++count, --ti) {
+            if (this._tokens[ti].type === TokenTypes.tokens.less_than) {
+              if (ti > 0 && this._tokens[ti - 1].isArrayOrTemplateType()) {
+                foundLessThan = true;
+              }
+              break;
+            }
+          }
+          if (foundLessThan) {
+            this._addToken(matchedType);
+            return true;
+          }
+        }
+        if (matchedType === TokenTypes.none) {
+          let lookAheadLexeme = lexeme;
+          let lookAhead = 0;
+          const maxLookAhead = 2;
+          for (let li = 0; li < maxLookAhead; ++li) {
+            lookAheadLexeme += this._peekAhead(li);
+            matchedType = this._findType(lookAheadLexeme);
+            if (matchedType !== TokenTypes.none) {
+              lookAhead = li;
+              break;
+            }
+          }
+          if (matchedType === TokenTypes.none) {
+            if (matchType === TokenTypes.none)
+              return false;
+            this._current--;
+            this._addToken(matchType);
+            return true;
+          }
+          lexeme = lookAheadLexeme;
+          this._current += lookAhead + 1;
+        }
+        matchType = matchedType;
+        if (this._isAtEnd())
+          break;
+        lexeme += this._advance();
+      }
+      if (matchType === TokenTypes.none)
+        return false;
+      this._addToken(matchType);
+      return true;
+    }
+    _findType(lexeme) {
+      for (const name12 in TokenTypes.keywords) {
+        const type = TokenTypes.keywords[name12];
+        if (this._match(lexeme, type.rule)) {
+          return type;
+        }
+      }
+      for (const name12 in TokenTypes.tokens) {
+        const type = TokenTypes.tokens[name12];
+        if (this._match(lexeme, type.rule)) {
+          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;
+    }
+    _isAtEnd() {
+      return this._current >= this._source.length;
+    }
+    _isWhitespace(c) {
+      return c == " " || c == "	" || c == "\r";
+    }
+    _advance() {
+      let amount = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+      let c = this._source[this._current];
+      amount = amount || 0;
+      amount++;
+      this._current += amount;
+      return c;
+    }
+    _peekAhead() {
+      let offset = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+      offset = offset || 0;
+      if (this._current + offset >= this._source.length)
+        return "\0";
+      return this._source[this._current + offset];
+    }
+    _addToken(type) {
+      const text = this._source.substring(this._start, this._current);
+      this._tokens.push(new Token(type, text, this._line));
+    }
+  };
+  var WgslParser = class {
+    constructor() {
+      this._tokens = [];
+      this._current = 0;
+      this._context = new ParseContext();
+    }
+    parse(tokensOrCode) {
+      this._initialize(tokensOrCode);
+      let statements = [];
+      while (!this._isAtEnd()) {
+        const statement = this._global_decl_or_directive();
+        if (!statement)
+          break;
+        statements.push(statement);
+      }
+      return statements;
+    }
+    _initialize(tokensOrCode) {
+      if (tokensOrCode) {
+        if (typeof tokensOrCode == "string") {
+          const scanner = new WgslScanner(tokensOrCode);
+          this._tokens = scanner.scanTokens();
+        } else {
+          this._tokens = tokensOrCode;
+        }
+      } else {
+        this._tokens = [];
+      }
+      this._current = 0;
+    }
+    _error(token, message) {
+      console.error(token, message);
+      return {
+        token,
+        message,
+        toString: function() {
+          return `${message}`;
+        }
+      };
+    }
+    _isAtEnd() {
+      return this._current >= this._tokens.length || this._peek().type == TokenTypes.eof;
+    }
+    _match(types) {
+      if (types instanceof TokenType) {
+        if (this._check(types)) {
+          this._advance();
+          return true;
+        }
+        return false;
+      }
+      for (let i3 = 0, l2 = types.length; i3 < l2; ++i3) {
+        const type = types[i3];
+        if (this._check(type)) {
+          this._advance();
+          return true;
+        }
+      }
+      return false;
+    }
+    _consume(types, message) {
+      if (this._check(types))
+        return this._advance();
+      throw this._error(this._peek(), message);
+    }
+    _check(types) {
+      if (this._isAtEnd())
+        return false;
+      const tk = this._peek();
+      if (types instanceof Array) {
+        let t2 = tk.type;
+        let index2 = types.indexOf(t2);
+        return index2 != -1;
+      }
+      return tk.type == types;
+    }
+    _advance() {
+      if (!this._isAtEnd())
+        this._current++;
+      return this._previous();
+    }
+    _peek() {
+      return this._tokens[this._current];
+    }
+    _previous() {
+      return this._tokens[this._current - 1];
+    }
+    _global_decl_or_directive() {
+      while (this._match(TokenTypes.tokens.semicolon) && !this._isAtEnd())
+        ;
+      if (this._match(TokenTypes.keywords.alias)) {
+        const type = this._type_alias();
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
+        return type;
+      }
+      if (this._match(TokenTypes.keywords.enable)) {
+        const enable = this._enable_directive();
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
+        return enable;
+      }
+      const attrs = this._attribute();
+      if (this._check(TokenTypes.keywords.var)) {
+        const _var = this._global_variable_decl();
+        if (_var != null)
+          _var.attributes = attrs;
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
+        return _var;
+      }
+      if (this._check(TokenTypes.keywords.override)) {
+        const _override = this._override_variable_decl();
+        if (_override != null)
+          _override.attributes = attrs;
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
+        return _override;
+      }
+      if (this._check(TokenTypes.keywords.let)) {
+        const _let = this._global_let_decl();
+        if (_let != null)
+          _let.attributes = attrs;
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
+        return _let;
+      }
+      if (this._check(TokenTypes.keywords.const)) {
+        const _const = this._global_const_decl();
+        if (_const != null)
+          _const.attributes = attrs;
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
+        return _const;
+      }
+      if (this._check(TokenTypes.keywords.struct)) {
+        const _struct = this._struct_decl();
+        if (_struct != null)
+          _struct.attributes = attrs;
+        return _struct;
+      }
+      if (this._check(TokenTypes.keywords.fn)) {
+        const _fn = this._function_decl();
+        if (_fn != null)
+          _fn.attributes = attrs;
+        return _fn;
+      }
+      return null;
+    }
+    _function_decl() {
+      if (!this._match(TokenTypes.keywords.fn))
+        return null;
+      const name12 = this._consume(TokenTypes.tokens.ident, "Expected function name.").toString();
+      this._consume(TokenTypes.tokens.paren_left, "Expected '(' for function arguments.");
+      const args = [];
+      if (!this._check(TokenTypes.tokens.paren_right)) {
+        do {
+          if (this._check(TokenTypes.tokens.paren_right))
+            break;
+          const argAttrs = this._attribute();
+          const name13 = this._consume(TokenTypes.tokens.ident, "Expected argument name.").toString();
+          this._consume(TokenTypes.tokens.colon, "Expected ':' for argument type.");
+          const typeAttrs = this._attribute();
+          const type = this._type_decl();
+          if (type != null) {
+            type.attributes = typeAttrs;
+            args.push(new Argument(name13, type, argAttrs));
+          }
+        } while (this._match(TokenTypes.tokens.comma));
+      }
+      this._consume(TokenTypes.tokens.paren_right, "Expected ')' after function arguments.");
+      let _return = null;
+      if (this._match(TokenTypes.tokens.arrow)) {
+        const attrs = this._attribute();
+        _return = this._type_decl();
+        if (_return != null)
+          _return.attributes = attrs;
+      }
+      const body = this._compound_statement();
+      return new Function(name12, args, _return, body);
+    }
+    _compound_statement() {
+      const statements = [];
+      this._consume(TokenTypes.tokens.brace_left, "Expected '{' for block.");
+      while (!this._check(TokenTypes.tokens.brace_right)) {
+        const statement = this._statement();
+        if (statement !== null)
+          statements.push(statement);
+      }
+      this._consume(TokenTypes.tokens.brace_right, "Expected '}' for block.");
+      return statements;
+    }
+    _statement() {
+      while (this._match(TokenTypes.tokens.semicolon) && !this._isAtEnd())
+        ;
+      if (this._check(TokenTypes.keywords.if))
+        return this._if_statement();
+      if (this._check(TokenTypes.keywords.switch))
+        return this._switch_statement();
+      if (this._check(TokenTypes.keywords.loop))
+        return this._loop_statement();
+      if (this._check(TokenTypes.keywords.for))
+        return this._for_statement();
+      if (this._check(TokenTypes.keywords.while))
+        return this._while_statement();
+      if (this._check(TokenTypes.keywords.continuing))
+        return this._continuing_statement();
+      if (this._check(TokenTypes.keywords.static_assert))
+        return this._static_assert_statement();
+      if (this._check(TokenTypes.tokens.brace_left))
+        return this._compound_statement();
+      let result = null;
+      if (this._check(TokenTypes.keywords.return))
+        result = this._return_statement();
+      else if (this._check([TokenTypes.keywords.var, TokenTypes.keywords.let, TokenTypes.keywords.const]))
+        result = this._variable_statement();
+      else if (this._match(TokenTypes.keywords.discard))
+        result = new Discard();
+      else if (this._match(TokenTypes.keywords.break))
+        result = new Break();
+      else if (this._match(TokenTypes.keywords.continue))
+        result = new Continue();
+      else
+        result = this._increment_decrement_statement() || this._func_call_statement() || this._assignment_statement();
+      if (result != null)
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';' after statement.");
+      return result;
+    }
+    _static_assert_statement() {
+      if (!this._match(TokenTypes.keywords.static_assert))
+        return null;
+      let expression = this._optional_paren_expression();
+      return new StaticAssert(expression);
+    }
+    _while_statement() {
+      if (!this._match(TokenTypes.keywords.while))
+        return null;
+      let condition = this._optional_paren_expression();
+      const block = this._compound_statement();
+      return new While(condition, block);
+    }
+    _continuing_statement() {
+      if (!this._match(TokenTypes.keywords.continuing))
+        return null;
+      const block = this._compound_statement();
+      return new Continuing(block);
+    }
+    _for_statement() {
+      if (!this._match(TokenTypes.keywords.for))
+        return null;
+      this._consume(TokenTypes.tokens.paren_left, "Expected '('.");
+      const init = !this._check(TokenTypes.tokens.semicolon) ? this._for_init() : null;
+      this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
+      const condition = !this._check(TokenTypes.tokens.semicolon) ? this._short_circuit_or_expression() : null;
+      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 ')'.");
+      const body = this._compound_statement();
+      return new For(init, condition, increment, body);
+    }
+    _for_init() {
+      return this._variable_statement() || this._func_call_statement() || this._assignment_statement();
+    }
+    _for_increment() {
+      return this._func_call_statement() || this._increment_decrement_statement() || this._assignment_statement();
+    }
+    _variable_statement() {
+      if (this._check(TokenTypes.keywords.var)) {
+        const _var = this._variable_decl();
+        if (_var === null)
+          throw this._error(this._peek(), "Variable declaration expected.");
+        let value = null;
+        if (this._match(TokenTypes.tokens.equal))
+          value = this._short_circuit_or_expression();
+        return new Var(_var.name, _var.type, _var.storage, _var.access, value);
+      }
+      if (this._match(TokenTypes.keywords.let)) {
+        const name12 = this._consume(TokenTypes.tokens.ident, "Expected name for let.").toString();
+        let type = null;
+        if (this._match(TokenTypes.tokens.colon)) {
+          const typeAttrs = this._attribute();
+          type = this._type_decl();
+          if (type != null)
+            type.attributes = typeAttrs;
+        }
+        this._consume(TokenTypes.tokens.equal, "Expected '=' for let.");
+        const value = this._short_circuit_or_expression();
+        return new Let(name12, type, null, null, value);
+      }
+      if (this._match(TokenTypes.keywords.const)) {
+        const name12 = this._consume(TokenTypes.tokens.ident, "Expected name for const.").toString();
+        let type = null;
+        if (this._match(TokenTypes.tokens.colon)) {
+          const typeAttrs = this._attribute();
+          type = this._type_decl();
+          if (type != null)
+            type.attributes = typeAttrs;
+        }
+        this._consume(TokenTypes.tokens.equal, "Expected '=' for const.");
+        const value = this._short_circuit_or_expression();
+        return new Const(name12, type, null, null, value);
+      }
+      return null;
+    }
+    _increment_decrement_statement() {
+      const savedPos = this._current;
+      const _var = this._unary_expression();
+      if (_var == null)
+        return null;
+      if (!this._check(TokenTypes.increment_operators)) {
+        this._current = savedPos;
+        return null;
+      }
+      const token = this._consume(TokenTypes.increment_operators, "Expected increment operator");
+      return new Increment(token.type === TokenTypes.tokens.plus_plus ? IncrementOperator.increment : IncrementOperator.decrement, _var);
+    }
+    _assignment_statement() {
+      let _var = null;
+      if (this._check(TokenTypes.tokens.brace_right))
+        return null;
+      let isUnderscore = this._match(TokenTypes.tokens.underscore);
+      if (!isUnderscore)
+        _var = this._unary_expression();
+      if (!isUnderscore && _var == null)
+        return null;
+      const type = this._consume(TokenTypes.assignment_operators, "Expected assignment operator.");
+      const value = this._short_circuit_or_expression();
+      return new Assign(AssignOperator.parse(type.lexeme), _var, value);
+    }
+    _func_call_statement() {
+      if (!this._check(TokenTypes.tokens.ident))
+        return null;
+      const savedPos = this._current;
+      const name12 = this._consume(TokenTypes.tokens.ident, "Expected function name.");
+      const args = this._argument_expression_list();
+      if (args === null) {
+        this._current = savedPos;
+        return null;
+      }
+      return new Call(name12.lexeme, args);
+    }
+    _loop_statement() {
+      if (!this._match(TokenTypes.keywords.loop))
+        return null;
+      this._consume(TokenTypes.tokens.brace_left, "Expected '{' for loop.");
+      const statements = [];
+      let statement = this._statement();
+      while (statement !== null) {
+        if (Array.isArray(statement)) {
+          for (let s2 of statement) {
+            statements.push(s2);
+          }
+        } else {
+          statements.push(statement);
+        }
+        statement = this._statement();
+      }
+      let continuing = null;
+      if (this._match(TokenTypes.keywords.continuing))
+        continuing = this._compound_statement();
+      this._consume(TokenTypes.tokens.brace_right, "Expected '}' for loop.");
+      return new Loop(statements, continuing);
+    }
+    _switch_statement() {
+      if (!this._match(TokenTypes.keywords.switch))
+        return null;
+      const condition = this._optional_paren_expression();
+      this._consume(TokenTypes.tokens.brace_left, "Expected '{' for switch.");
+      const body = this._switch_body();
+      if (body == null || body.length == 0)
+        throw this._error(this._previous(), "Expected 'case' or 'default'.");
+      this._consume(TokenTypes.tokens.brace_right, "Expected '}' for switch.");
+      return new Switch(condition, body);
+    }
+    _switch_body() {
+      const cases = [];
+      if (this._match(TokenTypes.keywords.case)) {
+        const selector = this._case_selectors();
+        this._match(TokenTypes.tokens.colon);
+        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.");
+        cases.push(new Case(selector, body));
+      }
+      if (this._match(TokenTypes.keywords.default)) {
+        this._match(TokenTypes.tokens.colon);
+        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.");
+        cases.push(new Default(body));
+      }
+      if (this._check([TokenTypes.keywords.default, TokenTypes.keywords.case])) {
+        const _cases = this._switch_body();
+        cases.push(_cases[0]);
+      }
+      return cases;
+    }
+    _case_selectors() {
+      var _a2, _b, _c, _d;
+      const selectors = [(_b = (_a2 = this._shift_expression()) === null || _a2 === void 0 ? void 0 : _a2.evaluate(this._context).toString()) !== null && _b !== void 0 ? _b : ""];
+      while (this._match(TokenTypes.tokens.comma)) {
+        selectors.push((_d = (_c = this._shift_expression()) === null || _c === void 0 ? void 0 : _c.evaluate(this._context).toString()) !== null && _d !== void 0 ? _d : "");
+      }
+      return selectors;
+    }
+    _case_body() {
+      if (this._match(TokenTypes.keywords.fallthrough)) {
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
+        return [];
+      }
+      let statement = this._statement();
+      if (statement == null)
+        return [];
+      if (!(statement instanceof Array)) {
+        statement = [statement];
+      }
+      const nextStatement = this._case_body();
+      if (nextStatement.length == 0)
+        return statement;
+      return [...statement, nextStatement[0]];
+    }
+    _if_statement() {
+      if (!this._match(TokenTypes.keywords.if))
+        return null;
+      const condition = this._optional_paren_expression();
+      const block = this._compound_statement();
+      let elseif = [];
+      if (this._match_elseif()) {
+        elseif = this._elseif_statement(elseif);
+      }
+      let _else = null;
+      if (this._match(TokenTypes.keywords.else))
+        _else = this._compound_statement();
+      return new If(condition, block, elseif, _else);
+    }
+    _match_elseif() {
+      if (this._tokens[this._current].type === TokenTypes.keywords.else && this._tokens[this._current + 1].type === TokenTypes.keywords.if) {
+        this._advance();
+        this._advance();
+        return true;
+      }
+      return false;
+    }
+    _elseif_statement() {
+      let elseif = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+      const condition = this._optional_paren_expression();
+      const block = this._compound_statement();
+      elseif.push(new ElseIf(condition, block));
+      if (this._match_elseif()) {
+        this._elseif_statement(elseif);
+      }
+      return elseif;
+    }
+    _return_statement() {
+      if (!this._match(TokenTypes.keywords.return))
+        return null;
+      const value = this._short_circuit_or_expression();
+      return new Return(value);
+    }
+    _short_circuit_or_expression() {
+      let expr = this._short_circuit_and_expr();
+      while (this._match(TokenTypes.tokens.or_or)) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._short_circuit_and_expr());
+      }
+      return expr;
+    }
+    _short_circuit_and_expr() {
+      let expr = this._inclusive_or_expression();
+      while (this._match(TokenTypes.tokens.and_and)) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._inclusive_or_expression());
+      }
+      return expr;
+    }
+    _inclusive_or_expression() {
+      let expr = this._exclusive_or_expression();
+      while (this._match(TokenTypes.tokens.or)) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._exclusive_or_expression());
+      }
+      return expr;
+    }
+    _exclusive_or_expression() {
+      let expr = this._and_expression();
+      while (this._match(TokenTypes.tokens.xor)) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._and_expression());
+      }
+      return expr;
+    }
+    _and_expression() {
+      let expr = this._equality_expression();
+      while (this._match(TokenTypes.tokens.and)) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._equality_expression());
+      }
+      return expr;
+    }
+    _equality_expression() {
+      const expr = this._relational_expression();
+      if (this._match([TokenTypes.tokens.equal_equal, TokenTypes.tokens.not_equal])) {
+        return new BinaryOperator(this._previous().toString(), expr, this._relational_expression());
+      }
+      return expr;
+    }
+    _relational_expression() {
+      let expr = this._shift_expression();
+      while (this._match([TokenTypes.tokens.less_than, TokenTypes.tokens.greater_than, TokenTypes.tokens.less_than_equal, TokenTypes.tokens.greater_than_equal])) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._shift_expression());
+      }
+      return expr;
+    }
+    _shift_expression() {
+      let expr = this._additive_expression();
+      while (this._match([TokenTypes.tokens.shift_left, TokenTypes.tokens.shift_right])) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._additive_expression());
+      }
+      return expr;
+    }
+    _additive_expression() {
+      let expr = this._multiplicative_expression();
+      while (this._match([TokenTypes.tokens.plus, TokenTypes.tokens.minus])) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._multiplicative_expression());
+      }
+      return expr;
+    }
+    _multiplicative_expression() {
+      let expr = this._unary_expression();
+      while (this._match([TokenTypes.tokens.star, TokenTypes.tokens.forward_slash, TokenTypes.tokens.modulo])) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._unary_expression());
+      }
+      return expr;
+    }
+    _unary_expression() {
+      if (this._match([TokenTypes.tokens.minus, TokenTypes.tokens.bang, TokenTypes.tokens.tilde, TokenTypes.tokens.star, TokenTypes.tokens.and])) {
+        return new UnaryOperator(this._previous().toString(), this._unary_expression());
+      }
+      return this._singular_expression();
+    }
+    _singular_expression() {
+      const expr = this._primary_expression();
+      const p2 = this._postfix_expression();
+      if (p2)
+        expr.postfix = p2;
+      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 p2 = this._postfix_expression();
+        if (p2)
+          expr.postfix = p2;
+        return expr;
+      }
+      if (this._match(TokenTypes.tokens.period)) {
+        const name12 = this._consume(TokenTypes.tokens.ident, "Expected member name.");
+        const p2 = this._postfix_expression();
+        const expr = new StringExpr(name12.lexeme);
+        if (p2)
+          expr.postfix = p2;
+        return expr;
+      }
+      return null;
+    }
+    _getStruct(name12) {
+      if (this._context.aliases.has(name12)) {
+        const alias = this._context.aliases.get(name12).type;
+        return alias;
+      }
+      if (this._context.structs.has(name12)) {
+        const struct = this._context.structs.get(name12);
+        return struct;
+      }
+      return null;
+    }
+    _primary_expression() {
+      if (this._match(TokenTypes.tokens.ident)) {
+        const name12 = this._previous().toString();
+        if (this._check(TokenTypes.tokens.paren_left)) {
+          const args2 = this._argument_expression_list();
+          const struct = this._getStruct(name12);
+          if (struct != null) {
+            return new CreateExpr(struct, args2);
+          }
+          return new CallExpr(name12, args2);
+        }
+        if (this._context.constants.has(name12)) {
+          const c = this._context.constants.get(name12);
+          return new ConstExpr(name12, c.value);
+        }
+        return new VariableExpr(name12);
+      }
+      if (this._match(TokenTypes.const_literal)) {
+        return new LiteralExpr(parseFloat(this._previous().toString()));
+      }
+      if (this._check(TokenTypes.tokens.paren_left)) {
+        return this._paren_expression();
+      }
+      if (this._match(TokenTypes.keywords.bitcast)) {
+        this._consume(TokenTypes.tokens.less_than, "Expected '<'.");
+        const type2 = this._type_decl();
+        this._consume(TokenTypes.tokens.greater_than, "Expected '>'.");
+        const value = this._paren_expression();
+        return new BitcastExpr(type2, value);
+      }
+      const type = this._type_decl();
+      const args = this._argument_expression_list();
+      return new TypecastExpr(type, args);
+    }
+    _argument_expression_list() {
+      if (!this._match(TokenTypes.tokens.paren_left))
+        return null;
+      const args = [];
+      do {
+        if (this._check(TokenTypes.tokens.paren_right))
+          break;
+        const arg = this._short_circuit_or_expression();
+        args.push(arg);
+      } while (this._match(TokenTypes.tokens.comma));
+      this._consume(TokenTypes.tokens.paren_right, "Expected ')' for agument list");
+      return args;
+    }
+    _optional_paren_expression() {
+      this._match(TokenTypes.tokens.paren_left);
+      const expr = this._short_circuit_or_expression();
+      this._match(TokenTypes.tokens.paren_right);
+      return new GroupingExpr([expr]);
+    }
+    _paren_expression() {
+      this._consume(TokenTypes.tokens.paren_left, "Expected '('.");
+      const expr = this._short_circuit_or_expression();
+      this._consume(TokenTypes.tokens.paren_right, "Expected ')'.");
+      return new GroupingExpr([expr]);
+    }
+    _struct_decl() {
+      if (!this._match(TokenTypes.keywords.struct))
+        return null;
+      const name12 = this._consume(TokenTypes.tokens.ident, "Expected name for struct.").toString();
+      this._consume(TokenTypes.tokens.brace_left, "Expected '{' for struct body.");
+      const members = [];
+      while (!this._check(TokenTypes.tokens.brace_right)) {
+        const memberAttrs = this._attribute();
+        const memberName = this._consume(TokenTypes.tokens.ident, "Expected variable name.").toString();
+        this._consume(TokenTypes.tokens.colon, "Expected ':' for struct member type.");
+        const typeAttrs = this._attribute();
+        const memberType = this._type_decl();
+        if (memberType != null)
+          memberType.attributes = typeAttrs;
+        if (!this._check(TokenTypes.tokens.brace_right))
+          this._consume(TokenTypes.tokens.comma, "Expected ',' for struct member.");
+        else
+          this._match(TokenTypes.tokens.comma);
+        members.push(new Member(memberName, memberType, memberAttrs));
+      }
+      this._consume(TokenTypes.tokens.brace_right, "Expected '}' after struct body.");
+      const structNode = new Struct(name12, members);
+      this._context.structs.set(name12, structNode);
+      return structNode;
+    }
+    _global_variable_decl() {
+      const _var = this._variable_decl();
+      if (_var && this._match(TokenTypes.tokens.equal))
+        _var.value = this._const_expression();
+      return _var;
+    }
+    _override_variable_decl() {
+      const _override = this._override_decl();
+      if (_override && this._match(TokenTypes.tokens.equal))
+        _override.value = this._const_expression();
+      return _override;
+    }
+    _global_const_decl() {
+      if (!this._match(TokenTypes.keywords.const))
+        return null;
+      const name12 = this._consume(TokenTypes.tokens.ident, "Expected variable name");
+      let type = null;
+      if (this._match(TokenTypes.tokens.colon)) {
+        const attrs = this._attribute();
+        type = this._type_decl();
+        if (type != null)
+          type.attributes = attrs;
+      }
+      let value = null;
+      if (this._match(TokenTypes.tokens.equal)) {
+        const valueExpr = this._short_circuit_or_expression();
+        if (valueExpr instanceof CreateExpr) {
+          value = valueExpr;
+        } else if (valueExpr instanceof ConstExpr && valueExpr.initializer instanceof CreateExpr) {
+          value = valueExpr.initializer;
+        } else {
+          try {
+            const constValue = valueExpr.evaluate(this._context);
+            value = new LiteralExpr(constValue);
+          } catch (_a2) {
+            value = valueExpr;
+          }
+        }
+      }
+      const c = new Const(name12.toString(), type, "", "", value);
+      this._context.constants.set(c.name, c);
+      return c;
+    }
+    _global_let_decl() {
+      if (!this._match(TokenTypes.keywords.let))
+        return null;
+      const name12 = this._consume(TokenTypes.tokens.ident, "Expected variable name");
+      let type = null;
+      if (this._match(TokenTypes.tokens.colon)) {
+        const attrs = this._attribute();
+        type = this._type_decl();
+        if (type != null)
+          type.attributes = attrs;
+      }
+      let value = null;
+      if (this._match(TokenTypes.tokens.equal)) {
+        value = this._const_expression();
+      }
+      return new Let(name12.toString(), type, "", "", value);
+    }
+    _const_expression() {
+      if (this._match(TokenTypes.const_literal))
+        return new StringExpr(this._previous().toString());
+      const type = this._type_decl();
+      this._consume(TokenTypes.tokens.paren_left, "Expected '('.");
+      let args = [];
+      while (!this._check(TokenTypes.tokens.paren_right)) {
+        args.push(this._const_expression());
+        if (!this._check(TokenTypes.tokens.comma))
+          break;
+        this._advance();
+      }
+      this._consume(TokenTypes.tokens.paren_right, "Expected ')'.");
+      return new CreateExpr(type, args);
+    }
+    _variable_decl() {
+      if (!this._match(TokenTypes.keywords.var))
+        return null;
+      let storage = "";
+      let access = "";
+      if (this._match(TokenTypes.tokens.less_than)) {
+        storage = this._consume(TokenTypes.storage_class, "Expected storage_class.").toString();
+        if (this._match(TokenTypes.tokens.comma))
+          access = this._consume(TokenTypes.access_mode, "Expected access_mode.").toString();
+        this._consume(TokenTypes.tokens.greater_than, "Expected '>'.");
+      }
+      const name12 = this._consume(TokenTypes.tokens.ident, "Expected variable name");
+      let type = null;
+      if (this._match(TokenTypes.tokens.colon)) {
+        const attrs = this._attribute();
+        type = this._type_decl();
+        if (type != null)
+          type.attributes = attrs;
+      }
+      return new Var(name12.toString(), type, storage, access, null);
+    }
+    _override_decl() {
+      if (!this._match(TokenTypes.keywords.override))
+        return null;
+      const name12 = this._consume(TokenTypes.tokens.ident, "Expected variable name");
+      let type = null;
+      if (this._match(TokenTypes.tokens.colon)) {
+        const attrs = this._attribute();
+        type = this._type_decl();
+        if (type != null)
+          type.attributes = attrs;
+      }
+      return new Override(name12.toString(), type, null);
+    }
+    _enable_directive() {
+      const name12 = this._consume(TokenTypes.tokens.ident, "identity expected.");
+      return new Enable(name12.toString());
+    }
+    _type_alias() {
+      const name12 = this._consume(TokenTypes.tokens.ident, "identity expected.");
+      this._consume(TokenTypes.tokens.equal, "Expected '=' for type alias.");
+      let aliasType = this._type_decl();
+      if (aliasType === null) {
+        throw this._error(this._peek(), "Expected Type for Alias.");
+      }
+      if (this._context.aliases.has(aliasType.name)) {
+        aliasType = this._context.aliases.get(aliasType.name).type;
+      }
+      const aliasNode = new Alias(name12.toString(), aliasType);
+      this._context.aliases.set(aliasNode.name, aliasNode);
+      return aliasNode;
+    }
+    _type_decl() {
+      if (this._check([TokenTypes.tokens.ident, ...TokenTypes.texel_format, TokenTypes.keywords.bool, TokenTypes.keywords.f32, TokenTypes.keywords.i32, TokenTypes.keywords.u32])) {
+        const type2 = this._advance();
+        const typeName = type2.toString();
+        if (this._context.structs.has(typeName)) {
+          return this._context.structs.get(typeName);
+        }
+        if (this._context.aliases.has(typeName)) {
+          return this._context.aliases.get(typeName).type;
+        }
+        return new Type(type2.toString());
+      }
+      let type = this._texture_sampler_types();
+      if (type)
+        return type;
+      if (this._check(TokenTypes.template_types)) {
+        let type2 = this._advance().toString();
+        let format = null;
+        let access = null;
+        if (this._match(TokenTypes.tokens.less_than)) {
+          format = this._type_decl();
+          access = null;
+          if (this._match(TokenTypes.tokens.comma))
+            access = this._consume(TokenTypes.access_mode, "Expected access_mode for pointer").toString();
+          this._consume(TokenTypes.tokens.greater_than, "Expected '>' for type.");
+        }
+        return new TemplateType(type2, format, access);
+      }
+      if (this._match(TokenTypes.keywords.ptr)) {
+        let pointer = this._previous().toString();
+        this._consume(TokenTypes.tokens.less_than, "Expected '<' for pointer.");
+        const storage = this._consume(TokenTypes.storage_class, "Expected storage_class for pointer");
+        this._consume(TokenTypes.tokens.comma, "Expected ',' for pointer.");
+        const decl = this._type_decl();
+        let access = null;
+        if (this._match(TokenTypes.tokens.comma))
+          access = this._consume(TokenTypes.access_mode, "Expected access_mode for pointer").toString();
+        this._consume(TokenTypes.tokens.greater_than, "Expected '>' for pointer.");
+        return new PointerType(pointer, storage.toString(), decl, access);
+      }
+      const attrs = this._attribute();
+      if (this._match(TokenTypes.keywords.array)) {
+        let format = null;
+        let countInt = -1;
+        const array = this._previous();
+        if (this._match(TokenTypes.tokens.less_than)) {
+          format = this._type_decl();
+          if (this._context.aliases.has(format.name)) {
+            format = this._context.aliases.get(format.name).type;
+          }
+          let count = "";
+          if (this._match(TokenTypes.tokens.comma)) {
+            let c = this._shift_expression();
+            count = c.evaluate(this._context).toString();
+          }
+          this._consume(TokenTypes.tokens.greater_than, "Expected '>' for array.");
+          countInt = count ? parseInt(count) : 0;
+        }
+        return new ArrayType(array.toString(), attrs, format, countInt);
+      }
+      return null;
+    }
+    _texture_sampler_types() {
+      if (this._match(TokenTypes.sampler_type))
+        return new SamplerType(this._previous().toString(), null, null);
+      if (this._match(TokenTypes.depth_texture_type))
+        return new SamplerType(this._previous().toString(), null, null);
+      if (this._match(TokenTypes.sampled_texture_type) || this._match(TokenTypes.multisampled_texture_type)) {
+        const sampler = this._previous();
+        this._consume(TokenTypes.tokens.less_than, "Expected '<' for sampler type.");
+        const format = this._type_decl();
+        this._consume(TokenTypes.tokens.greater_than, "Expected '>' for sampler type.");
+        return new SamplerType(sampler.toString(), format, null);
+      }
+      if (this._match(TokenTypes.storage_texture_type)) {
+        const sampler = this._previous();
+        this._consume(TokenTypes.tokens.less_than, "Expected '<' for sampler type.");
+        const format = this._consume(TokenTypes.texel_format, "Invalid texel format.").toString();
+        this._consume(TokenTypes.tokens.comma, "Expected ',' after texel format.");
+        const access = this._consume(TokenTypes.access_mode, "Expected access mode for storage texture type.").toString();
+        this._consume(TokenTypes.tokens.greater_than, "Expected '>' for sampler type.");
+        return new SamplerType(sampler.toString(), format, access);
+      }
+      return null;
+    }
+    _attribute() {
+      let attributes = [];
+      while (this._match(TokenTypes.tokens.attr)) {
+        const name12 = this._consume(TokenTypes.attribute_name, "Expected attribute name");
+        const attr = new Attribute(name12.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();
+              if (!(attr.value instanceof Array)) {
+                attr.value = [attr.value];
+              }
+              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.attr_left)) {
+        if (!this._check(TokenTypes.tokens.attr_right)) {
+          do {
+            const name12 = this._consume(TokenTypes.attribute_name, "Expected attribute name");
+            const attr = new Attribute(name12.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;
+      return attributes;
+    }
+  };
+  var TypeInfo = class {
+    constructor(name12, attributes) {
+      this.name = name12;
+      this.attributes = attributes;
+      this.size = 0;
+    }
+    get isArray() {
+      return false;
+    }
+    get isStruct() {
+      return false;
+    }
+    get isTemplate() {
+      return false;
+    }
+  };
+  var MemberInfo = class {
+    constructor(name12, type, attributes) {
+      this.name = name12;
+      this.type = type;
+      this.attributes = attributes;
+      this.offset = 0;
+      this.size = 0;
+    }
+    get isArray() {
+      return this.type.isArray;
+    }
+    get isStruct() {
+      return this.type.isStruct;
+    }
+    get isTemplate() {
+      return this.type.isTemplate;
+    }
+    get align() {
+      return this.type.isStruct ? this.type.align : 0;
+    }
+    get members() {
+      return this.type.isStruct ? this.type.members : null;
+    }
+    get format() {
+      return this.type.isArray ? this.type.format : this.type.isTemplate ? this.type.format : null;
+    }
+    get count() {
+      return this.type.isArray ? this.type.count : 0;
+    }
+    get stride() {
+      return this.type.isArray ? this.type.stride : this.size;
+    }
+  };
+  var StructInfo = class extends TypeInfo {
+    constructor(name12, attributes) {
+      super(name12, attributes);
+      this.members = [];
+      this.align = 0;
+    }
+    get isStruct() {
+      return true;
+    }
+  };
+  var ArrayInfo = class extends TypeInfo {
+    constructor(name12, attributes) {
+      super(name12, attributes);
+      this.count = 0;
+      this.stride = 0;
+    }
+    get isArray() {
+      return true;
+    }
+  };
+  var TemplateInfo = class extends TypeInfo {
+    constructor(name12, format, attributes, access) {
+      super(name12, attributes);
+      this.format = format;
+      this.access = access;
+    }
+    get isTemplate() {
+      return true;
+    }
+  };
+  var ResourceType;
+  (function(ResourceType2) {
+    ResourceType2[ResourceType2["Uniform"] = 0] = "Uniform";
+    ResourceType2[ResourceType2["Storage"] = 1] = "Storage";
+    ResourceType2[ResourceType2["Texture"] = 2] = "Texture";
+    ResourceType2[ResourceType2["Sampler"] = 3] = "Sampler";
+    ResourceType2[ResourceType2["StorageTexture"] = 4] = "StorageTexture";
+  })(ResourceType || (ResourceType = {}));
+  var VariableInfo = class {
+    constructor(name12, type, group, binding, attributes, resourceType, access) {
+      this.name = name12;
+      this.type = type;
+      this.group = group;
+      this.binding = binding;
+      this.attributes = attributes;
+      this.resourceType = resourceType;
+      this.access = access;
+    }
+    get isArray() {
+      return this.type.isArray;
+    }
+    get isStruct() {
+      return this.type.isStruct;
+    }
+    get isTemplate() {
+      return this.type.isTemplate;
+    }
+    get size() {
+      return this.type.size;
+    }
+    get align() {
+      return this.type.isStruct ? this.type.align : 0;
+    }
+    get members() {
+      return this.type.isStruct ? this.type.members : null;
+    }
+    get format() {
+      return this.type.isArray ? this.type.format : this.type.isTemplate ? this.type.format : null;
+    }
+    get count() {
+      return this.type.isArray ? this.type.count : 0;
+    }
+    get stride() {
+      return this.type.isArray ? this.type.stride : this.size;
+    }
+  };
+  var AliasInfo = class {
+    constructor(name12, type) {
+      this.name = name12;
+      this.type = type;
+    }
+  };
+  var _TypeSize = class {
+    constructor(align, size) {
+      this.align = align;
+      this.size = size;
+    }
+  };
+  var InputInfo = class {
+    constructor(name12, type, locationType, location) {
+      this.name = name12;
+      this.type = type;
+      this.locationType = locationType;
+      this.location = location;
+      this.interpolation = null;
+    }
+  };
+  var OutputInfo = class {
+    constructor(name12, type, locationType, location) {
+      this.name = name12;
+      this.type = type;
+      this.locationType = locationType;
+      this.location = location;
+    }
+  };
+  var FunctionInfo = class {
+    constructor(name12) {
+      let stage = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+      this.stage = null;
+      this.inputs = [];
+      this.outputs = [];
+      this.name = name12;
+      this.stage = stage;
+    }
+  };
+  var EntryFunctions = class {
+    constructor() {
+      this.vertex = [];
+      this.fragment = [];
+      this.compute = [];
+    }
+  };
+  var OverrideInfo = class {
+    constructor(name12, type, attributes, id) {
+      this.name = name12;
+      this.type = type;
+      this.attributes = attributes;
+      this.id = id;
+    }
+  };
+  var WgslReflect = class {
+    constructor(code) {
+      this.uniforms = [];
+      this.storage = [];
+      this.textures = [];
+      this.samplers = [];
+      this.aliases = [];
+      this.overrides = [];
+      this.structs = [];
+      this.entry = new EntryFunctions();
+      this._types = /* @__PURE__ */ new Map();
+      if (code) {
+        this.update(code);
+      }
+    }
+    _isStorageTexture(type) {
+      return type.name == "texture_storage_1d" || type.name == "texture_storage_2d" || type.name == "texture_storage_2d_array" || type.name == "texture_storage_3d";
+    }
+    update(code) {
+      const parser = new WgslParser();
+      const ast = parser.parse(code);
+      for (const node2 of ast) {
+        if (node2 instanceof Struct) {
+          const info = this._getTypeInfo(node2, null);
+          if (info instanceof StructInfo) {
+            this.structs.push(info);
+          }
+          continue;
+        }
+        if (node2 instanceof Alias) {
+          this.aliases.push(this._getAliasInfo(node2));
+          continue;
+        }
+        if (node2 instanceof Override) {
+          const v = node2;
+          const id = this._getAttributeNum(v.attributes, "id", 0);
+          const type = v.type != null ? this._getTypeInfo(v.type, v.attributes) : null;
+          this.overrides.push(new OverrideInfo(v.name, type, v.attributes, id));
+          continue;
+        }
+        if (this._isUniformVar(node2)) {
+          const v = node2;
+          const g = this._getAttributeNum(v.attributes, "group", 0);
+          const b = this._getAttributeNum(v.attributes, "binding", 0);
+          const type = this._getTypeInfo(v.type, v.attributes);
+          const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, ResourceType.Uniform, v.access);
+          this.uniforms.push(varInfo);
+          continue;
+        }
+        if (this._isStorageVar(node2)) {
+          const v = node2;
+          const g = this._getAttributeNum(v.attributes, "group", 0);
+          const b = this._getAttributeNum(v.attributes, "binding", 0);
+          const type = this._getTypeInfo(v.type, v.attributes);
+          const isStorageTexture = this._isStorageTexture(type);
+          const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, isStorageTexture ? ResourceType.StorageTexture : ResourceType.Storage, v.access);
+          this.storage.push(varInfo);
+          continue;
+        }
+        if (this._isTextureVar(node2)) {
+          const v = node2;
+          const g = this._getAttributeNum(v.attributes, "group", 0);
+          const b = this._getAttributeNum(v.attributes, "binding", 0);
+          const type = this._getTypeInfo(v.type, v.attributes);
+          const isStorageTexture = this._isStorageTexture(type);
+          const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, isStorageTexture ? ResourceType.StorageTexture : ResourceType.Texture, v.access);
+          if (isStorageTexture) {
+            this.storage.push(varInfo);
+          } else {
+            this.textures.push(varInfo);
+          }
+          continue;
+        }
+        if (this._isSamplerVar(node2)) {
+          const v = node2;
+          const g = this._getAttributeNum(v.attributes, "group", 0);
+          const b = this._getAttributeNum(v.attributes, "binding", 0);
+          const type = this._getTypeInfo(v.type, v.attributes);
+          const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, ResourceType.Sampler, v.access);
+          this.samplers.push(varInfo);
+          continue;
+        }
+        if (node2 instanceof Function) {
+          const vertexStage = this._getAttribute(node2, "vertex");
+          const fragmentStage = this._getAttribute(node2, "fragment");
+          const computeStage = this._getAttribute(node2, "compute");
+          const stage = vertexStage || fragmentStage || computeStage;
+          if (stage) {
+            const fn = new FunctionInfo(node2.name, stage.name);
+            fn.inputs = this._getInputs(node2.args);
+            fn.outputs = this._getOutputs(node2.returnType);
+            this.entry[stage.name].push(fn);
+          }
+          continue;
+        }
+      }
+    }
+    getBindGroups() {
+      const groups = [];
+      function _makeRoom(group, binding) {
+        if (group >= groups.length)
+          groups.length = group + 1;
+        if (groups[group] === void 0)
+          groups[group] = [];
+        if (binding >= groups[group].length)
+          groups[group].length = binding + 1;
+      }
+      for (const u of this.uniforms) {
+        _makeRoom(u.group, u.binding);
+        const group = groups[u.group];
+        group[u.binding] = u;
+      }
+      for (const u of this.storage) {
+        _makeRoom(u.group, u.binding);
+        const group = groups[u.group];
+        group[u.binding] = u;
+      }
+      for (const t2 of this.textures) {
+        _makeRoom(t2.group, t2.binding);
+        const group = groups[t2.group];
+        group[t2.binding] = t2;
+      }
+      for (const t2 of this.samplers) {
+        _makeRoom(t2.group, t2.binding);
+        const group = groups[t2.group];
+        group[t2.binding] = t2;
+      }
+      return groups;
+    }
+    _getOutputs(type) {
+      let outputs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0;
+      if (outputs === void 0)
+        outputs = [];
+      if (type instanceof Struct) {
+        this._getStructOutputs(type, outputs);
+      } else {
+        const output = this._getOutputInfo(type);
+        if (output !== null)
+          outputs.push(output);
+      }
+      return outputs;
+    }
+    _getStructOutputs(struct, outputs) {
+      for (const m of struct.members) {
+        if (m.type instanceof Struct) {
+          this._getStructOutputs(m.type, outputs);
+        } else {
+          const location = this._getAttribute(m, "location") || this._getAttribute(m, "builtin");
+          if (location !== null) {
+            const typeInfo = this._getTypeInfo(m.type, m.type.attributes);
+            const locationValue = this._parseInt(location.value);
+            const info = new OutputInfo(m.name, typeInfo, location.name, locationValue);
+            outputs.push(info);
+          }
+        }
+      }
+    }
+    _getOutputInfo(type) {
+      const location = this._getAttribute(type, "location") || this._getAttribute(type, "builtin");
+      if (location !== null) {
+        const typeInfo = this._getTypeInfo(type, type.attributes);
+        const locationValue = this._parseInt(location.value);
+        const info = new OutputInfo("", typeInfo, location.name, locationValue);
+        return info;
+      }
+      return null;
+    }
+    _getInputs(args) {
+      let inputs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0;
+      if (inputs === void 0)
+        inputs = [];
+      for (const arg of args) {
+        if (arg.type instanceof Struct) {
+          this._getStructInputs(arg.type, inputs);
+        } else {
+          const input = this._getInputInfo(arg);
+          if (input !== null)
+            inputs.push(input);
+        }
+      }
+      return inputs;
+    }
+    _getStructInputs(struct, inputs) {
+      for (const m of struct.members) {
+        if (m.type instanceof Struct) {
+          this._getStructInputs(m.type, inputs);
+        } else {
+          const input = this._getInputInfo(m);
+          if (input !== null)
+            inputs.push(input);
+        }
+      }
+    }
+    _getInputInfo(node2) {
+      const location = this._getAttribute(node2, "location") || this._getAttribute(node2, "builtin");
+      if (location !== null) {
+        const interpolation = this._getAttribute(node2, "interpolation");
+        const type = this._getTypeInfo(node2.type, node2.attributes);
+        const locationValue = this._parseInt(location.value);
+        const info = new InputInfo(node2.name, type, location.name, locationValue);
+        if (interpolation !== null) {
+          info.interpolation = this._parseString(interpolation.value);
+        }
+        return info;
+      }
+      return null;
+    }
+    _parseString(s2) {
+      if (s2 instanceof Array) {
+        s2 = s2[0];
+      }
+      return s2;
+    }
+    _parseInt(s2) {
+      if (s2 instanceof Array) {
+        s2 = s2[0];
+      }
+      const n2 = parseInt(s2);
+      return isNaN(n2) ? s2 : n2;
+    }
+    _getAlias(name12) {
+      for (const a2 of this.aliases) {
+        if (a2.name == name12)
+          return a2.type;
+      }
+      return null;
+    }
+    _getAliasInfo(node2) {
+      return new AliasInfo(node2.name, this._getTypeInfo(node2.type, null));
+    }
+    _getTypeInfo(type, attributes) {
+      if (this._types.has(type)) {
+        return this._types.get(type);
+      }
+      if (type instanceof ArrayType) {
+        const a2 = type;
+        const t2 = this._getTypeInfo(a2.format, a2.attributes);
+        const info2 = new ArrayInfo(a2.name, attributes);
+        info2.format = t2;
+        info2.count = a2.count;
+        this._types.set(type, info2);
+        this._updateTypeInfo(info2);
+        return info2;
+      }
+      if (type instanceof Struct) {
+        const s2 = type;
+        const info2 = new StructInfo(s2.name, attributes);
+        for (const m of s2.members) {
+          const t2 = this._getTypeInfo(m.type, m.attributes);
+          info2.members.push(new MemberInfo(m.name, t2, m.attributes));
+        }
+        this._types.set(type, info2);
+        this._updateTypeInfo(info2);
+        return info2;
+      }
+      if (type instanceof SamplerType) {
+        const s2 = type;
+        const formatIsType = s2.format instanceof Type;
+        const format = s2.format ? formatIsType ? this._getTypeInfo(s2.format, null) : new TypeInfo(s2.format, null) : null;
+        const info2 = new TemplateInfo(s2.name, format, attributes, s2.access);
+        this._types.set(type, info2);
+        this._updateTypeInfo(info2);
+        return info2;
+      }
+      if (type instanceof TemplateType) {
+        const t2 = type;
+        const format = t2.format ? this._getTypeInfo(t2.format, null) : null;
+        const info2 = new TemplateInfo(t2.name, format, attributes, t2.access);
+        this._types.set(type, info2);
+        this._updateTypeInfo(info2);
+        return info2;
+      }
+      const info = new TypeInfo(type.name, attributes);
+      this._types.set(type, info);
+      this._updateTypeInfo(info);
+      return info;
+    }
+    _updateTypeInfo(type) {
+      var _a2, _b;
+      const typeSize = this._getTypeSize(type);
+      type.size = (_a2 = typeSize === null || typeSize === void 0 ? void 0 : typeSize.size) !== null && _a2 !== void 0 ? _a2 : 0;
+      if (type instanceof ArrayInfo) {
+        const formatInfo = this._getTypeSize(type["format"]);
+        type.stride = (_b = formatInfo === null || formatInfo === void 0 ? void 0 : formatInfo.size) !== null && _b !== void 0 ? _b : 0;
+        this._updateTypeInfo(type["format"]);
+      }
+      if (type instanceof StructInfo) {
+        this._updateStructInfo(type);
+      }
+    }
+    _updateStructInfo(struct) {
+      var _a2;
+      let offset = 0;
+      let lastSize = 0;
+      let lastOffset = 0;
+      let structAlign = 0;
+      for (let mi = 0, ml = struct.members.length; mi < ml; ++mi) {
+        const member = struct.members[mi];
+        const sizeInfo = this._getTypeSize(member);
+        if (!sizeInfo)
+          continue;
+        (_a2 = this._getAlias(member.type.name)) !== null && _a2 !== void 0 ? _a2 : member.type;
+        const align = sizeInfo.align;
+        const size = sizeInfo.size;
+        offset = this._roundUp(align, offset + lastSize);
+        lastSize = size;
+        lastOffset = offset;
+        structAlign = Math.max(structAlign, align);
+        member.offset = offset;
+        member.size = size;
+        this._updateTypeInfo(member.type);
+      }
+      struct.size = this._roundUp(structAlign, lastOffset + lastSize);
+      struct.align = structAlign;
+    }
+    _getTypeSize(type) {
+      var _a2;
+      if (type === null || type === void 0)
+        return null;
+      const explicitSize = this._getAttributeNum(type.attributes, "size", 0);
+      const explicitAlign = this._getAttributeNum(type.attributes, "align", 0);
+      if (type instanceof MemberInfo)
+        type = type.type;
+      if (type instanceof TypeInfo) {
+        const alias = this._getAlias(type.name);
+        if (alias !== null) {
+          type = alias;
+        }
+      }
+      {
+        const info = WgslReflect._typeInfo[type.name];
+        if (info !== void 0) {
+          const divisor = type["format"] === "f16" ? 2 : 1;
+          return new _TypeSize(Math.max(explicitAlign, info.align / divisor), Math.max(explicitSize, info.size / divisor));
+        }
+      }
+      {
+        const info = WgslReflect._typeInfo[type.name.substring(0, type.name.length - 1)];
+        if (info) {
+          const divisor = type.name[type.name.length - 1] === "h" ? 2 : 1;
+          return new _TypeSize(Math.max(explicitAlign, info.align / divisor), Math.max(explicitSize, info.size / divisor));
+        }
+      }
+      if (type instanceof ArrayInfo) {
+        let arrayType = type;
+        let align = 8;
+        let size = 8;
+        const E = this._getTypeSize(arrayType.format);
+        if (E !== null) {
+          size = E.size;
+          align = E.align;
+        }
+        const N = arrayType.count;
+        const stride = this._getAttributeNum((_a2 = type === null || type === void 0 ? void 0 : type.attributes) !== null && _a2 !== void 0 ? _a2 : null, "stride", this._roundUp(align, size));
+        size = N * stride;
+        if (explicitSize)
+          size = explicitSize;
+        return new _TypeSize(Math.max(explicitAlign, align), Math.max(explicitSize, size));
+      }
+      if (type instanceof StructInfo) {
+        let align = 0;
+        let size = 0;
+        let offset = 0;
+        let lastSize = 0;
+        let lastOffset = 0;
+        for (const m of type.members) {
+          const mi = this._getTypeSize(m.type);
+          if (mi !== null) {
+            align = Math.max(mi.align, align);
+            offset = this._roundUp(mi.align, offset + lastSize);
+            lastSize = mi.size;
+            lastOffset = offset;
+          }
+        }
+        size = this._roundUp(align, lastOffset + lastSize);
+        return new _TypeSize(Math.max(explicitAlign, align), Math.max(explicitSize, size));
+      }
+      return null;
+    }
+    _isUniformVar(node2) {
+      return node2 instanceof Var && node2.storage == "uniform";
+    }
+    _isStorageVar(node2) {
+      return node2 instanceof Var && node2.storage == "storage";
+    }
+    _isTextureVar(node2) {
+      return node2 instanceof Var && node2.type !== null && WgslReflect._textureTypes.indexOf(node2.type.name) != -1;
+    }
+    _isSamplerVar(node2) {
+      return node2 instanceof Var && node2.type !== null && WgslReflect._samplerTypes.indexOf(node2.type.name) != -1;
+    }
+    _getAttribute(node2, name12) {
+      const obj = node2;
+      if (!obj || !obj["attributes"])
+        return null;
+      const attrs = obj["attributes"];
+      for (let a2 of attrs) {
+        if (a2.name == name12)
+          return a2;
+      }
+      return null;
+    }
+    _getAttributeNum(attributes, name12, defaultValue2) {
+      if (attributes === null)
+        return defaultValue2;
+      for (let a2 of attributes) {
+        if (a2.name == name12) {
+          let v = a2 !== null && a2.value !== null ? a2.value : defaultValue2;
+          if (v instanceof Array) {
+            v = v[0];
+          }
+          if (typeof v === "number") {
+            return v;
+          }
+          if (typeof v === "string") {
+            return parseInt(v);
+          }
+          return defaultValue2;
+        }
+      }
+      return defaultValue2;
+    }
+    _roundUp(k, n2) {
+      return Math.ceil(n2 / k) * k;
+    }
+  };
+  WgslReflect._typeInfo = {
+    f16: {
+      align: 2,
+      size: 2
+    },
+    i32: {
+      align: 4,
+      size: 4
+    },
+    u32: {
+      align: 4,
+      size: 4
+    },
+    f32: {
+      align: 4,
+      size: 4
+    },
+    atomic: {
+      align: 4,
+      size: 4
+    },
+    vec2: {
+      align: 8,
+      size: 8
+    },
+    vec3: {
+      align: 16,
+      size: 12
+    },
+    vec4: {
+      align: 16,
+      size: 16
+    },
+    mat2x2: {
+      align: 8,
+      size: 16
+    },
+    mat3x2: {
+      align: 8,
+      size: 24
+    },
+    mat4x2: {
+      align: 8,
+      size: 32
+    },
+    mat2x3: {
+      align: 16,
+      size: 32
+    },
+    mat3x3: {
+      align: 16,
+      size: 48
+    },
+    mat4x3: {
+      align: 16,
+      size: 64
+    },
+    mat2x4: {
+      align: 16,
+      size: 32
+    },
+    mat3x4: {
+      align: 16,
+      size: 48
+    },
+    mat4x4: {
+      align: 16,
+      size: 64
+    }
+  };
+  WgslReflect._textureTypes = TokenTypes.any_texture_type.map((t2) => {
+    return t2.name;
+  });
+  WgslReflect._samplerTypes = TokenTypes.sampler_type.map((t2) => {
+    return t2.name;
+  });
+
+  // ../../node_modules/@luma.gl/shadertools/dist/lib/wgsl/get-shader-layout-wgsl.js
+  function getShaderLayoutFromWGSL(source) {
+    const shaderLayout = {
+      attributes: [],
+      bindings: []
+    };
+    const parsedWGSL = parseWGSL(source);
+    for (const uniform of parsedWGSL.uniforms) {
+      const members = [];
+      for (const member of uniform.type.members) {
+        members.push({
+          name: member.name,
+          type: getType(member.type)
+        });
+      }
+      shaderLayout.bindings.push({
+        type: "uniform",
+        name: uniform.name,
+        location: uniform.binding,
+        group: uniform.group,
+        members
+      });
+    }
+    const vertex = parsedWGSL.entry.vertex[0];
+    const attributeCount = vertex.inputs.length;
+    for (let i3 = 0; i3 < attributeCount; i3++) {
+      const wgslAttribute = vertex.inputs[i3];
+      if (wgslAttribute.locationType === "location") {
+        const type = getType(wgslAttribute.type);
+        shaderLayout.attributes.push({
+          name: wgslAttribute.name,
+          location: wgslAttribute.location,
+          type
+        });
+      }
+    }
+    return shaderLayout;
+  }
+  function getType(type) {
+    return type.format ? `${type.name}<${type.format.name}>` : type.name;
+  }
+  function parseWGSL(source) {
+    try {
+      return new WgslReflect(source);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw error;
+      }
+      let message = "WGSL parse error";
+      if (typeof error === "object" && error !== null && error !== void 0 && error.message) {
+        message += `: ${error.message} `;
+      }
+      if (typeof error === "object" && error !== null && error !== void 0 && error.token) {
+        message += error.token.line || "";
+      }
+      throw new Error(message, {
+        cause: error
+      });
+    }
+  }
+
   // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/lighting/lights/lights.glsl.js
   var lightingShader = glsl`\
 #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
@@ -14056,10 +16829,17 @@ vec4 pbr_filterColor(vec4 colorUnused)
   };
 
   // ../../node_modules/@luma.gl/engine/dist/debug/debug-shader-layout.js
-  function getDebugTableForShaderLayout(layout) {
-    let name12 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+  function getDebugTableForShaderLayout(layout, name12) {
+    var _layout$varyings;
     const table = {};
-    const header = `Shader Layout for ${name12}`;
+    const header = "Values";
+    if (layout.attributes.length === 0 && !((_layout$varyings = layout.varyings) !== null && _layout$varyings !== void 0 && _layout$varyings.length)) {
+      return {
+        "No attributes or varyings": {
+          [header]: "N/A"
+        }
+      };
+    }
     for (const attributeDeclaration of layout.attributes) {
       if (attributeDeclaration) {
         const glslDeclaration = `${attributeDeclaration.location} ${attributeDeclaration.name}: ${attributeDeclaration.type}`;
@@ -14077,6 +16857,49 @@ vec4 pbr_filterColor(vec4 colorUnused)
     return table;
   }
 
+  // ../../node_modules/@luma.gl/engine/dist/debug/debug-framebuffer.js
+  var canvas = null;
+  var ctx = null;
+  function debugFramebuffer(fbo, _ref) {
+    let {
+      id,
+      minimap,
+      opaque,
+      top = "0",
+      left = "0",
+      rgbaScale = 1
+    } = _ref;
+    if (!canvas) {
+      canvas = document.createElement("canvas");
+      canvas.id = id;
+      canvas.title = id;
+      canvas.style.zIndex = "100";
+      canvas.style.position = "absolute";
+      canvas.style.top = top;
+      canvas.style.left = left;
+      canvas.style.border = "blue 1px solid";
+      canvas.style.transform = "scaleY(-1)";
+      document.body.appendChild(canvas);
+      ctx = canvas.getContext("2d");
+    }
+    if (canvas.width !== fbo.width || canvas.height !== fbo.height) {
+      canvas.width = fbo.width / 2;
+      canvas.height = fbo.height / 2;
+      canvas.style.width = "400px";
+      canvas.style.height = "400px";
+    }
+    const color = fbo.device.readPixelsToArrayWebGL(fbo);
+    const imageData = ctx.createImageData(fbo.width, fbo.height);
+    const offset = 0;
+    for (let i3 = 0; i3 < color.length; i3 += 4) {
+      imageData.data[offset + i3 + 0] = color[i3 + 0] * rgbaScale;
+      imageData.data[offset + i3 + 1] = color[i3 + 1] * rgbaScale;
+      imageData.data[offset + i3 + 2] = color[i3 + 2] * rgbaScale;
+      imageData.data[offset + i3 + 3] = opaque ? 255 : color[i3 + 3] * rgbaScale;
+    }
+    ctx.putImageData(imageData, 0, 0);
+  }
+
   // ../../node_modules/@luma.gl/engine/dist/model/model.js
   var LOG_DRAW_PRIORITY = 2;
   var LOG_DRAW_TIMEOUT = 1e4;
@@ -14111,6 +16934,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
       this.props = void 0;
       this._lastLogTime = 0;
       this._logOpen = false;
+      this._drawCount = 0;
       this.props = {
         ...Model.defaultProps,
         ...props
@@ -14121,6 +16945,19 @@ vec4 pbr_filterColor(vec4 colorUnused)
       Object.assign(this.userData, props.userData);
       const moduleMap = Object.fromEntries(((_this$props$modules = this.props.modules) === null || _this$props$modules === void 0 ? void 0 : _this$props$modules.map((module) => [module.name, module])) || []);
       this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
+      const isWebGPU = this.device.info.type === "webgpu";
+      if (this.props.source) {
+        if (isWebGPU) {
+          var _this$props;
+          (_this$props = this.props).shaderLayout || (_this$props.shaderLayout = getShaderLayoutFromWGSL(this.props.source));
+        }
+        this.props.fs = this.props.source;
+        this.props.vs = this.props.source;
+      }
+      if (isWebGPU && typeof this.props.vs !== "string") {
+        var _this$props2;
+        (_this$props2 = this.props).shaderLayout || (_this$props2.shaderLayout = getShaderLayoutFromWGSL(this.props.vs.wgsl));
+      }
       const platformInfo = getPlatformInfo(device);
       const modules = (((_this$props$modules2 = this.props.modules) === null || _this$props$modules2 === void 0 ? void 0 : _this$props$modules2.length) > 0 ? this.props.modules : (_this$shaderInputs = this.shaderInputs) === null || _this$shaderInputs === void 0 ? void 0 : _this$shaderInputs.getModules()) || [];
       const {
@@ -14208,6 +17045,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
       } finally {
         this._logDrawCallEnd();
       }
+      this._logFramebuffer(renderPass);
     }
     setGeometry(geometry) {
       const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
@@ -14219,9 +17057,18 @@ vec4 pbr_filterColor(vec4 colorUnused)
       return gpuGeometry;
     }
     _setGeometryAttributes(gpuGeometry) {
+      const attributes = {
+        ...gpuGeometry.attributes
+      };
+      for (const [attributeName] of Object.entries(attributes)) {
+        if (!this.pipeline.shaderLayout.attributes.find((layout) => layout.name === attributeName) && attributeName !== "positions") {
+          delete attributes[attributeName];
+        }
+      }
       this.vertexCount = gpuGeometry.vertexCount;
-      this.setAttributes(gpuGeometry.attributes, "ignore-unknown");
       this.setIndexBuffer(gpuGeometry.indices);
+      this.setAttributes(gpuGeometry.attributes, "ignore-unknown");
+      this.setAttributes(attributes);
     }
     setTopology(topology) {
       if (topology !== this.topology) {
@@ -14260,6 +17107,18 @@ vec4 pbr_filterColor(vec4 colorUnused)
         this.bindings[`${moduleName}Uniforms`] = uniformBuffer;
       }
     }
+    setShaderModuleProps(props) {
+      const uniforms = this._getModuleUniforms(props);
+      const keys = Object.keys(uniforms).filter((k) => {
+        const uniform = uniforms[k];
+        return !(0, import_core22.isNumberArray)(uniform) && typeof uniform !== "number" && typeof uniform !== "boolean";
+      });
+      const bindings = {};
+      for (const k of keys) {
+        bindings[k] = uniforms[k];
+        delete uniforms[k];
+      }
+    }
     updateShaderInputs() {
       this._uniformStore.setUniforms(this.shaderInputs.getUniformValues());
     }
@@ -14290,13 +17149,12 @@ vec4 pbr_filterColor(vec4 colorUnused)
         import_core22.log.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)();
       }
       for (const [bufferName, buffer] of Object.entries(buffers)) {
-        var _bufferLayout$attribu;
-        const bufferLayout = this.bufferLayout.find((layout) => layout.name === bufferName);
+        const bufferLayout = this.bufferLayout.find((layout) => getAttributeNames(layout).includes(bufferName));
         if (!bufferLayout) {
           import_core22.log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
           continue;
         }
-        const attributeNames = bufferLayout.attributes ? (_bufferLayout$attribu = bufferLayout.attributes) === null || _bufferLayout$attribu === void 0 ? void 0 : _bufferLayout$attribu.map((layout) => layout.attribute) : [bufferLayout.name];
+        const attributeNames = getAttributeNames(bufferLayout);
         let set4 = false;
         for (const attributeName of attributeNames) {
           const attributeInfo = this._attributeInfos[attributeName];
@@ -14329,21 +17187,23 @@ vec4 pbr_filterColor(vec4 colorUnused)
           import_core22.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
         }
         this._pipelineNeedsUpdate = false;
+        const vs2 = this.device.createShader({
+          id: `${this.id}-vertex`,
+          stage: "vertex",
+          source: this.vs
+        });
+        const fs2 = this.fs ? this.device.createShader({
+          id: `${this.id}-fragment`,
+          stage: "fragment",
+          source: this.fs
+        }) : null;
         this.pipeline = this.device.createRenderPipeline({
           ...this.props,
           bufferLayout: this.bufferLayout,
           topology: this.topology,
           parameters: this.parameters,
-          vs: this.device.createShader({
-            id: "{$this.id}-vertex",
-            stage: "vertex",
-            source: this.vs
-          }),
-          fs: this.fs ? this.device.createShader({
-            id: "{$this.id}-fragment",
-            stage: "fragment",
-            source: this.fs
-          }) : null
+          vs: vs2,
+          fs: fs2
         });
         this._attributeInfos = (0, import_core23.getAttributeInfosFromLayouts)(this.pipeline.shaderLayout, this.bufferLayout);
       }
@@ -14351,8 +17211,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
     _logDrawCallStart() {
       const logDrawTimeout = import_core22.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
-      if (Date.now() - this._lastLogTime < logDrawTimeout) {
-        return void 0;
+      if (import_core22.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
+        return;
       }
       this._lastLogTime = Date.now();
       this._logOpen = true;
@@ -14362,7 +17222,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
     _logDrawCallEnd() {
       if (this._logOpen) {
-        const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout);
+        const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout, this.id);
         import_core22.log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
         const uniformTable = this.shaderInputs.getDebugTable();
         for (const [name12, value] of Object.entries(this.uniforms)) {
@@ -14371,13 +17231,58 @@ vec4 pbr_filterColor(vec4 colorUnused)
           };
         }
         import_core22.log.table(LOG_DRAW_PRIORITY, uniformTable)();
+        const attributeTable = this._getAttributeDebugTable();
+        import_core22.log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
+        import_core22.log.table(LOG_DRAW_PRIORITY, attributeTable)();
         import_core22.log.groupEnd(LOG_DRAW_PRIORITY)();
         this._logOpen = false;
       }
     }
+    _logFramebuffer(renderPass) {
+      const debugFramebuffers = import_core22.log.get("framebuffer");
+      this._drawCount++;
+      if (!debugFramebuffers || this._drawCount++ > 3 && this._drawCount % 60) {
+        return;
+      }
+      const framebuffer = renderPass.props.framebuffer;
+      if (framebuffer) {
+        debugFramebuffer(framebuffer, {
+          id: framebuffer.id,
+          minimap: true
+        });
+      }
+    }
+    _getAttributeDebugTable() {
+      const table = {};
+      for (const [name12, attributeInfo] of Object.entries(this._attributeInfos)) {
+        table[attributeInfo.location] = {
+          name: name12,
+          type: attributeInfo.shaderType,
+          values: this._getBufferOrConstantValues(this.vertexArray.attributes[attributeInfo.location], attributeInfo.bufferDataType)
+        };
+      }
+      if (this.vertexArray.indexBuffer) {
+        const {
+          indexBuffer
+        } = this.vertexArray;
+        const values = indexBuffer.indexType === "uint32" ? new Uint32Array(indexBuffer.debugData) : new Uint16Array(indexBuffer.debugData);
+        table.indices = {
+          name: "indices",
+          type: indexBuffer.indexType,
+          values: values.toString()
+        };
+      }
+      return table;
+    }
+    _getBufferOrConstantValues(attribute, dataType) {
+      const TypedArrayConstructor = (0, import_core21.getTypedArrayFromDataType)(dataType);
+      const typedArray = attribute instanceof import_core21.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
+      return typedArray.toString();
+    }
   };
   Model.defaultProps = {
     ...import_core21.RenderPipeline.defaultProps,
+    source: null,
     vs: null,
     fs: null,
     id: "unnamed",
@@ -14417,6 +17322,10 @@ vec4 pbr_filterColor(vec4 colorUnused)
       features: device.features
     };
   }
+  function getAttributeNames(bufferLayout) {
+    var _bufferLayout$attribu;
+    return bufferLayout.attributes ? (_bufferLayout$attribu = bufferLayout.attributes) === null || _bufferLayout$attribu === void 0 ? void 0 : _bufferLayout$attribu.map((layout) => layout.attribute) : [bufferLayout.name];
+  }
 
   // ../../node_modules/@luma.gl/engine/dist/geometry/geometry.js
   var import_core24 = __toESM(require_core2(), 1);
@@ -14832,8 +17741,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
   }
   function getWebGLContext() {
     try {
-      const canvas = document.createElement("canvas");
-      return canvas.getContext("webgl");
+      const canvas2 = document.createElement("canvas");
+      return canvas2.getContext("webgl");
     } catch (error) {
       return null;
     }
@@ -18654,8 +21563,8 @@ void main(void) {
     static fromTypedArray(arrayOrType) {
       arrayOrType = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
       for (const glType in GL_TYPE_TO_ARRAY_TYPE) {
-        const ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];
-        if (ArrayType === arrayOrType) {
+        const ArrayType2 = GL_TYPE_TO_ARRAY_TYPE[glType];
+        if (ArrayType2 === arrayOrType) {
           return glType;
         }
       }
@@ -18675,16 +21584,16 @@ void main(void) {
         case GL_TYPE.UNSIGNED_SHORT_5_5_5_1:
           return Uint16Array;
         default:
-          const ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];
-          if (!ArrayType) {
+          const ArrayType2 = GL_TYPE_TO_ARRAY_TYPE[glType];
+          if (!ArrayType2) {
             throw new Error(ERR_TYPE_CONVERSION);
           }
-          return ArrayType;
+          return ArrayType2;
       }
     }
     static getByteSize(glType) {
-      const ArrayType = GLType.getArrayType(glType);
-      return ArrayType.BYTES_PER_ELEMENT;
+      const ArrayType2 = GLType.getArrayType(glType);
+      return ArrayType2.BYTES_PER_ELEMENT;
     }
     static validate(glType) {
       return Boolean(GLType.getArrayType(glType));
@@ -18695,8 +21604,8 @@ void main(void) {
       if (length5 === void 0) {
         length5 = (buffer.byteLength - byteOffset) / GLType.getByteSize(glType);
       }
-      const ArrayType = GLType.getArrayType(glType);
-      return new ArrayType(buffer, byteOffset, length5);
+      const ArrayType2 = GLType.getArrayType(glType);
+      return new ArrayType2(buffer, byteOffset, length5);
     }
   };
 
@@ -19816,7 +22725,7 @@ void main(void) {
     return componentType;
   }
   function getAccessorArrayTypeAndLength(accessor, bufferView) {
-    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+    const ArrayType2 = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
     const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
     const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
     const length5 = accessor.count * components;
@@ -19825,7 +22734,7 @@ void main(void) {
     const componentByteSize = BYTES[accessor.componentType];
     const numberOfComponentsInElement = COMPONENTS[accessor.type];
     return {
-      ArrayType,
+      ArrayType: ArrayType2,
       length: length5,
       byteLength,
       componentByteSize,
@@ -19878,7 +22787,7 @@ void main(void) {
     } = buffers[bufferView.buffer];
     const byteOffset = (bufferByteOffset || 0) + (gltfAccessor.byteOffset || 0) + (bufferView.byteOffset || 0);
     const {
-      ArrayType,
+      ArrayType: ArrayType2,
       length: length5,
       componentByteSize,
       numberOfComponentsInElement
@@ -19886,12 +22795,12 @@ void main(void) {
     const elementByteSize = componentByteSize * numberOfComponentsInElement;
     const elementAddressScale = bufferView.byteStride || elementByteSize;
     if (typeof bufferView.byteStride === "undefined" || bufferView.byteStride === elementByteSize) {
-      const result2 = new ArrayType(arrayBuffer, byteOffset, length5);
+      const result2 = new ArrayType2(arrayBuffer, byteOffset, length5);
       return result2;
     }
-    const result = new ArrayType(length5);
+    const result = new ArrayType2(length5);
     for (let i3 = 0; i3 < gltfAccessor.count; i3++) {
-      const values = new ArrayType(arrayBuffer, byteOffset + i3 * elementAddressScale, numberOfComponentsInElement);
+      const values = new ArrayType2(arrayBuffer, byteOffset + i3 * elementAddressScale, numberOfComponentsInElement);
       result.set(values, i3 * numberOfComponentsInElement);
     }
     return result;
@@ -20397,7 +23306,7 @@ void main(void) {
   function convertRawBufferToMetadataArray(data, attributeType, componentType) {
     let elementCount = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 1;
     const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
-    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2[componentType];
+    const ArrayType2 = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2[componentType];
     const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType];
     const length5 = elementCount * numberOfComponents;
     const byteLength = length5 * size;
@@ -20408,7 +23317,7 @@ void main(void) {
       buffer = bufferArray.slice(offset, offset + byteLength).buffer;
       offset = 0;
     }
-    return new ArrayType(buffer, offset, length5);
+    return new ArrayType2(buffer, offset, length5);
   }
   function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
     var _json$textures, _json$textures$textur;
@@ -21420,16 +24329,16 @@ void main(void) {
       count
     };
   }
-  function toTypedArray(array, ArrayType) {
+  function toTypedArray(array, ArrayType2) {
     let convertTypedArrays = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
     if (!array) {
       return null;
     }
     if (Array.isArray(array)) {
-      return new ArrayType(array);
+      return new ArrayType2(array);
     }
-    if (convertTypedArrays && !(array instanceof ArrayType)) {
-      return new ArrayType(array);
+    if (convertTypedArrays && !(array instanceof ArrayType2)) {
+      return new ArrayType2(array);
     }
     return array;
   }
@@ -21650,7 +24559,7 @@ void main(void) {
           } = gltfData.buffers[bufferView.buffer];
           const byteOffset = (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
           const {
-            ArrayType,
+            ArrayType: ArrayType2,
             length: length5
           } = getAccessorArrayTypeAndLength(accessor, bufferView);
           const bytes = BYTES[accessor.componentType];
@@ -21658,7 +24567,7 @@ void main(void) {
           const elementAddressScale = bufferView.byteStride || bytes * components;
           const result = new Float32Array(length5);
           for (let i3 = 0; i3 < accessor.count; i3++) {
-            const uv = new ArrayType(arrayBuffer, byteOffset + i3 * elementAddressScale, 2);
+            const uv = new ArrayType2(arrayBuffer, byteOffset + i3 * elementAddressScale, 2);
             scratchVector13.set(uv[0], uv[1], 1);
             scratchVector13.transformByMatrix3(matrix);
             result.set([scratchVector13[0], scratchVector13[1]], i3 * components);
@@ -22614,7 +25523,7 @@ void main(void) {
       if (accessor.bufferView) {
         const buffer = accessor.bufferView.buffer;
         const {
-          ArrayType,
+          ArrayType: ArrayType2,
           byteLength
         } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
         const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
@@ -22622,7 +25531,7 @@ void main(void) {
         if (accessor.bufferView.byteStride) {
           cutBuffer = this._getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
         }
-        accessor.value = new ArrayType(cutBuffer);
+        accessor.value = new ArrayType2(cutBuffer);
       }
       return accessor;
     }