@luma.gl/shadertools 9.0.15 → 9.0.16

package/dist/index.cjs

@@ -355,8 +355,8 @@ ${moduleSource}
   // Warn about deprecated uniforms or functions
   checkDeprecations(shaderSource, log2) {
     this.deprecations.forEach((def) => {
-      var _a2;
-      if ((_a2 = def.regex) == null ? void 0 : _a2.test(shaderSource)) {
+      var _a;
+      if ((_a = def.regex) == null ? void 0 : _a.test(shaderSource)) {
         if (def.deprecated) {
           log2.deprecated(def.old, def.new)();
         } else {
@@ -491,8 +491,8 @@ function getPlatformShaderDefines(platformInfo) {
 
 // dist/lib/shader-transpiler/transpile-glsl-shader.js
 function transpileGLSLShader(source, stage) {
-  var _a2;
-  const sourceGLSLVersion = Number(((_a2 = source.match(/^#version[ \t]+(\d+)/m)) == null ? void 0 : _a2[1]) || 100);
+  var _a;
+  const sourceGLSLVersion = Number(((_a = source.match(/^#version[ \t]+(\d+)/m)) == null ? void 0 : _a[1]) || 100);
   if (sourceGLSLVersion !== 300) {
     throw new Error("luma.gl v9 only supports GLSL 3.00 shader sources");
   }
@@ -1162,2826 +1162,9 @@ function generateShaderForModule(module2, options) {
 
 // dist/lib/wgsl/get-shader-layout-wgsl.js
 var import_core = require("@luma.gl/core");
-
-// 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(name, args, returnType, body) {
-    super();
-    this.name = name;
-    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(name, type, storage, access, value) {
-    super();
-    this.name = name;
-    this.type = type;
-    this.storage = storage;
-    this.access = access;
-    this.value = value;
-  }
-  get astNodeType() {
-    return "var";
-  }
-};
-var Override = class extends Statement {
-  constructor(name, type, value) {
-    super();
-    this.name = name;
-    this.type = type;
-    this.value = value;
-  }
-  get astNodeType() {
-    return "override";
-  }
-};
-var Let = class extends Statement {
-  constructor(name, type, storage, access, value) {
-    super();
-    this.name = name;
-    this.type = type;
-    this.storage = storage;
-    this.access = access;
-    this.value = value;
-  }
-  get astNodeType() {
-    return "let";
-  }
-};
-var Const = class extends Statement {
-  constructor(name, type, storage, access, value) {
-    super();
-    this.name = name;
-    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 parse(val) {
-    const key = val;
-    if (key == "parse")
-      throw new Error("Invalid value for IncrementOperator");
-    return IncrementOperator2[key];
-  }
-  IncrementOperator2.parse = parse;
-})(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 parse(val) {
-    const key = val;
-    if (key == "parse")
-      throw new Error("Invalid value for AssignOperator");
-    return AssignOperator2[key];
-  }
-  AssignOperator2.parse = parse;
-})(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(name, args) {
-    super();
-    this.name = name;
-    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(name) {
-    super();
-    this.name = name;
-  }
-  get astNodeType() {
-    return "enable";
-  }
-};
-var Alias = class extends Statement {
-  constructor(name, type) {
-    super();
-    this.name = name;
-    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(name) {
-    super();
-    this.name = name;
-  }
-  get astNodeType() {
-    return "type";
-  }
-  get isStruct() {
-    return false;
-  }
-  get isArray() {
-    return false;
-  }
-};
-var Struct = class extends Type {
-  constructor(name, members) {
-    super(name);
-    this.members = members;
-  }
-  get astNodeType() {
-    return "struct";
-  }
-  get isStruct() {
-    return true;
-  }
-  /// Return the index of the member with the given name, or -1 if not found.
-  getMemberIndex(name) {
-    for (let i = 0; i < this.members.length; i++) {
-      if (this.members[i].name == name)
-        return i;
-    }
-    return -1;
-  }
-};
-var TemplateType = class extends Type {
-  constructor(name, format, access) {
-    super(name);
-    this.format = format;
-    this.access = access;
-  }
-  get astNodeType() {
-    return "template";
-  }
-};
-var PointerType = class extends Type {
-  constructor(name, storage, type, access) {
-    super(name);
-    this.storage = storage;
-    this.type = type;
-    this.access = access;
-  }
-  get astNodeType() {
-    return "pointer";
-  }
-};
-var ArrayType = class extends Type {
-  constructor(name, attributes, format, count) {
-    super(name);
-    this.attributes = attributes;
-    this.format = format;
-    this.count = count;
-  }
-  get astNodeType() {
-    return "array";
-  }
-  get isArray() {
-    return true;
-  }
-};
-var SamplerType = class extends Type {
-  constructor(name, format, access) {
-    super(name);
-    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(name, args) {
-    super();
-    this.name = name;
-    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(name) {
-    super();
-    this.name = name;
-  }
-  get astNodeType() {
-    return "varExpr";
-  }
-};
-var ConstExpr = class extends Expression {
-  constructor(name, initializer) {
-    super();
-    this.name = name;
-    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(name, type, attributes) {
-    super();
-    this.name = name;
-    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(name, type, attributes) {
-    super();
-    this.name = name;
-    this.type = type;
-    this.attributes = attributes;
-  }
-  get astNodeType() {
-    return "member";
-  }
-};
-var Attribute = class extends Node {
-  constructor(name, value) {
-    super();
-    this.name = name;
-    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(name, type, rule) {
-    this.name = name;
-    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")
-  // WGSL grammar has a few keywords that have different token names than the strings they
-  // represent. Aliasing them here.
-  /*int32: new TokenType("i32", TokenClass.keyword, "i32"),
-      uint32: new TokenType("u32", TokenClass.keyword, "u32"),
-      float32: new TokenType("f32", TokenClass.keyword, "f32"),
-      pointer: new TokenType("ptr", TokenClass.keyword, "ptr"),*/
-};
-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 : "";
-  }
-  /// Scan all tokens from the 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;
-  }
-  /// Scan a single token from the source.
-  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 name in TokenTypes.keywords) {
-      const type = TokenTypes.keywords[name];
-      if (this._match(lexeme, type.rule)) {
-        return type;
-      }
-    }
-    for (const name in TokenTypes.tokens) {
-      const type = TokenTypes.tokens[name];
-      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(amount = 0) {
-    let c = this._source[this._current];
-    amount = amount || 0;
-    amount++;
-    this._current += amount;
-    return c;
-  }
-  _peekAhead(offset = 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 i = 0, l = types.length; i < l; ++i) {
-      const type = types[i];
-      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 t = tk.type;
-      let index2 = types.indexOf(t);
-      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 name = 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 name2 = 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(name2, 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(name, 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 name = 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(name, type, null, null, value);
-    }
-    if (this._match(TokenTypes.keywords.const)) {
-      const name = 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(name, 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 name = 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(name.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 s of statement) {
-          statements.push(s);
-        }
-      } 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(elseif = []) {
-    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 p = this._postfix_expression();
-    if (p)
-      expr.postfix = p;
-    return expr;
-  }
-  _postfix_expression() {
-    if (this._match(TokenTypes.tokens.bracket_left)) {
-      const expr = this._short_circuit_or_expression();
-      this._consume(TokenTypes.tokens.bracket_right, "Expected ']'.");
-      const p = this._postfix_expression();
-      if (p)
-        expr.postfix = p;
-      return expr;
-    }
-    if (this._match(TokenTypes.tokens.period)) {
-      const name = this._consume(TokenTypes.tokens.ident, "Expected member name.");
-      const p = this._postfix_expression();
-      const expr = new StringExpr(name.lexeme);
-      if (p)
-        expr.postfix = p;
-      return expr;
-    }
-    return null;
-  }
-  _getStruct(name) {
-    if (this._context.aliases.has(name)) {
-      const alias = this._context.aliases.get(name).type;
-      return alias;
-    }
-    if (this._context.structs.has(name)) {
-      const struct = this._context.structs.get(name);
-      return struct;
-    }
-    return null;
-  }
-  _primary_expression() {
-    if (this._match(TokenTypes.tokens.ident)) {
-      const name = this._previous().toString();
-      if (this._check(TokenTypes.tokens.paren_left)) {
-        const args2 = this._argument_expression_list();
-        const struct = this._getStruct(name);
-        if (struct != null) {
-          return new CreateExpr(struct, args2);
-        }
-        return new CallExpr(name, args2);
-      }
-      if (this._context.constants.has(name)) {
-        const c = this._context.constants.get(name);
-        return new ConstExpr(name, c.value);
-      }
-      return new VariableExpr(name);
-    }
-    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 name = 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(name, members);
-    this._context.structs.set(name, 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 name = 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(name.toString(), type, "", "", value);
-    this._context.constants.set(c.name, c);
-    return c;
-  }
-  _global_let_decl() {
-    if (!this._match(TokenTypes.keywords.let))
-      return null;
-    const name = 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(name.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 name = 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(name.toString(), type, storage, access, null);
-  }
-  _override_decl() {
-    if (!this._match(TokenTypes.keywords.override))
-      return null;
-    const name = 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(name.toString(), type, null);
-  }
-  _enable_directive() {
-    const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
-    return new Enable(name.toString());
-  }
-  _type_alias() {
-    const name = 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(name.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 name = this._consume(TokenTypes.attribute_name, "Expected attribute name");
-      const attr = new Attribute(name.toString(), null);
-      if (this._match(TokenTypes.tokens.paren_left)) {
-        attr.value = this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString();
-        if (this._check(TokenTypes.tokens.comma)) {
-          this._advance();
-          do {
-            const v = this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString();
-            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 name = this._consume(TokenTypes.attribute_name, "Expected attribute name");
-          const attr = new Attribute(name.toString(), null);
-          if (this._match(TokenTypes.tokens.paren_left)) {
-            attr.value = [
-              this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString()
-            ];
-            if (this._check(TokenTypes.tokens.comma)) {
-              this._advance();
-              do {
-                const v = this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString();
-                attr.value.push(v);
-              } while (this._match(TokenTypes.tokens.comma));
-            }
-            this._consume(TokenTypes.tokens.paren_right, "Expected ')'");
-          }
-          attributes.push(attr);
-        } while (this._match(TokenTypes.tokens.comma));
-      }
-      this._consume(TokenTypes.tokens.attr_right, "Expected ']]' after attribute declarations");
-    }
-    if (attributes.length == 0)
-      return null;
-    return attributes;
-  }
-};
-var TypeInfo = class {
-  constructor(name, attributes) {
-    this.name = name;
-    this.attributes = attributes;
-    this.size = 0;
-  }
-  get isArray() {
-    return false;
-  }
-  get isStruct() {
-    return false;
-  }
-  get isTemplate() {
-    return false;
-  }
-};
-var MemberInfo = class {
-  constructor(name, type, attributes) {
-    this.name = name;
-    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(name, attributes) {
-    super(name, attributes);
-    this.members = [];
-    this.align = 0;
-  }
-  get isStruct() {
-    return true;
-  }
-};
-var ArrayInfo = class extends TypeInfo {
-  constructor(name, attributes) {
-    super(name, attributes);
-    this.count = 0;
-    this.stride = 0;
-  }
-  get isArray() {
-    return true;
-  }
-};
-var TemplateInfo = class extends TypeInfo {
-  constructor(name, format, attributes, access) {
-    super(name, 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(name, type, group, binding, attributes, resourceType, access) {
-    this.name = name;
-    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(name, type) {
-    this.name = name;
-    this.type = type;
-  }
-};
-var _TypeSize = class {
-  constructor(align, size) {
-    this.align = align;
-    this.size = size;
-  }
-};
-var InputInfo = class {
-  constructor(name, type, locationType, location) {
-    this.name = name;
-    this.type = type;
-    this.locationType = locationType;
-    this.location = location;
-    this.interpolation = null;
-  }
-};
-var OutputInfo = class {
-  constructor(name, type, locationType, location) {
-    this.name = name;
-    this.type = type;
-    this.locationType = locationType;
-    this.location = location;
-  }
-};
-var FunctionInfo = class {
-  constructor(name, stage = null) {
-    this.stage = null;
-    this.inputs = [];
-    this.outputs = [];
-    this.name = name;
-    this.stage = stage;
-  }
-};
-var EntryFunctions = class {
-  constructor() {
-    this.vertex = [];
-    this.fragment = [];
-    this.compute = [];
-  }
-};
-var OverrideInfo = class {
-  constructor(name, type, attributes, id) {
-    this.name = name;
-    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 node of ast) {
-      if (node instanceof Struct) {
-        const info = this._getTypeInfo(node, null);
-        if (info instanceof StructInfo) {
-          this.structs.push(info);
-        }
-        continue;
-      }
-      if (node instanceof Alias) {
-        this.aliases.push(this._getAliasInfo(node));
-        continue;
-      }
-      if (node instanceof Override) {
-        const v = node;
-        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(node)) {
-        const v = node;
-        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(node)) {
-        const v = node;
-        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(node)) {
-        const v = node;
-        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(node)) {
-        const v = node;
-        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 (node instanceof Function) {
-        const vertexStage = this._getAttribute(node, "vertex");
-        const fragmentStage = this._getAttribute(node, "fragment");
-        const computeStage = this._getAttribute(node, "compute");
-        const stage = vertexStage || fragmentStage || computeStage;
-        if (stage) {
-          const fn = new FunctionInfo(node.name, stage.name);
-          fn.inputs = this._getInputs(node.args);
-          fn.outputs = this._getOutputs(node.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 t of this.textures) {
-      _makeRoom(t.group, t.binding);
-      const group = groups[t.group];
-      group[t.binding] = t;
-    }
-    for (const t of this.samplers) {
-      _makeRoom(t.group, t.binding);
-      const group = groups[t.group];
-      group[t.binding] = t;
-    }
-    return groups;
-  }
-  _getOutputs(type, outputs = 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, inputs = 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(node) {
-    const location = this._getAttribute(node, "location") || this._getAttribute(node, "builtin");
-    if (location !== null) {
-      const interpolation = this._getAttribute(node, "interpolation");
-      const type = this._getTypeInfo(node.type, node.attributes);
-      const locationValue = this._parseInt(location.value);
-      const info = new InputInfo(node.name, type, location.name, locationValue);
-      if (interpolation !== null) {
-        info.interpolation = this._parseString(interpolation.value);
-      }
-      return info;
-    }
-    return null;
-  }
-  _parseString(s) {
-    if (s instanceof Array) {
-      s = s[0];
-    }
-    return s;
-  }
-  _parseInt(s) {
-    if (s instanceof Array) {
-      s = s[0];
-    }
-    const n = parseInt(s);
-    return isNaN(n) ? s : n;
-  }
-  _getAlias(name) {
-    for (const a of this.aliases) {
-      if (a.name == name)
-        return a.type;
-    }
-    return null;
-  }
-  _getAliasInfo(node) {
-    return new AliasInfo(node.name, this._getTypeInfo(node.type, null));
-  }
-  _getTypeInfo(type, attributes) {
-    if (this._types.has(type)) {
-      return this._types.get(type);
-    }
-    if (type instanceof ArrayType) {
-      const a = type;
-      const t = this._getTypeInfo(a.format, a.attributes);
-      const info2 = new ArrayInfo(a.name, attributes);
-      info2.format = t;
-      info2.count = a.count;
-      this._types.set(type, info2);
-      this._updateTypeInfo(info2);
-      return info2;
-    }
-    if (type instanceof Struct) {
-      const s = type;
-      const info2 = new StructInfo(s.name, attributes);
-      for (const m of s.members) {
-        const t = this._getTypeInfo(m.type, m.attributes);
-        info2.members.push(new MemberInfo(m.name, t, m.attributes));
-      }
-      this._types.set(type, info2);
-      this._updateTypeInfo(info2);
-      return info2;
-    }
-    if (type instanceof SamplerType) {
-      const s = type;
-      const formatIsType = s.format instanceof Type;
-      const format = s.format ? formatIsType ? this._getTypeInfo(s.format, null) : new TypeInfo(s.format, null) : null;
-      const info2 = new TemplateInfo(s.name, format, attributes, s.access);
-      this._types.set(type, info2);
-      this._updateTypeInfo(info2);
-      return info2;
-    }
-    if (type instanceof TemplateType) {
-      const t = type;
-      const format = t.format ? this._getTypeInfo(t.format, null) : null;
-      const info2 = new TemplateInfo(t.name, format, attributes, t.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(node) {
-    return node instanceof Var && node.storage == "uniform";
-  }
-  _isStorageVar(node) {
-    return node instanceof Var && node.storage == "storage";
-  }
-  _isTextureVar(node) {
-    return node instanceof Var && node.type !== null && WgslReflect._textureTypes.indexOf(node.type.name) != -1;
-  }
-  _isSamplerVar(node) {
-    return node instanceof Var && node.type !== null && WgslReflect._samplerTypes.indexOf(node.type.name) != -1;
-  }
-  _getAttribute(node, name) {
-    const obj = node;
-    if (!obj || !obj["attributes"])
-      return null;
-    const attrs = obj["attributes"];
-    for (let a of attrs) {
-      if (a.name == name)
-        return a;
-    }
-    return null;
-  }
-  _getAttributeNum(attributes, name, defaultValue) {
-    if (attributes === null)
-      return defaultValue;
-    for (let a of attributes) {
-      if (a.name == name) {
-        let v = a !== null && a.value !== null ? a.value : defaultValue;
-        if (v instanceof Array) {
-          v = v[0];
-        }
-        if (typeof v === "number") {
-          return v;
-        }
-        if (typeof v === "string") {
-          return parseInt(v);
-        }
-        return defaultValue;
-      }
-    }
-    return defaultValue;
-  }
-  _roundUp(k, n) {
-    return Math.ceil(n / 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((t) => {
-  return t.name;
-});
-WgslReflect._samplerTypes = TokenTypes.sampler_type.map((t) => {
-  return t.name;
-});
-
-// dist/lib/wgsl/get-shader-layout-wgsl.js
+var import_wgsl_reflect = require("wgsl_reflect");
 function getShaderLayoutFromWGSL(source) {
+  var _a;
   const shaderLayout = { attributes: [], bindings: [] };
   let parsedWGSL;
   try {
@@ -3992,10 +1175,10 @@ function getShaderLayoutFromWGSL(source) {
   }
   for (const uniform of parsedWGSL.uniforms) {
     const members = [];
-    for (const member of uniform.type.members) {
+    for (const attribute of ((_a = uniform.type) == null ? void 0 : _a.members) || []) {
       members.push({
-        name: member.name,
-        type: getType(member.type)
+        name: attribute.name,
+        type: getType(attribute.type)
       });
     }
     shaderLayout.bindings.push({
@@ -4015,7 +1198,7 @@ function getShaderLayoutFromWGSL(source) {
       const type = getType(wgslAttribute.type);
       shaderLayout.attributes.push({
         name: wgslAttribute.name,
-        location: wgslAttribute.location,
+        location: Number(wgslAttribute.location),
         type
       });
     }
@@ -4027,7 +1210,7 @@ function getType(type) {
 }
 function parseWGSL(source) {
   try {
-    return new WgslReflect(source);
+    return new import_wgsl_reflect.WgslReflect(source);
   } catch (error) {
     if (error instanceof Error) {
       throw error;
@@ -4460,7 +1643,7 @@ function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLig
   return lightSourceUniforms;
 }
 function extractLightTypes(lights2) {
-  var _a2, _b;
+  var _a, _b;
   const lightSources = { pointLights: [], directionalLights: [] };
   for (const light of lights2 || []) {
     switch (light.type) {
@@ -4468,7 +1651,7 @@ function extractLightTypes(lights2) {
         lightSources.ambientLight = light;
         break;
       case "directional":
-        (_a2 = lightSources.directionalLights) == null ? void 0 : _a2.push(light);
+        (_a = lightSources.directionalLights) == null ? void 0 : _a.push(light);
         break;
       case "point":
         (_b = lightSources.pointLights) == null ? void 0 : _b.push(light);
@@ -7330,7 +4513,7 @@ function getLightSourceUniforms2({ ambientLight, pointLights = [], directionalLi
   return lightSourceUniforms;
 }
 function getUniforms6(opts = INITIAL_MODULE_OPTIONS) {
-  var _a2, _b;
+  var _a, _b;
   if ("lightSources" in opts) {
     const { ambientLight, pointLights, directionalLights } = opts.lightSources || {};
     const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
@@ -7349,7 +4532,7 @@ function getUniforms6(opts = INITIAL_MODULE_OPTIONS) {
           lightSources.ambientLight = light;
           break;
         case "directional":
-          (_a2 = lightSources.directionalLights) == null ? void 0 : _a2.push(light);
+          (_a = lightSources.directionalLights) == null ? void 0 : _a.push(light);
           break;
         case "point":
           (_b = lightSources.pointLights) == null ? void 0 : _b.push(light);