@luma.gl/engine 9.0.14 → 9.0.16

package/dist/dist.dev.js

@@ -273,8 +273,6 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
   var Stat = class {
     constructor(name, type) {
-      this.name = void 0;
-      this.type = void 0;
       this.sampleSize = 1;
       this.time = 0;
       this.count = 0;
@@ -309,26 +307,31 @@ var __exports__ = (() => {
       this.sampleSize = samples;
       return this;
     }
+    /** Call to increment count (+1) */
     incrementCount() {
       this.addCount(1);
       return this;
     }
+    /** Call to decrement count (-1) */
     decrementCount() {
       this.subtractCount(1);
       return this;
     }
+    /** Increase count */
     addCount(value) {
       this._count += value;
       this._samples++;
       this._checkSampling();
       return this;
     }
+    /** Decrease count */
     subtractCount(value) {
       this._count -= value;
       this._samples++;
       this._checkSampling();
       return this;
     }
+    /** Add an arbitrary timing and bump the count */
     addTime(time) {
       this._time += time;
       this.lastTiming = time;
@@ -336,11 +339,13 @@ var __exports__ = (() => {
       this._checkSampling();
       return this;
     }
+    /** Start a timer */
     timeStart() {
       this._startTime = getHiResTimestamp();
       this._timerPending = true;
       return this;
     }
+    /** End a timer. Adds to time and bumps the timing count. */
     timeEnd() {
       if (!this._timerPending) {
         return this;
@@ -353,18 +358,22 @@ var __exports__ = (() => {
     getSampleAverageCount() {
       return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
     }
+    /** Calculate average time / count for the previous window */
     getSampleAverageTime() {
       return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
     }
+    /** Calculate counts per second for the previous window */
     getSampleHz() {
       return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
     }
     getAverageCount() {
       return this.samples > 0 ? this.count / this.samples : 0;
     }
+    /** Calculate average time / count */
     getAverageTime() {
       return this.samples > 0 ? this.time / this.samples : 0;
     }
+    /** Calculate counts per second */
     getHz() {
       return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
     }
@@ -385,23 +394,20 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
   var Stats = class {
     constructor(options) {
-      this.id = void 0;
       this.stats = {};
       this.id = options.id;
       this.stats = {};
       this._initializeStats(options.stats);
       Object.seal(this);
     }
-    get(name) {
-      let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
-      return this._getOrCreate({
-        name,
-        type
-      });
+    /** Acquire a stat. Create if it doesn't exist. */
+    get(name, type = "count") {
+      return this._getOrCreate({ name, type });
     }
     get size() {
       return Object.keys(this.stats).length;
     }
+    /** Reset all stats */
     reset() {
       for (const stat of Object.values(this.stats)) {
         stat.reset();
@@ -425,15 +431,11 @@ var __exports__ = (() => {
       });
       return table;
     }
-    _initializeStats() {
-      let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    _initializeStats(stats = []) {
       stats.forEach((stat) => this._getOrCreate(stat));
     }
     _getOrCreate(stat) {
-      const {
-        name,
-        type
-      } = stat;
+      const { name, type } = stat;
       let result = this.stats[name];
       if (!result) {
         if (stat instanceof Stat) {
@@ -1831,7 +1833,7 @@ void main() {
   // ../shadertools/src/lib/wgsl/get-shader-layout-wgsl.ts
   var import_core4 = __toESM(require_core(), 1);
 
-  // ../shadertools/src/libs/wgsl-reflect/wgsl_reflect.module.js
+  // ../../node_modules/wgsl_reflect/wgsl_reflect.module.js
   var ParseContext = class {
     constructor() {
       this.constants = /* @__PURE__ */ new Map();
@@ -1854,23 +1856,50 @@ void main() {
     evaluateString(context) {
       return this.evaluate(context).toString();
     }
+    search(callback) {
+    }
+    searchBlock(block, callback) {
+      if (block) {
+        callback(_BlockStart.instance);
+        for (const node of block) {
+          if (node instanceof Array) {
+            this.searchBlock(node, callback);
+          } else {
+            node.search(callback);
+          }
+        }
+        callback(_BlockEnd.instance);
+      }
+    }
   };
+  var _BlockStart = class extends Node {
+  };
+  _BlockStart.instance = new _BlockStart();
+  var _BlockEnd = class extends Node {
+  };
+  _BlockEnd.instance = new _BlockEnd();
   var Statement = class extends Node {
     constructor() {
       super();
     }
   };
   var Function = class extends Statement {
-    constructor(name, args, returnType, body) {
+    constructor(name, args, returnType, body, startLine, endLine) {
       super();
+      this.calls = /* @__PURE__ */ new Set();
       this.name = name;
       this.args = args;
       this.returnType = returnType;
       this.body = body;
+      this.startLine = startLine;
+      this.endLine = endLine;
     }
     get astNodeType() {
       return "function";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var StaticAssert = class extends Statement {
     constructor(expression) {
@@ -1880,6 +1909,9 @@ void main() {
     get astNodeType() {
       return "staticAssert";
     }
+    search(callback) {
+      this.expression.search(callback);
+    }
   };
   var While = class extends Statement {
     constructor(condition, body) {
@@ -1890,6 +1922,10 @@ void main() {
     get astNodeType() {
       return "while";
     }
+    search(callback) {
+      this.condition.search(callback);
+      this.searchBlock(this.body, callback);
+    }
   };
   var Continuing = class extends Statement {
     constructor(body) {
@@ -1899,6 +1935,9 @@ void main() {
     get astNodeType() {
       return "continuing";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var For = class extends Statement {
     constructor(init, condition, increment, body) {
@@ -1911,6 +1950,13 @@ void main() {
     get astNodeType() {
       return "for";
     }
+    search(callback) {
+      var _a2, _b, _c;
+      (_a2 = this.init) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+      (_b = this.condition) === null || _b === void 0 ? void 0 : _b.search(callback);
+      (_c = this.increment) === null || _c === void 0 ? void 0 : _c.search(callback);
+      this.searchBlock(this.body, callback);
+    }
   };
   var Var = class extends Statement {
     constructor(name, type, storage, access, value) {
@@ -1924,6 +1970,11 @@ void main() {
     get astNodeType() {
       return "var";
     }
+    search(callback) {
+      var _a2;
+      callback(this);
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Override = class extends Statement {
     constructor(name, type, value) {
@@ -1935,6 +1986,10 @@ void main() {
     get astNodeType() {
       return "override";
     }
+    search(callback) {
+      var _a2;
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Let = class extends Statement {
     constructor(name, type, storage, access, value) {
@@ -1948,6 +2003,11 @@ void main() {
     get astNodeType() {
       return "let";
     }
+    search(callback) {
+      var _a2;
+      callback(this);
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Const = class extends Statement {
     constructor(name, type, storage, access, value) {
@@ -1964,6 +2024,11 @@ void main() {
     evaluate(context) {
       return this.value.evaluate(context);
     }
+    search(callback) {
+      var _a2;
+      callback(this);
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var IncrementOperator;
   (function(IncrementOperator2) {
@@ -1988,6 +2053,9 @@ void main() {
     get astNodeType() {
       return "increment";
     }
+    search(callback) {
+      this.variable.search(callback);
+    }
   };
   var AssignOperator;
   (function(AssignOperator2) {
@@ -2006,9 +2074,10 @@ void main() {
   (function(AssignOperator2) {
     function parse(val) {
       const key = val;
-      if (key == "parse")
+      if (key == "parse") {
         throw new Error("Invalid value for AssignOperator");
-      return AssignOperator2[key];
+      }
+      return key;
     }
     AssignOperator2.parse = parse;
   })(AssignOperator || (AssignOperator = {}));
@@ -2022,6 +2091,10 @@ void main() {
     get astNodeType() {
       return "assign";
     }
+    search(callback) {
+      this.variable.search(callback);
+      this.value.search(callback);
+    }
   };
   var Call = class extends Statement {
     constructor(name, args) {
@@ -2032,6 +2105,12 @@ void main() {
     get astNodeType() {
       return "call";
     }
+    search(callback) {
+      for (const node of this.args) {
+        node.search(callback);
+      }
+      callback(this);
+    }
   };
   var Loop = class extends Statement {
     constructor(body, continuing) {
@@ -2064,6 +2143,12 @@ void main() {
     get astNodeType() {
       return "if";
     }
+    search(callback) {
+      this.condition.search(callback);
+      this.searchBlock(this.body, callback);
+      this.searchBlock(this.elseif, callback);
+      this.searchBlock(this.else, callback);
+    }
   };
   var Return = class extends Statement {
     constructor(value) {
@@ -2073,6 +2158,10 @@ void main() {
     get astNodeType() {
       return "return";
     }
+    search(callback) {
+      var _a2;
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Enable = class extends Statement {
     constructor(name) {
@@ -2083,6 +2172,25 @@ void main() {
       return "enable";
     }
   };
+  var Requires = class extends Statement {
+    constructor(extensions) {
+      super();
+      this.extensions = extensions;
+    }
+    get astNodeType() {
+      return "requires";
+    }
+  };
+  var Diagnostic = class extends Statement {
+    constructor(severity, rule) {
+      super();
+      this.severity = severity;
+      this.rule = rule;
+    }
+    get astNodeType() {
+      return "diagnostic";
+    }
+  };
   var Alias = class extends Statement {
     constructor(name, type) {
       super();
@@ -2133,9 +2241,11 @@ void main() {
     }
   };
   var Struct = class extends Type {
-    constructor(name, members) {
+    constructor(name, members, startLine, endLine) {
       super(name);
       this.members = members;
+      this.startLine = startLine;
+      this.endLine = endLine;
     }
     get astNodeType() {
       return "struct";
@@ -2226,6 +2336,12 @@ void main() {
     get astNodeType() {
       return "createExpr";
     }
+    search(callback) {
+      callback(this);
+      for (const node of this.args) {
+        node.search(callback);
+      }
+    }
   };
   var CallExpr = class extends Expression {
     constructor(name, args) {
@@ -2319,6 +2435,12 @@ void main() {
           throw new Error("Non const function: " + this.name);
       }
     }
+    search(callback) {
+      for (const node of this.args) {
+        node.search(callback);
+      }
+      callback(this);
+    }
   };
   var VariableExpr = class extends Expression {
     constructor(name) {
@@ -2328,6 +2450,19 @@ void main() {
     get astNodeType() {
       return "varExpr";
     }
+    search(callback) {
+      callback(this);
+      if (this.postfix) {
+        this.postfix.search(callback);
+      }
+    }
+    evaluate(context) {
+      const constant = context.constants.get(this.name);
+      if (!constant) {
+        throw new Error("Cannot evaluate node");
+      }
+      return constant.evaluate(context);
+    }
   };
   var ConstExpr = class extends Expression {
     constructor(name, initializer) {
@@ -2353,6 +2488,9 @@ void main() {
       }
       return this.initializer.evaluate(context);
     }
+    search(callback) {
+      this.initializer.search(callback);
+    }
   };
   var LiteralExpr = class extends Expression {
     constructor(value) {
@@ -2375,6 +2513,9 @@ void main() {
     get astNodeType() {
       return "bitcastExpr";
     }
+    search(callback) {
+      this.value.search(callback);
+    }
   };
   var TypecastExpr = class extends Expression {
     constructor(type, args) {
@@ -2388,6 +2529,9 @@ void main() {
     evaluate(context) {
       return this.args[0].evaluate(context);
     }
+    search(callback) {
+      this.searchBlock(this.args, callback);
+    }
   };
   var GroupingExpr = class extends Expression {
     constructor(contents) {
@@ -2400,6 +2544,18 @@ void main() {
     evaluate(context) {
       return this.contents[0].evaluate(context);
     }
+    search(callback) {
+      this.searchBlock(this.contents, callback);
+    }
+  };
+  var ArrayIndex = class extends Expression {
+    constructor(index2) {
+      super();
+      this.index = index2;
+    }
+    search(callback) {
+      this.index.search(callback);
+    }
   };
   var Operator = class extends Expression {
     constructor() {
@@ -2429,6 +2585,9 @@ void main() {
           throw new Error("Unknown unary operator: " + this.operator);
       }
     }
+    search(callback) {
+      this.right.search(callback);
+    }
   };
   var BinaryOperator = class extends Operator {
     constructor(operator, left, right) {
@@ -2472,6 +2631,10 @@ void main() {
           throw new Error(`Unknown operator ${this.operator}`);
       }
     }
+    search(callback) {
+      this.left.search(callback);
+      this.right.search(callback);
+    }
   };
   var SwitchCase = class extends Node {
     constructor() {
@@ -2487,6 +2650,9 @@ void main() {
     get astNodeType() {
       return "case";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var Default = class extends SwitchCase {
     constructor(body) {
@@ -2496,6 +2662,9 @@ void main() {
     get astNodeType() {
       return "default";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var Argument = class extends Node {
     constructor(name, type, attributes) {
@@ -2517,6 +2686,10 @@ void main() {
     get astNodeType() {
       return "elseif";
     }
+    search(callback) {
+      this.condition.search(callback);
+      this.searchBlock(this.body, callback);
+    }
   };
   var Member = class extends Node {
     constructor(name, type, attributes) {
@@ -2631,6 +2804,7 @@ void main() {
     continue: new TokenType("continue", TokenClass.keyword, "continue"),
     continuing: new TokenType("continuing", TokenClass.keyword, "continuing"),
     default: new TokenType("default", TokenClass.keyword, "default"),
+    diagnostic: new TokenType("diagnostic", TokenClass.keyword, "diagnostic"),
     discard: new TokenType("discard", TokenClass.keyword, "discard"),
     else: new TokenType("else", TokenClass.keyword, "else"),
     enable: new TokenType("enable", TokenClass.keyword, "enable"),
@@ -2648,6 +2822,7 @@ void main() {
     read: new TokenType("read", TokenClass.keyword, "read"),
     read_write: new TokenType("read_write", TokenClass.keyword, "read_write"),
     return: new TokenType("return", TokenClass.keyword, "return"),
+    requires: new TokenType("requires", TokenClass.keyword, "requires"),
     storage: new TokenType("storage", TokenClass.keyword, "storage"),
     switch: new TokenType("switch", TokenClass.keyword, "switch"),
     true: new TokenType("true", TokenClass.keyword, "true"),
@@ -2706,13 +2881,11 @@ void main() {
     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_]*/),
+    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, "["),
@@ -2756,6 +2929,63 @@ void main() {
     shift_right_equal: new TokenType("shift_right_equal", TokenClass.token, ">>="),
     shift_left_equal: new TokenType("shift_left_equal", TokenClass.token, "<<=")
   };
+  TokenTypes.simpleTokens = {
+    "@": _a.tokens.attr,
+    "{": _a.tokens.brace_left,
+    "}": _a.tokens.brace_right,
+    ":": _a.tokens.colon,
+    ",": _a.tokens.comma,
+    "(": _a.tokens.paren_left,
+    ")": _a.tokens.paren_right,
+    ";": _a.tokens.semicolon
+  };
+  TokenTypes.literalTokens = {
+    "&": _a.tokens.and,
+    "&&": _a.tokens.and_and,
+    "->": _a.tokens.arrow,
+    "/": _a.tokens.forward_slash,
+    "!": _a.tokens.bang,
+    "[": _a.tokens.bracket_left,
+    "]": _a.tokens.bracket_right,
+    "=": _a.tokens.equal,
+    "==": _a.tokens.equal_equal,
+    "!=": _a.tokens.not_equal,
+    ">": _a.tokens.greater_than,
+    ">=": _a.tokens.greater_than_equal,
+    ">>": _a.tokens.shift_right,
+    "<": _a.tokens.less_than,
+    "<=": _a.tokens.less_than_equal,
+    "<<": _a.tokens.shift_left,
+    "%": _a.tokens.modulo,
+    "-": _a.tokens.minus,
+    "--": _a.tokens.minus_minus,
+    ".": _a.tokens.period,
+    "+": _a.tokens.plus,
+    "++": _a.tokens.plus_plus,
+    "|": _a.tokens.or,
+    "||": _a.tokens.or_or,
+    "*": _a.tokens.star,
+    "~": _a.tokens.tilde,
+    "_": _a.tokens.underscore,
+    "^": _a.tokens.xor,
+    "+=": _a.tokens.plus_equal,
+    "-=": _a.tokens.minus_equal,
+    "*=": _a.tokens.times_equal,
+    "/=": _a.tokens.division_equal,
+    "%=": _a.tokens.modulo_equal,
+    "&=": _a.tokens.and_equal,
+    "|=": _a.tokens.or_equal,
+    "^=": _a.tokens.xor_equal,
+    ">>=": _a.tokens.shift_right_equal,
+    "<<=": _a.tokens.shift_left_equal
+  };
+  TokenTypes.regexTokens = {
+    decimal_float_literal: _a.tokens.decimal_float_literal,
+    hex_float_literal: _a.tokens.hex_float_literal,
+    int_literal: _a.tokens.int_literal,
+    uint_literal: _a.tokens.uint_literal,
+    ident: _a.tokens.ident
+  };
   TokenTypes.storage_class = [
     _a.keywords.function,
     _a.keywords.private,
@@ -2878,7 +3108,7 @@ void main() {
     _a.keywords.bitcast,
     ..._a.any_texture_type
   ];
-  TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block];
+  TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block, _a.keywords.diagnostic];
   TokenTypes.assignment_operators = [
     _a.tokens.equal,
     _a.tokens.plus_equal,
@@ -2927,8 +3157,9 @@ void main() {
     scanTokens() {
       while (!this._isAtEnd()) {
         this._start = this._current;
-        if (!this.scanToken())
+        if (!this.scanToken()) {
           throw `Invalid syntax at line ${this._line}`;
+        }
       }
       this._tokens.push(new Token(TokenTypes.eof, "", this._line));
       return this._tokens;
@@ -2946,8 +3177,9 @@ void main() {
       if (lexeme == "/") {
         if (this._peekAhead() == "/") {
           while (lexeme != "\n") {
-            if (this._isAtEnd())
+            if (this._isAtEnd()) {
               return true;
+            }
             lexeme = this._advance();
           }
           this._line++;
@@ -2956,8 +3188,9 @@ void main() {
           this._advance();
           let commentLevel = 1;
           while (commentLevel > 0) {
-            if (this._isAtEnd())
+            if (this._isAtEnd()) {
               return true;
+            }
             lexeme = this._advance();
             if (lexeme == "\n") {
               this._line++;
@@ -2979,7 +3212,32 @@ void main() {
           return true;
         }
       }
+      const simpleToken = TokenTypes.simpleTokens[lexeme];
+      if (simpleToken) {
+        this._addToken(simpleToken);
+        return true;
+      }
       let matchType = TokenTypes.none;
+      const isAlpha = this._isAlpha(lexeme);
+      const isUnderscore = lexeme === "_";
+      if (this._isAlphaNumeric(lexeme)) {
+        let nextChar = this._peekAhead();
+        while (this._isAlphaNumeric(nextChar)) {
+          lexeme += this._advance();
+          nextChar = this._peekAhead();
+        }
+      }
+      if (isAlpha) {
+        const matchedType = TokenTypes.keywords[lexeme];
+        if (matchedType) {
+          this._addToken(matchedType);
+          return true;
+        }
+      }
+      if (isAlpha || isUnderscore) {
+        this._addToken(TokenTypes.tokens.ident);
+        return true;
+      }
       for (; ; ) {
         let matchedType = this._findType(lexeme);
         const nextLexeme = this._peekAhead();
@@ -3012,8 +3270,9 @@ void main() {
             }
           }
           if (matchedType === TokenTypes.none) {
-            if (matchType === TokenTypes.none)
+            if (matchType === TokenTypes.none) {
               return false;
+            }
             this._current--;
             this._addToken(matchType);
             return true;
@@ -3022,45 +3281,43 @@ void main() {
           this._current += lookAhead + 1;
         }
         matchType = matchedType;
-        if (this._isAtEnd())
+        if (this._isAtEnd()) {
           break;
+        }
         lexeme += this._advance();
       }
-      if (matchType === TokenTypes.none)
+      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.regexTokens) {
+        const type2 = TokenTypes.regexTokens[name];
+        if (this._match(lexeme, type2.rule)) {
+          return type2;
         }
       }
-      for (const name in TokenTypes.tokens) {
-        const type = TokenTypes.tokens[name];
-        if (this._match(lexeme, type.rule)) {
-          return type;
-        }
+      const type = TokenTypes.literalTokens[lexeme];
+      if (type) {
+        return type;
       }
       return TokenTypes.none;
     }
     _match(lexeme, rule) {
-      if (typeof rule === "string") {
-        if (rule == lexeme) {
-          return true;
-        }
-      } else {
-        const match = rule.exec(lexeme);
-        if (match && match.index == 0 && match[0] == lexeme)
-          return true;
-      }
-      return false;
+      const match = rule.exec(lexeme);
+      return match && match.index == 0 && match[0] == lexeme;
     }
     _isAtEnd() {
       return this._current >= this._source.length;
     }
+    _isAlpha(c) {
+      return c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+    }
+    _isAlphaNumeric(c) {
+      return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c == "_" || c >= "0" && c <= "9";
+    }
     _isWhitespace(c) {
       return c == " " || c == "	" || c == "\r";
     }
@@ -3073,8 +3330,9 @@ void main() {
     }
     _peekAhead(offset = 0) {
       offset = offset || 0;
-      if (this._current + offset >= this._source.length)
+      if (this._current + offset >= this._source.length) {
         return "\0";
+      }
       return this._source[this._current + offset];
     }
     _addToken(type) {
@@ -3086,17 +3344,40 @@ void main() {
     constructor() {
       this._tokens = [];
       this._current = 0;
+      this._currentLine = 0;
       this._context = new ParseContext();
+      this._deferArrayCountEval = [];
     }
     parse(tokensOrCode) {
       this._initialize(tokensOrCode);
-      let statements = [];
+      this._deferArrayCountEval.length = 0;
+      const statements = [];
       while (!this._isAtEnd()) {
         const statement = this._global_decl_or_directive();
-        if (!statement)
+        if (!statement) {
           break;
+        }
         statements.push(statement);
       }
+      if (this._deferArrayCountEval.length > 0) {
+        for (const arrayDecl of this._deferArrayCountEval) {
+          const arrayType = arrayDecl["arrayType"];
+          const countNode = arrayDecl["countNode"];
+          if (countNode instanceof VariableExpr) {
+            const variable = countNode;
+            const name = variable.name;
+            const constant = this._context.constants.get(name);
+            if (constant) {
+              try {
+                const count = constant.evaluate(this._context);
+                arrayType.count = count;
+              } catch (e) {
+              }
+            }
+          }
+        }
+        this._deferArrayCountEval.length = 0;
+      }
       return statements;
     }
     _initialize(tokensOrCode) {
@@ -3113,7 +3394,6 @@ void main() {
       this._current = 0;
     }
     _error(token, message) {
-      console.error(token, message);
       return {
         token,
         message,
@@ -3143,24 +3423,29 @@ void main() {
       return false;
     }
     _consume(types, message) {
-      if (this._check(types))
+      if (this._check(types)) {
         return this._advance();
+      }
       throw this._error(this._peek(), message);
     }
     _check(types) {
-      if (this._isAtEnd())
+      if (this._isAtEnd()) {
         return false;
+      }
       const tk = this._peek();
       if (types instanceof Array) {
-        let t = tk.type;
-        let index2 = types.indexOf(t);
+        const t = tk.type;
+        const index2 = types.indexOf(t);
         return index2 != -1;
       }
       return tk.type == types;
     }
     _advance() {
-      if (!this._isAtEnd())
+      var _a2, _b;
+      this._currentLine = (_b = (_a2 = this._peek()) === null || _a2 === void 0 ? void 0 : _a2.line) !== null && _b !== void 0 ? _b : -1;
+      if (!this._isAtEnd()) {
         this._current++;
+      }
       return this._previous();
     }
     _peek() {
@@ -3177,6 +3462,16 @@ void main() {
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
         return type;
       }
+      if (this._match(TokenTypes.keywords.diagnostic)) {
+        const directive = this._diagnostic();
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
+        return directive;
+      }
+      if (this._match(TokenTypes.keywords.requires)) {
+        const requires = this._requires_directive();
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
+        return requires;
+      }
       if (this._match(TokenTypes.keywords.enable)) {
         const enable = this._enable_directive();
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
@@ -3185,56 +3480,65 @@ void main() {
       const attrs = this._attribute();
       if (this._check(TokenTypes.keywords.var)) {
         const _var = this._global_variable_decl();
-        if (_var != null)
+        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)
+        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)
+        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)
+        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)
+        if (_struct != null) {
           _struct.attributes = attrs;
+        }
         return _struct;
       }
       if (this._check(TokenTypes.keywords.fn)) {
         const _fn = this._function_decl();
-        if (_fn != null)
+        if (_fn != null) {
           _fn.attributes = attrs;
+        }
         return _fn;
       }
       return null;
     }
     _function_decl() {
-      if (!this._match(TokenTypes.keywords.fn))
+      if (!this._match(TokenTypes.keywords.fn)) {
         return null;
+      }
+      const startLine = this._currentLine;
       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))
+          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.");
@@ -3251,19 +3555,22 @@ void main() {
       if (this._match(TokenTypes.tokens.arrow)) {
         const attrs = this._attribute();
         _return = this._type_decl();
-        if (_return != null)
+        if (_return != null) {
           _return.attributes = attrs;
+        }
       }
       const body = this._compound_statement();
-      return new Function(name, args, _return, body);
+      const endLine = this._currentLine;
+      return new Function(name, args, _return, body, startLine, endLine);
     }
     _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)
+        if (statement !== null) {
           statements.push(statement);
+        }
       }
       this._consume(TokenTypes.tokens.brace_right, "Expected '}' for block.");
       return statements;
@@ -3271,65 +3578,85 @@ void main() {
     _statement() {
       while (this._match(TokenTypes.tokens.semicolon) && !this._isAtEnd())
         ;
-      if (this._check(TokenTypes.keywords.if))
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
+      if (this._check(TokenTypes.keywords.if)) {
         return this._if_statement();
-      if (this._check(TokenTypes.keywords.switch))
+      }
+      if (this._check(TokenTypes.keywords.switch)) {
         return this._switch_statement();
-      if (this._check(TokenTypes.keywords.loop))
+      }
+      if (this._check(TokenTypes.keywords.loop)) {
         return this._loop_statement();
-      if (this._check(TokenTypes.keywords.for))
+      }
+      if (this._check(TokenTypes.keywords.for)) {
         return this._for_statement();
-      if (this._check(TokenTypes.keywords.while))
+      }
+      if (this._check(TokenTypes.keywords.while)) {
         return this._while_statement();
-      if (this._check(TokenTypes.keywords.continuing))
+      }
+      if (this._check(TokenTypes.keywords.continuing)) {
         return this._continuing_statement();
-      if (this._check(TokenTypes.keywords.static_assert))
+      }
+      if (this._check(TokenTypes.keywords.static_assert)) {
         return this._static_assert_statement();
-      if (this._check(TokenTypes.tokens.brace_left))
+      }
+      if (this._check(TokenTypes.tokens.brace_left)) {
         return this._compound_statement();
+      }
       let result = null;
-      if (this._check(TokenTypes.keywords.return))
+      if (this._check(TokenTypes.keywords.return)) {
         result = this._return_statement();
-      else if (this._check([
+      } else if (this._check([
         TokenTypes.keywords.var,
         TokenTypes.keywords.let,
         TokenTypes.keywords.const
-      ]))
+      ])) {
         result = this._variable_statement();
-      else if (this._match(TokenTypes.keywords.discard))
+      } else if (this._match(TokenTypes.keywords.discard)) {
         result = new Discard();
-      else if (this._match(TokenTypes.keywords.break))
+      } else if (this._match(TokenTypes.keywords.break)) {
         result = new Break();
-      else if (this._match(TokenTypes.keywords.continue))
+      } else if (this._match(TokenTypes.keywords.continue)) {
         result = new Continue();
-      else
+      } else {
         result = this._increment_decrement_statement() || this._func_call_statement() || this._assignment_statement();
-      if (result != null)
+      }
+      if (result != null) {
         this._consume(TokenTypes.tokens.semicolon, "Expected ';' after statement.");
+      }
       return result;
     }
     _static_assert_statement() {
-      if (!this._match(TokenTypes.keywords.static_assert))
+      if (!this._match(TokenTypes.keywords.static_assert)) {
         return null;
-      let expression = this._optional_paren_expression();
+      }
+      const expression = this._optional_paren_expression();
       return new StaticAssert(expression);
     }
     _while_statement() {
-      if (!this._match(TokenTypes.keywords.while))
+      if (!this._match(TokenTypes.keywords.while)) {
         return null;
-      let condition = this._optional_paren_expression();
+      }
+      const condition = this._optional_paren_expression();
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       const block = this._compound_statement();
       return new While(condition, block);
     }
     _continuing_statement() {
-      if (!this._match(TokenTypes.keywords.continuing))
+      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))
+      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 ';'.");
@@ -3337,6 +3664,9 @@ void main() {
       this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
       const increment = !this._check(TokenTypes.tokens.paren_right) ? this._for_increment() : null;
       this._consume(TokenTypes.tokens.paren_right, "Expected ')'.");
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       const body = this._compound_statement();
       return new For(init, condition, increment, body);
     }
@@ -3349,11 +3679,13 @@ void main() {
     _variable_statement() {
       if (this._check(TokenTypes.keywords.var)) {
         const _var = this._variable_decl();
-        if (_var === null)
+        if (_var === null) {
           throw this._error(this._peek(), "Variable declaration expected.");
+        }
         let value = null;
-        if (this._match(TokenTypes.tokens.equal))
+        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)) {
@@ -3362,8 +3694,9 @@ void main() {
         if (this._match(TokenTypes.tokens.colon)) {
           const typeAttrs = this._attribute();
           type = this._type_decl();
-          if (type != null)
+          if (type != null) {
             type.attributes = typeAttrs;
+          }
         }
         this._consume(TokenTypes.tokens.equal, "Expected '=' for let.");
         const value = this._short_circuit_or_expression();
@@ -3375,8 +3708,9 @@ void main() {
         if (this._match(TokenTypes.tokens.colon)) {
           const typeAttrs = this._attribute();
           type = this._type_decl();
-          if (type != null)
+          if (type != null) {
             type.attributes = typeAttrs;
+          }
         }
         this._consume(TokenTypes.tokens.equal, "Expected '=' for const.");
         const value = this._short_circuit_or_expression();
@@ -3387,8 +3721,9 @@ void main() {
     _increment_decrement_statement() {
       const savedPos = this._current;
       const _var = this._unary_expression();
-      if (_var == null)
+      if (_var == null) {
         return null;
+      }
       if (!this._check(TokenTypes.increment_operators)) {
         this._current = savedPos;
         return null;
@@ -3398,20 +3733,24 @@ void main() {
     }
     _assignment_statement() {
       let _var = null;
-      if (this._check(TokenTypes.tokens.brace_right))
+      if (this._check(TokenTypes.tokens.brace_right)) {
         return null;
+      }
       let isUnderscore = this._match(TokenTypes.tokens.underscore);
-      if (!isUnderscore)
+      if (!isUnderscore) {
         _var = this._unary_expression();
-      if (!isUnderscore && _var == null)
+      }
+      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))
+      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();
@@ -3422,8 +3761,12 @@ void main() {
       return new Call(name.lexeme, args);
     }
     _loop_statement() {
-      if (!this._match(TokenTypes.keywords.loop))
+      if (!this._match(TokenTypes.keywords.loop)) {
         return null;
+      }
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for loop.");
       const statements = [];
       let statement = this._statement();
@@ -3438,19 +3781,25 @@ void main() {
         statement = this._statement();
       }
       let continuing = null;
-      if (this._match(TokenTypes.keywords.continuing))
+      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))
+      if (!this._match(TokenTypes.keywords.switch)) {
         return null;
+      }
       const condition = this._optional_paren_expression();
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for switch.");
       const body = this._switch_body();
-      if (body == null || body.length == 0)
+      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);
     }
@@ -3459,6 +3808,9 @@ void main() {
       if (this._match(TokenTypes.keywords.case)) {
         const selector = this._case_selectors();
         this._match(TokenTypes.tokens.colon);
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         this._consume(TokenTypes.tokens.brace_left, "Exected '{' for switch case.");
         const body = this._case_body();
         this._consume(TokenTypes.tokens.brace_right, "Exected '}' for switch case.");
@@ -3466,6 +3818,9 @@ void main() {
       }
       if (this._match(TokenTypes.keywords.default)) {
         this._match(TokenTypes.tokens.colon);
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         this._consume(TokenTypes.tokens.brace_left, "Exected '{' for switch default.");
         const body = this._case_body();
         this._consume(TokenTypes.tokens.brace_right, "Exected '}' for switch default.");
@@ -3478,12 +3833,12 @@ void main() {
       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 : ""
+        this._shift_expression()
+        //?.evaluate(this._context).toString() ?? "",
       ];
       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 : "");
+        selectors.push(this._shift_expression());
       }
       return selectors;
     }
@@ -3493,28 +3848,41 @@ void main() {
         return [];
       }
       let statement = this._statement();
-      if (statement == null)
+      if (statement == null) {
         return [];
+      }
       if (!(statement instanceof Array)) {
         statement = [statement];
       }
       const nextStatement = this._case_body();
-      if (nextStatement.length == 0)
+      if (nextStatement.length == 0) {
         return statement;
+      }
       return [...statement, nextStatement[0]];
     }
     _if_statement() {
-      if (!this._match(TokenTypes.keywords.if))
+      if (!this._match(TokenTypes.keywords.if)) {
         return null;
+      }
       const condition = this._optional_paren_expression();
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       const block = this._compound_statement();
       let elseif = [];
       if (this._match_elseif()) {
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         elseif = this._elseif_statement(elseif);
       }
       let _else = null;
-      if (this._match(TokenTypes.keywords.else))
+      if (this._match(TokenTypes.keywords.else)) {
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         _else = this._compound_statement();
+      }
       return new If(condition, block, elseif, _else);
     }
     _match_elseif() {
@@ -3530,13 +3898,17 @@ void main() {
       const block = this._compound_statement();
       elseif.push(new ElseIf(condition, block));
       if (this._match_elseif()) {
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         this._elseif_statement(elseif);
       }
       return elseif;
     }
     _return_statement() {
-      if (!this._match(TokenTypes.keywords.return))
+      if (!this._match(TokenTypes.keywords.return)) {
         return null;
+      }
       const value = this._short_circuit_or_expression();
       return new Return(value);
     }
@@ -3634,25 +4006,29 @@ void main() {
     _singular_expression() {
       const expr = this._primary_expression();
       const p = this._postfix_expression();
-      if (p)
+      if (p) {
         expr.postfix = p;
+      }
       return expr;
     }
     _postfix_expression() {
       if (this._match(TokenTypes.tokens.bracket_left)) {
         const expr = this._short_circuit_or_expression();
         this._consume(TokenTypes.tokens.bracket_right, "Expected ']'.");
+        const arrayIndex = new ArrayIndex(expr);
         const p = this._postfix_expression();
-        if (p)
-          expr.postfix = p;
-        return expr;
+        if (p) {
+          arrayIndex.postfix = p;
+        }
+        return arrayIndex;
       }
       if (this._match(TokenTypes.tokens.period)) {
         const name = this._consume(TokenTypes.tokens.ident, "Expected member name.");
         const p = this._postfix_expression();
         const expr = new StringExpr(name.lexeme);
-        if (p)
+        if (p) {
           expr.postfix = p;
+        }
         return expr;
       }
       return null;
@@ -3703,12 +4079,14 @@ void main() {
       return new TypecastExpr(type, args);
     }
     _argument_expression_list() {
-      if (!this._match(TokenTypes.tokens.paren_left))
+      if (!this._match(TokenTypes.tokens.paren_left)) {
         return null;
+      }
       const args = [];
       do {
-        if (this._check(TokenTypes.tokens.paren_right))
+        if (this._check(TokenTypes.tokens.paren_right)) {
           break;
+        }
         const arg = this._short_circuit_or_expression();
         args.push(arg);
       } while (this._match(TokenTypes.tokens.comma));
@@ -3728,8 +4106,10 @@ void main() {
       return new GroupingExpr([expr]);
     }
     _struct_decl() {
-      if (!this._match(TokenTypes.keywords.struct))
+      if (!this._match(TokenTypes.keywords.struct)) {
         return null;
+      }
+      const startLine = this._currentLine;
       const name = this._consume(TokenTypes.tokens.ident, "Expected name for struct.").toString();
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for struct body.");
       const members = [];
@@ -3739,8 +4119,9 @@ void main() {
         this._consume(TokenTypes.tokens.colon, "Expected ':' for struct member type.");
         const typeAttrs = this._attribute();
         const memberType = this._type_decl();
-        if (memberType != null)
+        if (memberType != null) {
           memberType.attributes = typeAttrs;
+        }
         if (!this._check(TokenTypes.tokens.brace_right))
           this._consume(TokenTypes.tokens.comma, "Expected ',' for struct member.");
         else
@@ -3748,32 +4129,37 @@ void main() {
         members.push(new Member(memberName, memberType, memberAttrs));
       }
       this._consume(TokenTypes.tokens.brace_right, "Expected '}' after struct body.");
-      const structNode = new Struct(name, members);
+      const endLine = this._currentLine;
+      const structNode = new Struct(name, members, startLine, endLine);
       this._context.structs.set(name, structNode);
       return structNode;
     }
     _global_variable_decl() {
       const _var = this._variable_decl();
-      if (_var && this._match(TokenTypes.tokens.equal))
+      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))
+      if (_override && this._match(TokenTypes.tokens.equal)) {
         _override.value = this._const_expression();
+      }
       return _override;
     }
     _global_const_decl() {
-      if (!this._match(TokenTypes.keywords.const))
+      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)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       let value = null;
       if (this._match(TokenTypes.tokens.equal)) {
@@ -3796,15 +4182,17 @@ void main() {
       return c;
     }
     _global_let_decl() {
-      if (!this._match(TokenTypes.keywords.let))
+      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)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       let value = null;
       if (this._match(TokenTypes.tokens.equal)) {
@@ -3813,23 +4201,26 @@ void main() {
       return new Let(name.toString(), type, "", "", value);
     }
     _const_expression() {
-      if (this._match(TokenTypes.const_literal))
+      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))
+        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))
+      if (!this._match(TokenTypes.keywords.var)) {
         return null;
+      }
       let storage = "";
       let access = "";
       if (this._match(TokenTypes.tokens.less_than)) {
@@ -3843,28 +4234,47 @@ void main() {
       if (this._match(TokenTypes.tokens.colon)) {
         const attrs = this._attribute();
         type = this._type_decl();
-        if (type != null)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       return new Var(name.toString(), type, storage, access, null);
     }
     _override_decl() {
-      if (!this._match(TokenTypes.keywords.override))
+      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)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       return new Override(name.toString(), type, null);
     }
+    _diagnostic() {
+      this._consume(TokenTypes.tokens.paren_left, "Expected '('");
+      const severity = this._consume(TokenTypes.tokens.ident, "Expected severity control name.");
+      this._consume(TokenTypes.tokens.comma, "Expected ','");
+      const rule = this._consume(TokenTypes.tokens.ident, "Expected diagnostic rule name.");
+      this._consume(TokenTypes.tokens.paren_right, "Expected ')'");
+      return new Diagnostic(severity.toString(), rule.toString());
+    }
     _enable_directive() {
       const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
       return new Enable(name.toString());
     }
+    _requires_directive() {
+      const extensions = [this._consume(TokenTypes.tokens.ident, "identity expected.").toString()];
+      while (this._match(TokenTypes.tokens.comma)) {
+        const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
+        extensions.push(name.toString());
+      }
+      return new Requires(extensions);
+    }
     _type_alias() {
       const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
       this._consume(TokenTypes.tokens.equal, "Expected '=' for type alias.");
@@ -3899,8 +4309,9 @@ void main() {
         return new Type(type2.toString());
       }
       let type = this._texture_sampler_types();
-      if (type)
+      if (type) {
         return type;
+      }
       if (this._check(TokenTypes.template_types)) {
         let type2 = this._advance().toString();
         let format = null;
@@ -3908,8 +4319,9 @@ void main() {
         if (this._match(TokenTypes.tokens.less_than)) {
           format = this._type_decl();
           access = null;
-          if (this._match(TokenTypes.tokens.comma))
+          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);
@@ -3921,8 +4333,9 @@ void main() {
         this._consume(TokenTypes.tokens.comma, "Expected ',' for pointer.");
         const decl = this._type_decl();
         let access = null;
-        if (this._match(TokenTypes.tokens.comma))
+        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);
       }
@@ -3931,6 +4344,7 @@ void main() {
         let format = null;
         let countInt = -1;
         const array = this._previous();
+        let countNode = null;
         if (this._match(TokenTypes.tokens.less_than)) {
           format = this._type_decl();
           if (this._context.aliases.has(format.name)) {
@@ -3938,21 +4352,32 @@ void main() {
           }
           let count = "";
           if (this._match(TokenTypes.tokens.comma)) {
-            let c = this._shift_expression();
-            count = c.evaluate(this._context).toString();
+            countNode = this._shift_expression();
+            try {
+              count = countNode.evaluate(this._context).toString();
+              countNode = null;
+            } catch (e) {
+              count = "1";
+            }
           }
           this._consume(TokenTypes.tokens.greater_than, "Expected '>' for array.");
           countInt = count ? parseInt(count) : 0;
         }
-        return new ArrayType(array.toString(), attrs, format, countInt);
+        const arrayType = new ArrayType(array.toString(), attrs, format, countInt);
+        if (countNode) {
+          this._deferArrayCountEval.push({ arrayType, countNode });
+        }
+        return arrayType;
       }
       return null;
     }
     _texture_sampler_types() {
-      if (this._match(TokenTypes.sampler_type))
+      if (this._match(TokenTypes.sampler_type)) {
         return new SamplerType(this._previous().toString(), null, null);
-      if (this._match(TokenTypes.depth_texture_type))
+      }
+      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.");
@@ -3992,31 +4417,9 @@ void main() {
         }
         attributes.push(attr);
       }
-      while (this._match(TokenTypes.tokens.attr_left)) {
-        if (!this._check(TokenTypes.tokens.attr_right)) {
-          do {
-            const name = this._consume(TokenTypes.attribute_name, "Expected attribute name");
-            const attr = new Attribute(name.toString(), null);
-            if (this._match(TokenTypes.tokens.paren_left)) {
-              attr.value = [
-                this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString()
-              ];
-              if (this._check(TokenTypes.tokens.comma)) {
-                this._advance();
-                do {
-                  const v = this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString();
-                  attr.value.push(v);
-                } while (this._match(TokenTypes.tokens.comma));
-              }
-              this._consume(TokenTypes.tokens.paren_right, "Expected ')'");
-            }
-            attributes.push(attr);
-          } while (this._match(TokenTypes.tokens.comma));
-        }
-        this._consume(TokenTypes.tokens.attr_right, "Expected ']]' after attribute declarations");
-      }
-      if (attributes.length == 0)
+      if (attributes.length == 0) {
         return null;
+      }
       return attributes;
     }
   };
@@ -4074,6 +4477,9 @@ void main() {
       super(name, attributes);
       this.members = [];
       this.align = 0;
+      this.startLine = -1;
+      this.endLine = -1;
+      this.inUse = false;
     }
     get isStruct() {
       return true;
@@ -4179,6 +4585,11 @@ void main() {
       this.stage = null;
       this.inputs = [];
       this.outputs = [];
+      this.resources = [];
+      this.startLine = -1;
+      this.endLine = -1;
+      this.inUse = false;
+      this.calls = /* @__PURE__ */ new Set();
       this.name = name;
       this.stage = stage;
     }
@@ -4198,6 +4609,14 @@ void main() {
       this.id = id;
     }
   };
+  var _FunctionResources = class {
+    constructor(node) {
+      this.resources = null;
+      this.inUse = false;
+      this.info = null;
+      this.node = node;
+    }
+  };
   var WgslReflect = class {
     constructor(code) {
       this.uniforms = [];
@@ -4208,7 +4627,9 @@ void main() {
       this.overrides = [];
       this.structs = [];
       this.entry = new EntryFunctions();
+      this.functions = [];
       this._types = /* @__PURE__ */ new Map();
+      this._functions = /* @__PURE__ */ new Map();
       if (code) {
         this.update(code);
       }
@@ -4219,14 +4640,20 @@ void main() {
     update(code) {
       const parser = new WgslParser();
       const ast = parser.parse(code);
+      for (const node of ast) {
+        if (node instanceof Function) {
+          this._functions.set(node.name, new _FunctionResources(node));
+        }
+      }
       for (const node of ast) {
         if (node instanceof Struct) {
           const info = this._getTypeInfo(node, null);
           if (info instanceof StructInfo) {
             this.structs.push(info);
           }
-          continue;
         }
+      }
+      for (const node of ast) {
         if (node instanceof Alias) {
           this.aliases.push(this._getAliasInfo(node));
           continue;
@@ -4285,8 +4712,15 @@ void main() {
           const fragmentStage = this._getAttribute(node, "fragment");
           const computeStage = this._getAttribute(node, "compute");
           const stage = vertexStage || fragmentStage || computeStage;
+          const fn = new FunctionInfo(node.name, stage === null || stage === void 0 ? void 0 : stage.name);
+          fn.startLine = node.startLine;
+          fn.endLine = node.endLine;
+          this.functions.push(fn);
+          this._functions.get(node.name).info = fn;
           if (stage) {
-            const fn = new FunctionInfo(node.name, stage.name);
+            this._functions.get(node.name).inUse = true;
+            fn.inUse = true;
+            fn.resources = this._findResources(node, !!stage);
             fn.inputs = this._getInputs(node.args);
             fn.outputs = this._getOutputs(node.returnType);
             this.entry[stage.name].push(fn);
@@ -4294,16 +4728,180 @@ void main() {
           continue;
         }
       }
+      for (const fn of this._functions.values()) {
+        if (fn.info) {
+          fn.info.inUse = fn.inUse;
+          this._addCalls(fn.node, fn.info.calls);
+        }
+      }
+      for (const u of this.uniforms) {
+        this._markStructsInUse(u.type);
+      }
+      for (const s of this.storage) {
+        this._markStructsInUse(s.type);
+      }
+    }
+    _markStructsInUse(type) {
+      if (type.isStruct) {
+        type.inUse = true;
+        for (const m of type.members) {
+          this._markStructsInUse(m.type);
+        }
+      } else if (type.isArray) {
+        this._markStructsInUse(type.format);
+      } else if (type.isTemplate) {
+        this._markStructsInUse(type.format);
+      } else {
+        const alias = this._getAlias(type.name);
+        if (alias) {
+          this._markStructsInUse(alias);
+        }
+      }
+    }
+    _addCalls(fn, calls) {
+      var _a2;
+      for (const call of fn.calls) {
+        const info = (_a2 = this._functions.get(call.name)) === null || _a2 === void 0 ? void 0 : _a2.info;
+        if (info) {
+          calls.add(info);
+        }
+      }
+    }
+    /// Find a resource by its group and binding.
+    findResource(group, binding) {
+      for (const u of this.uniforms) {
+        if (u.group == group && u.binding == binding) {
+          return u;
+        }
+      }
+      for (const s of this.storage) {
+        if (s.group == group && s.binding == binding) {
+          return s;
+        }
+      }
+      for (const t of this.textures) {
+        if (t.group == group && t.binding == binding) {
+          return t;
+        }
+      }
+      for (const s of this.samplers) {
+        if (s.group == group && s.binding == binding) {
+          return s;
+        }
+      }
+      return null;
+    }
+    _findResource(name) {
+      for (const u of this.uniforms) {
+        if (u.name == name) {
+          return u;
+        }
+      }
+      for (const s of this.storage) {
+        if (s.name == name) {
+          return s;
+        }
+      }
+      for (const t of this.textures) {
+        if (t.name == name) {
+          return t;
+        }
+      }
+      for (const s of this.samplers) {
+        if (s.name == name) {
+          return s;
+        }
+      }
+      return null;
+    }
+    _markStructsFromAST(type) {
+      const info = this._getTypeInfo(type, null);
+      this._markStructsInUse(info);
+    }
+    _findResources(fn, isEntry) {
+      const resources = [];
+      const self = this;
+      const varStack = [];
+      fn.search((node) => {
+        if (node instanceof _BlockStart) {
+          varStack.push({});
+        } else if (node instanceof _BlockEnd) {
+          varStack.pop();
+        } else if (node instanceof Var) {
+          const v = node;
+          if (isEntry && v.type !== null) {
+            this._markStructsFromAST(v.type);
+          }
+          if (varStack.length > 0) {
+            varStack[varStack.length - 1][v.name] = v;
+          }
+        } else if (node instanceof CreateExpr) {
+          const c = node;
+          if (isEntry && c.type !== null) {
+            this._markStructsFromAST(c.type);
+          }
+        } else if (node instanceof Let) {
+          const v = node;
+          if (isEntry && v.type !== null) {
+            this._markStructsFromAST(v.type);
+          }
+          if (varStack.length > 0) {
+            varStack[varStack.length - 1][v.name] = v;
+          }
+        } else if (node instanceof VariableExpr) {
+          const v = node;
+          if (varStack.length > 0) {
+            const varInfo2 = varStack[varStack.length - 1][v.name];
+            if (varInfo2) {
+              return;
+            }
+          }
+          const varInfo = self._findResource(v.name);
+          if (varInfo) {
+            resources.push(varInfo);
+          }
+        } else if (node instanceof CallExpr) {
+          const c = node;
+          const callFn = self._functions.get(c.name);
+          if (callFn) {
+            if (isEntry) {
+              callFn.inUse = true;
+            }
+            fn.calls.add(callFn.node);
+            if (callFn.resources === null) {
+              callFn.resources = self._findResources(callFn.node, isEntry);
+            }
+            resources.push(...callFn.resources);
+          }
+        } else if (node instanceof Call) {
+          const c = node;
+          const callFn = self._functions.get(c.name);
+          if (callFn) {
+            if (isEntry) {
+              callFn.inUse = true;
+            }
+            fn.calls.add(callFn.node);
+            if (callFn.resources === null) {
+              callFn.resources = self._findResources(callFn.node, isEntry);
+            }
+            resources.push(...callFn.resources);
+          }
+        }
+      });
+      return [...new Map(resources.map((r) => [r.name, r])).values()];
     }
     getBindGroups() {
       const groups = [];
       function _makeRoom(group, binding) {
-        if (group >= groups.length)
+        if (group >= groups.length) {
           groups.length = group + 1;
-        if (groups[group] === void 0)
+        }
+        if (groups[group] === void 0) {
           groups[group] = [];
-        if (binding >= groups[group].length)
+        }
+        if (binding >= groups[group].length) {
           groups[group].length = binding + 1;
+        }
       }
       for (const u of this.uniforms) {
         _makeRoom(u.group, u.binding);
@@ -4328,14 +4926,16 @@ void main() {
       return groups;
     }
     _getOutputs(type, outputs = void 0) {
-      if (outputs === void 0)
+      if (outputs === void 0) {
         outputs = [];
+      }
       if (type instanceof Struct) {
         this._getStructOutputs(type, outputs);
       } else {
         const output = this._getOutputInfo(type);
-        if (output !== null)
+        if (output !== null) {
           outputs.push(output);
+        }
       }
       return outputs;
     }
@@ -4365,15 +4965,17 @@ void main() {
       return null;
     }
     _getInputs(args, inputs = void 0) {
-      if (inputs === void 0)
+      if (inputs === void 0) {
         inputs = [];
+      }
       for (const arg of args) {
         if (arg.type instanceof Struct) {
           this._getStructInputs(arg.type, inputs);
         } else {
           const input = this._getInputInfo(arg);
-          if (input !== null)
+          if (input !== null) {
             inputs.push(input);
+          }
         }
       }
       return inputs;
@@ -4384,8 +4986,9 @@ void main() {
           this._getStructInputs(m.type, inputs);
         } else {
           const input = this._getInputInfo(m);
-          if (input !== null)
+          if (input !== null) {
             inputs.push(input);
+          }
         }
       }
     }
@@ -4418,8 +5021,9 @@ void main() {
     }
     _getAlias(name) {
       for (const a of this.aliases) {
-        if (a.name == name)
+        if (a.name == name) {
           return a.type;
+        }
       }
       return null;
     }
@@ -4443,6 +5047,8 @@ void main() {
       if (type instanceof Struct) {
         const s = type;
         const info2 = new StructInfo(s.name, attributes);
+        info2.startLine = s.startLine;
+        info2.endLine = s.endLine;
         for (const m of s.members) {
           const t = this._getTypeInfo(m.type, m.attributes);
           info2.members.push(new MemberInfo(m.name, t, m.attributes));
@@ -4495,8 +5101,9 @@ void main() {
       for (let mi = 0, ml = struct.members.length; mi < ml; ++mi) {
         const member = struct.members[mi];
         const sizeInfo = this._getTypeSize(member);
-        if (!sizeInfo)
+        if (!sizeInfo) {
           continue;
+        }
         (_a2 = this._getAlias(member.type.name)) !== null && _a2 !== void 0 ? _a2 : member.type;
         const align = sizeInfo.align;
         const size = sizeInfo.size;
@@ -4513,12 +5120,14 @@ void main() {
     }
     _getTypeSize(type) {
       var _a2;
-      if (type === null || type === void 0)
+      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)
+      if (type instanceof MemberInfo) {
         type = type.type;
+      }
       if (type instanceof TypeInfo) {
         const alias = this._getAlias(type.name);
         if (alias !== null) {
@@ -4551,8 +5160,9 @@ void main() {
         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)
+        if (explicitSize) {
           size = explicitSize;
+        }
         return new _TypeSize(Math.max(explicitAlign, align), Math.max(explicitSize, size));
       }
       if (type instanceof StructInfo) {
@@ -4589,18 +5199,21 @@ void main() {
     }
     _getAttribute(node, name) {
       const obj = node;
-      if (!obj || !obj["attributes"])
+      if (!obj || !obj["attributes"]) {
         return null;
+      }
       const attrs = obj["attributes"];
       for (let a of attrs) {
-        if (a.name == name)
+        if (a.name == name) {
           return a;
+        }
       }
       return null;
     }
     _getAttributeNum(attributes, name, defaultValue) {
-      if (attributes === null)
+      if (attributes === null) {
         return defaultValue;
+      }
       for (let a of attributes) {
         if (a.name == name) {
           let v = a !== null && a.value !== null ? a.value : defaultValue;
@@ -4660,10 +5273,10 @@ void main() {
     }
     for (const uniform of parsedWGSL.uniforms) {
       const members = [];
-      for (const member of uniform.type.members) {
+      for (const attribute of uniform.type?.members || []) {
         members.push({
-          name: member.name,
-          type: getType(member.type)
+          name: attribute.name,
+          type: getType(attribute.type)
         });
       }
       shaderLayout.bindings.push({
@@ -4683,7 +5296,7 @@ void main() {
         const type = getType(wgslAttribute.type);
         shaderLayout.attributes.push({
           name: wgslAttribute.name,
-          location: wgslAttribute.location,
+          location: Number(wgslAttribute.location),
           type
         });
       }
@@ -4723,17 +5336,11 @@ void main() {
     printRowMajor: true,
     _cartographicRadians: false
   };
-  globalThis.mathgl = globalThis.mathgl || {
-    config: {
-      ...DEFAULT_CONFIG
-    }
-  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
   var config = globalThis.mathgl.config;
-  function formatValue(value, {
-    precision = config.precision
-  } = {}) {
+  function formatValue(value, { precision = config.precision } = {}) {
     value = round(value);
-    return "".concat(parseFloat(value.toPrecision(precision)));
+    return `${parseFloat(value.toPrecision(precision))}`;
   }
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
@@ -4777,28 +5384,12 @@ void main() {
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  function _extendableBuiltin(cls) {
-    function ExtendableBuiltin() {
-      var instance = Reflect.construct(cls, Array.from(arguments));
-      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-      return instance;
-    }
-    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-      constructor: {
-        value: cls,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(ExtendableBuiltin, cls);
-    } else {
-      ExtendableBuiltin.__proto__ = cls;
-    }
-    return ExtendableBuiltin;
-  }
-  var MathArray = class extends _extendableBuiltin(Array) {
+  var MathArray = class extends Array {
+    // Common methods
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
     clone() {
       return new this.constructor().copy(this);
     }
@@ -4818,7 +5409,10 @@ void main() {
       return targetObject;
     }
     from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
+        // @ts-ignore
+        this.fromObject(arrayOrObject)
+      );
     }
     to(arrayOrObject) {
       if (arrayOrObject === this) {
@@ -4829,18 +5423,20 @@ void main() {
     toTarget(target) {
       return target ? this.to(target) : this;
     }
+    /** @deprecated */
     toFloat32Array() {
       return new Float32Array(this);
     }
     toString() {
       return this.formatString(config);
     }
+    /** Formats string according to options */
     formatString(opts) {
       let string = "";
       for (let i = 0; i < this.ELEMENTS; ++i) {
         string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
       }
-      return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
+      return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
     }
     equals(array) {
       if (!array || this.length !== array.length) {
@@ -4864,6 +5460,8 @@ void main() {
       }
       return true;
     }
+    // Modifiers
+    /** Negates all values in this object */
     negate() {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = -this[i];
@@ -4881,12 +5479,14 @@ void main() {
       }
       return this.check();
     }
+    /** Minimal */
     min(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(vector[i], this[i]);
       }
       return this.check();
     }
+    /** Maximal */
     max(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.max(vector[i], this[i]);
@@ -4927,18 +5527,25 @@ void main() {
       }
       return this.check();
     }
+    /**
+     * Multiplies all elements by `scale`
+     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+     */
     multiplyByScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
+    // Debug checks
+    /** Throws an error if array length is incorrect or contains illegal values */
     check() {
       if (config.debug && !this.validate()) {
-        throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
+        throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
       }
       return this;
     }
+    /** Returns false if the array length is incorrect or contains illegal values */
     validate() {
       let valid = this.length === this.ELEMENTS;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -4946,39 +5553,48 @@ void main() {
       }
       return valid;
     }
+    // three.js compatibility
+    /** @deprecated */
     sub(a) {
       return this.subtract(a);
     }
+    /** @deprecated */
     setScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = a;
       }
       return this.check();
     }
+    /** @deprecated */
     addScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] += a;
       }
       return this.check();
     }
+    /** @deprecated */
     subScalar(a) {
       return this.addScalar(-a);
     }
+    /** @deprecated */
     multiplyScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
+    /** @deprecated */
     divideScalar(a) {
       return this.multiplyByScalar(1 / a);
     }
+    /** @deprecated */
     clampScalar(min, max) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(Math.max(this[i], min), max);
       }
       return this.check();
     }
+    /** @deprecated */
     get elements() {
       return this;
     }
@@ -4998,13 +5614,13 @@ void main() {
   }
   function checkNumber(value) {
     if (!Number.isFinite(value)) {
-      throw new Error("Invalid number ".concat(JSON.stringify(value)));
+      throw new Error(`Invalid number ${JSON.stringify(value)}`);
     }
     return value;
   }
   function checkVector(v, length, callerName = "") {
     if (config.debug && !validateVector(v, length)) {
-      throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
+      throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
     }
     return v;
   }
@@ -5012,12 +5628,13 @@ void main() {
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
   function assert2(condition, message) {
     if (!condition) {
-      throw new Error("math.gl assertion ".concat(message));
+      throw new Error(`math.gl assertion ${message}`);
     }
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/vector.js
   var Vector = class extends MathArray {
+    // ACCESSORS
     get x() {
       return this[0];
     }
@@ -5030,12 +5647,24 @@ void main() {
     set y(value) {
       this[1] = checkNumber(value);
     }
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     *
+     * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
+     * Instead we provide `len` and `magnitude`
+     */
     len() {
       return Math.sqrt(this.lengthSquared());
     }
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     */
     magnitude() {
       return this.len();
     }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
     lengthSquared() {
       let length = 0;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -5043,6 +5672,9 @@ void main() {
       }
       return length;
     }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
     magnitudeSquared() {
       return this.lengthSquared();
     }
@@ -5064,6 +5696,7 @@ void main() {
       }
       return checkNumber(product);
     }
+    // MODIFIERS
     normalize() {
       const length = this.magnitude();
       if (length !== 0) {
@@ -5089,6 +5722,7 @@ void main() {
       }
       return this.check();
     }
+    // THREE.js compatibility
     lengthSq() {
       return this.lengthSquared();
     }
@@ -5361,6 +5995,12 @@ void main() {
       }
       return ZERO;
     }
+    /**
+     * @class
+     * @param x
+     * @param y
+     * @param z
+     */
     constructor(x = 0, y = 0, z = 0) {
       super(-0, -0, -0);
       if (arguments.length === 1 && isArray(x)) {
@@ -5405,6 +6045,7 @@ void main() {
       object.z = this[2];
       return object;
     }
+    // Getters/setters
     get ELEMENTS() {
       return 3;
     }
@@ -5414,41 +6055,38 @@ void main() {
     set z(value) {
       this[2] = checkNumber(value);
     }
+    // ACCESSORS
     angle(vector) {
       return angle(this, vector);
     }
+    // MODIFIERS
     cross(vector) {
       cross(this, this, vector);
       return this.check();
     }
-    rotateX({
-      radians,
-      origin = ORIGIN
-    }) {
+    rotateX({ radians, origin = ORIGIN }) {
       rotateX(this, this, origin, radians);
       return this.check();
     }
-    rotateY({
-      radians,
-      origin = ORIGIN
-    }) {
+    rotateY({ radians, origin = ORIGIN }) {
       rotateY(this, this, origin, radians);
       return this.check();
     }
-    rotateZ({
-      radians,
-      origin = ORIGIN
-    }) {
+    rotateZ({ radians, origin = ORIGIN }) {
       rotateZ(this, this, origin, radians);
       return this.check();
     }
+    // Transforms
+    // transforms as point (4th component is implicitly 1)
     transform(matrix4) {
       return this.transformAsPoint(matrix4);
     }
+    // transforms as point (4th component is implicitly 1)
     transformAsPoint(matrix4) {
       transformMat42(this, this, matrix4);
       return this.check();
     }
+    // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)
     transformAsVector(matrix4) {
       vec3_transformMat4AsVector(this, this, matrix4);
       return this.check();
@@ -5469,19 +6107,29 @@ void main() {
 
   // ../../node_modules/@math.gl/core/dist/classes/base/matrix.js
   var Matrix = class extends MathArray {
+    // fromObject(object) {
+    //   const array = object.elements;
+    //   return this.fromRowMajor(array);
+    // }
+    // toObject(object) {
+    //   const array = object.elements;
+    //   this.toRowMajor(array);
+    //   return object;
+    // }
+    // TODO better override formatString?
     toString() {
       let string = "[";
       if (config.printRowMajor) {
         string += "row-major:";
         for (let row = 0; row < this.RANK; ++row) {
           for (let col = 0; col < this.RANK; ++col) {
-            string += " ".concat(this[col * this.RANK + row]);
+            string += ` ${this[col * this.RANK + row]}`;
           }
         }
       } else {
         string += "column-major:";
         for (let i = 0; i < this.ELEMENTS; ++i) {
-          string += " ".concat(this[i]);
+          string += ` ${this[i]}`;
         }
       }
       string += "]";
@@ -5490,9 +6138,11 @@ void main() {
     getElementIndex(row, col) {
       return col * this.RANK + row;
     }
+    // By default assumes row major indices
     getElement(row, col) {
       return this[col * this.RANK + row];
     }
+    // By default assumes row major indices
     setElement(row, col, value) {
       this[col * this.RANK + row] = checkNumber(value);
       return this;
@@ -6258,6 +6908,7 @@ void main() {
       this[15] = array[15];
       return this.check();
     }
+    // eslint-disable-next-line max-params
     set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {
       this[0] = m00;
       this[1] = m10;
@@ -6277,6 +6928,8 @@ void main() {
       this[15] = m33;
       return this.check();
     }
+    // accepts row major order, stores as column major
+    // eslint-disable-next-line max-params
     setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
       this[0] = m00;
       this[1] = m10;
@@ -6315,25 +6968,41 @@ void main() {
       result[15] = this[15];
       return result;
     }
+    // Constructors
+    /** Set to identity matrix */
     identity() {
       return this.copy(IDENTITY_MATRIX);
     }
+    /**
+     *
+     * @param object
+     * @returns self
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     fromObject(object) {
       return this.check();
     }
+    /**
+     * Calculates a 4x4 matrix from the given quaternion
+     * @param quaternion Quaternion to create matrix from
+     * @returns self
+     */
     fromQuaternion(quaternion) {
       fromQuat(this, quaternion);
       return this.check();
     }
+    /**
+     * Generates a frustum matrix with the given bounds
+     * @param view.left - Left bound of the frustum
+     * @param view.right - Right bound of the frustum
+     * @param view.bottom - Bottom bound of the frustum
+     * @param view.top - Top bound of the frustum
+     * @param view.near - Near bound of the frustum
+     * @param view.far - Far bound of the frustum. Can be set to Infinity.
+     * @returns self
+     */
     frustum(view) {
-      const {
-        left,
-        right,
-        bottom,
-        top,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       if (far === Infinity) {
         computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
       } else {
@@ -6341,35 +7010,47 @@ void main() {
       }
       return this.check();
     }
+    /**
+     * Generates a look-at matrix with the given eye position, focal point,
+     * and up axis
+     * @param view.eye - (vector) Position of the viewer
+     * @param view.center - (vector) Point the viewer is looking at
+     * @param view.up - (vector) Up axis
+     * @returns self
+     */
     lookAt(view) {
-      const {
-        eye,
-        center = [0, 0, 0],
-        up = [0, 1, 0]
-      } = view;
+      const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
       lookAt(this, eye, center, up);
       return this.check();
     }
+    /**
+     * Generates a orthogonal projection matrix with the given bounds
+     * from "traditional" view space parameters
+     * @param view.left - Left bound of the frustum
+     * @param view.right number  Right bound of the frustum
+     * @param view.bottom - Bottom bound of the frustum
+     * @param view.top number  Top bound of the frustum
+     * @param view.near - Near bound of the frustum
+     * @param view.far number  Far bound of the frustum
+     * @returns self
+     */
     ortho(view) {
-      const {
-        left,
-        right,
-        bottom,
-        top,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       ortho(this, left, right, bottom, top, near, far);
       return this.check();
     }
+    /**
+     * Generates an orthogonal projection matrix with the same parameters
+     * as a perspective matrix (plus focalDistance)
+     * @param view.fovy Vertical field of view in radians
+     * @param view.aspect Aspect ratio. Typically viewport width / viewport height
+     * @param view.focalDistance Distance in the view frustum used for extent calculations
+     * @param view.near Near bound of the frustum
+     * @param view.far Far bound of the frustum
+     * @returns self
+     */
     orthographic(view) {
-      const {
-        fovy = DEFAULT_FOVY,
-        aspect = DEFAULT_ASPECT,
-        focalDistance = 1,
-        near = DEFAULT_NEAR,
-        far = DEFAULT_FAR
-      } = view;
+      const { fovy = DEFAULT_FOVY, aspect = DEFAULT_ASPECT, focalDistance = 1, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       checkRadians(fovy);
       const halfY = fovy / 2;
       const top = focalDistance * Math.tan(halfY);
@@ -6383,32 +7064,53 @@ void main() {
         far
       });
     }
+    /**
+     * Generates a perspective projection matrix with the given bounds
+     * @param view.fovy Vertical field of view in radians
+     * @param view.aspect Aspect ratio. typically viewport width/height
+     * @param view.near Near bound of the frustum
+     * @param view.far Far bound of the frustum
+     * @returns self
+     */
     perspective(view) {
-      const {
-        fovy = 45 * Math.PI / 180,
-        aspect = 1,
-        near = 0.1,
-        far = 500
-      } = view;
+      const { fovy = 45 * Math.PI / 180, aspect = 1, near = 0.1, far = 500 } = view;
       checkRadians(fovy);
       perspective(this, fovy, aspect, near, far);
       return this.check();
     }
+    // Accessors
     determinant() {
       return determinant(this);
     }
+    /**
+     * Extracts the non-uniform scale assuming the matrix is an affine transformation.
+     * The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix.
+     * @param result
+     * @returns self
+     */
     getScale(result = [-0, -0, -0]) {
       result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);
       result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]);
       result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]);
       return result;
     }
+    /**
+     * Gets the translation portion, assuming the matrix is a affine transformation matrix.
+     * @param result
+     * @returns self
+     */
     getTranslation(result = [-0, -0, -0]) {
       result[0] = this[12];
       result[1] = this[13];
       result[2] = this[14];
       return result;
     }
+    /**
+     * Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix
+     * @param result
+     * @param scaleResult
+     * @returns self
+     */
     getRotation(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
@@ -6434,6 +7136,12 @@ void main() {
       result[15] = 1;
       return result;
     }
+    /**
+     *
+     * @param result
+     * @param scaleResult
+     * @returns self
+     */
     getRotationMatrix3(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
@@ -6452,6 +7160,7 @@ void main() {
       result[8] = this[10] * inverseScale2;
       return result;
     }
+    // Modifiers
     transpose() {
       transpose(this, this);
       return this.check();
@@ -6460,6 +7169,7 @@ void main() {
       invert(this, this);
       return this.check();
     }
+    // Operations
     multiplyLeft(a) {
       multiply(this, a, this);
       return this.check();
@@ -6468,33 +7178,68 @@ void main() {
       multiply(this, this, a);
       return this.check();
     }
+    // Rotates a matrix by the given angle around the X axis
     rotateX(radians) {
       rotateX2(this, this, radians);
       return this.check();
     }
+    // Rotates a matrix by the given angle around the Y axis.
     rotateY(radians) {
       rotateY2(this, this, radians);
       return this.check();
     }
+    /**
+     * Rotates a matrix by the given angle around the Z axis.
+     * @param radians
+     * @returns self
+     */
     rotateZ(radians) {
       rotateZ2(this, this, radians);
       return this.check();
     }
+    /**
+     *
+     * @param param0
+     * @returns self
+     */
     rotateXYZ(angleXYZ) {
       return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
     }
+    /**
+     *
+     * @param radians
+     * @param axis
+     * @returns self
+     */
     rotateAxis(radians, axis) {
       rotate(this, this, radians, axis);
       return this.check();
     }
+    /**
+     *
+     * @param factor
+     * @returns self
+     */
     scale(factor) {
       scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
       return this.check();
     }
+    /**
+     *
+     * @param vec
+     * @returns self
+     */
     translate(vector) {
       translate(this, this, vector);
       return this.check();
     }
+    // Transforms
+    /**
+     * Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transform(vector, result) {
       if (vector.length === 4) {
         result = transformMat43(result || [-0, -0, -0, -0], vector, this);
@@ -6503,10 +7248,14 @@ void main() {
       }
       return this.transformAsPoint(vector, result);
     }
+    /**
+     * Transforms any 2 or 3 element array as point (w implicitly 1)
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transformAsPoint(vector, result) {
-      const {
-        length
-      } = vector;
+      const { length } = vector;
       let out;
       switch (length) {
         case 2:
@@ -6521,6 +7270,12 @@ void main() {
       checkVector(out, vector.length);
       return out;
     }
+    /**
+     * Transforms any 2 or 3 element array as vector (w implicitly 0)
+     * @param vector
+     * @param result
+     * @returns self
+     */
     transformAsVector(vector, result) {
       let out;
       switch (vector.length) {
@@ -6536,15 +7291,19 @@ void main() {
       checkVector(out, vector.length);
       return out;
     }
+    /** @deprecated */
     transformPoint(vector, result) {
       return this.transformAsPoint(vector, result);
     }
+    /** @deprecated */
     transformVector(vector, result) {
       return this.transformAsPoint(vector, result);
     }
+    /** @deprecated */
     transformDirection(vector, result) {
       return this.transformAsVector(vector, result);
     }
+    // three.js math API compatibility
     makeRotationX(radians) {
       return this.identity().rotateX(radians);
     }
@@ -6741,8 +7500,11 @@ void main() {
           continue;
         }
         const oldUniforms = this.moduleUniforms[moduleName];
-        const uniforms = module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || moduleProps;
+        const oldBindings = this.moduleBindings[moduleName];
+        const uniformsAndBindings = module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || moduleProps;
+        const { uniforms, bindings } = (0, import_core6.splitUniformsAndBindings)(uniformsAndBindings);
         this.moduleUniforms[moduleName] = { ...oldUniforms, ...uniforms };
+        this.moduleBindings[moduleName] = { ...oldBindings, ...bindings };
       }
     }
     /** Merges all bindings for the shader (from the various modules) */
@@ -7269,6 +8031,7 @@ void main() {
     /** Update uniform buffers from the model's shader inputs */
     updateShaderInputs() {
       this._uniformStore.setUniforms(this.shaderInputs.getUniformValues());
+      this.setBindings(this.shaderInputs.getBindings());
       this.setNeedsRedraw("shaderInputs");
     }
     /**