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

package/dist/dist.dev.js

@@ -1377,7 +1377,7 @@ ${moduleSource}
   }
   function getShaderName(shader) {
     let defaultName = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "unnamed";
-    const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
+    const SHADER_NAME_REGEXP = /#define[^\S\r\n]*SHADER_NAME[^\S\r\n]*([A-Za-z0-9_-]+)\s*/;
     const match = SHADER_NAME_REGEXP.exec(shader);
     return match ? match[1] : defaultName;
   }
@@ -1831,6 +1831,2779 @@ void main() {
     }
   }
 
+  // ../../node_modules/@luma.gl/shadertools/dist/libs/wgsl-reflect/wgsl_reflect.module.js
+  var ParseContext = class {
+    constructor() {
+      this.constants = /* @__PURE__ */ new Map();
+      this.aliases = /* @__PURE__ */ new Map();
+      this.structs = /* @__PURE__ */ new Map();
+    }
+  };
+  var Node = class {
+    constructor() {
+    }
+    get isAstNode() {
+      return true;
+    }
+    get astNodeType() {
+      return "";
+    }
+    evaluate(context) {
+      throw new Error("Cannot evaluate node");
+    }
+    evaluateString(context) {
+      return this.evaluate(context).toString();
+    }
+  };
+  var Statement = class extends Node {
+    constructor() {
+      super();
+    }
+  };
+  var Function = class extends Statement {
+    constructor(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;
+    }
+    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")
+  };
+  TokenTypes.tokens = {
+    decimal_float_literal: new TokenType("decimal_float_literal", TokenClass.token, /((-?[0-9]*\.[0-9]+|-?[0-9]+\.[0-9]*)((e|E)(\+|-)?[0-9]+)?f?)|(-?[0-9]+(e|E)(\+|-)?[0-9]+f?)|([0-9]+f)/),
+    hex_float_literal: new TokenType("hex_float_literal", TokenClass.token, /-?0x((([0-9a-fA-F]*\.[0-9a-fA-F]+|[0-9a-fA-F]+\.[0-9a-fA-F]*)((p|P)(\+|-)?[0-9]+f?)?)|([0-9a-fA-F]+(p|P)(\+|-)?[0-9]+f?))/),
+    int_literal: new TokenType("int_literal", TokenClass.token, /-?0x[0-9a-fA-F]+|0i?|-?[1-9][0-9]*i?/),
+    uint_literal: new TokenType("uint_literal", TokenClass.token, /0x[0-9a-fA-F]+u|0u|[1-9][0-9]*u/),
+    ident: new TokenType("ident", TokenClass.token, /[a-zA-Z][0-9a-zA-Z_]*/),
+    and: new TokenType("and", TokenClass.token, "&"),
+    and_and: new TokenType("and_and", TokenClass.token, "&&"),
+    arrow: new TokenType("arrow ", TokenClass.token, "->"),
+    attr: new TokenType("attr", TokenClass.token, "@"),
+    attr_left: new TokenType("attr_left", TokenClass.token, "[["),
+    attr_right: new TokenType("attr_right", TokenClass.token, "]]"),
+    forward_slash: new TokenType("forward_slash", TokenClass.token, "/"),
+    bang: new TokenType("bang", TokenClass.token, "!"),
+    bracket_left: new TokenType("bracket_left", TokenClass.token, "["),
+    bracket_right: new TokenType("bracket_right", TokenClass.token, "]"),
+    brace_left: new TokenType("brace_left", TokenClass.token, "{"),
+    brace_right: new TokenType("brace_right", TokenClass.token, "}"),
+    colon: new TokenType("colon", TokenClass.token, ":"),
+    comma: new TokenType("comma", TokenClass.token, ","),
+    equal: new TokenType("equal", TokenClass.token, "="),
+    equal_equal: new TokenType("equal_equal", TokenClass.token, "=="),
+    not_equal: new TokenType("not_equal", TokenClass.token, "!="),
+    greater_than: new TokenType("greater_than", TokenClass.token, ">"),
+    greater_than_equal: new TokenType("greater_than_equal", TokenClass.token, ">="),
+    shift_right: new TokenType("shift_right", TokenClass.token, ">>"),
+    less_than: new TokenType("less_than", TokenClass.token, "<"),
+    less_than_equal: new TokenType("less_than_equal", TokenClass.token, "<="),
+    shift_left: new TokenType("shift_left", TokenClass.token, "<<"),
+    modulo: new TokenType("modulo", TokenClass.token, "%"),
+    minus: new TokenType("minus", TokenClass.token, "-"),
+    minus_minus: new TokenType("minus_minus", TokenClass.token, "--"),
+    period: new TokenType("period", TokenClass.token, "."),
+    plus: new TokenType("plus", TokenClass.token, "+"),
+    plus_plus: new TokenType("plus_plus", TokenClass.token, "++"),
+    or: new TokenType("or", TokenClass.token, "|"),
+    or_or: new TokenType("or_or", TokenClass.token, "||"),
+    paren_left: new TokenType("paren_left", TokenClass.token, "("),
+    paren_right: new TokenType("paren_right", TokenClass.token, ")"),
+    semicolon: new TokenType("semicolon", TokenClass.token, ";"),
+    star: new TokenType("star", TokenClass.token, "*"),
+    tilde: new TokenType("tilde", TokenClass.token, "~"),
+    underscore: new TokenType("underscore", TokenClass.token, "_"),
+    xor: new TokenType("xor", TokenClass.token, "^"),
+    plus_equal: new TokenType("plus_equal", TokenClass.token, "+="),
+    minus_equal: new TokenType("minus_equal", TokenClass.token, "-="),
+    times_equal: new TokenType("times_equal", TokenClass.token, "*="),
+    division_equal: new TokenType("division_equal", TokenClass.token, "/="),
+    modulo_equal: new TokenType("modulo_equal", TokenClass.token, "%="),
+    and_equal: new TokenType("and_equal", TokenClass.token, "&="),
+    or_equal: new TokenType("or_equal", TokenClass.token, "|="),
+    xor_equal: new TokenType("xor_equal", TokenClass.token, "^="),
+    shift_right_equal: new TokenType("shift_right_equal", TokenClass.token, ">>="),
+    shift_left_equal: new TokenType("shift_left_equal", TokenClass.token, "<<=")
+  };
+  TokenTypes.storage_class = [_a.keywords.function, _a.keywords.private, _a.keywords.workgroup, _a.keywords.uniform, _a.keywords.storage];
+  TokenTypes.access_mode = [_a.keywords.read, _a.keywords.write, _a.keywords.read_write];
+  TokenTypes.sampler_type = [_a.keywords.sampler, _a.keywords.sampler_comparison];
+  TokenTypes.sampled_texture_type = [_a.keywords.texture_1d, _a.keywords.texture_2d, _a.keywords.texture_2d_array, _a.keywords.texture_3d, _a.keywords.texture_cube, _a.keywords.texture_cube_array];
+  TokenTypes.multisampled_texture_type = [_a.keywords.texture_multisampled_2d];
+  TokenTypes.storage_texture_type = [_a.keywords.texture_storage_1d, _a.keywords.texture_storage_2d, _a.keywords.texture_storage_2d_array, _a.keywords.texture_storage_3d];
+  TokenTypes.depth_texture_type = [_a.keywords.texture_depth_2d, _a.keywords.texture_depth_2d_array, _a.keywords.texture_depth_cube, _a.keywords.texture_depth_cube_array, _a.keywords.texture_depth_multisampled_2d];
+  TokenTypes.texture_external_type = [_a.keywords.texture_external];
+  TokenTypes.any_texture_type = [..._a.sampled_texture_type, ..._a.multisampled_texture_type, ..._a.storage_texture_type, ..._a.depth_texture_type, ..._a.texture_external_type];
+  TokenTypes.texel_format = [_a.keywords.r8unorm, _a.keywords.r8snorm, _a.keywords.r8uint, _a.keywords.r8sint, _a.keywords.r16uint, _a.keywords.r16sint, _a.keywords.r16float, _a.keywords.rg8unorm, _a.keywords.rg8snorm, _a.keywords.rg8uint, _a.keywords.rg8sint, _a.keywords.r32uint, _a.keywords.r32sint, _a.keywords.r32float, _a.keywords.rg16uint, _a.keywords.rg16sint, _a.keywords.rg16float, _a.keywords.rgba8unorm, _a.keywords.rgba8unorm_srgb, _a.keywords.rgba8snorm, _a.keywords.rgba8uint, _a.keywords.rgba8sint, _a.keywords.bgra8unorm, _a.keywords.bgra8unorm_srgb, _a.keywords.rgb10a2unorm, _a.keywords.rg11b10float, _a.keywords.rg32uint, _a.keywords.rg32sint, _a.keywords.rg32float, _a.keywords.rgba16uint, _a.keywords.rgba16sint, _a.keywords.rgba16float, _a.keywords.rgba32uint, _a.keywords.rgba32sint, _a.keywords.rgba32float];
+  TokenTypes.const_literal = [_a.tokens.int_literal, _a.tokens.uint_literal, _a.tokens.decimal_float_literal, _a.tokens.hex_float_literal, _a.keywords.true, _a.keywords.false];
+  TokenTypes.literal_or_ident = [_a.tokens.ident, _a.tokens.int_literal, _a.tokens.uint_literal, _a.tokens.decimal_float_literal, _a.tokens.hex_float_literal];
+  TokenTypes.element_count_expression = [_a.tokens.int_literal, _a.tokens.uint_literal, _a.tokens.ident];
+  TokenTypes.template_types = [_a.keywords.vec2, _a.keywords.vec3, _a.keywords.vec4, _a.keywords.mat2x2, _a.keywords.mat2x3, _a.keywords.mat2x4, _a.keywords.mat3x2, _a.keywords.mat3x3, _a.keywords.mat3x4, _a.keywords.mat4x2, _a.keywords.mat4x3, _a.keywords.mat4x4, _a.keywords.atomic, _a.keywords.bitcast, ..._a.any_texture_type];
+  TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block];
+  TokenTypes.assignment_operators = [_a.tokens.equal, _a.tokens.plus_equal, _a.tokens.minus_equal, _a.tokens.times_equal, _a.tokens.division_equal, _a.tokens.modulo_equal, _a.tokens.and_equal, _a.tokens.or_equal, _a.tokens.xor_equal, _a.tokens.shift_right_equal, _a.tokens.shift_left_equal];
+  TokenTypes.increment_operators = [_a.tokens.plus_plus, _a.tokens.minus_minus];
+  var Token = class {
+    constructor(type, lexeme, line) {
+      this.type = type;
+      this.lexeme = lexeme;
+      this.line = line;
+    }
+    toString() {
+      return this.lexeme;
+    }
+    isTemplateType() {
+      return TokenTypes.template_types.indexOf(this.type) != -1;
+    }
+    isArrayType() {
+      return this.type == TokenTypes.keywords.array;
+    }
+    isArrayOrTemplateType() {
+      return this.isArrayType() || this.isTemplateType();
+    }
+  };
+  var WgslScanner = class {
+    constructor(source) {
+      this._tokens = [];
+      this._start = 0;
+      this._current = 0;
+      this._line = 1;
+      this._source = source !== null && source !== void 0 ? source : "";
+    }
+    scanTokens() {
+      while (!this._isAtEnd()) {
+        this._start = this._current;
+        if (!this.scanToken())
+          throw `Invalid syntax at line ${this._line}`;
+      }
+      this._tokens.push(new Token(TokenTypes.eof, "", this._line));
+      return this._tokens;
+    }
+    scanToken() {
+      let lexeme = this._advance();
+      if (lexeme == "\n") {
+        this._line++;
+        return true;
+      }
+      if (this._isWhitespace(lexeme)) {
+        return true;
+      }
+      if (lexeme == "/") {
+        if (this._peekAhead() == "/") {
+          while (lexeme != "\n") {
+            if (this._isAtEnd())
+              return true;
+            lexeme = this._advance();
+          }
+          this._line++;
+          return true;
+        } else if (this._peekAhead() == "*") {
+          this._advance();
+          let commentLevel = 1;
+          while (commentLevel > 0) {
+            if (this._isAtEnd())
+              return true;
+            lexeme = this._advance();
+            if (lexeme == "\n") {
+              this._line++;
+            } else if (lexeme == "*") {
+              if (this._peekAhead() == "/") {
+                this._advance();
+                commentLevel--;
+                if (commentLevel == 0) {
+                  return true;
+                }
+              }
+            } else if (lexeme == "/") {
+              if (this._peekAhead() == "*") {
+                this._advance();
+                commentLevel++;
+              }
+            }
+          }
+          return true;
+        }
+      }
+      let matchType = TokenTypes.none;
+      for (; ; ) {
+        let matchedType = this._findType(lexeme);
+        const nextLexeme = this._peekAhead();
+        if (lexeme == ">" && (nextLexeme == ">" || nextLexeme == "=")) {
+          let foundLessThan = false;
+          let ti = this._tokens.length - 1;
+          for (let count = 0; count < 5 && ti >= 0; ++count, --ti) {
+            if (this._tokens[ti].type === TokenTypes.tokens.less_than) {
+              if (ti > 0 && this._tokens[ti - 1].isArrayOrTemplateType()) {
+                foundLessThan = true;
+              }
+              break;
+            }
+          }
+          if (foundLessThan) {
+            this._addToken(matchedType);
+            return true;
+          }
+        }
+        if (matchedType === TokenTypes.none) {
+          let lookAheadLexeme = lexeme;
+          let lookAhead = 0;
+          const maxLookAhead = 2;
+          for (let li = 0; li < maxLookAhead; ++li) {
+            lookAheadLexeme += this._peekAhead(li);
+            matchedType = this._findType(lookAheadLexeme);
+            if (matchedType !== TokenTypes.none) {
+              lookAhead = li;
+              break;
+            }
+          }
+          if (matchedType === TokenTypes.none) {
+            if (matchType === TokenTypes.none)
+              return false;
+            this._current--;
+            this._addToken(matchType);
+            return true;
+          }
+          lexeme = lookAheadLexeme;
+          this._current += lookAhead + 1;
+        }
+        matchType = matchedType;
+        if (this._isAtEnd())
+          break;
+        lexeme += this._advance();
+      }
+      if (matchType === TokenTypes.none)
+        return false;
+      this._addToken(matchType);
+      return true;
+    }
+    _findType(lexeme) {
+      for (const 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() {
+      let amount = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+      let c = this._source[this._current];
+      amount = amount || 0;
+      amount++;
+      this._current += amount;
+      return c;
+    }
+    _peekAhead() {
+      let offset = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+      offset = offset || 0;
+      if (this._current + offset >= this._source.length)
+        return "\0";
+      return this._source[this._current + offset];
+    }
+    _addToken(type) {
+      const text = this._source.substring(this._start, this._current);
+      this._tokens.push(new Token(type, text, this._line));
+    }
+  };
+  var WgslParser = class {
+    constructor() {
+      this._tokens = [];
+      this._current = 0;
+      this._context = new ParseContext();
+    }
+    parse(tokensOrCode) {
+      this._initialize(tokensOrCode);
+      let statements = [];
+      while (!this._isAtEnd()) {
+        const statement = this._global_decl_or_directive();
+        if (!statement)
+          break;
+        statements.push(statement);
+      }
+      return statements;
+    }
+    _initialize(tokensOrCode) {
+      if (tokensOrCode) {
+        if (typeof tokensOrCode == "string") {
+          const scanner = new WgslScanner(tokensOrCode);
+          this._tokens = scanner.scanTokens();
+        } else {
+          this._tokens = tokensOrCode;
+        }
+      } else {
+        this._tokens = [];
+      }
+      this._current = 0;
+    }
+    _error(token, message2) {
+      console.error(token, message2);
+      return {
+        token,
+        message: message2,
+        toString: function() {
+          return `${message2}`;
+        }
+      };
+    }
+    _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, message2) {
+      if (this._check(types))
+        return this._advance();
+      throw this._error(this._peek(), message2);
+    }
+    _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 enable2 = this._enable_directive();
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
+        return enable2;
+      }
+      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() {
+      let elseif = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+      const condition = this._optional_paren_expression();
+      const block = this._compound_statement();
+      elseif.push(new ElseIf(condition, block));
+      if (this._match_elseif()) {
+        this._elseif_statement(elseif);
+      }
+      return elseif;
+    }
+    _return_statement() {
+      if (!this._match(TokenTypes.keywords.return))
+        return null;
+      const value = this._short_circuit_or_expression();
+      return new Return(value);
+    }
+    _short_circuit_or_expression() {
+      let expr = this._short_circuit_and_expr();
+      while (this._match(TokenTypes.tokens.or_or)) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._short_circuit_and_expr());
+      }
+      return expr;
+    }
+    _short_circuit_and_expr() {
+      let expr = this._inclusive_or_expression();
+      while (this._match(TokenTypes.tokens.and_and)) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._inclusive_or_expression());
+      }
+      return expr;
+    }
+    _inclusive_or_expression() {
+      let expr = this._exclusive_or_expression();
+      while (this._match(TokenTypes.tokens.or)) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._exclusive_or_expression());
+      }
+      return expr;
+    }
+    _exclusive_or_expression() {
+      let expr = this._and_expression();
+      while (this._match(TokenTypes.tokens.xor)) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._and_expression());
+      }
+      return expr;
+    }
+    _and_expression() {
+      let expr = this._equality_expression();
+      while (this._match(TokenTypes.tokens.and)) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._equality_expression());
+      }
+      return expr;
+    }
+    _equality_expression() {
+      const expr = this._relational_expression();
+      if (this._match([TokenTypes.tokens.equal_equal, TokenTypes.tokens.not_equal])) {
+        return new BinaryOperator(this._previous().toString(), expr, this._relational_expression());
+      }
+      return expr;
+    }
+    _relational_expression() {
+      let expr = this._shift_expression();
+      while (this._match([TokenTypes.tokens.less_than, TokenTypes.tokens.greater_than, TokenTypes.tokens.less_than_equal, TokenTypes.tokens.greater_than_equal])) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._shift_expression());
+      }
+      return expr;
+    }
+    _shift_expression() {
+      let expr = this._additive_expression();
+      while (this._match([TokenTypes.tokens.shift_left, TokenTypes.tokens.shift_right])) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._additive_expression());
+      }
+      return expr;
+    }
+    _additive_expression() {
+      let expr = this._multiplicative_expression();
+      while (this._match([TokenTypes.tokens.plus, TokenTypes.tokens.minus])) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._multiplicative_expression());
+      }
+      return expr;
+    }
+    _multiplicative_expression() {
+      let expr = this._unary_expression();
+      while (this._match([TokenTypes.tokens.star, TokenTypes.tokens.forward_slash, TokenTypes.tokens.modulo])) {
+        expr = new BinaryOperator(this._previous().toString(), expr, this._unary_expression());
+      }
+      return expr;
+    }
+    _unary_expression() {
+      if (this._match([TokenTypes.tokens.minus, TokenTypes.tokens.bang, TokenTypes.tokens.tilde, TokenTypes.tokens.star, TokenTypes.tokens.and])) {
+        return new UnaryOperator(this._previous().toString(), this._unary_expression());
+      }
+      return this._singular_expression();
+    }
+    _singular_expression() {
+      const expr = this._primary_expression();
+      const 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) {
+      let stage = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 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) {
+      let outputs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0;
+      if (outputs === void 0)
+        outputs = [];
+      if (type instanceof Struct) {
+        this._getStructOutputs(type, outputs);
+      } else {
+        const output = this._getOutputInfo(type);
+        if (output !== null)
+          outputs.push(output);
+      }
+      return outputs;
+    }
+    _getStructOutputs(struct, outputs) {
+      for (const m of struct.members) {
+        if (m.type instanceof Struct) {
+          this._getStructOutputs(m.type, outputs);
+        } else {
+          const location = this._getAttribute(m, "location") || this._getAttribute(m, "builtin");
+          if (location !== null) {
+            const typeInfo = this._getTypeInfo(m.type, m.type.attributes);
+            const locationValue = this._parseInt(location.value);
+            const info = new OutputInfo(m.name, typeInfo, location.name, locationValue);
+            outputs.push(info);
+          }
+        }
+      }
+    }
+    _getOutputInfo(type) {
+      const location = this._getAttribute(type, "location") || this._getAttribute(type, "builtin");
+      if (location !== null) {
+        const typeInfo = this._getTypeInfo(type, type.attributes);
+        const locationValue = this._parseInt(location.value);
+        const info = new OutputInfo("", typeInfo, location.name, locationValue);
+        return info;
+      }
+      return null;
+    }
+    _getInputs(args) {
+      let inputs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0;
+      if (inputs === void 0)
+        inputs = [];
+      for (const arg of args) {
+        if (arg.type instanceof Struct) {
+          this._getStructInputs(arg.type, inputs);
+        } else {
+          const input = this._getInputInfo(arg);
+          if (input !== null)
+            inputs.push(input);
+        }
+      }
+      return inputs;
+    }
+    _getStructInputs(struct, inputs) {
+      for (const m of struct.members) {
+        if (m.type instanceof Struct) {
+          this._getStructInputs(m.type, inputs);
+        } else {
+          const input = this._getInputInfo(m);
+          if (input !== null)
+            inputs.push(input);
+        }
+      }
+    }
+    _getInputInfo(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;
+  });
+
+  // ../../node_modules/@luma.gl/shadertools/dist/lib/wgsl/get-shader-layout-wgsl.js
+  function getShaderLayoutFromWGSL(source) {
+    const shaderLayout = {
+      attributes: [],
+      bindings: []
+    };
+    const parsedWGSL = parseWGSL(source);
+    for (const uniform of parsedWGSL.uniforms) {
+      const members = [];
+      for (const member of uniform.type.members) {
+        members.push({
+          name: member.name,
+          type: getType(member.type)
+        });
+      }
+      shaderLayout.bindings.push({
+        type: "uniform",
+        name: uniform.name,
+        location: uniform.binding,
+        group: uniform.group,
+        members
+      });
+    }
+    const vertex = parsedWGSL.entry.vertex[0];
+    const attributeCount = vertex.inputs.length;
+    for (let i = 0; i < attributeCount; i++) {
+      const wgslAttribute = vertex.inputs[i];
+      if (wgslAttribute.locationType === "location") {
+        const type = getType(wgslAttribute.type);
+        shaderLayout.attributes.push({
+          name: wgslAttribute.name,
+          location: wgslAttribute.location,
+          type
+        });
+      }
+    }
+    return shaderLayout;
+  }
+  function getType(type) {
+    return type.format ? `${type.name}<${type.format.name}>` : type.name;
+  }
+  function parseWGSL(source) {
+    try {
+      return new WgslReflect(source);
+    } catch (error2) {
+      if (error2 instanceof Error) {
+        throw error2;
+      }
+      let message2 = "WGSL parse error";
+      if (typeof error2 === "object" && error2 !== null && error2 !== void 0 && error2.message) {
+        message2 += `: ${error2.message} `;
+      }
+      if (typeof error2 === "object" && error2 !== null && error2 !== void 0 && error2.token) {
+        message2 += error2.token.line || "";
+      }
+      throw new Error(message2, {
+        cause: error2
+      });
+    }
+  }
+
   // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-utils.js
   function fp64ify(a) {
     let out = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
@@ -2313,10 +5086,17 @@ vec2 sqrt_fp64(vec2 a) {
   };
 
   // ../../node_modules/@luma.gl/engine/dist/debug/debug-shader-layout.js
-  function getDebugTableForShaderLayout(layout) {
-    let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+  function getDebugTableForShaderLayout(layout, name) {
+    var _layout$varyings;
     const table = {};
-    const header = `Shader Layout for ${name}`;
+    const header = "Values";
+    if (layout.attributes.length === 0 && !((_layout$varyings = layout.varyings) !== null && _layout$varyings !== void 0 && _layout$varyings.length)) {
+      return {
+        "No attributes or varyings": {
+          [header]: "N/A"
+        }
+      };
+    }
     for (const attributeDeclaration of layout.attributes) {
       if (attributeDeclaration) {
         const glslDeclaration = `${attributeDeclaration.location} ${attributeDeclaration.name}: ${attributeDeclaration.type}`;
@@ -2334,6 +5114,49 @@ vec2 sqrt_fp64(vec2 a) {
     return table;
   }
 
+  // ../../node_modules/@luma.gl/engine/dist/debug/debug-framebuffer.js
+  var canvas = null;
+  var ctx = null;
+  function debugFramebuffer(fbo, _ref) {
+    let {
+      id,
+      minimap,
+      opaque,
+      top = "0",
+      left = "0",
+      rgbaScale = 1
+    } = _ref;
+    if (!canvas) {
+      canvas = document.createElement("canvas");
+      canvas.id = id;
+      canvas.title = id;
+      canvas.style.zIndex = "100";
+      canvas.style.position = "absolute";
+      canvas.style.top = top;
+      canvas.style.left = left;
+      canvas.style.border = "blue 1px solid";
+      canvas.style.transform = "scaleY(-1)";
+      document.body.appendChild(canvas);
+      ctx = canvas.getContext("2d");
+    }
+    if (canvas.width !== fbo.width || canvas.height !== fbo.height) {
+      canvas.width = fbo.width / 2;
+      canvas.height = fbo.height / 2;
+      canvas.style.width = "400px";
+      canvas.style.height = "400px";
+    }
+    const color = fbo.device.readPixelsToArrayWebGL(fbo);
+    const imageData = ctx.createImageData(fbo.width, fbo.height);
+    const offset = 0;
+    for (let i = 0; i < color.length; i += 4) {
+      imageData.data[offset + i + 0] = color[i + 0] * rgbaScale;
+      imageData.data[offset + i + 1] = color[i + 1] * rgbaScale;
+      imageData.data[offset + i + 2] = color[i + 2] * rgbaScale;
+      imageData.data[offset + i + 3] = opaque ? 255 : color[i + 3] * rgbaScale;
+    }
+    ctx.putImageData(imageData, 0, 0);
+  }
+
   // ../../node_modules/@luma.gl/engine/dist/model/model.js
   var LOG_DRAW_PRIORITY = 2;
   var LOG_DRAW_TIMEOUT = 1e4;
@@ -2368,6 +5191,7 @@ vec2 sqrt_fp64(vec2 a) {
       this.props = void 0;
       this._lastLogTime = 0;
       this._logOpen = false;
+      this._drawCount = 0;
       this.props = {
         ...Model.defaultProps,
         ...props
@@ -2378,6 +5202,19 @@ vec2 sqrt_fp64(vec2 a) {
       Object.assign(this.userData, props.userData);
       const moduleMap = Object.fromEntries(((_this$props$modules = this.props.modules) === null || _this$props$modules === void 0 ? void 0 : _this$props$modules.map((module) => [module.name, module])) || []);
       this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
+      const isWebGPU = this.device.info.type === "webgpu";
+      if (this.props.source) {
+        if (isWebGPU) {
+          var _this$props;
+          (_this$props = this.props).shaderLayout || (_this$props.shaderLayout = getShaderLayoutFromWGSL(this.props.source));
+        }
+        this.props.fs = this.props.source;
+        this.props.vs = this.props.source;
+      }
+      if (isWebGPU && typeof this.props.vs !== "string") {
+        var _this$props2;
+        (_this$props2 = this.props).shaderLayout || (_this$props2.shaderLayout = getShaderLayoutFromWGSL(this.props.vs.wgsl));
+      }
       const platformInfo = getPlatformInfo(device);
       const modules = (((_this$props$modules2 = this.props.modules) === null || _this$props$modules2 === void 0 ? void 0 : _this$props$modules2.length) > 0 ? this.props.modules : (_this$shaderInputs = this.shaderInputs) === null || _this$shaderInputs === void 0 ? void 0 : _this$shaderInputs.getModules()) || [];
       const {
@@ -2465,6 +5302,7 @@ vec2 sqrt_fp64(vec2 a) {
       } finally {
         this._logDrawCallEnd();
       }
+      this._logFramebuffer(renderPass);
     }
     setGeometry(geometry) {
       const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
@@ -2476,9 +5314,18 @@ vec2 sqrt_fp64(vec2 a) {
       return gpuGeometry;
     }
     _setGeometryAttributes(gpuGeometry) {
+      const attributes = {
+        ...gpuGeometry.attributes
+      };
+      for (const [attributeName] of Object.entries(attributes)) {
+        if (!this.pipeline.shaderLayout.attributes.find((layout) => layout.name === attributeName) && attributeName !== "positions") {
+          delete attributes[attributeName];
+        }
+      }
       this.vertexCount = gpuGeometry.vertexCount;
-      this.setAttributes(gpuGeometry.attributes, "ignore-unknown");
       this.setIndexBuffer(gpuGeometry.indices);
+      this.setAttributes(gpuGeometry.attributes, "ignore-unknown");
+      this.setAttributes(attributes);
     }
     setTopology(topology) {
       if (topology !== this.topology) {
@@ -2517,6 +5364,18 @@ vec2 sqrt_fp64(vec2 a) {
         this.bindings[`${moduleName}Uniforms`] = uniformBuffer;
       }
     }
+    setShaderModuleProps(props) {
+      const uniforms = this._getModuleUniforms(props);
+      const keys = Object.keys(uniforms).filter((k) => {
+        const uniform = uniforms[k];
+        return !(0, import_core5.isNumberArray)(uniform) && typeof uniform !== "number" && typeof uniform !== "boolean";
+      });
+      const bindings = {};
+      for (const k of keys) {
+        bindings[k] = uniforms[k];
+        delete uniforms[k];
+      }
+    }
     updateShaderInputs() {
       this._uniformStore.setUniforms(this.shaderInputs.getUniformValues());
     }
@@ -2547,13 +5406,12 @@ vec2 sqrt_fp64(vec2 a) {
         import_core5.log.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)();
       }
       for (const [bufferName, buffer] of Object.entries(buffers)) {
-        var _bufferLayout$attribu;
-        const bufferLayout = this.bufferLayout.find((layout) => layout.name === bufferName);
+        const bufferLayout = this.bufferLayout.find((layout) => getAttributeNames(layout).includes(bufferName));
         if (!bufferLayout) {
           import_core5.log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
           continue;
         }
-        const attributeNames = bufferLayout.attributes ? (_bufferLayout$attribu = bufferLayout.attributes) === null || _bufferLayout$attribu === void 0 ? void 0 : _bufferLayout$attribu.map((layout) => layout.attribute) : [bufferLayout.name];
+        const attributeNames = getAttributeNames(bufferLayout);
         let set = false;
         for (const attributeName of attributeNames) {
           const attributeInfo = this._attributeInfos[attributeName];
@@ -2586,21 +5444,23 @@ vec2 sqrt_fp64(vec2 a) {
           import_core5.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
         }
         this._pipelineNeedsUpdate = false;
+        const vs = this.device.createShader({
+          id: `${this.id}-vertex`,
+          stage: "vertex",
+          source: this.vs
+        });
+        const fs = this.fs ? this.device.createShader({
+          id: `${this.id}-fragment`,
+          stage: "fragment",
+          source: this.fs
+        }) : null;
         this.pipeline = this.device.createRenderPipeline({
           ...this.props,
           bufferLayout: this.bufferLayout,
           topology: this.topology,
           parameters: this.parameters,
-          vs: this.device.createShader({
-            id: "{$this.id}-vertex",
-            stage: "vertex",
-            source: this.vs
-          }),
-          fs: this.fs ? this.device.createShader({
-            id: "{$this.id}-fragment",
-            stage: "fragment",
-            source: this.fs
-          }) : null
+          vs,
+          fs
         });
         this._attributeInfos = (0, import_core6.getAttributeInfosFromLayouts)(this.pipeline.shaderLayout, this.bufferLayout);
       }
@@ -2608,8 +5468,8 @@ vec2 sqrt_fp64(vec2 a) {
     }
     _logDrawCallStart() {
       const logDrawTimeout = import_core5.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
-      if (Date.now() - this._lastLogTime < logDrawTimeout) {
-        return void 0;
+      if (import_core5.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
+        return;
       }
       this._lastLogTime = Date.now();
       this._logOpen = true;
@@ -2619,7 +5479,7 @@ vec2 sqrt_fp64(vec2 a) {
     }
     _logDrawCallEnd() {
       if (this._logOpen) {
-        const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout);
+        const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout, this.id);
         import_core5.log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
         const uniformTable = this.shaderInputs.getDebugTable();
         for (const [name, value] of Object.entries(this.uniforms)) {
@@ -2628,13 +5488,58 @@ vec2 sqrt_fp64(vec2 a) {
           };
         }
         import_core5.log.table(LOG_DRAW_PRIORITY, uniformTable)();
+        const attributeTable = this._getAttributeDebugTable();
+        import_core5.log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
+        import_core5.log.table(LOG_DRAW_PRIORITY, attributeTable)();
         import_core5.log.groupEnd(LOG_DRAW_PRIORITY)();
         this._logOpen = false;
       }
     }
+    _logFramebuffer(renderPass) {
+      const debugFramebuffers = import_core5.log.get("framebuffer");
+      this._drawCount++;
+      if (!debugFramebuffers || this._drawCount++ > 3 && this._drawCount % 60) {
+        return;
+      }
+      const framebuffer = renderPass.props.framebuffer;
+      if (framebuffer) {
+        debugFramebuffer(framebuffer, {
+          id: framebuffer.id,
+          minimap: true
+        });
+      }
+    }
+    _getAttributeDebugTable() {
+      const table = {};
+      for (const [name, attributeInfo] of Object.entries(this._attributeInfos)) {
+        table[attributeInfo.location] = {
+          name,
+          type: attributeInfo.shaderType,
+          values: this._getBufferOrConstantValues(this.vertexArray.attributes[attributeInfo.location], attributeInfo.bufferDataType)
+        };
+      }
+      if (this.vertexArray.indexBuffer) {
+        const {
+          indexBuffer
+        } = this.vertexArray;
+        const values = indexBuffer.indexType === "uint32" ? new Uint32Array(indexBuffer.debugData) : new Uint16Array(indexBuffer.debugData);
+        table.indices = {
+          name: "indices",
+          type: indexBuffer.indexType,
+          values: values.toString()
+        };
+      }
+      return table;
+    }
+    _getBufferOrConstantValues(attribute, dataType) {
+      const TypedArrayConstructor = (0, import_core4.getTypedArrayFromDataType)(dataType);
+      const typedArray = attribute instanceof import_core4.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
+      return typedArray.toString();
+    }
   };
   Model.defaultProps = {
     ...import_core4.RenderPipeline.defaultProps,
+    source: null,
     vs: null,
     fs: null,
     id: "unnamed",
@@ -2674,6 +5579,10 @@ vec2 sqrt_fp64(vec2 a) {
       features: device.features
     };
   }
+  function getAttributeNames(bufferLayout) {
+    var _bufferLayout$attribu;
+    return bufferLayout.attributes ? (_bufferLayout$attribu = bufferLayout.attributes) === null || _bufferLayout$attribu === void 0 ? void 0 : _bufferLayout$attribu.map((layout) => layout.attribute) : [bufferLayout.name];
+  }
 
   // ../../node_modules/@luma.gl/engine/dist/transform/texture-transform.js
   var FS_OUTPUT_VARIABLE = "transform_output";
@@ -2914,7 +5823,7 @@ vec2 sqrt_fp64(vec2 a) {
   var CUBE_POSITIONS = new Float32Array([-1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1]);
   var CUBE_NORMALS = new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0]);
   var CUBE_TEX_COORDS = new Float32Array([0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1]);
-  var CUBE_NON_INDEXED_POSITIONS = new Float32Array([1, -1, 1, 1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1, -1, 1, -1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, 1, -1, -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1, -1, 1, -1, 1]);
+  var CUBE_NON_INDEXED_POSITIONS = new Float32Array([1, -1, 1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1, -1, -1, 1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1]);
   var CUBE_NON_INDEXED_TEX_COORDS = new Float32Array([1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0]);
   var CUBE_NON_INDEXED_COLORS = new Float32Array([1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1]);
   var ATTRIBUTES = {
@@ -2933,7 +5842,7 @@ vec2 sqrt_fp64(vec2 a) {
   };
   var NON_INDEXED_ATTRIBUTES = {
     POSITION: {
-      size: 4,
+      size: 3,
       value: CUBE_NON_INDEXED_POSITIONS
     },
     TEXCOORD_0: {
@@ -2984,7 +5893,7 @@ vec2 sqrt_fp64(vec2 a) {
   }
 
   // ../../node_modules/@luma.gl/webgl/dist/adapter/webgl-device.js
-  var import_core34 = __toESM(require_core2(), 1);
+  var import_core36 = __toESM(require_core2(), 1);
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
   function isElectron(mockUserAgent) {
@@ -4321,14 +7230,14 @@ vec2 sqrt_fp64(vec2 a) {
     onContextLost: () => console.error("WebGL context lost"),
     onContextRestored: () => console.info("WebGL context restored")
   };
-  function createBrowserContext(canvas, props) {
+  function createBrowserContext(canvas2, props) {
     props = {
       ...DEFAULT_CONTEXT_PROPS,
       ...props
     };
     let errorMessage = null;
     const onCreateError = (error2) => errorMessage = error2.statusMessage || errorMessage;
-    canvas.addEventListener("webglcontextcreationerror", onCreateError, false);
+    canvas2.addEventListener("webglcontextcreationerror", onCreateError, false);
     let gl = null;
     if (props.type === "webgl2") {
       props = {
@@ -4343,12 +7252,12 @@ vec2 sqrt_fp64(vec2 a) {
       };
     }
     if (!gl && props.webgl2) {
-      gl = canvas.getContext("webgl2", props);
+      gl = canvas2.getContext("webgl2", props);
     }
     if (!gl && props.webgl1) {
-      gl = canvas.getContext("webgl", props);
+      gl = canvas2.getContext("webgl", props);
     }
-    canvas.removeEventListener("webglcontextcreationerror", onCreateError, false);
+    canvas2.removeEventListener("webglcontextcreationerror", onCreateError, false);
     if (!gl) {
       throw new Error(`Failed to create ${props.webgl2 && !props.webgl1 ? "WebGL2" : "WebGL"} context: ${errorMessage || "Unknown error"}`);
     }
@@ -4356,13 +7265,13 @@ vec2 sqrt_fp64(vec2 a) {
       const {
         onContextLost
       } = props;
-      canvas.addEventListener("webglcontextlost", (event) => onContextLost(event), false);
+      canvas2.addEventListener("webglcontextlost", (event) => onContextLost(event), false);
     }
     if (props.onContextRestored) {
       const {
         onContextRestored
       } = props;
-      canvas.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false);
+      canvas2.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false);
     }
     return gl;
   }
@@ -5824,7 +8733,6 @@ void main(void) {}`;
 
   // ../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-buffer.js
   var import_core15 = __toESM(require_core2(), 1);
-  var DEBUG_DATA_LENGTH = 10;
   var WEBGLBuffer = class extends import_core15.Buffer {
     constructor(device) {
       let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
@@ -5838,7 +8746,6 @@ void main(void) {}`;
       this.glIndexType = 5123;
       this.byteLength = void 0;
       this.bytesUsed = void 0;
-      this.debugData = null;
       this.device = device;
       this.gl = this.device.gl;
       this.gl2 = this.device.gl2;
@@ -5851,7 +8758,6 @@ void main(void) {}`;
       this.glTarget = getWebGLTarget(this.props.usage);
       this.glUsage = getWebGLUsage(this.props.usage);
       this.glIndexType = this.props.indexType === "uint32" ? 5125 : 5123;
-      this.debugData = null;
       if (props.data) {
         this._initWithData(props.data, props.byteOffset, props.byteLength);
       } else {
@@ -5861,17 +8767,15 @@ void main(void) {}`;
     _initWithData(data) {
       let byteOffset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
       let byteLength = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : data.byteLength + byteOffset;
-      (0, import_core15.assert)(ArrayBuffer.isView(data));
-      const glTarget = this._getWriteTarget();
+      const glTarget = this.glTarget;
       this.gl.bindBuffer(glTarget, this.handle);
       this.gl.bufferData(glTarget, byteLength, this.glUsage);
       this.gl.bufferSubData(glTarget, byteOffset, data);
       this.gl.bindBuffer(glTarget, null);
-      this.debugData = data.slice(0, DEBUG_DATA_LENGTH);
       this.bytesUsed = byteLength;
       this.byteLength = byteLength;
+      this._setDebugData(data, byteOffset, byteLength);
       this.trackAllocatedMemory(byteLength);
-      return this;
     }
     _initWithByteLength(byteLength) {
       (0, import_core15.assert)(byteLength >= 0);
@@ -5879,13 +8783,14 @@ void main(void) {}`;
       if (byteLength === 0) {
         data = new Float32Array(0);
       }
-      const glTarget = this._getWriteTarget();
+      const glTarget = this.glTarget;
       this.gl.bindBuffer(glTarget, this.handle);
       this.gl.bufferData(glTarget, data, this.glUsage);
       this.gl.bindBuffer(glTarget, null);
-      this.debugData = null;
       this.bytesUsed = byteLength;
       this.byteLength = byteLength;
+      this._setDebugData(null, 0, byteLength);
+      this.trackAllocatedMemory(byteLength);
       return this;
     }
     destroy() {
@@ -5910,29 +8815,27 @@ void main(void) {}`;
         this.gl.bufferSubData(glTarget, byteOffset, data);
       }
       this.gl.bindBuffer(glTarget, null);
+      this._setDebugData(data, byteOffset, data.byteLength);
     }
     async readAsync() {
+      let byteOffset = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+      let byteLength = arguments.length > 1 ? arguments[1] : void 0;
+      return this.readSyncWebGL2(byteOffset, byteLength);
+    }
+    readSyncWebGL2() {
       var _byteLength;
       let byteOffset = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
       let byteLength = arguments.length > 1 ? arguments[1] : void 0;
       this.device.assertWebGL2();
-      byteLength = (_byteLength = byteLength) !== null && _byteLength !== void 0 ? _byteLength : this.byteLength;
+      byteLength = (_byteLength = byteLength) !== null && _byteLength !== void 0 ? _byteLength : this.byteLength - byteOffset;
       const data = new Uint8Array(byteLength);
       const dstOffset = 0;
       this.gl.bindBuffer(36662, this.handle);
       this.gl2.getBufferSubData(36662, byteOffset, data, dstOffset, byteLength);
       this.gl.bindBuffer(36662, null);
+      this._setDebugData(data, byteOffset, byteLength);
       return data;
     }
-    _invalidateDebugData() {
-      this.debugData = null;
-    }
-    _getWriteTarget() {
-      return this.glTarget;
-    }
-    _getReadTarget() {
-      return this.glTarget;
-    }
   };
   function getWebGLTarget(usage) {
     if (usage & import_core15.Buffer.INDEX) {
@@ -7145,9 +10048,12 @@ void main(void) {}`;
       const sizeChanged = size[0] !== this.presentationSize[0] || size[1] !== this.presentationSize[1];
       if (sizeChanged) {
         this.presentationSize = size;
+        this.resize();
       }
     }
     resize(options) {
+      if (!this.device.gl)
+        return;
       if (this.canvas) {
         const devicePixelRatio = this.getDevicePixelRatio(options === null || options === void 0 ? void 0 : options.useDevicePixels);
         this.setDevicePixelRatio(devicePixelRatio, options);
@@ -7537,6 +10443,30 @@ ${source2}`;
   var import_core27 = __toESM(require_core2(), 1);
 
   // ../../node_modules/@luma.gl/webgl/dist/classic/typed-array-utils.js
+  var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array";
+  function getGLTypeFromTypedArray(arrayOrType) {
+    const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+    switch (type) {
+      case Float32Array:
+        return 5126;
+      case Uint16Array:
+        return 5123;
+      case Uint32Array:
+        return 5125;
+      case Uint8Array:
+        return 5121;
+      case Uint8ClampedArray:
+        return 5121;
+      case Int8Array:
+        return 5120;
+      case Int16Array:
+        return 5122;
+      case Int32Array:
+        return 5124;
+      default:
+        throw new Error(ERR_TYPE_DEDUCTION);
+    }
+  }
   function getTypedArrayFromGLType(glType, options) {
     const {
       clamped = true
@@ -7582,13 +10512,13 @@ ${source2}`;
   };
   var Accessor = class {
     static getBytesPerElement(accessor) {
-      const ArrayType = getTypedArrayFromGLType(accessor.type || 5126);
-      return ArrayType.BYTES_PER_ELEMENT;
+      const ArrayType2 = getTypedArrayFromGLType(accessor.type || 5126);
+      return ArrayType2.BYTES_PER_ELEMENT;
     }
     static getBytesPerVertex(accessor) {
       (0, import_core27.assert)(accessor.size);
-      const ArrayType = getTypedArrayFromGLType(accessor.type || 5126);
-      return ArrayType.BYTES_PER_ELEMENT * accessor.size;
+      const ArrayType2 = getTypedArrayFromGLType(accessor.type || 5126);
+      return ArrayType2.BYTES_PER_ELEMENT * accessor.size;
     }
     static resolve() {
       for (var _len = arguments.length, accessors = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -8157,6 +11087,13 @@ ${source2}`;
       this._compileAndLink();
       this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
       this.shaderLayout = (0, import_core29.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
+      switch (this.props.topology) {
+        case "triangle-fan-webgl":
+        case "line-loop-webgl":
+          import_core28.log.warn(`Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`);
+          break;
+        default:
+      }
     }
     destroy() {
       if (this.handle) {
@@ -8872,27 +11809,192 @@ ${source2}`;
         this.gl2.bindBufferBase(35982, Number(bufferIndex), null);
       }
     }
-    _bindBuffer(index2, buffer) {
-      let byteOffset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
-      let byteLength = arguments.length > 3 ? arguments[3] : void 0;
-      const handle = buffer && buffer.handle;
-      if (!handle || byteLength === void 0) {
-        this.gl2.bindBufferBase(35982, index2, handle);
-      } else {
-        this.gl2.bindBufferRange(35982, index2, handle, byteOffset, byteLength);
-      }
+    _bindBuffer(index2, buffer) {
+      let byteOffset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+      let byteLength = arguments.length > 3 ? arguments[3] : void 0;
+      const handle = buffer && buffer.handle;
+      if (!handle || byteLength === void 0) {
+        this.gl2.bindBufferBase(35982, index2, handle);
+      } else {
+        this.gl2.bindBufferRange(35982, index2, handle, byteOffset, byteLength);
+      }
+    }
+  };
+  function isIndex(value) {
+    if (typeof value === "number") {
+      return Number.isInteger(value);
+    }
+    return /^\d+$/.test(value);
+  }
+
+  // ../../node_modules/@luma.gl/webgl/dist/classic/copy-and-blit.js
+  var import_core35 = __toESM(require_core2(), 1);
+
+  // ../../node_modules/@luma.gl/webgl/dist/classic/format-utils.js
+  var import_core34 = __toESM(require_core2(), 1);
+  function glFormatToComponents(format) {
+    switch (format) {
+      case 6406:
+      case 33326:
+      case 6403:
+        return 1;
+      case 33328:
+      case 33319:
+        return 2;
+      case 6407:
+      case 34837:
+        return 3;
+      case 6408:
+      case 34836:
+        return 4;
+      default:
+        (0, import_core34.assert)(false);
+        return 0;
+    }
+  }
+  function glTypeToBytes(type) {
+    switch (type) {
+      case 5121:
+        return 1;
+      case 33635:
+      case 32819:
+      case 32820:
+        return 2;
+      case 5126:
+        return 4;
+      default:
+        (0, import_core34.assert)(false);
+        return 0;
+    }
+  }
+
+  // ../../node_modules/@luma.gl/webgl/dist/classic/copy-and-blit.js
+  function readPixelsToArray(source, options) {
+    var _framebuffer$colorAtt;
+    const {
+      sourceX = 0,
+      sourceY = 0,
+      sourceFormat = 6408,
+      sourceAttachment = 36064
+    } = options || {};
+    let {
+      target = null,
+      sourceWidth,
+      sourceHeight,
+      sourceType
+    } = options || {};
+    const {
+      framebuffer,
+      deleteFramebuffer
+    } = getFramebuffer2(source);
+    (0, import_core35.assert)(framebuffer);
+    const {
+      gl,
+      handle
+    } = framebuffer;
+    sourceWidth = sourceWidth || framebuffer.width;
+    sourceHeight = sourceHeight || framebuffer.height;
+    const attachment = sourceAttachment - 36064;
+    sourceType = sourceType || ((_framebuffer$colorAtt = framebuffer.colorAttachments[attachment]) === null || _framebuffer$colorAtt === void 0 ? void 0 : _framebuffer$colorAtt.type) || 5121;
+    target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
+    sourceType = sourceType || getGLTypeFromTypedArray(target);
+    const prevHandle = gl.bindFramebuffer(36160, handle);
+    gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+    gl.bindFramebuffer(36160, prevHandle || null);
+    if (deleteFramebuffer) {
+      framebuffer.destroy();
+    }
+    return target;
+  }
+  function readPixelsToBuffer(source, options) {
+    const {
+      target,
+      sourceX = 0,
+      sourceY = 0,
+      sourceFormat = 6408,
+      targetByteOffset = 0
+    } = options || {};
+    let {
+      sourceWidth,
+      sourceHeight,
+      sourceType
+    } = options || {};
+    const {
+      framebuffer,
+      deleteFramebuffer
+    } = getFramebuffer2(source);
+    (0, import_core35.assert)(framebuffer);
+    sourceWidth = sourceWidth || framebuffer.width;
+    sourceHeight = sourceHeight || framebuffer.height;
+    const webglFramebuffer = framebuffer;
+    sourceType = sourceType || 5121;
+    let webglBufferTarget = target;
+    if (!webglBufferTarget) {
+      const components = glFormatToComponents(sourceFormat);
+      const byteCount = glTypeToBytes(sourceType);
+      const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
+      webglBufferTarget = webglFramebuffer.device.createBuffer({
+        byteLength
+      });
+    }
+    const commandEncoder = source.device.createCommandEncoder();
+    commandEncoder.copyTextureToBuffer({
+      source,
+      width: sourceWidth,
+      height: sourceHeight,
+      origin: [sourceX, sourceY],
+      destination: webglBufferTarget,
+      byteOffset: targetByteOffset
+    });
+    commandEncoder.destroy();
+    if (deleteFramebuffer) {
+      framebuffer.destroy();
+    }
+    return webglBufferTarget;
+  }
+  function getFramebuffer2(source) {
+    if (!(source instanceof import_core35.Framebuffer)) {
+      return {
+        framebuffer: toFramebuffer(source),
+        deleteFramebuffer: true
+      };
     }
-  };
-  function isIndex(value) {
-    if (typeof value === "number") {
-      return Number.isInteger(value);
+    return {
+      framebuffer: source,
+      deleteFramebuffer: false
+    };
+  }
+  function toFramebuffer(texture, props) {
+    const {
+      device,
+      width,
+      height,
+      id
+    } = texture;
+    const framebuffer = device.createFramebuffer({
+      ...props,
+      id: `framebuffer-for-${id}`,
+      width,
+      height,
+      colorAttachments: [texture]
+    });
+    return framebuffer;
+  }
+  function getPixelArray(pixelArray, type, format, width, height) {
+    if (pixelArray) {
+      return pixelArray;
     }
-    return /^\d+$/.test(value);
+    type = type || 5121;
+    const ArrayType2 = getTypedArrayFromGLType(type, {
+      clamped: false
+    });
+    const components = glFormatToComponents(format);
+    return new ArrayType2(width * height * components);
   }
 
   // ../../node_modules/@luma.gl/webgl/dist/adapter/webgl-device.js
   var LOG_LEVEL2 = 1;
-  var WebGLDevice = class extends import_core34.Device {
+  var WebGLDevice = class extends import_core36.Device {
     static isSupported() {
       return typeof WebGLRenderingContext !== "undefined" || isHeadlessGLRegistered();
     }
@@ -8908,7 +12010,7 @@ ${source2}`;
       if (gl instanceof WebGLDevice) {
         return gl;
       }
-      if ((gl === null || gl === void 0 ? void 0 : gl.device) instanceof import_core34.Device) {
+      if ((gl === null || gl === void 0 ? void 0 : gl.device) instanceof import_core36.Device) {
         return gl.device;
       }
       if (!isWebGL3(gl)) {
@@ -8920,35 +12022,35 @@ ${source2}`;
     }
     static async create() {
       let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-      import_core34.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
+      import_core36.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
       if (typeof props.canvas === "string") {
-        await import_core34.CanvasContext.pageLoaded;
+        await import_core36.CanvasContext.pageLoaded;
       }
-      if (import_core34.log.get("debug") || props.debug) {
+      if (import_core36.log.get("debug") || props.debug) {
         await loadWebGLDeveloperTools();
       }
       const {
         spector: spector2
       } = props;
-      if (import_core34.log.get("spector") || spector2) {
+      if (import_core36.log.get("spector") || spector2) {
         await loadSpectorJS();
       }
-      import_core34.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+      import_core36.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
       if (props.gl && props.gl.device) {
         return WebGLDevice.attach(props.gl);
       }
       const device = new WebGLDevice(props);
       const message2 = `Created ${device.info.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
-      import_core34.log.probe(LOG_LEVEL2, message2)();
-      import_core34.log.table(LOG_LEVEL2, device.info)();
-      import_core34.log.groupEnd(LOG_LEVEL2)();
+      import_core36.log.probe(LOG_LEVEL2, message2)();
+      import_core36.log.table(LOG_LEVEL2, device.info)();
+      import_core36.log.groupEnd(LOG_LEVEL2)();
       return device;
     }
     constructor(props) {
-      var _props$gl;
+      var _props$gl, _props$gl2;
       super({
         ...props,
-        id: props.id || (0, import_core34.uid)("webgl-device")
+        id: props.id || (0, import_core36.uid)("webgl-device")
       });
       this.info = void 0;
       this.canvasContext = void 0;
@@ -8977,7 +12079,11 @@ ${source2}`;
       if (device) {
         throw new Error(`WebGL context already attached to device ${device.id}`);
       }
-      this.canvasContext = new WebGLCanvasContext(this, props);
+      const canvas2 = props.canvas || ((_props$gl2 = props.gl) === null || _props$gl2 === void 0 ? void 0 : _props$gl2.canvas);
+      this.canvasContext = new WebGLCanvasContext(this, {
+        ...props,
+        canvas: canvas2
+      });
       this.lost = new Promise((resolve) => {
         this._resolveContextLost = resolve;
       });
@@ -9005,6 +12111,7 @@ ${source2}`;
       this.gl2 = this.gl;
       this.isWebGL2 = isWebGL22(this.gl);
       this.isWebGL1 = !this.isWebGL2;
+      this.canvasContext.resize();
       this.info = getDeviceInfo(this.gl);
       this.gl.device = this;
       this.gl._version = this.isWebGL2 ? 2 : 1;
@@ -9020,7 +12127,7 @@ ${source2}`;
           for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
             args[_key] = arguments[_key];
           }
-          return import_core34.log.log(1, ...args)();
+          return import_core36.log.log(1, ...args)();
         }
       });
       if (isBrowser() && props.debug) {
@@ -9031,14 +12138,14 @@ ${source2}`;
         });
         this.gl2 = this.gl;
         this.debug = true;
-        import_core34.log.level = Math.max(import_core34.log.level, 1);
-        import_core34.log.warn("WebGL debug mode activated. Performance reduced.")();
+        import_core36.log.level = Math.max(import_core36.log.level, 1);
+        import_core36.log.warn("WebGL debug mode activated. Performance reduced.")();
       }
       if (isBrowser() && props.spector) {
-        const canvas = this.handle.canvas || props.canvas;
+        const canvas3 = this.handle.canvas || props.canvas;
         this.spector = initializeSpectorJS({
           ...this.props,
-          canvas
+          canvas: canvas3
         });
       }
     }
@@ -9123,6 +12230,12 @@ ${source2}`;
       (_this$renderPass = this.renderPass) === null || _this$renderPass === void 0 ? void 0 : _this$renderPass.end();
       this.renderPass = null;
     }
+    readPixelsToArrayWebGL(source, options) {
+      return readPixelsToArray(source, options);
+    }
+    readPixelsToBufferWebGL2(source, options) {
+      return readPixelsToBuffer(source, options);
+    }
     get webglLimits() {
       this._webglLimits = this._webglLimits || getWebGLLimits(this.gl);
       return this._webglLimits;
@@ -9164,7 +12277,7 @@ ${source2}`;
       this._constants = this._constants || new Array(this.limits.maxVertexAttributes).fill(null);
       const currentConstant = this._constants[location];
       if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
-        import_core34.log.info(1, `setConstantAttribute(${location}) could have been skipped, value unchanged`)();
+        import_core36.log.info(1, `setConstantAttribute(${location}) could have been skipped, value unchanged`)();
       }
       this._constants[location] = constant;
       switch (constant.constructor) {
@@ -9178,7 +12291,7 @@ ${source2}`;
           setConstantUintArray(this, location, constant);
           break;
         default:
-          (0, import_core34.assert)(false);
+          (0, import_core36.assert)(false);
       }
     }
   };
@@ -9213,7 +12326,7 @@ ${source2}`;
         device.gl.vertexAttrib4fv(location, array);
         break;
       default:
-        (0, import_core34.assert)(false);
+        (0, import_core36.assert)(false);
     }
   }
   function setConstantIntArray(device, location, array) {
@@ -9239,7 +12352,7 @@ ${source2}`;
   }
 
   // ../../node_modules/@luma.gl/webgl/dist/classic/clear.js
-  var import_core35 = __toESM(require_core2(), 1);
+  var import_core37 = __toESM(require_core2(), 1);
   var GL_DEPTH_BUFFER_BIT2 = 256;
   var GL_STENCIL_BUFFER_BIT2 = 1024;
   var GL_COLOR_BUFFER_BIT2 = 16384;
@@ -9275,128 +12388,12 @@ ${source2}`;
         parameters.clearStencil = depth;
       }
     }
-    (0, import_core35.assert)(clearFlags !== 0, ERR_ARGUMENTS);
+    (0, import_core37.assert)(clearFlags !== 0, ERR_ARGUMENTS);
     withGLParameters(device.gl, parameters, () => {
       device.gl.clear(clearFlags);
     });
   }
 
-  // ../../node_modules/@luma.gl/webgl/dist/classic/copy-and-blit.js
-  var import_core37 = __toESM(require_core2(), 1);
-
-  // ../../node_modules/@luma.gl/webgl/dist/classic/format-utils.js
-  var import_core36 = __toESM(require_core2(), 1);
-  function glFormatToComponents(format) {
-    switch (format) {
-      case 6406:
-      case 33326:
-      case 6403:
-        return 1;
-      case 33328:
-      case 33319:
-        return 2;
-      case 6407:
-      case 34837:
-        return 3;
-      case 6408:
-      case 34836:
-        return 4;
-      default:
-        (0, import_core36.assert)(false);
-        return 0;
-    }
-  }
-  function glTypeToBytes(type) {
-    switch (type) {
-      case 5121:
-        return 1;
-      case 33635:
-      case 32819:
-      case 32820:
-        return 2;
-      case 5126:
-        return 4;
-      default:
-        (0, import_core36.assert)(false);
-        return 0;
-    }
-  }
-
-  // ../../node_modules/@luma.gl/webgl/dist/classic/copy-and-blit.js
-  function readPixelsToBuffer(source, options) {
-    const {
-      sourceX = 0,
-      sourceY = 0,
-      sourceFormat = 6408,
-      targetByteOffset = 0
-    } = options || {};
-    let {
-      target,
-      sourceWidth,
-      sourceHeight,
-      sourceType
-    } = options || {};
-    const {
-      framebuffer,
-      deleteFramebuffer
-    } = getFramebuffer2(source);
-    (0, import_core37.assert)(framebuffer);
-    sourceWidth = sourceWidth || framebuffer.width;
-    sourceHeight = sourceHeight || framebuffer.height;
-    const webglFramebuffer = framebuffer;
-    sourceType = sourceType || 5121;
-    if (!target) {
-      const components = glFormatToComponents(sourceFormat);
-      const byteCount = glTypeToBytes(sourceType);
-      const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
-      target = webglFramebuffer.device.createBuffer({
-        byteLength
-      });
-    }
-    const commandEncoder = source.device.createCommandEncoder();
-    commandEncoder.copyTextureToBuffer({
-      source,
-      width: sourceWidth,
-      height: sourceHeight,
-      origin: [sourceX, sourceY],
-      destination: target,
-      byteOffset: targetByteOffset
-    });
-    commandEncoder.destroy();
-    if (deleteFramebuffer) {
-      framebuffer.destroy();
-    }
-    return target;
-  }
-  function getFramebuffer2(source) {
-    if (!(source instanceof import_core37.Framebuffer)) {
-      return {
-        framebuffer: toFramebuffer(source),
-        deleteFramebuffer: true
-      };
-    }
-    return {
-      framebuffer: source,
-      deleteFramebuffer: false
-    };
-  }
-  function toFramebuffer(texture, props) {
-    const {
-      device,
-      width,
-      height,
-      id
-    } = texture;
-    const framebuffer = device.createFramebuffer({
-      ...props,
-      id: `framebuffer-for-${id}`,
-      width,
-      height,
-      colorAttachments: [texture]
-    });
-    return framebuffer;
-  }
-
   // src/utils/gpu-grid-aggregation/gpu-grid-aggregator.ts
   var import_core38 = __toESM(require_core());
 
@@ -9663,7 +12660,6 @@ void main()
       width = 1,
       height = 1,
       data = null,
-      unpackFlipY = true,
       parameters = DEFAULT_PARAMETERS
     } = opts;
     const texture = device.createTexture({
@@ -10325,12 +13321,12 @@ void main()
 
   // src/utils/color-utils.ts
   var defaultColorRange = [[255, 255, 178], [254, 217, 118], [254, 178, 76], [253, 141, 60], [240, 59, 32], [189, 0, 38]];
-  function colorRangeToFlatArray(colorRange, normalize = false, ArrayType = Float32Array) {
+  function colorRangeToFlatArray(colorRange, normalize = false, ArrayType2 = Float32Array) {
     let flatArray;
     if (Number.isFinite(colorRange[0])) {
-      flatArray = new ArrayType(colorRange);
+      flatArray = new ArrayType2(colorRange);
     } else {
-      flatArray = new ArrayType(colorRange.length * 4);
+      flatArray = new ArrayType2(colorRange.length * 4);
       let index2 = 0;
       for (let i = 0; i < colorRange.length; i++) {
         const color = colorRange[i];
@@ -10668,7 +13664,9 @@ void main(void) {
       const moduleSettings = Object.assign(Object.create(this.props), {
         viewport,
         mousePosition,
-        pickingActive: 0,
+        picking: {
+          isActive: 0
+        },
         devicePixelRatio: device.canvasContext.cssToDeviceRatio()
       });
       return moduleSettings;
@@ -11452,7 +14450,7 @@ void main(void) {
       type: "accessor",
       value: 1
     },
-    gpuAggregation: true,
+    gpuAggregation: false,
     aggregation: "SUM"
   };
   var POSITION_ATTRIBUTE_NAME = "positions";
@@ -13115,7 +16113,7 @@ void main(void) {
       type: "accessor",
       value: 1
     },
-    gpuAggregation: true,
+    gpuAggregation: false,
     aggregation: "SUM",
     contours: {
       type: "object",
@@ -13332,7 +16330,7 @@ void main(void) {
         aggregationData
       } = count;
       if (!aggregationData) {
-        aggregationData = count.aggregationBuffer.getData();
+        aggregationData = count.aggregationBuffer.readSyncWebGL2();
         count.aggregationData = aggregationData;
       }
       const {
@@ -13750,7 +16748,7 @@ void main(void) {
         dimensions: DIMENSIONS3
       });
       this.setState({
-        gpuAggregation: true,
+        gpuAggregation: false,
         projectPoints: false,
         isSupported,
         weights: {
@@ -14063,14 +17061,14 @@ void main(void) {
   var GridLayer = class extends import_core52.CompositeLayer {
     initializeState() {
       this.state = {
-        useGPUAggregation: true
+        useGPUAggregation: false
       };
     }
     updateState({
       props
     }) {
       this.setState({
-        useGPUAggregation: this.canUseGPUAggregation(props)
+        useGPUAggregation: false
       });
     }
     renderLayers() {
@@ -14166,18 +17164,6 @@ void main(void) {
     const [xMin, yMin, xMax, yMax] = bounds;
     return [(point[0] - xMin) / (xMax - xMin), (point[1] - yMin) / (yMax - yMin)];
   }
-  function getTextureParams({
-    device,
-    floatTargetSupport
-  }) {
-    return floatTargetSupport ? {
-      format: device.info.type === "webgl2" ? 34836 : 6408,
-      type: 5126
-    } : {
-      format: 6408,
-      type: 5121
-    };
-  }
 
   // src/heatmap-layer/heatmap-layer.ts
   var import_core54 = __toESM(require_core());
@@ -14225,7 +17211,7 @@ void main(void) {
 precision highp float;
 
 uniform float opacity;
-uniform sampler2D texture;
+uniform sampler2D weightsTexture;
 uniform sampler2D colorTexture;
 uniform float aggregationMode;
 
@@ -14243,7 +17229,7 @@ vec4 getLinearColor(float value) {
 }
 
 void main(void) {
-  vec4 weights = texture(texture, vTexCoords);
+  vec4 weights = texture(weightsTexture, vTexCoords);
   float weight = weights.r;
 
   if (aggregationMode > 0.5) {
@@ -14273,32 +17259,36 @@ void main(void) {
     initializeState({
       device
     }) {
-      const attributeManager = this.getAttributeManager();
-      attributeManager.add({
-        positions: {
-          size: 3,
-          noAlloc: true
-        },
-        texCoords: {
-          size: 2,
-          noAlloc: true
-        }
-      });
       this.setState({
         model: this._getModel(device)
       });
     }
     _getModel(device) {
       const {
-        vertexCount
+        vertexCount,
+        data,
+        weightsTexture,
+        maxTexture,
+        colorTexture
       } = this.props;
       return new Model(device, {
         ...this.getShaders(),
         id: this.props.id,
-        geometry: new Geometry({
-          topology: "triangle-fan-webgl",
-          vertexCount
-        })
+        bindings: {
+          weightsTexture,
+          maxTexture,
+          colorTexture
+        },
+        attributes: data.attributes,
+        bufferLayout: [{
+          name: "positions",
+          format: "float32x3"
+        }, {
+          name: "texCoords",
+          format: "float32x2"
+        }],
+        topology: "triangle-fan-webgl",
+        vertexCount
       });
     }
     draw({
@@ -14308,9 +17298,6 @@ void main(void) {
         model
       } = this.state;
       const {
-        texture,
-        maxTexture,
-        colorTexture,
         intensity,
         threshold: threshold2,
         aggregationMode,
@@ -14318,9 +17305,6 @@ void main(void) {
       } = this.props;
       model.setUniforms({
         ...uniforms,
-        texture,
-        maxTexture,
-        colorTexture,
         intensity,
         threshold: threshold2,
         aggregationMode,
@@ -14341,18 +17325,20 @@ uniform float radiusPixels;
 uniform float textureWidth;
 uniform vec4 commonBounds;
 uniform float weightsScale;
+
 void main()
 {
   weightsTexture = vec4(weights * weightsScale, 0., 0., 1.);
 
-  float radiusTexels  = project_pixel_size(radiusPixels) * textureWidth / (commonBounds.z - commonBounds.x);
+  float radiusTexels = project_pixel_size(radiusPixels) * textureWidth / (commonBounds.z - commonBounds.x);
   gl_PointSize = radiusTexels * 2.;
 
   vec3 commonPosition = project_position(positions, positions64Low);
 
-  // map xy from commonBounds to [-1, 1]
+  // // map xy from commonBounds to [-1, 1]
   gl_Position.xy = (commonPosition.xy - commonBounds.xy) / (commonBounds.zw - commonBounds.xy) ;
   gl_Position.xy = (gl_Position.xy * 2.) - (1.);
+  gl_Position.w = 1.0;
 }
 `;
 
@@ -14380,15 +17366,21 @@ void main()
 
   // src/heatmap-layer/max-vs.glsl.ts
   var max_vs_glsl_default = `#version 300 es
-in vec4 inTexture;
+uniform sampler2D inTexture;
+uniform float textureSize;
 out vec4 outTexture;
 
 void main()
 {
-outTexture = inTexture;
-gl_Position = vec4(0, 0, 0, 1.);
-// Enforce default value for ANGLE issue (https://bugs.chromium.org/p/angleproject/issues/detail?id=3941)
-gl_PointSize = 1.0;
+  // Sample every pixel in texture
+  int yIndex = gl_VertexID / int(textureSize);
+  int xIndex = gl_VertexID - (yIndex * int(textureSize));
+  vec2 uv = (0.5 + vec2(float(xIndex), float(yIndex))) / textureSize;
+  outTexture = texture(inTexture, uv);
+
+  gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+  // Enforce default value for ANGLE issue (https://bugs.chromium.org/p/angleproject/issues/detail?id=3941)
+  gl_PointSize = 1.0;
 }
 `;
 
@@ -14408,8 +17400,8 @@ void main() {
     format: "rgba8unorm",
     mipmaps: false,
     sampler: {
-      minFilter: "nearest",
-      magFilter: "nearest",
+      minFilter: "linear",
+      magFilter: "linear",
       addressModeU: "clamp-to-edge",
       addressModeV: "clamp-to-edge"
     }
@@ -14564,7 +17556,7 @@ void main() {
         maxTexture: maxWeightsTexture,
         colorTexture,
         aggregationMode: AGGREGATION_MODE[aggregation] || 0,
-        texture: weightsTexture,
+        weightsTexture,
         intensity,
         threshold: threshold2,
         colorDomain
@@ -14620,21 +17612,20 @@ void main() {
     _createTextures() {
       const {
         textureSize,
-        format,
-        type
+        format
       } = this.state;
       this.setState({
         weightsTexture: this.context.device.createTexture({
+          ...TEXTURE_PROPS,
           width: textureSize,
           height: textureSize,
-          format,
-          type,
-          ...TEXTURE_PROPS
+          format
         }),
         maxWeightsTexture: this.context.device.createTexture({
-          format,
-          type,
-          ...TEXTURE_PROPS
+          ...TEXTURE_PROPS,
+          width: 1,
+          height: 1,
+          format
         })
       });
     }
@@ -14664,43 +17655,40 @@ void main() {
       } = this.props;
       const textureSize = Math.min(weightsTextureSize, device.limits.maxTextureDimension2D);
       const floatTargetSupport = FLOAT_TARGET_FEATURES.every((feature) => device.features.has(feature));
-      const {
-        format,
-        type
-      } = getTextureParams({
-        device,
-        floatTargetSupport
-      });
+      const format = floatTargetSupport ? "rgba32float" : "rgba8unorm";
       const weightsScale = floatTargetSupport ? 1 : 1 / 255;
       this.setState({
         textureSize,
         format,
-        type,
         weightsScale
       });
       if (!floatTargetSupport) {
-        import_core54.log.warn(`HeatmapLayer: ${this.id} rendering to float texture not supported, fallingback to low precession format`)();
+        import_core54.log.warn(`HeatmapLayer: ${this.id} rendering to float texture not supported, falling back to low precision format`)();
       }
     }
-    getShaders(type) {
-      return super.getShaders(type === "max-weights-transform" ? {
-        vs: max_vs_glsl_default,
-        _fs: max_fs_glsl_default
-      } : {
-        vs: weights_vs_glsl_default,
-        _fs: weights_fs_glsl_default
-      });
-    }
-    _createWeightsTransform(shaders = {}) {
+    _createWeightsTransform(shaders) {
       let {
         weightsTransform
       } = this.state;
-      weightsTransform?.delete();
+      const {
+        weightsTexture
+      } = this.state;
+      const attributeManager = this.getAttributeManager();
+      weightsTransform?.destroy();
       weightsTransform = new TextureTransform(this.context.device, {
         id: `${this.id}-weights-transform`,
+        bufferLayout: attributeManager.getBufferLayouts(),
         vertexCount: 1,
-        targetTexture: this.state.weightsTexture,
-        targetTextureVarying: "weightsTexture",
+        targetTexture: weightsTexture,
+        parameters: {
+          depthWriteEnabled: false,
+          blendColorOperation: "add",
+          blendColorSrcFactor: "one",
+          blendColorDstFactor: "one",
+          blendAlphaSrcFactor: "one",
+          blendAlphaDstFactor: "one"
+        },
+        topology: "point-list",
         ...shaders
       });
       this.setState({
@@ -14709,57 +17697,75 @@ void main() {
     }
     _setupResources() {
       this._createTextures();
+      const {
+        device
+      } = this.context;
       const {
         textureSize,
         weightsTexture,
         maxWeightsTexture
       } = this.state;
-      const weightsTransformShaders = this.getShaders("weights-transform");
+      const weightsTransformShaders = this.getShaders({
+        vs: weights_vs_glsl_default,
+        fs: weights_fs_glsl_default
+      });
       this._createWeightsTransform(weightsTransformShaders);
-      const maxWeightsTransformShaders = this.getShaders("max-weights-transform");
-      const maxWeightTransform = new TextureTransform(this.context.device, {
+      const maxWeightsTransformShaders = this.getShaders({
+        vs: max_vs_glsl_default,
+        fs: max_fs_glsl_default
+      });
+      const maxWeightTransform = new TextureTransform(device, {
         id: `${this.id}-max-weights-transform`,
-        _sourceTextures: {
+        bindings: {
           inTexture: weightsTexture
         },
-        _targetTexture: maxWeightsTexture,
-        _targetTextureVarying: "outTexture",
+        uniforms: {
+          textureSize
+        },
+        targetTexture: maxWeightsTexture,
         ...maxWeightsTransformShaders,
-        elementCount: textureSize * textureSize
+        vertexCount: textureSize * textureSize,
+        topology: "point-list",
+        parameters: {
+          depthWriteEnabled: false,
+          blendColorOperation: "max",
+          blendAlphaOperation: "max",
+          blendColorSrcFactor: "one",
+          blendColorDstFactor: "one",
+          blendAlphaSrcFactor: "one",
+          blendAlphaDstFactor: "one"
+        }
       });
       this.setState({
         weightsTexture,
         maxWeightsTexture,
         maxWeightTransform,
         zoom: null,
-        triPositionBuffer: this.context.device.createBuffer({
-          byteLength: 48,
-          accessor: {
-            size: 3
-          }
+        triPositionBuffer: device.createBuffer({
+          byteLength: 48
         }),
-        triTexCoordBuffer: this.context.device.createBuffer({
-          byteLength: 48,
-          accessor: {
-            size: 2
-          }
+        triTexCoordBuffer: device.createBuffer({
+          byteLength: 48
         })
       });
     }
     updateShaders(shaderOptions) {
-      this._createWeightsTransform(shaderOptions);
+      this._createWeightsTransform({
+        vs: weights_vs_glsl_default,
+        fs: weights_fs_glsl_default,
+        ...shaderOptions
+      });
     }
     _updateMaxWeightValue() {
       const {
-        maxWeightTransform
+        maxWeightTransform,
+        textureSize
       } = this.state;
       maxWeightTransform.run({
         parameters: {
-          blend: true,
-          depthTest: false,
-          blendFunc: [1, 1],
-          blendEquation: 32776
-        }
+          viewport: [0, 0, 1, 1]
+        },
+        clearColor: [0, 0, 0, 0]
       });
     }
     _updateBounds(forceUpdate = false) {
@@ -14812,17 +17818,17 @@ void main() {
         colorTexture
       } = this.state;
       const colors = colorRangeToFlatArray(colorRange, false, Uint8Array);
-      if (colorTexture) {
-        colorTexture.setImageData({
-          data: colors,
-          width: colorRange.length
+      if (colorTexture && colorTexture?.width === colorRange.length) {
+        colorTexture.setSubImageData({
+          data: colors
         });
       } else {
+        colorTexture?.destroy();
         colorTexture = this.context.device.createTexture({
+          ...TEXTURE_PROPS,
           data: colors,
           width: colorRange.length,
-          height: 1,
-          ...TEXTURE_PROPS
+          height: 1
         });
       }
       this.setState({
@@ -14854,30 +17860,29 @@ void main() {
       } else {
         this.state.colorDomain = colorDomain || DEFAULT_COLOR_DOMAIN;
       }
+      const attributeManager = this.getAttributeManager();
+      const attributes = attributeManager.getAttributes();
+      const moduleSettings = this.getModuleSettings();
+      const positions = attributes.positions.buffer;
       const uniforms = {
         radiusPixels,
         commonBounds,
         textureWidth: textureSize,
         weightsScale
       };
-      weightsTransform.update({
-        elementCount: this.getNumInstances()
+      const weights = attributes.weights.buffer;
+      weightsTransform.model.setAttributes({
+        positions,
+        weights
       });
-      withGLParameters(this.context.gl, {
+      weightsTransform.model.setVertexCount(this.getNumInstances());
+      weightsTransform.model.setUniforms(uniforms);
+      weightsTransform.model.updateModuleSettings(moduleSettings);
+      weightsTransform.run({
+        parameters: {
+          viewport: [0, 0, textureSize, textureSize]
+        },
         clearColor: [0, 0, 0, 0]
-      }, () => {
-        weightsTransform.run({
-          uniforms,
-          parameters: {
-            blend: true,
-            depthTest: false,
-            blendFunc: [1, 1],
-            blendEquation: 32774
-          },
-          clearRenderTarget: true,
-          attributes: this.getAttributes(),
-          moduleSettings: this.getModuleSettings()
-        });
       });
       this._updateMaxWeightValue();
     }