wesl 0.6.0-pre10

package/dist/index.js

@@ -0,0 +1,4468 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _fragments, _destLength, _entries, _fragments2, _column, _spc, _oneLine, _isHanging, _hangingSpc;
+function assertThat(condition, msg) {
+  if (!condition) {
+    throw new Error(msg);
+  }
+}
+function assertUnreachable$1(value) {
+  throw new ErrorWithData$1("Unreachable value", { data: value });
+}
+let ErrorWithData$1 = class ErrorWithData extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.data = options == null ? void 0 : options.data;
+  }
+};
+let log = console.log;
+function srcLog(src, pos, ...msgs) {
+  logInternal(log, src, pos, ...msgs);
+}
+function quotedText(text2) {
+  return text2 ? `'${text2.replace(/\n/g, "\\n")}'` : "";
+}
+function logInternal(log2, srcOrSrcMap, destPos, ...msgs) {
+  if (typeof srcOrSrcMap === "string") {
+    logInternalSrc(log2, srcOrSrcMap, destPos, ...msgs);
+    return;
+  }
+  const { src, positions } = mapSrcPositions(srcOrSrcMap, destPos);
+  logInternalSrc(log2, src.text, positions, ...msgs);
+}
+function mapSrcPositions(srcMap, destPos) {
+  var _a, _b, _c, _d;
+  const srcPos = srcMap.mapPositions(...[destPos].flat());
+  const { src } = srcPos[0];
+  let positions;
+  if (((_b = (_a = srcPos[1]) == null ? void 0 : _a.src) == null ? void 0 : _b.path) === src.path && ((_d = (_c = srcPos[1]) == null ? void 0 : _c.src) == null ? void 0 : _d.text) === src.text) {
+    positions = srcPos.map((p) => p.position);
+  } else {
+    positions = srcPos[0].position;
+  }
+  return { src, positions };
+}
+function logInternalSrc(log2, src, pos, ...msgs) {
+  log2(...msgs);
+  const { line, lineNum, linePos, linePos2 } = srcLine(src, pos);
+  {
+    log2(line, `  Ln ${lineNum}`);
+  }
+  const caret = carets(linePos, linePos2);
+  log2(caret);
+}
+function carets(linePos, linePos2) {
+  const firstCaret = " ".repeat(linePos) + "^";
+  let secondCaret = "";
+  if (linePos2 && linePos2 > linePos) {
+    secondCaret = " ".repeat(linePos2 - linePos - 1) + "^";
+  }
+  return firstCaret + secondCaret;
+}
+const startCache = /* @__PURE__ */ new Map();
+function srcLine(src, position) {
+  let pos;
+  let pos2;
+  if (typeof position === "number") {
+    pos = position;
+  } else {
+    [pos, pos2] = position;
+  }
+  const starts = getStarts(src);
+  let start = 0;
+  let end = starts.length - 1;
+  if (pos >= starts[end]) {
+    start = end;
+  }
+  while (start + 1 < end) {
+    const mid = start + end >> 1;
+    if (pos >= starts[mid]) {
+      start = mid;
+    } else {
+      end = mid;
+    }
+  }
+  let linePos2;
+  if (pos2 !== void 0 && pos2 >= starts[start] && pos2 < starts[end]) {
+    linePos2 = pos2 - starts[start];
+  }
+  const lineNl = src.slice(starts[start], starts[start + 1] || src.length);
+  const line = lineNl.slice(-1) === "\n" ? lineNl.slice(0, -1) : lineNl;
+  return { line, linePos: pos - starts[start], linePos2, lineNum: start + 1 };
+}
+function getStarts(src) {
+  const found = startCache.get(src);
+  if (found) return found;
+  const starts = [...src.matchAll(/\n/g)].map((m) => m.index + 1);
+  starts.unshift(0);
+  startCache.set(src, starts);
+  return starts;
+}
+function peekToken(stream) {
+  const start = stream.checkpoint();
+  const token2 = stream.nextToken();
+  stream.reset(start);
+  return token2;
+}
+function token(kindStr, value) {
+  return simpleParser(
+    `token '${kindStr}' ${quotedText(value)}`,
+    function _token(state) {
+      const start = state.stream.checkpoint();
+      const next = state.stream.nextToken();
+      if (next === null) return null;
+      if (next.kind !== kindStr || next.text !== value) {
+        state.stream.reset(start);
+        return null;
+      }
+      return { value: next };
+    }
+  );
+}
+function tokenOf(kindStr, values) {
+  return simpleParser(
+    `tokenOf '${kindStr}'`,
+    function _tokenOf(state) {
+      const start = state.stream.checkpoint();
+      const next = state.stream.nextToken();
+      if (next === null) return null;
+      if (next.kind !== kindStr || !values.includes(next.text)) {
+        state.stream.reset(start);
+        return null;
+      }
+      return { value: next };
+    }
+  );
+}
+function tokenKind(kindStr) {
+  return simpleParser(
+    `tokenKind '${kindStr}'`,
+    function _tokenKind(state) {
+      const start = state.stream.checkpoint();
+      const next = state.stream.nextToken();
+      if (next === null) return null;
+      if (next.kind !== kindStr) {
+        state.stream.reset(start);
+        return null;
+      }
+      return { value: next };
+    }
+  );
+}
+function kind(kindStr) {
+  return simpleParser(
+    `kind '${kindStr}'`,
+    function _kind(state) {
+      const start = state.stream.checkpoint();
+      const next = state.stream.nextToken();
+      if (next === null) return null;
+      if (next.kind !== kindStr) {
+        state.stream.reset(start);
+        return null;
+      }
+      return { value: next.text };
+    }
+  );
+}
+function text(value) {
+  return simpleParser(
+    `${quotedText(value)}`,
+    function _text(state) {
+      const start = state.stream.checkpoint();
+      const next = state.stream.nextToken();
+      if (next === null) return null;
+      if (next.text !== value) {
+        state.stream.reset(start);
+        return null;
+      }
+      return { value: next.text };
+    }
+  );
+}
+function seq(...args) {
+  const parsers = args.map(parserArg);
+  const seqParser = parser("seq", function _seq(ctx) {
+    const values = [];
+    for (const p of parsers) {
+      const result = p._run(ctx);
+      if (result === null) {
+        return null;
+      }
+      values.push(result.value);
+    }
+    return { value: values };
+  });
+  trackChildren(seqParser, ...parsers);
+  return seqParser;
+}
+function seqObj(args) {
+  const parsers = Object.entries(args).map(
+    ([name2, arg]) => [name2, parserArg(arg)]
+  );
+  const seqObjParser = parser("seqObj", function _seqObj(ctx) {
+    const values = {};
+    for (const [name2, p] of parsers) {
+      const result = p._run(ctx);
+      if (result === null) {
+        return null;
+      }
+      values[name2] = result.value;
+    }
+    return { value: values };
+  });
+  trackChildren(seqObjParser, ...parsers.map((v) => v[1]));
+  return seqObjParser;
+}
+function collectArray(p) {
+  return p.collect({ before: pushOpenArray, after: closeArray });
+}
+function preceded(ignoredArg, arg) {
+  const ignored = parserArg(ignoredArg);
+  const p = parserArg(arg);
+  const precededParser = parser(
+    "preceded",
+    function _preceded(ctx) {
+      const ignoredResult = ignored._run(ctx);
+      if (ignoredResult === null) return null;
+      const result = p._run(ctx);
+      return result;
+    }
+  );
+  return precededParser;
+}
+function terminated(arg, ignoredArg) {
+  const p = parserArg(arg);
+  const ignored = parserArg(ignoredArg);
+  const terminatedParser = parser(
+    "terminated",
+    function _terminated(ctx) {
+      const result = p._run(ctx);
+      if (result === null) return null;
+      const ignoredResult = ignored._run(ctx);
+      if (ignoredResult === null) return null;
+      return result;
+    }
+  );
+  return terminatedParser;
+}
+function delimited(ignoredArg1, arg, ignoredArg2) {
+  const ignored1 = parserArg(ignoredArg1);
+  const p = parserArg(arg);
+  const ignored2 = parserArg(ignoredArg2);
+  const delimitedParser = parser(
+    "delimited",
+    function _delimited(ctx) {
+      const ignoredResult1 = ignored1._run(ctx);
+      if (ignoredResult1 === null) return null;
+      const result = p._run(ctx);
+      if (result === null) return null;
+      const ignoredResult2 = ignored2._run(ctx);
+      if (ignoredResult2 === null) return null;
+      return result;
+    }
+  );
+  return delimitedParser;
+}
+function separated_pair(arg1, ignoredArg, arg2) {
+  const p1 = parserArg(arg1);
+  const ignored = parserArg(ignoredArg);
+  const p2 = parserArg(arg2);
+  const terminatedParser = parser(
+    "terminated",
+    function _terminated(ctx) {
+      const result1 = p1._run(ctx);
+      if (result1 === null) return null;
+      const ignoredResult = ignored._run(ctx);
+      if (ignoredResult === null) return null;
+      const result2 = p2._run(ctx);
+      if (result2 === null) return null;
+      return { value: [result1.value, result2.value] };
+    }
+  );
+  return terminatedParser;
+}
+function or(...args) {
+  const parsers = args.map(parserArg);
+  const orParser = parser("or", function _or(state) {
+    const start = state.stream.checkpoint();
+    for (const p of parsers) {
+      state.stream.reset(start);
+      const result = p._run(state);
+      if (result !== null) {
+        return result;
+      }
+    }
+    return null;
+  });
+  trackChildren(orParser, ...parsers);
+  return orParser;
+}
+function opt(arg) {
+  const p = parserArg(arg);
+  const optParser = parser(
+    "opt",
+    function _opt(state) {
+      const start = state.stream.checkpoint();
+      const result = p._run(state);
+      if (result === null) {
+        state.stream.reset(start);
+        return { value: null };
+      } else {
+        return result;
+      }
+    }
+  );
+  return optParser;
+}
+function repeat(arg) {
+  const p = parserArg(arg);
+  const repeatParser = parser("repeat", repeatWhileFilter(p));
+  return repeatParser;
+}
+function repeatPlus(arg) {
+  const p = parserArg(arg);
+  const repeatParser = seq(p, repeat(p)).map((r) => [r[0], ...r[1]]).setTraceName("repeatPlus");
+  return repeatParser;
+}
+function repeatWhileFilter(p, filterFn = () => true) {
+  return function _repeatWhileFilter(ctx) {
+    const values = [];
+    for (; ; ) {
+      const before = ctx.stream.checkpoint();
+      const result = runExtended(ctx, p);
+      if (result === null) {
+        ctx.stream.reset(before);
+        return { value: values };
+      }
+      if (!filterFn(result)) {
+        return { value: values };
+      }
+      values.push(result.value);
+    }
+  };
+}
+function span(arg) {
+  const p = parserArg(arg);
+  const result = parser("span", function _span(ctx) {
+    var _a, _b;
+    const start = ((_b = (_a = peekToken(ctx.stream)) == null ? void 0 : _a.span) == null ? void 0 : _b[0]) ?? null;
+    const result2 = p._run(ctx);
+    if (result2 === null) return null;
+    const end = ctx.stream.checkpoint();
+    return {
+      value: {
+        value: result2.value,
+        span: [start ?? end, end]
+      }
+    };
+  });
+  return result;
+}
+function eof() {
+  return simpleParser("eof", function _eof(state) {
+    const start = state.stream.checkpoint();
+    const result = state.stream.nextToken();
+    if (result !== null) {
+      state.stream.reset(start);
+      return null;
+    }
+    return { value: true };
+  });
+}
+function req(arg, msg) {
+  const p = parserArg(arg);
+  const reqParser = parser("req", function _req(ctx) {
+    const result = p._run(ctx);
+    if (result === null) {
+      throw new ParseError(msg, ctx.stream.checkpoint());
+    }
+    return result;
+  });
+  return reqParser;
+}
+function yes() {
+  return simpleParser("yes", function _yes() {
+    return { value: null };
+  });
+}
+function withSep(sep, p, opts = {}) {
+  const { trailing = true, requireOne = false } = opts;
+  const elementParser = parserArg(p);
+  const sepParser = parserArg(sep);
+  return parser("withSep", function _withSep(ctx) {
+    const results = [];
+    const startPosition = ctx.stream.checkpoint();
+    const result = elementParser._run(ctx);
+    if (result === null) {
+      ctx.stream.reset(startPosition);
+      if (requireOne) {
+        return null;
+      } else {
+        return {
+          value: results
+        };
+      }
+    }
+    results.push(result.value);
+    while (true) {
+      const beforeSeparator = ctx.stream.checkpoint();
+      const resultSeparator = sepParser._run(ctx);
+      if (resultSeparator === null) {
+        ctx.stream.reset(beforeSeparator);
+        break;
+      }
+      const beforeElement = ctx.stream.checkpoint();
+      const resultElement = elementParser._run(ctx);
+      if (resultElement === null) {
+        if (trailing) {
+          ctx.stream.reset(beforeElement);
+        } else {
+          ctx.stream.reset(beforeSeparator);
+        }
+        break;
+      }
+      results.push(resultElement.value);
+    }
+    return {
+      value: results
+    };
+  });
+}
+function withSepPlus(sep, p) {
+  return withSep(sep, p, { requireOne: true }).setTraceName("withSepPlus");
+}
+function withStreamAction(action) {
+  return simpleParser(
+    `withStreamAction`,
+    function _withStreamAction(state) {
+      const result = action(state.stream);
+      if (result === null) return null;
+      return { value: result };
+    }
+  );
+}
+function parserArg(arg) {
+  if (typeof arg === "string") {
+    return text(arg);
+  } else if (arg instanceof Parser) {
+    return arg;
+  }
+  return fn(arg);
+}
+function fn(fn2) {
+  const fp = parser(
+    "fn()",
+    function _fn(state) {
+      if (!fn2) {
+        throw new ParseError(
+          `fn parser called before definition`,
+          state.stream.checkpoint()
+        );
+      }
+      const stage = fn2();
+      return stage._run(state);
+    }
+  );
+  return fp;
+}
+function collect(p, collectFn, ctag2) {
+  const origAfter = collectFn.after ?? collectFn;
+  const beforeFn = collectFn.before;
+  let afterFn = origAfter;
+  if (ctag2) {
+    afterFn = (cc) => {
+      const result = origAfter(cc);
+      if (result !== void 0 && result !== null) {
+        addTagValue(cc.tags, ctag2, result);
+      }
+      return result;
+    };
+  }
+  const debugName = ctag2 ? `${p.debugName}-${ctag2}` : `${p.debugName}`;
+  const collectParser = parser(
+    `collect`,
+    function _collect(ctx) {
+      const origStart = ctx.stream.checkpoint();
+      if (beforeFn) {
+        queueCollectFn(ctx, origStart, beforeFn, `${debugName}.before`);
+      }
+      return runAndCollectAfter(p, ctx, afterFn, debugName);
+    }
+  );
+  return collectParser;
+}
+function tagScope(arg) {
+  const p = parserArg(arg);
+  const sp = parser(
+    `tagScope`,
+    function _tagScope(ctx) {
+      const origStart = ctx.stream.checkpoint();
+      let origTags;
+      queueCollectFn(
+        ctx,
+        origStart,
+        (cc) => {
+          origTags = cloneTags(cc.tags);
+          cc.tags = {};
+        },
+        `scope.before ${p.debugName}`
+      );
+      return runAndCollectAfter(
+        p,
+        ctx,
+        (cc) => {
+          cc.tags = origTags;
+        },
+        `tagScope`
+      );
+    }
+  );
+  return sp;
+}
+function cloneTags(tags) {
+  const cloned = Object.entries(tags).map(([tag, values]) => {
+    return [tag, [...values]];
+  });
+  return Object.fromEntries(cloned);
+}
+function ctag(p, name2) {
+  const cp = parser(
+    `ctag`,
+    function _ctag(ctx) {
+      return runAndCollectAfter(
+        p,
+        ctx,
+        (cc) => {
+          const valueEntry = last$1(cc._values);
+          addTagValue(cc.tags, name2, valueEntry.value);
+        },
+        `ctag ${name2}`
+      );
+    }
+  );
+  return cp;
+}
+function runAndCollectAfter(p, ctx, collectFn, debugName = "") {
+  const origStart = ctx.stream.checkpoint();
+  const result = p._run(ctx);
+  if (result) {
+    queueCollectFn(ctx, origStart, collectFn, debugName);
+  }
+  return result;
+}
+function queueCollectFn(ctx, origStart, collectFn, debugName) {
+  const srcPosition = refinePosition(ctx.stream, origStart);
+  ctx._collect.push({
+    srcPosition,
+    collectFn,
+    debugName
+  });
+}
+function pushOpenArray(cc) {
+  cc._values.push({ value: null, openArray: [] });
+}
+function closeArray(cc) {
+  const lastValue = last$1(cc._values);
+  if (lastValue.openArray === void 0)
+    console.log("---closeArray: no open array");
+  cc._values.pop();
+  saveCollectValue(cc, lastValue.openArray);
+}
+function ptag(p, name2) {
+  const cp = parser(
+    `ptag`,
+    function _ptag(ctx) {
+      const origStart = ctx.stream.checkpoint();
+      const result = p._run(ctx);
+      if (result) {
+        const tagFn = (ctx2) => addTagValue(ctx2.tags, name2, result.value);
+        queueCollectFn(ctx, origStart, tagFn, `ptag ${name2}`);
+      }
+      return result;
+    }
+  );
+  return cp;
+}
+function addTagValue(tags, name2, value) {
+  if (tags[name2] === void 0) {
+    tags[name2] = [];
+  }
+  tags[name2].push(value);
+}
+function runCollection(_collect, app, stream) {
+  const tags = {};
+  const { src } = stream;
+  const _values = [{ value: null, openArray: void 0 }];
+  const collectContext = {
+    tags,
+    src,
+    start: -1,
+    end: -1,
+    app,
+    _values
+  };
+  _collect.forEach((entry) => {
+    const { collectFn, srcPosition } = entry;
+    collectContext.start = srcPosition.start;
+    collectContext.end = srcPosition.end;
+    const collectResult = collectFn(collectContext);
+    saveCollectValue(collectContext, collectResult);
+  });
+}
+function saveCollectValue(cc, value) {
+  if (value !== void 0) {
+    const valueEntry = last$1(cc._values);
+    if (!valueEntry) console.log("----saveCollectValue: no valueEntry");
+    if (valueEntry) valueEntry.value = value;
+    if ((valueEntry == null ? void 0 : valueEntry.openArray) !== void 0) {
+      valueEntry.openArray.push(value);
+    }
+  }
+}
+function last$1(elems) {
+  return elems[elems.length - 1];
+}
+function refinePosition(stream, origStart) {
+  const end = stream.checkpoint();
+  stream.reset(origStart);
+  const start = skipIgnored(stream);
+  stream.reset(end);
+  return { start, end };
+}
+function skipIgnored(stream) {
+  const result = stream.nextToken();
+  if (result === null) {
+    return stream.checkpoint();
+  } else {
+    stream.reset(result.span[0]);
+    return stream.checkpoint();
+  }
+}
+class ParseError extends Error {
+  constructor(msg, position) {
+    super(msg);
+    this.position = position;
+  }
+}
+class Parser {
+  constructor(args) {
+    this.fn = args.fn;
+  }
+  /** run the parser given an already created parsing context
+   *
+   * Execute a parser by running the core parsing fn given the parsing context
+   * also:
+   * . log if tracing is enabled
+   * . backtrack on failure
+   * . rollback context on failure
+   */
+  _run(context) {
+    {
+      const origAppContext = context.app.context;
+      const origCollectLength = context._collect.length;
+      const result = this.fn(context);
+      if (result === null) {
+        context.app.context = origAppContext;
+        context._collect.length = origCollectLength;
+      }
+      return result;
+    }
+  }
+  /** tag parse results */
+  ptag(name2) {
+    return ptag(this, name2);
+  }
+  /** tag collect results */
+  ctag(name2) {
+    return ctag(this, name2);
+  }
+  /** record a name for debug tracing */
+  setTraceName(name2) {
+    return this;
+  }
+  /** trigger tracing for this parser (and by default also this parsers descendants) */
+  setTrace(opts = {}) {
+    return this;
+  }
+  /** map results to a new value, or add to app state as a side effect.
+   * Return null to cause the parser to fail.
+   * SAFETY: Side-effects should not be done if backtracking could occur!
+   */
+  mapExtended(fn2) {
+    return mapExtended(this, fn2);
+  }
+  /** map results to a new value.
+   */
+  map(fn2) {
+    return map(this, fn2);
+  }
+  /** Queue a function that runs later, typically to collect AST elements from the parse.
+   * when a commit() is parsed.
+   * Collection functions are dropped with parser backtracking, so
+   * only succsessful parses are collected. */
+  collect(fn2, ctag2) {
+    return collect(this, fn2, ctag2);
+  }
+  /** switch next parser based on results */
+  toParser(fn2) {
+    return toParser(this, fn2);
+  }
+  /**
+   * start parsing
+   *
+   * @throws {ParseError} when a combinator like `req` fails
+   */
+  parse(init) {
+    const { stream, appState: app = { context: {}, stable: [] } } = init;
+    const _collect = [];
+    const result = this._run({
+      stream,
+      app,
+      _collect
+    });
+    if (result) runCollection(_collect, app, stream);
+    return result;
+  }
+  /** name of this parser for debugging/tracing */
+  get debugName() {
+    return "parser";
+  }
+}
+function parser(traceName, fn2, terminal) {
+  return new Parser({ fn: fn2, traceName, terminal });
+}
+function simpleParser(traceName, parserFn) {
+  return parser(traceName, parserFn, true);
+}
+function mapExtended(p, fn2) {
+  const mapParser = parser(
+    `mapExtended`,
+    function _mapExtended(ctx) {
+      const extended = runExtended(ctx, p);
+      if (!extended) return null;
+      const mappedValue = fn2(extended);
+      if (mappedValue === null) return null;
+      return { value: mappedValue };
+    }
+  );
+  return mapParser;
+}
+function map(p, fn2) {
+  const mapParser = parser(
+    `map`,
+    function _map(ctx) {
+      const result = p._run(ctx);
+      if (result === null) return null;
+      return { value: fn2(result.value) };
+    }
+  );
+  return mapParser;
+}
+function toParser(p, toParserFn) {
+  const newParser = parser(
+    "toParser",
+    function _toParser(ctx) {
+      const result = p._run(ctx);
+      if (result === null) return null;
+      const newParser2 = toParserFn(result);
+      if (newParser2 === null) {
+        return result;
+      }
+      const nextResult = newParser2._run(ctx);
+      return nextResult;
+    }
+  );
+  return newParser;
+}
+function runExtended(ctx, p) {
+  const origStart = ctx.stream.checkpoint();
+  const origResults = p._run(ctx);
+  if (origResults === null) {
+    ctx.stream.reset(origStart);
+    return null;
+  }
+  const { app } = ctx;
+  return { ...origResults, app };
+}
+function trackChildren(p, ...args) {
+}
+class SrcMap {
+  constructor(dest, entries = []) {
+    this.dest = dest;
+    this.entries = entries;
+  }
+  /** add a new mapping from src to dest ranges.
+   * entries must be non-overlapping in the destination
+   */
+  addEntries(newEntries) {
+    this.entries.push(...newEntries);
+  }
+  /** given positions in the dest string,
+   * @return corresponding positions in the src strings */
+  mapPositions(...positions) {
+    return positions.map((p) => this.destToSrc(p));
+  }
+  /** internally compress adjacent entries where possible */
+  compact() {
+    if (!this.entries.length) return;
+    let prev = this.entries[0];
+    const newEntries = [prev];
+    for (let i = 1; i < this.entries.length; i++) {
+      const e = this.entries[i];
+      if (e.src.path === prev.src.path && e.src.text === prev.src.text && prev.destEnd === e.destStart && prev.srcEnd === e.srcStart) {
+        prev.destEnd = e.destEnd;
+        prev.srcEnd = e.srcEnd;
+      } else {
+        newEntries.push(e);
+        prev = e;
+      }
+    }
+    this.entries = newEntries;
+  }
+  /** sort in destination order */
+  sort() {
+    this.entries.sort((a, b) => a.destStart - b.destStart);
+  }
+  /** This SrcMap's destination is a src for the other srcmap,
+   * so combine the two and return the result.
+   */
+  merge(other) {
+    if (other === this) return this;
+    const mappedEntries = other.entries.filter(
+      (e) => e.src.path === this.dest.path && e.src.text === this.dest.text
+    );
+    if (mappedEntries.length === 0) {
+      console.log("other source map does not link to this one");
+      return other;
+    }
+    sortSrc(mappedEntries);
+    const newEntries = mappedEntries.map((e) => {
+      const { src, position: srcStart } = this.destToSrc(e.srcStart);
+      const { src: endSrc, position: srcEnd } = this.destToSrc(e.srcEnd);
+      if (endSrc !== src) throw new Error("NYI, need to split");
+      const newEntry = {
+        src,
+        srcStart,
+        srcEnd,
+        destStart: e.destStart,
+        destEnd: e.destEnd
+      };
+      return newEntry;
+    });
+    const otherSources = other.entries.filter(
+      (e) => e.src.path !== this.dest.path || e.src.text !== this.dest.text
+    );
+    const newMap = new SrcMap(other.dest, [...otherSources, ...newEntries]);
+    newMap.sort();
+    return newMap;
+  }
+  /**
+   * @param entries should be sorted in destStart order
+   * @return the source position corresponding to a provided destination position
+   *
+   */
+  destToSrc(destPos) {
+    const entry = this.entries.find(
+      (e) => e.destStart <= destPos && e.destEnd >= destPos
+    );
+    if (!entry) {
+      return {
+        src: this.dest,
+        position: destPos
+      };
+    }
+    return {
+      src: entry.src,
+      position: entry.srcStart + destPos - entry.destStart
+    };
+  }
+}
+function sortSrc(entries) {
+  entries.sort((a, b) => a.srcStart - b.srcStart);
+}
+class SrcMapBuilder {
+  constructor(source) {
+    __privateAdd(this, _fragments, []);
+    __privateAdd(this, _destLength, 0);
+    __privateAdd(this, _entries, []);
+    this.source = source;
+  }
+  /** append a string fragment to the destination string */
+  add(fragment, srcStart, srcEnd) {
+    const destStart = __privateGet(this, _destLength);
+    __privateSet(this, _destLength, __privateGet(this, _destLength) + fragment.length);
+    const destEnd = __privateGet(this, _destLength);
+    __privateGet(this, _fragments).push(fragment);
+    __privateGet(this, _entries).push({
+      src: this.source,
+      srcStart,
+      srcEnd,
+      destStart,
+      destEnd
+    });
+  }
+  /**
+   * Append a fragment to the destination string,
+   * mapping source to the pervious,
+   * and guessing that the source fragment is just as long as the the dest fragment.
+   * (LATER we plan to drop or make optional src end positions)
+   */
+  appendNext(fragment) {
+    var _a;
+    const lastEnd = ((_a = __privateGet(this, _entries).at(-1)) == null ? void 0 : _a.destEnd) ?? 0;
+    this.add(fragment, lastEnd, lastEnd + fragment.length);
+  }
+  addSynthetic(fragment, syntheticSource, srcStart, srcEnd) {
+    const destStart = __privateGet(this, _destLength);
+    __privateSet(this, _destLength, __privateGet(this, _destLength) + fragment.length);
+    const destEnd = __privateGet(this, _destLength);
+    __privateGet(this, _fragments).push(fragment);
+    __privateGet(this, _entries).push({
+      src: { text: syntheticSource },
+      srcStart,
+      srcEnd,
+      destStart,
+      destEnd
+    });
+  }
+  /** append a synthetic newline, mapped to previous source location */
+  addNl() {
+    const lastEntry = __privateGet(this, _entries).at(-1) ?? { srcStart: 0, srcEnd: 0 };
+    const { srcStart, srcEnd } = lastEntry;
+    this.add("\n", srcStart, srcEnd);
+  }
+  /** copy a string fragment from the src to the destination string */
+  addCopy(srcStart, srcEnd) {
+    const fragment = this.source.text.slice(srcStart, srcEnd);
+    this.add(fragment, srcStart, srcEnd);
+  }
+  /** return a SrcMap */
+  static build(builders) {
+    const map2 = new SrcMap(
+      { text: builders.map((b) => __privateGet(b, _fragments).join("")).join("") },
+      builders.flatMap((b) => __privateGet(b, _entries))
+    );
+    map2.compact();
+    return map2;
+  }
+}
+_fragments = new WeakMap();
+_destLength = new WeakMap();
+_entries = new WeakMap();
+class CachingStream {
+  constructor(inner) {
+    this.inner = inner;
+    this.cache = new Cache(5);
+  }
+  checkpoint() {
+    return this.inner.checkpoint();
+  }
+  reset(position) {
+    this.inner.reset(position);
+  }
+  nextToken() {
+    const startPos = this.checkpoint();
+    const cachedValue = this.cache.get(startPos);
+    if (cachedValue !== void 0) {
+      this.reset(cachedValue.checkpoint);
+      return cachedValue.token;
+    } else {
+      const token2 = this.inner.nextToken();
+      const checkpoint = this.checkpoint();
+      this.cache.set(startPos, { token: token2, checkpoint });
+      return token2;
+    }
+  }
+  get src() {
+    return this.inner.src;
+  }
+}
+class Cache extends Map {
+  constructor(max) {
+    super();
+    this.max = max;
+  }
+  set(k, v) {
+    if (this.size > this.max) {
+      const first = this.keys().next().value;
+      if (first) this.delete(first);
+    }
+    return super.set(k, v);
+  }
+}
+function toRegexSource(nameExp) {
+  const [name2, e] = nameExp;
+  if (typeof e === "string") {
+    const expSrc = `(${escapeRegex(e)})`;
+    verifyNonCapturing(name2, new RegExp(expSrc));
+    return expSrc;
+  } else {
+    verifyNonCapturing(name2, e);
+    return `(${e.source})`;
+  }
+}
+function verifyNonCapturing(name2, exp) {
+  const willMatch = new RegExp("|" + exp.source);
+  const result = willMatch.exec("");
+  if (result.length > 1) {
+    throw new Error(
+      `match expression groups must be non-capturing: ${name2}: /${exp.source}/. Use (?:...) instead.`
+    );
+  }
+}
+const regexSpecials = /[$+*.?|(){}[\]\\/^]/g;
+function escapeRegex(s) {
+  return s.replace(regexSpecials, "\\$&");
+}
+function matchOneOf(syms) {
+  const symbolList = syms.split(/\s+/).sort((a, b) => b.length - a.length);
+  const escaped = symbolList.filter((s) => s).map(escapeRegex);
+  return new RegExp(escaped.join("|"));
+}
+class MatchersStream {
+  constructor(text2, matchers) {
+    this.text = text2;
+    this.matchers = matchers;
+    this.position = 0;
+  }
+  checkpoint() {
+    return this.position;
+  }
+  reset(position) {
+    this.position = position;
+  }
+  nextToken() {
+    const result = this.matchers.execAt(this.text, this.position);
+    if (result === null) return null;
+    this.position = result.span[1];
+    return result;
+  }
+  get src() {
+    return this.text;
+  }
+}
+class RegexMatchers {
+  constructor(matchers) {
+    this.groups = Object.keys(matchers);
+    const expParts = Object.entries(matchers).map(toRegexSource).join("|");
+    this.exp = new RegExp(expParts, "dyu");
+  }
+  execAt(text2, position) {
+    this.exp.lastIndex = position;
+    const matches = this.exp.exec(text2);
+    const matchedIndex = findGroupDex(matches == null ? void 0 : matches.indices);
+    if (matchedIndex) {
+      const { span: span2, groupDex } = matchedIndex;
+      const kind2 = this.groups[groupDex];
+      return {
+        kind: kind2,
+        span: span2,
+        text: text2.slice(span2[0], span2[1])
+      };
+    } else {
+      return null;
+    }
+  }
+}
+function findGroupDex(indices) {
+  if (indices !== void 0) {
+    for (let i = 1; i < indices.length; i++) {
+      const span2 = indices[i];
+      if (span2 !== void 0) {
+        return { span: span2, groupDex: i - 1 };
+      }
+    }
+  }
+}
+function assertThatDebug(condition, msg) {
+}
+function assertUnreachable(value) {
+  throw new ErrorWithData2("Unreachable value", { data: value });
+}
+class ErrorWithData2 extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.data = options == null ? void 0 : options.data;
+  }
+}
+function last(a) {
+  return a[a.length - 1];
+}
+function filterMap(arr, fn2) {
+  const out = [];
+  for (const t of arr) {
+    const u = fn2(t);
+    if (u) out.push(u);
+  }
+  return out;
+}
+function findMap(arr, fn2) {
+  for (const t of arr) {
+    const u = fn2(t);
+    if (u) return u;
+  }
+  return void 0;
+}
+function mapValues(obj, fn2) {
+  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn2(v)]));
+}
+function offsetToLineNumber(offset, text2) {
+  offset = Math.min(text2.length, Math.max(0, offset));
+  let lineStartOffset = 0;
+  let lineNum = 1;
+  while (true) {
+    const lineEnd = text2.indexOf("\n", lineStartOffset);
+    if (lineEnd === -1 || offset <= lineEnd) {
+      const linePos = 1 + (offset - lineStartOffset);
+      return [lineNum, linePos];
+    } else {
+      lineStartOffset = lineEnd + 1;
+      lineNum += 1;
+    }
+  }
+}
+function errorHighlight(source, span2) {
+  let lineStartOffset = source.lastIndexOf("\n", span2[0]);
+  if (lineStartOffset === -1) {
+    lineStartOffset = 0;
+  }
+  let lineEndOffset = source.indexOf("\n", span2[0]);
+  if (lineEndOffset === -1) {
+    lineEndOffset = source.length;
+  }
+  const errorLength = span2[1] - span2[0];
+  const caretCount = Math.max(1, errorLength);
+  const linePos = span2[0] - lineStartOffset;
+  return [
+    source.slice(lineStartOffset, lineEndOffset),
+    " ".repeat(linePos) + "^".repeat(caretCount)
+  ];
+}
+function elementValid(elem, conditions) {
+  const attributes = elem.attributes;
+  if (!attributes) return true;
+  const ifAttr = findMap(attributes, extractIfAttribute);
+  return !ifAttr || evaluateIfAttribute(ifAttr);
+}
+function scopeValid(scope, conditions) {
+  const { ifAttribute } = scope;
+  if (!ifAttribute) return true;
+  const result = evaluateIfAttribute(ifAttribute);
+  return result;
+}
+function extractIfAttribute(elem) {
+  const { attribute } = elem;
+  return attribute.kind === "@if" ? attribute : void 0;
+}
+function evaluateIfAttribute(ifAttribute, conditions) {
+  return evaluateIfExpression(ifAttribute.param.expression);
+}
+function evaluateIfExpression(expression2, conditions) {
+  const { kind: kind2 } = expression2;
+  if (kind2 == "unary-expression") {
+    assertThatDebug(expression2.operator.value === "!");
+    return !evaluateIfExpression(expression2.expression);
+  } else if (kind2 == "binary-expression") {
+    const op = expression2.operator.value;
+    const leftResult = evaluateIfExpression(expression2.left);
+    if (op === "||") {
+      return leftResult || evaluateIfExpression(expression2.right);
+    } else if (op === "&&") {
+      return leftResult && evaluateIfExpression(expression2.right);
+    } else {
+      assertUnreachable(op);
+    }
+  } else if (kind2 == "literal") {
+    const { value } = expression2;
+    return value === "true";
+  } else if (kind2 == "parenthesized-expression") {
+    return evaluateIfExpression(expression2.expression);
+  } else {
+    throw new Error("unexpected @if expression ${expression}");
+  }
+}
+function mergeScope(a, b) {
+  assertThatDebug(a.kind === b.kind);
+  assertThatDebug(a.parent === b.parent);
+  assertThatDebug(!b.ifAttribute);
+  a.contents = a.contents.concat(b.contents);
+}
+function resetScopeIds() {
+  scopeId = 0;
+  identId = 0;
+}
+let scopeId = 0;
+let identId = 0;
+function nextIdentId() {
+  return identId++;
+}
+function emptyScope(parent, kind2 = "scope") {
+  const id = scopeId++;
+  return { id, kind: kind2, parent, contents: [] };
+}
+function childScope(child) {
+  const { kind: kind2 } = child;
+  return kind2 === "partial" || kind2 === "scope";
+}
+function publicDecl(scope, name2, conditions) {
+  for (const elem of scope.contents) {
+    if (elem.kind === "decl" && elem.originalName === name2) {
+      return elem;
+    } else if (elem.kind === "partial" && scopeValid(elem)) {
+      const found = publicDecl(elem, name2);
+      if (found) return found;
+    }
+  }
+}
+class LineWrapper {
+  constructor(indent = 0, maxWidth = 60, hangingIndent = 2) {
+    __privateAdd(this, _fragments2, []);
+    __privateAdd(this, _column, 0);
+    __privateAdd(this, _spc);
+    __privateAdd(this, _oneLine, true);
+    __privateAdd(this, _isHanging, false);
+    __privateAdd(this, _hangingSpc);
+    this.indent = indent;
+    this.maxWidth = maxWidth;
+    this.hangingIndent = hangingIndent;
+    __privateSet(this, _spc, " ".repeat(indent));
+    __privateSet(this, _hangingSpc, " ".repeat(hangingIndent));
+  }
+  /** add a new line to the constructed string */
+  nl() {
+    __privateGet(this, _fragments2).push("\n");
+    __privateSet(this, _column, 0);
+    __privateSet(this, _oneLine, false);
+    __privateSet(this, _isHanging, false);
+  }
+  /** add a string, wrapping to the next line if necessary */
+  add(s) {
+    if (__privateGet(this, _column) + firstLineLength(s) > this.maxWidth) {
+      this.hangingNl();
+    }
+    if (__privateGet(this, _column) === 0) {
+      __privateGet(this, _fragments2).push(__privateGet(this, _spc));
+      if (__privateGet(this, _isHanging)) {
+        __privateGet(this, _fragments2).push(__privateGet(this, _hangingSpc));
+      }
+      __privateSet(this, _column, this.indent);
+    }
+    __privateGet(this, _fragments2).push(s);
+    __privateSet(this, _column, __privateGet(this, _column) + s.length);
+  }
+  /** add a raw block of text with no wrapping */
+  addBlock(s, andNewLine = true) {
+    __privateGet(this, _fragments2).push(s);
+    if (andNewLine) this.nl();
+  }
+  /** @return the constructed string */
+  get result() {
+    return __privateGet(this, _fragments2).join("");
+  }
+  /** true if the result contains no newlines */
+  get oneLine() {
+    return __privateGet(this, _oneLine);
+  }
+  hangingNl() {
+    this.nl();
+    __privateSet(this, _isHanging, true);
+  }
+}
+_fragments2 = new WeakMap();
+_column = new WeakMap();
+_spc = new WeakMap();
+_oneLine = new WeakMap();
+_isHanging = new WeakMap();
+_hangingSpc = new WeakMap();
+function firstLineLength(s) {
+  const i = s.indexOf("\n");
+  return i === -1 ? s.length : i;
+}
+function scopeToString(scope, indent = 0, shortIdents = true) {
+  const { contents, kind: kind2, ifAttribute } = scope;
+  const str = new LineWrapper(indent);
+  const attrStrings = ifAttribute && attributeToString$1(ifAttribute);
+  if (attrStrings) str.add(attrStrings + " ");
+  if (kind2 === "partial") str.add("-");
+  str.add("{ ");
+  const last2 = contents.length - 1;
+  let lastWasScope = false;
+  let hasBlock = false;
+  contents.forEach((elem, i) => {
+    if (childScope(elem)) {
+      const childScope2 = elem;
+      const childBlock = scopeToString(childScope2, indent + 2, shortIdents);
+      !lastWasScope && str.nl();
+      str.addBlock(childBlock);
+      lastWasScope = true;
+      hasBlock = true;
+    } else {
+      lastWasScope && str.add("  ");
+      lastWasScope = false;
+      const ident2 = elem;
+      if (shortIdents) {
+        str.add(identShortString(ident2));
+      } else {
+        str.add(identToString(ident2));
+      }
+      if (i < last2) str.add(" ");
+    }
+  });
+  if (!hasBlock && str.oneLine) {
+    str.add(" }");
+  } else {
+    if (hasBlock && !lastWasScope) str.nl();
+    str.add("}");
+  }
+  str.add(` #${scope.id}`);
+  return str.result;
+}
+function scopeToStringLong(scope) {
+  return scopeToString(scope, 0, false);
+}
+function identShortString(ident2) {
+  const { kind: kind2, originalName } = ident2;
+  const prefix = kind2 === "decl" ? "%" : "";
+  return `${prefix}${originalName}`;
+}
+function identToString(ident2) {
+  if (!ident2) return JSON.stringify(ident2);
+  const { kind: kind2, originalName } = ident2;
+  const idStr = ident2.id ? `#${ident2.id}` : "";
+  if (kind2 === "ref") {
+    const ref = identToString(ident2.refersTo);
+    return `${originalName} ${idStr} -> ${ref}`;
+  } else {
+    const { mangledName } = ident2;
+    const mangled = mangledName ? `(${mangledName})` : "";
+    return `%${originalName}${mangled} ${idStr} `;
+  }
+}
+function makeLiveDecls(parent = null) {
+  return { decls: /* @__PURE__ */ new Map(), parent };
+}
+function minimalMangle(_d, _s, proposedName, globalNames) {
+  return minimallyMangledName(proposedName, globalNames);
+}
+function minimallyMangledName(proposedName, globalNames) {
+  let renamed = proposedName;
+  let conflicts = 0;
+  while (globalNames.has(renamed)) {
+    renamed = proposedName + conflicts++;
+  }
+  return renamed;
+}
+function flattenTreeImport(imp) {
+  return recursiveResolve([], [], imp.segments, imp.finalSegment);
+  function recursiveResolve(resolvedImportPath, resolvedExportPath, remainingPath, finalSegment) {
+    if (remainingPath.length > 0) {
+      const [segment, ...rest] = remainingPath;
+      const importPath = [...resolvedImportPath, segment.name];
+      const modulePath = [...resolvedExportPath, segment.name];
+      return recursiveResolve(importPath, modulePath, rest, finalSegment);
+    } else if (finalSegment.kind === "import-collection") {
+      return finalSegment.subtrees.flatMap((elem) => {
+        return recursiveResolve(
+          resolvedImportPath,
+          resolvedExportPath,
+          elem.segments,
+          elem.finalSegment
+        );
+      });
+    } else if (finalSegment.kind === "import-item") {
+      const importPath = [
+        ...resolvedImportPath,
+        finalSegment.as ?? finalSegment.name
+      ];
+      const modulePath = [...resolvedExportPath, finalSegment.name];
+      return [{ importPath, modulePath }];
+    } else {
+      assertUnreachable(finalSegment);
+    }
+  }
+}
+var spaces = memoize((nesting) => {
+  return " ".repeat(nesting);
+});
+var defaultCallerSize = 20;
+"\n" + spaces(defaultCallerSize + 3);
+function memoize(fn2) {
+  const cache = /* @__PURE__ */ new Map();
+  return function(...args) {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    } else {
+      const value = fn2(...args);
+      cache.set(key, value);
+      return value;
+    }
+  };
+}
+if (typeof DOMRect === "undefined") {
+  globalThis.DOMRect = function() {
+  };
+}
+function importElem(cc) {
+  var _a;
+  const importElems = (_a = cc.tags.owo) == null ? void 0 : _a[0];
+  for (const importElem2 of importElems) {
+    cc.app.stable.imports.push(importElem2.imports);
+    addToOpenElem(cc, importElem2);
+  }
+}
+function addToOpenElem(cc, elem) {
+  const weslContext = cc.app.context;
+  const { openElems } = weslContext;
+  if (openElems && openElems.length) {
+    const open = openElems[openElems.length - 1];
+    open.contents.push(elem);
+  }
+}
+function refIdent(cc) {
+  const { src, start, end } = cc;
+  const app = cc.app;
+  const { srcModule } = app.stable;
+  const originalName = src.slice(start, end);
+  const kind2 = "ref";
+  const ident2 = {
+    kind: kind2,
+    originalName,
+    ast: cc.app.stable,
+    id: nextIdentId(),
+    refIdentElem: null
+    // set below
+  };
+  const identElem = { kind: kind2, start, end, srcModule, ident: ident2 };
+  ident2.refIdentElem = identElem;
+  saveIdent(cc, identElem);
+  addToOpenElem(cc, identElem);
+  return identElem;
+}
+function declCollect(cc) {
+  return declCollectInternal(cc, false);
+}
+function globalDeclCollect(cc) {
+  return declCollectInternal(cc, true);
+}
+function declCollectInternal(cc, isGlobal2) {
+  const { src, start, end } = cc;
+  const app = cc.app;
+  const { scope } = app.context;
+  const { srcModule } = app.stable;
+  const originalName = src.slice(start, end);
+  const kind2 = "decl";
+  const declElem = null;
+  const ident2 = {
+    declElem,
+    kind: kind2,
+    originalName,
+    scope,
+    isGlobal: isGlobal2,
+    id: nextIdentId(),
+    srcModule
+  };
+  const identElem = { kind: kind2, start, end, srcModule, ident: ident2 };
+  saveIdent(cc, identElem);
+  addToOpenElem(cc, identElem);
+  return identElem;
+}
+const typedDecl = collectElem(
+  "typeDecl",
+  (cc, openElem) => {
+    var _a, _b;
+    const decl = (_a = cc.tags.decl_elem) == null ? void 0 : _a[0];
+    const typeRef = (_b = cc.tags.typeRefElem) == null ? void 0 : _b[0];
+    const partial = { ...openElem, decl, typeRef };
+    const elem = withTextCover(partial, cc);
+    return elem;
+  }
+);
+function saveIdent(cc, identElem) {
+  const { ident: ident2 } = identElem;
+  ident2.id = nextIdentId();
+  const weslContext = cc.app.context;
+  weslContext.scope.contents.push(ident2);
+}
+function startScope(cc) {
+  startSomeScope("scope", cc);
+}
+function startPartialScope(cc) {
+  startSomeScope("partial", cc);
+}
+function startSomeScope(kind2, cc) {
+  const { scope } = cc.app.context;
+  const newScope = emptyScope(scope, kind2);
+  scope.contents.push(newScope);
+  cc.app.context.scope = newScope;
+}
+function completeScope(cc) {
+  const weslContext = cc.app.context;
+  const completedScope = weslContext.scope;
+  const ifAttributes = collectIfAttributes(cc);
+  const { parent } = completedScope;
+  if (parent) {
+    weslContext.scope = parent;
+  }
+  completedScope.ifAttribute = ifAttributes == null ? void 0 : ifAttributes[0];
+  return completedScope;
+}
+function collectIfAttributes(cc) {
+  const attributes = cc.tags.attribute;
+  return filterIfAttributes(attributes);
+}
+function filterIfAttributes(attributes) {
+  if (!attributes) return;
+  return filterMap(
+    attributes,
+    (a) => a.attribute.kind === "@if" ? a.attribute : void 0
+  );
+}
+function collectVarLike(kind2) {
+  return collectElem(kind2, (cc, openElem) => {
+    var _a, _b;
+    const name2 = (_a = cc.tags.var_name) == null ? void 0 : _a[0];
+    const decl_scope = (_b = cc.tags.decl_scope) == null ? void 0 : _b[0];
+    const attributes = cc.tags.attribute;
+    const partElem = { ...openElem, name: name2, attributes };
+    const varElem = withTextCover(partElem, cc);
+    name2.decl.ident.declElem = varElem;
+    name2.decl.ident.scope = decl_scope;
+    return varElem;
+  });
+}
+const aliasCollect = collectElem(
+  "alias",
+  (cc, openElem) => {
+    var _a, _b, _c, _d;
+    const name2 = (_a = cc.tags.alias_name) == null ? void 0 : _a[0];
+    const alias_scope = (_b = cc.tags.alias_scope) == null ? void 0 : _b[0];
+    const typeRef = (_c = cc.tags.typeRefElem) == null ? void 0 : _c[0];
+    const attributes = ((_d = cc.tags.attributes) == null ? void 0 : _d.flat()) ?? [];
+    const partElem = { ...openElem, name: name2, attributes, typeRef };
+    const aliasElem = withTextCover(partElem, cc);
+    name2.ident.scope = alias_scope;
+    name2.ident.declElem = aliasElem;
+    return aliasElem;
+  }
+);
+const fnCollect = collectElem(
+  "fn",
+  (cc, openElem) => {
+    var _a;
+    const ourTags = fnTags(cc);
+    const { name: name2, headerScope, returnScope, bodyScope, body, params } = ourTags;
+    const { attributes, returnAttributes, returnType, fnScope } = ourTags;
+    const fnElem = {
+      ...openElem,
+      ...{ name: name2, attributes, params, returnAttributes, body, returnType }
+    };
+    fnScope.ifAttribute = (_a = filterIfAttributes(attributes)) == null ? void 0 : _a[0];
+    const mergedScope = headerScope;
+    returnScope && mergeScope(mergedScope, returnScope);
+    mergeScope(mergedScope, bodyScope);
+    const filtered = [];
+    for (const e of fnScope.contents) {
+      if (e === headerScope || e == returnScope) {
+        continue;
+      } else if (e === bodyScope) {
+        filtered.push(mergedScope);
+      } else {
+        filtered.push(e);
+      }
+    }
+    fnScope.contents = filtered;
+    name2.ident.declElem = fnElem;
+    name2.ident.scope = mergedScope;
+    return fnElem;
+  }
+);
+function fnTags(cc) {
+  const { fn_attributes, fn_name, fn_param, return_attributes } = cc.tags;
+  const { return_type } = cc.tags;
+  const { header_scope, return_scope, body_scope, body_statement } = cc.tags;
+  const { fn_partial_scope } = cc.tags;
+  const name2 = fn_name == null ? void 0 : fn_name[0];
+  const headerScope = header_scope == null ? void 0 : header_scope[0];
+  const returnScope = return_scope == null ? void 0 : return_scope[0];
+  const bodyScope = body_scope == null ? void 0 : body_scope[0];
+  const body = body_statement == null ? void 0 : body_statement[0];
+  const params = (fn_param == null ? void 0 : fn_param.flat(3)) ?? [];
+  const attributes = fn_attributes == null ? void 0 : fn_attributes.flat();
+  const returnAttributes = return_attributes == null ? void 0 : return_attributes.flat();
+  const returnType = return_type == null ? void 0 : return_type.flat(3)[0];
+  const fnScope = fn_partial_scope == null ? void 0 : fn_partial_scope[0];
+  return {
+    ...{ name: name2, headerScope, returnScope, bodyScope, body, params },
+    ...{ attributes, returnAttributes, returnType, fnScope }
+  };
+}
+const collectFnParam = collectElem(
+  "param",
+  (cc, openElem) => {
+    var _a, _b;
+    const name2 = (_a = cc.tags.param_name) == null ? void 0 : _a[0];
+    const attributes = ((_b = cc.tags.attributes) == null ? void 0 : _b.flat()) ?? [];
+    const elem = { ...openElem, name: name2, attributes };
+    const paramElem = withTextCover(elem, cc);
+    name2.decl.ident.declElem = paramElem;
+    return paramElem;
+  }
+);
+const collectStruct = collectElem(
+  "struct",
+  (cc, openElem) => {
+    var _a, _b, _c;
+    const name2 = (_a = cc.tags.type_name) == null ? void 0 : _a[0];
+    const members = cc.tags.members;
+    const attributes = ((_b = cc.tags.attributes) == null ? void 0 : _b.flat()) ?? [];
+    name2.ident.scope = (_c = cc.tags.struct_scope) == null ? void 0 : _c[0];
+    const structElem = { ...openElem, name: name2, attributes, members };
+    const elem = withTextCover(structElem, cc);
+    name2.ident.declElem = elem;
+    return elem;
+  }
+);
+const collectStructMember = collectElem(
+  "member",
+  (cc, openElem) => {
+    var _a, _b, _c;
+    const name2 = (_a = cc.tags.nameElem) == null ? void 0 : _a[0];
+    const typeRef = (_b = cc.tags.typeRefElem) == null ? void 0 : _b[0];
+    const attributes = (_c = cc.tags.attribute) == null ? void 0 : _c.flat(3);
+    const partElem = { ...openElem, name: name2, attributes, typeRef };
+    return withTextCover(partElem, cc);
+  }
+);
+const specialAttribute = collectElem(
+  "attribute",
+  (cc, openElem) => {
+    var _a;
+    const attribute = (_a = cc.tags.attr_variant) == null ? void 0 : _a[0];
+    const attrElem = { ...openElem, attribute };
+    return attrElem;
+  }
+);
+const assertCollect = attrElemCollect("assert");
+const statementCollect = attrElemCollect("statement");
+const switchClauseCollect = attrElemCollect("switch-clause");
+function attrElemCollect(kind2) {
+  return collectElem(kind2, (cc, openElem) => {
+    var _a;
+    const attributes = (_a = cc.tags.attribute) == null ? void 0 : _a.flat(3);
+    const partElem = { ...openElem, attributes };
+    return withTextCover(partElem, cc);
+  });
+}
+const collectAttribute = collectElem(
+  "attribute",
+  (cc, openElem) => {
+    var _a;
+    const params = cc.tags.attrParam;
+    const name2 = (_a = cc.tags.name) == null ? void 0 : _a[0];
+    const kind2 = "@attribute";
+    const stdAttribute = { kind: kind2, name: name2, params };
+    const attrElem = { ...openElem, attribute: stdAttribute };
+    return attrElem;
+  }
+);
+const typeRefCollect = collectElem(
+  "type",
+  // @ts-ignore
+  (cc, openElem) => {
+    var _a, _b;
+    let templateParamsTemp = (_a = cc.tags.templateParam) == null ? void 0 : _a.flat(3);
+    const typeRef = (_b = cc.tags.typeRefName) == null ? void 0 : _b[0];
+    const name2 = typeof typeRef === "string" ? typeRef : typeRef.ident;
+    const partElem = {
+      ...openElem,
+      name: name2,
+      templateParams: templateParamsTemp
+    };
+    return withTextCover(partElem, cc);
+  }
+);
+const expressionCollect = collectElem(
+  "expression",
+  (cc, openElem) => {
+    const partElem = { ...openElem };
+    return withTextCover(partElem, cc);
+  }
+);
+function globalAssertCollect(cc) {
+  var _a;
+  const globalAssert = (_a = cc.tags.const_assert) == null ? void 0 : _a.flat()[0];
+  const ast = cc.app.stable;
+  if (!ast.moduleAsserts) ast.moduleAsserts = [];
+  ast.moduleAsserts.push(globalAssert);
+}
+const stuffCollect = collectElem(
+  "stuff",
+  (cc, openElem) => {
+    const partElem = { ...openElem };
+    return withTextCover(partElem, cc);
+  }
+);
+const memberRefCollect = collectElem(
+  "memberRef",
+  (cc, openElem) => {
+    const { component, structRef, extra_components } = cc.tags;
+    const member = component[0];
+    const name2 = structRef == null ? void 0 : structRef.flat()[0];
+    const extraComponents = extra_components == null ? void 0 : extra_components.flat()[0];
+    const partElem = {
+      ...openElem,
+      name: name2,
+      member,
+      extraComponents
+    };
+    return withTextCover(partElem, cc);
+  }
+);
+function nameCollect(cc) {
+  const { start, end, src, app } = cc;
+  const name2 = src.slice(start, end);
+  const elem = { kind: "name", start, end, name: name2 };
+  addToOpenElem(cc, elem);
+  return elem;
+}
+const collectModule = collectElem(
+  "module",
+  (cc, openElem) => {
+    const ccComplete = { ...cc, start: 0, end: cc.src.length };
+    const moduleElem = withTextCover(openElem, ccComplete);
+    const weslState = cc.app.stable;
+    weslState.moduleElem = moduleElem;
+    return moduleElem;
+  }
+);
+function directiveCollect(cc) {
+  var _a, _b;
+  const { start, end } = cc;
+  const directive = (_a = cc.tags.directive) == null ? void 0 : _a.flat()[0];
+  const attributes = (_b = cc.tags.attribute) == null ? void 0 : _b.flat();
+  const kind2 = "directive";
+  const elem = { kind: kind2, attributes, start, end, directive };
+  addToOpenElem(cc, elem);
+  return elem;
+}
+const scopeCollect = {
+  before: startScope,
+  after: completeScope
+};
+const partialScopeCollect = {
+  before: startPartialScope,
+  after: completeScope
+};
+function collectElem(kind2, fn2) {
+  return {
+    before: (cc) => {
+      const partialElem = { kind: kind2, contents: [] };
+      const weslContext = cc.app.context;
+      weslContext.openElems.push(partialElem);
+    },
+    after: (cc) => {
+      const weslContext = cc.app.context;
+      const partialElem = weslContext.openElems.pop();
+      console.assert(partialElem && partialElem.kind === kind2);
+      const elem = fn2(cc, { ...partialElem, start: cc.start, end: cc.end });
+      if (elem) addToOpenElem(cc, elem);
+      return elem;
+    }
+  };
+}
+function withTextCover(elem, cc) {
+  const contents = coverWithText(cc, elem);
+  return { ...elem, contents };
+}
+function coverWithText(cc, elem) {
+  let { start: pos } = cc;
+  const ast = cc.app.stable;
+  const { contents, end } = elem;
+  const sorted = contents.sort((a, b) => a.start - b.start);
+  const elems = [];
+  for (const elem2 of sorted) {
+    if (pos < elem2.start) {
+      elems.push(makeTextElem(elem2.start));
+    }
+    elems.push(elem2);
+    pos = elem2.end;
+  }
+  if (pos < end) {
+    elems.push(makeTextElem(end));
+  }
+  return elems;
+  function makeTextElem(end2) {
+    return { kind: "text", start: pos, end: end2, srcModule: ast.srcModule };
+  }
+}
+const word = kind("word");
+kind("keyword");
+const qualified_ident = withSepPlus("::", or(word, "package", "super"));
+const number = kind("number");
+function makeStatement(segments, finalSegment) {
+  return { kind: "import-statement", segments, finalSegment };
+}
+function makeSegment(name2) {
+  return { kind: "import-segment", name: name2 };
+}
+function makeCollection(subtrees) {
+  return {
+    kind: "import-collection",
+    subtrees
+  };
+}
+function makeItem(name2, as) {
+  return { kind: "import-item", name: name2, as };
+}
+function prependSegments(segments, statement2) {
+  statement2.segments = segments.concat(statement2.segments);
+  return statement2;
+}
+let import_collection = null;
+const import_path_or_item = seq(
+  word,
+  or(
+    preceded(
+      "::",
+      req(
+        or(
+          fn(() => import_collection),
+          fn(() => import_path_or_item)
+        ),
+        "invalid import, expected '{' or name"
+      )
+    ),
+    preceded("as", req(word, "invalid alias, expected name")).map(
+      (v) => makeItem("", v)
+    ),
+    yes().map(() => makeItem(""))
+    // Optional
+  )
+).map(([name2, next]) => {
+  if (next.kind === "import-collection") {
+    return makeStatement([makeSegment(name2)], next);
+  } else if (next.kind === "import-statement") {
+    return prependSegments([makeSegment(name2)], next);
+  } else if (next.kind === "import-item") {
+    next.name = name2;
+    return makeStatement([], next);
+  } else {
+    assertUnreachable(next);
+  }
+});
+import_collection = delimited(
+  "{",
+  withSepPlus(",", () => import_path_or_item).map(makeCollection),
+  req("}", "invalid import collection, expected }")
+);
+const import_relative = or(
+  terminated("package", req("::", "invalid import, expected '::'")).map((v) => [
+    makeSegment(v)
+  ]),
+  repeatPlus(
+    terminated("super", req("::", "invalid import, expected '::'")).map(
+      makeSegment
+    )
+  )
+);
+const import_statement = span(
+  delimited(
+    "import",
+    seqObj({
+      relative: opt(import_relative),
+      collection_or_statement: req(
+        or(import_collection, import_path_or_item),
+        "invalid import, expected { or name"
+      )
+    }).map(({ relative, collection_or_statement }) => {
+      if (collection_or_statement.kind === "import-statement") {
+        return prependSegments(relative ?? [], collection_or_statement);
+      } else {
+        return makeStatement(relative ?? [], collection_or_statement);
+      }
+    }),
+    req(";", "invalid import, expected ';'")
+  )
+).map(
+  (v) => ({
+    kind: "import",
+    imports: v.value,
+    start: v.span[0],
+    end: v.span[1]
+  })
+);
+const weslImports = tagScope(
+  repeat(import_statement).ptag("owo").collect(importElem)
+);
+const keywords = `alias break case const const_assert continue continuing 
+  default diagnostic discard else enable false fn for if 
+  let loop override requires return struct switch true var while`.split(/\s+/);
+const reservedWords = `NULL Self abstract active alignas alignof as asm asm_fragment async attribute auto await 
+  become binding_array cast catch class co_await co_return co_yield coherent column_major 
+  common compile compile_fragment concept const_cast consteval constexpr constinit crate 
+  debugger decltype delete demote demote_to_helper do dynamic_cast 
+  enum explicit export extends extern external fallthrough filter final finally friend from fxgroup 
+  get goto groupshared highp impl implements import inline instanceof interface layout lowp 
+  macro macro_rules match mediump meta mod module move mut mutable 
+  namespace new nil noexcept noinline nointerpolation non_coherent noncoherent noperspective null nullptr 
+  of operator package packoffset partition pass patch pixelfragment precise precision premerge 
+  priv protected pub public readonly ref regardless register reinterpret_cast require resource restrict 
+  self set shared sizeof smooth snorm static static_assert static_cast std subroutine super 
+  target template this thread_local throw trait try type typedef typeid typename typeof 
+  union unless unorm unsafe unsized use using varying virtual volatile wgsl where with writeonly yield`.split(
+  /\s+/
+);
+const blankspaces = /[ \t\n\v\f\r\u{0085}\u{200E}\u{200F}\u{2028}\u{2029}]+/u;
+const symbolSet = "& && -> @ / ! [ ] { } :: : , == = != >>= >> >= > <<= << <= < % - -- . + ++ | || ( ) ; * ~ ^ // /* */ += -= *= /= %= &= |= ^= _";
+const ident = /(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))/u;
+const keywordOrReserved = new Set(keywords.concat(reservedWords));
+const digits = new RegExp(
+  // decimal_float_literal
+  /(?:0[fh])|(?:[1-9][0-9]*[fh])/.source + /|(?:[0-9]*\.[0-9]+(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+\.[0-9]*(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+[eE][+-]?[0-9]+[fh]?)/.source + // hex_float_literal
+  /|(?:0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+[pP][+-]?[0-9]+[fh]?)/.source + // hex_int_literal
+  /|(?:0[xX][0-9a-fA-F]+[iu]?)/.source + // decimal_int_literal
+  /|(?:0[iu]?)|(?:[1-9][0-9]*[iu]?)/.source
+);
+const commentStart = /\/\/|\/\*/;
+const weslMatcher = new RegexMatchers({
+  word: ident,
+  number: digits,
+  blankspaces,
+  commentStart,
+  symbol: matchOneOf(symbolSet),
+  invalid: /[^]/
+});
+function weslExtension(combinator) {
+  return combinator;
+}
+class WeslStream {
+  constructor(src) {
+    this.src = src;
+    this.eolPattern = /[\n\v\f\u{0085}\u{2028}\u{2029}]|\r\n?/gu;
+    this.blockCommentPattern = /\/\*|\*\//g;
+    this.stream = new CachingStream(new MatchersStream(src, weslMatcher));
+  }
+  checkpoint() {
+    return this.stream.checkpoint();
+  }
+  reset(position) {
+    this.stream.reset(position);
+  }
+  nextToken() {
+    while (true) {
+      const token2 = this.stream.nextToken();
+      if (token2 === null) return null;
+      const kind2 = token2.kind;
+      if (kind2 === "blankspaces") {
+        continue;
+      } else if (kind2 === "commentStart") {
+        if (token2.text === "//") {
+          this.stream.reset(this.skipToEol(token2.span[1]));
+        } else {
+          this.stream.reset(this.skipBlockComment(token2.span[1]));
+        }
+      } else if (kind2 === "word") {
+        let returnToken = token2;
+        if (keywordOrReserved.has(token2.text)) {
+          returnToken.kind = "keyword";
+        }
+        return returnToken;
+      } else if (kind2 === "invalid") {
+        throw new ParseError(
+          "Invalid token " + token2.text,
+          this.stream.checkpoint()
+        );
+      } else {
+        return token2;
+      }
+    }
+  }
+  skipToEol(position) {
+    this.eolPattern.lastIndex = position;
+    const result = this.eolPattern.exec(this.src);
+    if (result === null) {
+      return this.src.length;
+    } else {
+      return this.eolPattern.lastIndex;
+    }
+  }
+  skipBlockComment(position) {
+    while (true) {
+      this.blockCommentPattern.lastIndex = position;
+      const result = this.blockCommentPattern.exec(this.src);
+      if (result === null) {
+        throw new ParseError("Unclosed block comment!", position);
+      } else if (result[0] === "*/") {
+        return this.blockCommentPattern.lastIndex;
+      } else if (result[0] === "/*") {
+        position = this.skipBlockComment(this.blockCommentPattern.lastIndex);
+      } else {
+        throw new Error("Unreachable, invalid block comment pattern");
+      }
+    }
+  }
+  /**
+   * Only matches the `<` token if it is a template
+   * Precondition: An ident was parsed right before this.
+   * Runs the [template list discovery algorithm](https://www.w3.org/TR/WGSL/#template-list-discovery).
+   */
+  nextTemplateStartToken() {
+    const startPosition = this.stream.checkpoint();
+    const token2 = this.nextToken();
+    this.stream.reset(startPosition);
+    if (token2 === null) return null;
+    if (token2.kind !== "symbol") {
+      return null;
+    }
+    if (token2.text === "<") {
+      if (this.isTemplateStart(token2.span[1])) {
+        this.stream.reset(token2.span[1]);
+        return token2;
+      } else {
+        this.stream.reset(startPosition);
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+  nextTemplateEndToken() {
+    const startPosition = this.stream.checkpoint();
+    const token2 = this.nextToken();
+    this.stream.reset(startPosition);
+    if (token2 === null) return null;
+    if (token2.kind === "symbol" && token2.text[0] === ">") {
+      const tokenPosition = token2.span[0];
+      this.stream.reset(tokenPosition + 1);
+      return {
+        kind: "symbol",
+        span: [tokenPosition, tokenPosition + 1],
+        text: ">"
+      };
+    } else {
+      return null;
+    }
+  }
+  isTemplateStart(afterToken) {
+    this.stream.reset(afterToken);
+    let pendingCounter = 1;
+    while (true) {
+      const nextToken = this.stream.nextToken();
+      if (nextToken === null) return false;
+      if (nextToken.kind !== "symbol") continue;
+      if (nextToken.text === "<") {
+        pendingCounter += 1;
+      } else if (nextToken.text[0] === ">") {
+        if (nextToken.text === ">" || nextToken.text == ">=") {
+          pendingCounter -= 1;
+        } else if (nextToken.text === ">>=" || nextToken.text === ">>") {
+          pendingCounter -= 2;
+        } else {
+          throw new Error(
+            "This case should never be reached, looks like we forgot one of the tokens that start with >"
+          );
+        }
+        if (pendingCounter <= 0) {
+          return true;
+        }
+      } else if (nextToken.text === "(") {
+        this.skipBracketsTo(")");
+      } else if (nextToken.text === "[") {
+        this.skipBracketsTo("]");
+      } else if (nextToken.text === "==" || nextToken.text === "!=" || nextToken.text === ";" || nextToken.text === "{" || nextToken.text === ":" || nextToken.text === "&&" || nextToken.text === "||") {
+        return false;
+      }
+    }
+  }
+  /**
+   * Call this after consuming an opening bracket.
+   * Skips until a closing bracket. This also consumes the closing bracket.
+   */
+  skipBracketsTo(closingBracket) {
+    while (true) {
+      const nextToken = this.stream.nextToken();
+      if (nextToken === null)
+        throw new ParseError("Unclosed bracket!", this.stream.checkpoint());
+      if (nextToken.kind !== "symbol") continue;
+      if (nextToken.text === "(") {
+        this.skipBracketsTo(")");
+      } else if (nextToken.text === "[") {
+        this.skipBracketsTo("]");
+      } else if (nextToken.text === closingBracket) {
+        return;
+      }
+    }
+  }
+}
+const templateOpen = withStreamAction((stream) => {
+  return stream.nextTemplateStartToken();
+});
+const templateClose = withStreamAction((stream) => {
+  return stream.nextTemplateEndToken();
+});
+const opt_template_list = opt(
+  seq(
+    templateOpen,
+    withSepPlus(",", () => template_parameter),
+    req(templateClose, "invalid template, expected '>'")
+  )
+);
+const template_elaborated_ident = seq(
+  qualified_ident.collect(refIdent),
+  opt_template_list
+);
+const literal = or("true", "false", number);
+const paren_expression = seq(
+  "(",
+  () => expression,
+  req(")", "invalid expression, expected ')'")
+);
+const primary_expression = or(
+  literal,
+  paren_expression,
+  seq(template_elaborated_ident, opt(fn(() => argument_expression_list)))
+);
+const component_or_swizzle = repeatPlus(
+  or(
+    preceded(".", word),
+    collectArray(
+      delimited(
+        "[",
+        () => expression,
+        req("]", "invalid expression, expected ']'")
+      )
+    )
+  )
+);
+const simple_component_reference = tagScope(
+  seq(
+    qualified_ident.collect(refIdent, "structRef"),
+    seq(".", word.collect(nameCollect, "component")),
+    opt(component_or_swizzle.collect(stuffCollect, "extra_components"))
+  ).collect(memberRefCollect)
+);
+const unary_expression = or(
+  seq(tokenOf("symbol", ["!", "&", "*", "-", "~"]), () => unary_expression),
+  or(
+    simple_component_reference,
+    seq(primary_expression, opt(component_or_swizzle))
+  )
+);
+const bitwise_post_unary = or(
+  // LATER I can skip template list discovery in these cases, because a&b<c cannot be a comparison. Must be a template
+  repeatPlus(seq("&", unary_expression)),
+  repeatPlus(seq("^", unary_expression)),
+  repeatPlus(seq("|", unary_expression))
+);
+const multiplicative_operator = or("%", "*", "/");
+const additive_operator = or("+", "-");
+const shift_post_unary = (inTemplate) => {
+  const shift_left = seq("<<", unary_expression);
+  const shift_right = seq(">>", unary_expression);
+  const mul_add = seq(
+    repeat(seq(multiplicative_operator, unary_expression)),
+    repeat(
+      seq(
+        additive_operator,
+        unary_expression,
+        repeat(seq(multiplicative_operator, unary_expression))
+      )
+    )
+  );
+  return inTemplate ? or(shift_left, mul_add) : or(shift_left, shift_right, mul_add);
+};
+const relational_post_unary = (inTemplate) => {
+  return seq(
+    shift_post_unary(inTemplate),
+    opt(
+      seq(
+        // '<' is unambiguous, since templates were already caught by the primary expression inside of the previous unary_expression!
+        inTemplate ? tokenOf("symbol", ["<", "<=", "!=", "=="]) : tokenOf("symbol", [">", ">=", "<", "<=", "!=", "=="]),
+        // LATER I can skip template list discovery in this cases, because a>=b<c cannot be a comparison. Must be a template
+        unary_expression,
+        shift_post_unary(inTemplate)
+      )
+    )
+  );
+};
+const expressionParser = (inTemplate) => {
+  return seq(
+    unary_expression,
+    or(
+      bitwise_post_unary,
+      seq(
+        relational_post_unary(inTemplate),
+        inTemplate ? (
+          // Don't accept || or && in template mode
+          yes()
+        ) : or(
+          repeatPlus(
+            seq("||", seq(unary_expression, relational_post_unary(false)))
+          ),
+          repeatPlus(
+            seq("&&", seq(unary_expression, relational_post_unary(false)))
+          ),
+          yes().map(() => [])
+        )
+      )
+    )
+  );
+};
+let maybe_template = false;
+const expression = expressionParser(maybe_template);
+let is_template = true;
+const template_arg_expression = expressionParser(is_template);
+const std_type_specifier = seq(
+  qualified_ident.collect(refIdent, "typeRefName"),
+  () => opt_template_list
+).collect(typeRefCollect);
+const type_specifier = tagScope(
+  std_type_specifier
+).ctag("typeRefElem");
+const template_parameter = or(
+  // LATER Remove this, it's wrong. This should instead be done by inspecting the syntax tree.
+  type_specifier.ctag("templateParam"),
+  template_arg_expression.collect(expressionCollect, "templateParam")
+);
+const argument_expression_list = seq(
+  "(",
+  withSep(",", expression),
+  req(")", "invalid fn arguments, expected ')'")
+);
+const name = tokenKind("word").map(makeName);
+const diagnostic_rule_name = seq(
+  name,
+  opt(preceded(".", req(name, "invalid diagnostic rule name, expected name")))
+);
+const diagnostic_control = delimited(
+  "(",
+  req(
+    separated_pair(name, ",", diagnostic_rule_name),
+    "invalid diagnostic control, expected rule name"
+  ),
+  seq(opt(","), req(")", "invalid diagnostic control, expected ')'"))
+);
+const name_list = withSep(",", name, { requireOne: true });
+const special_attribute = tagScope(
+  preceded(
+    "@",
+    or(
+      // These attributes have no arguments
+      or("compute", "const", "fragment", "invariant", "must_use", "vertex").map((name2) => makeStandardAttribute([name2, []])),
+      // These attributes have arguments, but the argument doesn't have any identifiers
+      preceded("interpolate", req(delimited("(", name_list, ")"), "invalid @interpolate, expected '('")).map(makeInterpolateAttribute),
+      preceded("builtin", req(delimited("(", name, ")"), "invalid @builtin, expected '('")).map(makeBuiltinAttribute),
+      preceded("diagnostic", req(diagnostic_control, "invalid @diagnostic, expected '('")).map(makeDiagnosticAttribute)
+    ).ptag("attr_variant")
+  ).collect(specialAttribute)
+);
+const if_attribute = tagScope(
+  preceded(
+    seq("@", weslExtension("if")),
+    span(
+      delimited(
+        "(",
+        fn(() => attribute_if_expression),
+        seq(opt(","), ")")
+      )
+    ).map(makeTranslateTimeExpressionElem)
+  ).map(makeIfAttribute).ptag("attr_variant").collect(specialAttribute)
+);
+const normal_attribute = tagScope(
+  preceded(
+    "@",
+    or(
+      // These are normal attributes, with required arguments
+      seq(
+        or(
+          "workgroup_size",
+          "align",
+          "binding",
+          "blend_src",
+          "group",
+          "id",
+          "location",
+          "size"
+        ).ptag("name"),
+        req(() => attribute_argument_list, "invalid attribute, expected '('")
+      ),
+      // Everything else is also a normal attribute, optional expression list
+      seq(
+        // we don't want this to interfere with if_attribute, 
+        // but not("if") isn't necessary for now, since 'if' is a keyword, not a word
+        word.ptag("name"),
+        opt(() => attribute_argument_list)
+      )
+    )
+  ).collect(collectAttribute)
+);
+const attribute_argument_list = delimited(
+  "(",
+  withSep(
+    ",",
+    span(fn(() => expression)).collect(expressionCollect, "attrParam")
+    // LATER These unknown expressions have decls inside of them, that's why they're tough to replace!
+  ),
+  req(")", "invalid attribute arguments, expected ')'")
+);
+const attribute_no_if = or(
+  special_attribute,
+  normal_attribute
+).ctag("attribute");
+const attribute_incl_if = or(
+  if_attribute,
+  special_attribute,
+  normal_attribute
+).ctag("attribute");
+const opt_attributes = repeat(attribute_incl_if);
+const opt_attributes_no_if = repeat(attribute_no_if);
+const globalTypeNameDecl = req(
+  word.collect(globalDeclCollect, "type_name"),
+  "invalid type name, expected a name"
+);
+const fnNameDecl = req(
+  word.collect(globalDeclCollect, "fn_name"),
+  "missing fn name"
+);
+const optionally_typed_ident = tagScope(
+  seq(
+    word.collect(declCollect, "decl_elem"),
+    opt(seq(":", type_specifier))
+  ).collect(typedDecl)
+).ctag("var_name");
+const req_optionally_typed_ident = req(optionally_typed_ident, "invalid ident");
+const global_ident = tagScope(
+  req(
+    seq(
+      word.collect(globalDeclCollect, "decl_elem"),
+      opt(seq(":", type_specifier))
+    ).collect(typedDecl),
+    "expected identifier"
+  )
+).ctag("var_name");
+const struct_member = tagScope(
+  seq(
+    opt_attributes,
+    word.collect(nameCollect, "nameElem"),
+    req(":", "invalid struct member, expected ':'"),
+    req(type_specifier, "invalid struct member, expected type specifier")
+  ).collect(collectStructMember)
+).ctag("members");
+const struct_decl = seq(
+  weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"),
+  "struct",
+  req(globalTypeNameDecl, "invalid struct, expected name"),
+  seq(
+    req("{", "invalid struct, expected '{'"),
+    withSepPlus(",", struct_member),
+    req("}", "invalid struct, expected '}'")
+  ).collect(scopeCollect, "struct_scope")
+).collect(collectStruct);
+const fn_call = seq(
+  qualified_ident.collect(refIdent),
+  () => opt_template_list,
+  argument_expression_list
+);
+const fnParam = tagScope(
+  seq(
+    opt_attributes.collect((cc) => cc.tags.attribute, "attributes"),
+    word.collect(declCollect, "decl_elem"),
+    opt(seq(":", req(type_specifier, "invalid fn parameter, expected type specifier"))).collect(typedDecl, "param_name")
+  ).collect(collectFnParam)
+).ctag("fn_param");
+const fnParamList = seq("(", withSep(",", fnParam), ")");
+const local_variable_decl = seq(
+  "var",
+  () => opt_template_list,
+  req_optionally_typed_ident,
+  opt(seq("=", () => expression))
+  // no decl_scope, but I think that's ok
+).collect(collectVarLike("var"));
+const global_variable_decl = seq(
+  "var",
+  () => opt_template_list,
+  global_ident,
+  // TODO shouldn't decl_scope include the ident type?
+  opt(seq("=", () => expression.collect(scopeCollect, "decl_scope")))
+);
+const attribute_if_primary_expression = or(
+  tokenOf("keyword", ["true", "false"]).map(makeLiteral),
+  delimited(
+    token("symbol", "("),
+    fn(() => attribute_if_expression),
+    token("symbol", ")")
+  ).map(makeParenthesizedExpression),
+  tokenKind("word").map(makeTranslateTimeFeature)
+);
+const attribute_if_unary_expression = or(
+  seq(
+    token("symbol", "!").map(makeUnaryOperator),
+    fn(() => attribute_if_unary_expression)
+  ).map(makeUnaryExpression),
+  attribute_if_primary_expression
+);
+const attribute_if_expression = weslExtension(
+  seq(
+    attribute_if_unary_expression,
+    or(
+      repeatPlus(
+        seq(
+          token("symbol", "||").map(makeBinaryOperator),
+          req(
+            attribute_if_unary_expression,
+            "invalid expression, expected expression"
+          )
+        )
+      ),
+      repeatPlus(
+        seq(
+          token("symbol", "&&").map(makeBinaryOperator),
+          req(
+            attribute_if_unary_expression,
+            "invalid expression, expected expression"
+          )
+        )
+      ),
+      yes().map(() => [])
+    )
+  ).map(makeRepeatingBinaryExpression)
+);
+const unscoped_compound_statement = seq(
+  opt_attributes,
+  text("{"),
+  repeat(() => statement),
+  req("}", "invalid block, expected }")
+).collect(statementCollect);
+const compound_statement = tagScope(
+  seq(
+    opt_attributes,
+    seq(
+      text("{"),
+      repeat(() => statement),
+      req("}", "invalid block, expected '}'")
+    ).collect(scopeCollect)
+  ).collect(statementCollect)
+);
+const for_init = seq(
+  opt_attributes,
+  or(
+    fn_call,
+    () => variable_or_value_statement,
+    () => variable_updating_statement
+  )
+);
+const for_update = seq(
+  opt_attributes,
+  or(fn_call, () => variable_updating_statement)
+);
+const for_statement = seq(
+  // LATER consider allowing @if on for_init, expression and for_update
+  "for",
+  seq(
+    req("(", "invalid for loop, expected '('"),
+    opt(for_init),
+    req(";", "invalid for loop, expected ';'"),
+    opt(expression),
+    req(";", "invalid for loop, expected ';'"),
+    opt(for_update),
+    req(")", "invalid for loop, expected ')'"),
+    unscoped_compound_statement
+  ).collect(scopeCollect)
+);
+const if_statement = seq(
+  "if",
+  req(seq(expression, compound_statement), "invalid if statement"),
+  repeat(
+    seq(
+      "else",
+      "if",
+      req(seq(expression, compound_statement), "invalid else if branch")
+    )
+  ),
+  opt(
+    seq("else", req(compound_statement, "invalid else branch, expected '{'"))
+  )
+);
+const loop_statement = seq(
+  "loop",
+  opt_attributes_no_if,
+  req(
+    seq(
+      "{",
+      repeat(() => statement),
+      opt(
+        tagScope(
+          seq(
+            opt_attributes,
+            "continuing",
+            opt_attributes_no_if,
+            "{",
+            repeat(() => statement),
+            tagScope(
+              opt(
+                seq(
+                  opt_attributes,
+                  seq("break", "if", expression, ";")
+                ).collect(statementCollect)
+              )
+            ),
+            "}"
+          ).collect(statementCollect).collect(scopeCollect)
+        )
+      ),
+      "}"
+    ),
+    "invalid loop statement"
+  )
+).collect(scopeCollect);
+const case_selector = or("default", expression);
+const switch_clause = tagScope(
+  seq(
+    opt_attributes,
+    or(
+      seq(
+        "case",
+        withSep(",", case_selector, { requireOne: true }),
+        opt(":"),
+        compound_statement
+      ),
+      seq("default", opt(":"), compound_statement)
+    ).collect(switchClauseCollect)
+  )
+);
+const switch_body = seq(opt_attributes, "{", repeatPlus(switch_clause), "}");
+const switch_statement = seq("switch", expression, switch_body);
+const while_statement = seq("while", expression, compound_statement);
+const regular_statement = or(
+  for_statement,
+  if_statement,
+  loop_statement,
+  switch_statement,
+  while_statement,
+  seq("break", ";"),
+  // ambiguous with break if
+  seq("continue", req(";", "invalid statement, expected ';'")),
+  seq(";"),
+  // LATER this one cannot have attributes in front of it
+  () => const_assert,
+  seq("discard", req(";", "invalid statement, expected ';'")),
+  seq("return", opt(expression), req(";", "invalid statement, expected ';'")),
+  seq(fn_call, req(";", "invalid statement, expected ';'")),
+  seq(
+    () => variable_or_value_statement,
+    req(";", "invalid statement, expected ';'")
+  ),
+  seq(
+    () => variable_updating_statement,
+    req(";", "invalid statement, expected ';'")
+  )
+);
+const conditional_statement = tagScope(
+  seq(
+    opt_attributes,
+    regular_statement
+  ).collect(statementCollect).collect(partialScopeCollect)
+);
+const unconditional_statement = tagScope(
+  seq(
+    opt_attributes_no_if,
+    regular_statement
+  )
+);
+const statement = or(
+  compound_statement,
+  unconditional_statement,
+  conditional_statement
+);
+const lhs_expression = or(
+  simple_component_reference,
+  seq(
+    qualified_ident.collect(refIdent),
+    opt(component_or_swizzle)
+  ),
+  seq(
+    "(",
+    () => lhs_expression,
+    ")",
+    opt(component_or_swizzle)
+    // LATER this doesn't find member references.
+  ),
+  seq("&", () => lhs_expression),
+  seq("*", () => lhs_expression)
+);
+const variable_or_value_statement = tagScope(
+  // LATER consider collecting these as var elems and scopes
+  or(
+    // Also covers the = expression case
+    local_variable_decl,
+    seq("const", req_optionally_typed_ident, req("=", "invalid const declaration, expected '='"), expression),
+    seq(
+      "let",
+      req_optionally_typed_ident,
+      req("=", "invalid let declaration, expected '='"),
+      expression
+    )
+  )
+);
+const variable_updating_statement = or(
+  seq(
+    lhs_expression,
+    or("=", "<<=", ">>=", "%=", "&=", "*=", "+=", "-=", "/=", "^=", "|="),
+    expression
+  ),
+  seq(lhs_expression, or("++", "--")),
+  seq("_", "=", expression)
+);
+const fn_decl = seq(
+  tagScope(
+    opt_attributes.collect((cc) => cc.tags.attribute || [])
+  ).ctag("fn_attributes"),
+  text("fn"),
+  req(fnNameDecl, "invalid fn, expected function name"),
+  seq(
+    req(fnParamList, "invalid fn, expected function parameters").collect(scopeCollect, "header_scope"),
+    opt(seq(
+      "->",
+      opt_attributes.collect((cc) => cc.tags.attribute, "return_attributes"),
+      type_specifier.ctag("return_type").collect(scopeCollect, "return_scope")
+    )),
+    req(
+      unscoped_compound_statement,
+      "invalid fn, expected function body"
+    ).ctag("body_statement").collect(scopeCollect, "body_scope")
+  )
+).collect(partialScopeCollect, "fn_partial_scope").collect(fnCollect);
+const global_value_decl = or(
+  seq(
+    opt_attributes,
+    "override",
+    global_ident,
+    seq(opt(seq("=", expression.collect(scopeCollect, "decl_scope")))),
+    // TODO partial scopes for decl_scopes?
+    ";"
+  ).collect(collectVarLike("override")),
+  seq(
+    opt_attributes,
+    "const",
+    global_ident,
+    "=",
+    seq(expression).collect(scopeCollect, "decl_scope"),
+    ";"
+  ).collect(collectVarLike("const"))
+);
+const global_alias = seq(
+  weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"),
+  "alias",
+  req(word, "invalid alias, expected name").collect(globalDeclCollect, "alias_name"),
+  req("=", "invalid alias, expected '='"),
+  req(type_specifier, "invalid alias, expected type").collect(scopeCollect, "alias_scope"),
+  req(";", "invalid alias, expected ';'")
+).collect(aliasCollect);
+const const_assert = tagScope(
+  seq(
+    opt_attributes,
+    "const_assert",
+    req(expression, "invalid const_assert, expected expression"),
+    req(";", "invalid statement, expected ';'")
+  ).collect(assertCollect)
+).ctag("const_assert");
+const global_directive = tagScope(
+  seq(
+    opt_attributes,
+    terminated(
+      or(
+        preceded("diagnostic", diagnostic_control).map(makeDiagnosticDirective),
+        preceded("enable", name_list).map(makeEnableDirective),
+        preceded("requires", name_list).map(makeRequiresDirective)
+      ).ptag("directive"),
+      ";"
+    )
+  ).collect(directiveCollect)
+);
+const global_decl = tagScope(
+  or(
+    fn_decl,
+    seq(
+      opt_attributes,
+      global_variable_decl,
+      ";"
+    ).collect(collectVarLike("gvar")),
+    global_value_decl,
+    ";",
+    global_alias,
+    const_assert.collect(globalAssertCollect),
+    struct_decl
+  )
+);
+const weslRoot = seq(
+  weslExtension(weslImports),
+  repeat(global_directive),
+  repeat(global_decl),
+  req(eof(), "invalid WESL, expected EOF")
+).collect(collectModule, "collectModule");
+function makeDiagnosticDirective([severity, rule]) {
+  return { kind: "diagnostic", severity, rule };
+}
+function makeEnableDirective(extensions) {
+  return { kind: "enable", extensions };
+}
+function makeRequiresDirective(extensions) {
+  return { kind: "requires", extensions };
+}
+function makeStandardAttribute([name2, params]) {
+  return {
+    kind: "@attribute",
+    name: name2,
+    params
+  };
+}
+function makeInterpolateAttribute(params) {
+  return {
+    kind: "@interpolate",
+    params
+  };
+}
+function makeBuiltinAttribute(param) {
+  return {
+    kind: "@builtin",
+    param
+  };
+}
+function makeDiagnosticAttribute([severity, rule]) {
+  return {
+    kind: "@diagnostic",
+    severity,
+    rule
+  };
+}
+function makeIfAttribute(param) {
+  return {
+    kind: "@if",
+    param
+  };
+}
+function makeTranslateTimeExpressionElem(args) {
+  return {
+    kind: "translate-time-expression",
+    expression: args.value,
+    span: args.span
+  };
+}
+function makeName(token2) {
+  return {
+    kind: "name",
+    name: token2.text,
+    start: token2.span[0],
+    end: token2.span[1]
+  };
+}
+function makeLiteral(token2) {
+  return {
+    kind: "literal",
+    value: token2.text,
+    span: token2.span
+  };
+}
+function makeTranslateTimeFeature(token2) {
+  return {
+    kind: "translate-time-feature",
+    name: token2.text,
+    span: token2.span
+  };
+}
+function makeParenthesizedExpression(expression2) {
+  return {
+    kind: "parenthesized-expression",
+    expression: expression2
+  };
+}
+function makeUnaryOperator(token2) {
+  return {
+    value: token2.text,
+    span: token2.span
+  };
+}
+function makeBinaryOperator(token2) {
+  return {
+    value: token2.text,
+    span: token2.span
+  };
+}
+function makeUnaryExpression([operator, expression2]) {
+  return {
+    kind: "unary-expression",
+    operator,
+    expression: expression2
+  };
+}
+function makeRepeatingBinaryExpression([start, repeating]) {
+  let result = start;
+  for (const [op, left] of repeating) {
+    result = makeBinaryExpression([result, op, left]);
+  }
+  return result;
+}
+function makeBinaryExpression([left, operator, right]) {
+  return {
+    kind: "binary-expression",
+    operator,
+    left,
+    right
+  };
+}
+/*!
+Copyright (c) 2017-2021 [these people](https://github.com/Rich-Harris/vlq/graphs/contributors)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+let integer_to_char = {};
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("").forEach(function(char, i) {
+  integer_to_char[i] = char;
+});
+function encodeVlq(value) {
+  if (typeof value === "number") {
+    return encode_integer(value);
+  }
+  let result = "";
+  for (let i = 0; i < value.length; i += 1) {
+    result += encode_integer(value[i]);
+  }
+  return result;
+}
+function encode_integer(num) {
+  let result = "";
+  if (num < 0) {
+    num = -num << 1 | 1;
+  } else {
+    num <<= 1;
+  }
+  do {
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0) {
+      clamped |= 32;
+    }
+    result += integer_to_char[clamped];
+  } while (num > 0);
+  return result;
+}
+function makeWeslDevice(device) {
+  const errorScopeStack = [];
+  device.injectError = (type, error) => {
+    const errorScope = errorScopeStack.findLast((v) => v.filter === type);
+    if (errorScope !== void 0) {
+      errorScope.errors.push(error);
+    } else {
+      error.then((e) => {
+        if (e !== null) {
+          dispatchError(e);
+        }
+      });
+    }
+  };
+  function dispatchError(e) {
+    device.addEventListener(
+      "uncapturederror",
+      (ev) => {
+        if (!ev.defaultPrevented) {
+          if ("compilationInfo" in ev.error) {
+            const error = ev.error;
+            if (error.compilationInfo) {
+              for (const message of error.compilationInfo.messages) {
+                throwClickableError({
+                  url: message.module.url,
+                  text: message.module.text ?? null,
+                  lineNumber: message.lineNum,
+                  lineColumn: message.linePos,
+                  length: message.length,
+                  error: new Error(message.type + ": " + message.message)
+                });
+              }
+            } else {
+              console.error(ev.error.message);
+            }
+          } else {
+            console.error(ev.error.message);
+          }
+        }
+      },
+      {
+        // This event listener should only happen for this event!
+        once: true
+      }
+    );
+    device.dispatchEvent(
+      new GPUUncapturedErrorEvent("uncapturederror", { error: e })
+    );
+  }
+  device.pushErrorScope = /* @__PURE__ */ ((baseFn) => {
+    return function(filter) {
+      errorScopeStack.push({
+        filter,
+        errors: []
+      });
+      return baseFn.call(this, filter);
+    };
+  })(device.pushErrorScope);
+  device.popErrorScope = /* @__PURE__ */ ((baseFn) => {
+    return function() {
+      const errorScope = errorScopeStack.pop();
+      if (errorScope === void 0) {
+        throw new DOMException(
+          "popErrorScope called on empty error scope stack",
+          "OperationError"
+        );
+      }
+      errorScope.errors.push(baseFn.call(this));
+      const errorPromise = Promise.all(errorScope.errors).then(
+        (values) => values.find((v) => v !== null) ?? null
+      );
+      return errorPromise;
+    };
+  })(device.popErrorScope);
+  return device;
+}
+function throwClickableError({
+  url,
+  text: text2,
+  lineNumber,
+  lineColumn,
+  length,
+  error
+}) {
+  let mappings = encodeVlq([
+    0,
+    0,
+    Math.max(0, lineNumber - 1),
+    Math.max(0, lineColumn - 1)
+  ]) + "," + // Sadly no browser makes use of this info to map the error properly
+  encodeVlq([
+    18,
+    // Arbitrary number that is high enough
+    0,
+    Math.max(0, lineNumber - 1),
+    Math.max(0, lineColumn - 1) + length
+  ]);
+  const sourceMap = {
+    version: 3,
+    file: null,
+    sources: [url],
+    sourcesContent: [text2 ?? null],
+    names: [],
+    mappings
+  };
+  let generatedCode = `throw new Error(${JSON.stringify(error.message + "")})`;
+  generatedCode += "\n//# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));
+  generatedCode += "\n//# sourceURL=" + sourceMap.sources[0];
+  let oldLimit = 0;
+  if ("stackTraceLimit" in Error) {
+    oldLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 1;
+  }
+  try {
+    (0, eval)(generatedCode);
+  } catch (e) {
+    if ("stackTraceLimit" in Error) {
+      Error.stackTraceLimit = oldLimit;
+    }
+    error.message = "";
+    e.cause = error;
+    throw e;
+  }
+}
+class WeslParseError extends Error {
+  constructor(opts) {
+    const source = opts.src.src;
+    const [lineNum, linePos] = offsetToLineNumber(opts.cause.position, source);
+    let message = `${opts.src.debugFilePath}:${lineNum}:${linePos}`;
+    message += ` error: ${opts.cause.message}
+`;
+    message += errorHighlight(source, [
+      opts.cause.position,
+      opts.cause.position + 1
+    ]).join("\n");
+    super(message, {
+      cause: opts.cause
+    });
+    this.position = opts.cause.position;
+    this.src = opts.src;
+  }
+}
+function parseSrcModule(srcModule, srcMap) {
+  const stream = new WeslStream(srcModule.src);
+  const appState = blankWeslParseState(srcModule);
+  const init = { stream, appState };
+  try {
+    const parseResult = weslRoot.parse(init);
+    if (parseResult === null) {
+      throw new Error("parseWESL failed");
+    }
+  } catch (e) {
+    if (e instanceof ParseError) {
+      const [lineNumber, lineColumn] = offsetToLineNumber(
+        e.position,
+        srcModule.src
+      );
+      const error = new WeslParseError({ cause: e, src: srcModule });
+      throwClickableError({
+        url: srcModule.debugFilePath,
+        text: srcModule.src,
+        error,
+        lineNumber,
+        lineColumn,
+        length: 1
+      });
+    } else {
+      throw e;
+    }
+  }
+  return appState.stable;
+}
+function parseWESL(src, srcMap) {
+  const srcModule = {
+    modulePath: "package::test",
+    // TODO this ought not be used outside of tests
+    debugFilePath: "./test.wesl",
+    src
+  };
+  return parseSrcModule(srcModule);
+}
+function blankWeslParseState(srcModule) {
+  const rootScope = emptyScope(null);
+  const moduleElem = null;
+  return {
+    context: { scope: rootScope, openElems: [] },
+    stable: { srcModule, imports: [], rootScope, moduleElem }
+  };
+}
+function syntheticWeslParseState() {
+  const srcModule = {
+    modulePath: "package::test",
+    debugFilePath: "./test.wesl",
+    src: ""
+  };
+  return blankWeslParseState(srcModule);
+}
+function flatImports(ast) {
+  if (ast._flatImports) return ast._flatImports;
+  const flat = ast.imports.flatMap(flattenTreeImport);
+  ast._flatImports = flat;
+  return flat;
+}
+const stdFns = `bitcast all any select arrayLength 
+  abs acos acosh asin asinh atan atanh atan2 ceil clamp cos cosh 
+  countLeadingZeros countOneBits countTrailingZeros cross 
+  degrees determinant distance dot dot4U8Packed dot4I8Packed 
+  exp exp2 extractBits faceForward firstLeadingBit firstTrailingBit 
+  floor fma fract frexp insertBits inverseSqrt ldexp length log log2
+  max min mix modf normalize pow quantizeToF16 radians reflect refract
+  reverseBits round saturate sign sin sinh smoothstep sqrt step tan tanh
+  transpose trunc
+  dpdx dpdxCoarse dpdxFine dpdy dpdyCoarse dpdyFine fwidth 
+  fwidthCoarse fwidthFine
+  textureDimensions textureGather textureGatherCompare textureLoad
+  textureNumLayers textureNumLevels textureNumSamples
+  textureSample textureSampleBias textureSampleCompare textureSampleCompareLevel
+  textureSampleGrad textureSampleLevel textureSampleBaseClampToEdge
+  textureStore
+  atomicLoad atomicStore atomicAdd atomicSub atomicMax atomicMin
+  atomicAnd atomicOr atomicXor atomicExchange atomicCompareExchangeWeak
+  pack4x8snorm pack4x8unorm pack4xI8 pack4xU8 pack4xI8Clamp pack4xU8Clamp
+  pack2x16snorm pack2x16unorm pack2x16float
+  unpack4x8snorm unpack4x8unorm unpack4xI8 unpack4xU8 
+  unpack2x16snorm unpack2x16unorm unpack2x16float
+  storageBarrier textureBarrier workgroupBarrier workgroupUniformLoad
+  subgroupAdd subgroupAll subgroupAnd subgroupAny subgroupBallot 
+  subgroupBroadcast subgroupBroadcastFirst subgroupElect 
+  subgroupExclusiveAdd subgroupExclusiveMul subgroupInclusiveAdd 
+  subgroupInclusiveMul subgroupMax subgroupMin subgroupMul subgroupOr 
+  subgroupShuffle subgroupShuffleUp subgroupShuffleXor subgroupXor
+  quadBroadcast quadSwapDiagonal quadSwapX quadSwapY`.split(/\s+/);
+const sampledTextureTypes = `
+  texture_1d texture_2d texture_2d_array texture_3d 
+  texture_cube texture_cube_array
+`;
+const multisampledTextureTypes = `
+  texture_multisampled_2d texture_depth_multisampled_2d
+`;
+const textureStorageTypes = `
+  texture_storage_1d texture_storage_2d texture_storage_2d_array 
+  texture_storage_3d
+`;
+const stdTypes = `array atomic bool f16 f32 i32 
+  mat2x2 mat2x3 mat2x4 mat3x2 mat3x3 mat3x4 mat4x2 mat4x3 mat4x4
+  mat2x2f mat2x3f mat2x4f mat3x2f mat3x3f mat3x4f
+  mat4x2f mat4x3f mat4x4f
+  mat2x2h mat2x3h mat2x4h mat3x2h mat3x3h mat3x4h
+  mat4x2h mat4x3h mat4x4h
+  u32 vec2 vec3 vec4 ptr
+  vec2i vec3i vec4i vec2u vec3u vec4u
+  vec2f vec3f vec4f vec2h vec3h vec4h
+  ${sampledTextureTypes}
+  ${multisampledTextureTypes}
+  texture_external
+  ${textureStorageTypes}
+  texture_depth_2d texture_depth_2d_array texture_depth_cube
+  texture_depth_cube_array
+  sampler sampler_comparison
+  rgba8unorm rgba8snorm rgba8uint rgba8sint
+  rgba16uint rgba16sint rgba16float 
+  r32uint r32sint r32float rg32uint rg32sint rg32float
+  rgba32uint rgba32sint rgba32float
+  bgra8unorm`.split(/\s+/);
+const stdEnumerants = `read write read_write 
+  function private workgroup uniform storage
+  rgba8unorm rgba8snorm rgba8uint rgba8sint 
+  rgba16uint rgba16sint rgba16float 
+  r32uint r32sint r32float rg32uint rg32sint rg32float
+  rgba32uint rgba32sint rgba32float bgra8unorm`.split(/\s+/);
+function stdType(name2) {
+  return stdTypes.includes(name2);
+}
+function stdFn(name2) {
+  return stdFns.includes(name2) || stdType(name2);
+}
+function stdEnumerant(name2) {
+  return stdEnumerants.includes(name2);
+}
+function bindIdents(params) {
+  const { rootAst, registry, virtuals } = params;
+  const { conditions = {}, mangler = minimalMangle } = params;
+  const { rootScope } = rootAst;
+  const globalNames = /* @__PURE__ */ new Set();
+  const knownDecls = /* @__PURE__ */ new Set();
+  const validRootDecls = findValidRootDecls(rootScope);
+  validRootDecls.forEach((decl) => {
+    decl.mangledName = decl.originalName;
+    globalNames.add(decl.originalName);
+    knownDecls.add(decl);
+  });
+  const globalStatements = /* @__PURE__ */ new Map();
+  const bindContext = {
+    registry,
+    conditions,
+    knownDecls,
+    foundScopes: /* @__PURE__ */ new Set(),
+    globalNames,
+    globalStatements,
+    virtuals,
+    mangler
+  };
+  const declEntries = validRootDecls.map((d) => [d.originalName, d]);
+  const liveDecls = { decls: new Map(declEntries), parent: null };
+  const decls = bindIdentsRecursive(rootScope, bindContext, liveDecls, true);
+  const filteredDecls = decls.filter(isGlobal);
+  const newStatements = [...globalStatements.values()];
+  return { decls: filteredDecls, globalNames, newStatements };
+}
+function findValidRootDecls(rootScope, conditions) {
+  const found = [];
+  for (const e of rootScope.contents) {
+    if (e.kind === "decl") {
+      assertThatDebug(e.declElem);
+      if (elementValid(e.declElem)) {
+        found.push(e);
+      }
+    } else if (e.kind === "partial") {
+      found.push(...findValidRootDecls(e));
+    }
+  }
+  return found;
+}
+function bindIdentsRecursive(scope, bindContext, liveDecls, isRoot = false) {
+  const { conditions, foundScopes } = bindContext;
+  if (foundScopes.has(scope)) return [];
+  foundScopes.add(scope);
+  const newGlobals = [];
+  const newFromChildren = [];
+  scope.contents.forEach((child) => {
+    const { kind: kind2 } = child;
+    if (kind2 === "decl") {
+      const ident2 = child;
+      if (!isRoot) liveDecls.decls.set(ident2.originalName, ident2);
+    } else if (kind2 === "ref") {
+      const newDecl = handleRef(child, liveDecls, bindContext);
+      newDecl && newGlobals.push(newDecl);
+    } else {
+      const fromScope = handleScope(child, liveDecls, bindContext);
+      if (fromScope) {
+        newFromChildren.push(...fromScope);
+      }
+    }
+  });
+  const newFromRefs = newGlobals.flatMap((decl) => {
+    const foundsScope = decl.scope;
+    const rootDecls = globalDeclToRootLiveDecls(decl);
+    {
+      const rootLive = makeLiveDecls(rootDecls);
+      return bindIdentsRecursive(foundsScope, bindContext, rootLive);
+    }
+  });
+  return [newGlobals, newFromChildren, newFromRefs].flat();
+}
+function handleRef(ident2, liveDecls, bindContext) {
+  const { registry, conditions } = bindContext;
+  const { virtuals } = bindContext;
+  if (!ident2.refersTo && !ident2.std) {
+    const foundDecl = findDeclInModule(ident2, liveDecls) ?? findQualifiedImport(ident2, registry, conditions, virtuals);
+    if (foundDecl) {
+      ident2.refersTo = foundDecl.decl;
+      return handleNewDecl(ident2, foundDecl, bindContext);
+    } else if (stdWgsl(ident2.originalName)) {
+      ident2.std = true;
+    } else {
+      failMissingIdent(ident2);
+    }
+  }
+}
+function handleScope(childScope2, liveDecls, bindContext) {
+  if (!scopeValid(childScope2)) return;
+  const { kind: kind2 } = childScope2;
+  if (kind2 === "scope") {
+    const newLive = makeLiveDecls(liveDecls);
+    return bindIdentsRecursive(childScope2, bindContext, newLive);
+  } else if (kind2 === "partial") {
+    return bindIdentsRecursive(childScope2, bindContext, liveDecls);
+  } else ;
+}
+function handleNewDecl(refIdent2, foundDecl, bindContext) {
+  const { decl, moduleAst } = foundDecl;
+  const { knownDecls, globalNames, mangler, globalStatements } = bindContext;
+  if (!knownDecls.has(decl)) {
+    knownDecls.add(decl);
+    const { srcModule } = decl;
+    const proposed = refIdent2.originalName;
+    setMangledName(proposed, decl, globalNames, srcModule, mangler);
+    if (isGlobal(decl)) {
+      const { moduleAsserts } = moduleAst;
+      const moduleEmit = moduleAsserts == null ? void 0 : moduleAsserts.map((elem) => ({ srcModule, elem }));
+      moduleEmit == null ? void 0 : moduleEmit.forEach((e) => globalStatements.set(e.elem, e));
+      return decl;
+    }
+  }
+}
+function globalDeclToRootLiveDecls(decl, conditions) {
+  assertThatDebug(decl.isGlobal, identToString(decl));
+  let rootScope = decl.scope;
+  while (rootScope.parent) {
+    rootScope = rootScope.parent;
+  }
+  const rootDecls = findValidRootDecls(rootScope);
+  const entires = rootDecls.map((d) => [d.originalName, d]);
+  const decls = new Map(entires);
+  return { decls };
+}
+function failMissingIdent(ident2) {
+  const { refIdentElem } = ident2;
+  if (refIdentElem) {
+    const { srcModule, start, end } = refIdentElem;
+    const { debugFilePath: filePath } = srcModule;
+    const msg = `unresolved identifier '${ident2.originalName}' in file: ${filePath}`;
+    srcLog(srcModule.src, [start, end], msg);
+    throw new Error(msg);
+  }
+}
+function setMangledName(proposedName, decl, globalNames, srcModule, mangler) {
+  if (!decl.mangledName) {
+    let mangledName;
+    if (isGlobal(decl)) {
+      const sep = proposedName.lastIndexOf("::");
+      const name2 = sep === -1 ? proposedName : proposedName.slice(sep + 2);
+      mangledName = mangler(decl, srcModule, name2, globalNames);
+    } else {
+      mangledName = decl.originalName;
+    }
+    decl.mangledName = mangledName;
+    globalNames.add(mangledName);
+  }
+}
+function stdWgsl(name2) {
+  return stdType(name2) || stdFn(name2) || stdEnumerant(name2);
+}
+function findDeclInModule(ident2, liveDecls) {
+  const { originalName } = ident2;
+  const found = liveDecls.decls.get(originalName);
+  if (found) {
+    return { decl: found, moduleAst: ident2.ast };
+  }
+  const { parent } = liveDecls;
+  if (parent) {
+    return findDeclInModule(ident2, parent);
+  }
+}
+function findQualifiedImport(refIdent2, parsed, conditions, virtuals) {
+  const flatImps = flatImports(refIdent2.ast);
+  const identParts = refIdent2.originalName.split("::");
+  const modulePathParts = matchingImport(identParts, flatImps) ?? qualifiedImport(identParts);
+  if (modulePathParts) {
+    const { srcModule } = refIdent2.ast;
+    return findExport(modulePathParts, srcModule, parsed, conditions, virtuals);
+  }
+}
+function qualifiedImport(identParts) {
+  if (identParts.length > 1) return identParts;
+}
+function matchingImport(identParts, flatImports2) {
+  for (const flat of flatImports2) {
+    if (flat.importPath.at(-1) === identParts.at(0)) {
+      return [...flat.modulePath, ...identParts.slice(1)];
+    }
+  }
+}
+function findExport(modulePathParts, srcModule, parsed, conditions = {}, virtuals) {
+  const fqPathParts = absoluteModulePath(modulePathParts, srcModule);
+  const modulePath = fqPathParts.slice(0, -1).join("::");
+  const moduleAst = parsed.modules[modulePath] ?? virtualModule(modulePathParts[0], conditions, virtuals);
+  if (!moduleAst) {
+    console.log(`ident ${modulePathParts.join("::")}, but module not found`);
+    return void 0;
+  }
+  const name2 = last(modulePathParts);
+  const decl = publicDecl(moduleAst.rootScope, name2);
+  if (decl) {
+    return { decl, moduleAst };
+  }
+}
+function absoluteModulePath(modulePathParts, srcModule) {
+  const lastSuper = modulePathParts.findLastIndex((p) => p === "super");
+  if (lastSuper > -1) {
+    const srcModuleParts = srcModule.modulePath.split("::");
+    const base = srcModuleParts.slice(0, -(lastSuper + 1));
+    const noSupers = modulePathParts.slice(lastSuper + 1);
+    return [...base, ...noSupers];
+  }
+  return modulePathParts;
+}
+function virtualModule(moduleName, conditions = {}, virtuals) {
+  if (!virtuals) return void 0;
+  const found = virtuals[moduleName];
+  if (found) {
+    const { ast, fn: fn2 } = found;
+    if (ast) return ast;
+    const src = fn2(conditions);
+    const srcModule = {
+      modulePath: moduleName,
+      debugFilePath: moduleName,
+      src
+    };
+    found.ast = parseSrcModule(srcModule);
+    return found.ast;
+  }
+}
+function isGlobal(declIdent) {
+  const { declElem } = declIdent;
+  if (!declElem) return false;
+  return ["alias", "const", "override", "fn", "struct", "gvar"].includes(
+    declElem.kind
+  );
+}
+function lowerAndEmit(srcBuilder, rootElems, conditions, extracting = true) {
+  const emitContext = { conditions, srcBuilder, extracting };
+  rootElems.forEach((e) => lowerAndEmitElem(e, emitContext));
+}
+function lowerAndEmitElem(e, ctx) {
+  if (!conditionsValid(e, ctx.conditions)) return;
+  switch (e.kind) {
+    // import statements are dropped from from emitted text
+    case "import":
+      return;
+    // terminal elements copy strings to the output
+    case "text":
+      return emitText(e, ctx);
+    case "name":
+      return emitName(e, ctx);
+    case "synthetic":
+      return emitSynthetic(e, ctx);
+    // identifiers are copied to the output, but with potentially mangled names
+    case "ref":
+      return emitRefIdent(e, ctx);
+    case "decl":
+      return emitDeclIdent(e, ctx);
+    // container elements just emit their child elements
+    case "param":
+    case "var":
+    case "typeDecl":
+    case "let":
+    case "module":
+    case "member":
+    case "memberRef":
+    case "expression":
+    case "type":
+    case "statement":
+    case "stuff":
+    case "switch-clause":
+      return emitContents(e, ctx);
+    // root level container elements get some extra newlines to make the output prettier
+    case "override":
+    case "const":
+    case "assert":
+    case "alias":
+    case "gvar":
+      emitRootElemNl(ctx);
+      return emitContents(e, ctx);
+    case "fn":
+      emitRootElemNl(ctx);
+      return emitFn(e, ctx);
+    case "struct":
+      emitRootElemNl(ctx);
+      return emitStruct(e, ctx);
+    case "attribute":
+      return emitAttribute(e, ctx);
+    case "directive":
+      return emitDirective(e, ctx);
+    default:
+      assertUnreachable(e);
+  }
+}
+function emitRootElemNl(ctx) {
+  if (ctx.extracting) {
+    ctx.srcBuilder.addNl();
+    ctx.srcBuilder.addNl();
+  }
+}
+function emitText(e, ctx) {
+  ctx.srcBuilder.addCopy(e.start, e.end);
+}
+function emitName(e, ctx) {
+  ctx.srcBuilder.add(e.name, e.start, e.end);
+}
+function emitFn(e, ctx) {
+  const { attributes, name: name2, params, returnAttributes, returnType, body } = e;
+  const { conditions, srcBuilder: builder } = ctx;
+  emitAttributes(attributes, ctx);
+  builder.add("fn ", name2.start - 3, name2.start);
+  emitDeclIdent(name2, ctx);
+  builder.appendNext("(");
+  const validParams = params.filter((p) => conditionsValid(p));
+  validParams.forEach((p, i) => {
+    emitContentsNoWs(p, ctx);
+    if (i < validParams.length - 1) {
+      builder.appendNext(", ");
+    }
+  });
+  builder.appendNext(") ");
+  if (returnType) {
+    builder.appendNext("-> ");
+    emitAttributes(returnAttributes, ctx);
+    emitContents(returnType, ctx);
+    builder.appendNext(" ");
+  }
+  emitContents(body, ctx);
+}
+function emitAttributes(attributes, ctx) {
+  attributes == null ? void 0 : attributes.forEach((a) => {
+    emitAttribute(a, ctx);
+    ctx.srcBuilder.add(" ", a.start, a.end);
+  });
+}
+function emitStruct(e, ctx) {
+  const { name: name2, members, start, end } = e;
+  const { srcBuilder } = ctx;
+  const validMembers = members.filter((m) => conditionsValid(m, ctx.conditions));
+  const validLength = validMembers.length;
+  if (validLength === 0) {
+    warnEmptyStruct(e);
+    return;
+  }
+  srcBuilder.add("struct ", start, name2.start);
+  emitDeclIdent(name2, ctx);
+  if (validLength === 1) {
+    srcBuilder.add(" { ", name2.end, members[0].start);
+    emitContentsNoWs(validMembers[0], ctx);
+    srcBuilder.add(" }\n", end - 1, end);
+  } else {
+    srcBuilder.add(" {\n", name2.end, members[0].start);
+    validMembers.forEach((m) => {
+      srcBuilder.add("  ", m.start - 1, m.start);
+      emitContentsNoWs(m, ctx);
+      srcBuilder.add(",", m.end, m.end + 1);
+      srcBuilder.addNl();
+    });
+    srcBuilder.add("}\n", end - 1, end);
+  }
+}
+function warnEmptyStruct(e) {
+  const { name: name2, members } = e;
+  const condStr = members.length ? "(with current conditions)" : "";
+  const { debugFilePath: filePath } = name2.srcModule;
+  srcLog(
+    name2.srcModule.src,
+    e.start,
+    `struct ${name2.ident.originalName} in ${filePath} has no members ${condStr}`
+  );
+}
+function emitSynthetic(e, ctx) {
+  const { text: text2 } = e;
+  ctx.srcBuilder.addSynthetic(text2, text2, 0, text2.length);
+}
+function emitContents(elem, ctx) {
+  elem.contents.forEach((e) => lowerAndEmitElem(e, ctx));
+}
+function emitContentsNoWs(elem, ctx) {
+  elem.contents.forEach((e) => {
+    if (e.kind === "text") {
+      const { srcModule, start, end } = e;
+      const text2 = srcModule.src.slice(start, end);
+      if (text2.trim() === "") {
+        return;
+      }
+    }
+    lowerAndEmitElem(e, ctx);
+  });
+}
+function emitRefIdent(e, ctx) {
+  if (e.ident.std) {
+    ctx.srcBuilder.add(e.ident.originalName, e.start, e.end);
+  } else {
+    const declIdent = findDecl(e.ident);
+    const mangledName = displayName(declIdent);
+    ctx.srcBuilder.add(mangledName, e.start, e.end);
+  }
+}
+function emitDeclIdent(e, ctx) {
+  const mangledName = displayName(e.ident);
+  ctx.srcBuilder.add(mangledName, e.start, e.end);
+}
+function emitAttribute(e, ctx) {
+  const { kind: kind2 } = e.attribute;
+  if (kind2 === "@attribute") {
+    const { params } = e.attribute;
+    if (!params || params.length === 0) {
+      ctx.srcBuilder.add("@" + e.attribute.name, e.start, e.end);
+    } else {
+      ctx.srcBuilder.add(
+        "@" + e.attribute.name + "(",
+        e.start,
+        params[0].start
+      );
+      for (let i = 0; i < params.length; i++) {
+        emitContents(params[i], ctx);
+        if (i < params.length - 1) {
+          ctx.srcBuilder.add(",", params[i].end, params[i + 1].start);
+        }
+      }
+      ctx.srcBuilder.add(")", params[params.length - 1].end, e.end);
+    }
+  } else if (kind2 === "@builtin") {
+    ctx.srcBuilder.add(
+      "@builtin(" + e.attribute.param.name + ")",
+      e.start,
+      e.end
+    );
+  } else if (kind2 === "@diagnostic") {
+    ctx.srcBuilder.add(
+      "@diagnostic" + diagnosticControlToString(e.attribute.severity, e.attribute.rule),
+      e.start,
+      e.end
+    );
+  } else if (kind2 === "@if") ;
+  else if (kind2 === "@interpolate") {
+    ctx.srcBuilder.add(
+      `@interpolate(${e.attribute.params.map((v) => v.name).join(", ")})`,
+      e.start,
+      e.end
+    );
+  } else {
+    assertUnreachable(kind2);
+  }
+}
+function diagnosticControlToString(severity, rule) {
+  const ruleStr = rule[0].name + (rule[1] !== null ? "." + rule[1].name : "");
+  return `(${severity.name}, ${ruleStr})`;
+}
+function expressionToString(elem) {
+  const { kind: kind2 } = elem;
+  if (kind2 === "binary-expression") {
+    return `${expressionToString(elem.left)} ${elem.operator.value} ${expressionToString(elem.right)}`;
+  } else if (kind2 === "unary-expression") {
+    return `${elem.operator.value}${expressionToString(elem.expression)}`;
+  } else if (kind2 === "ref") {
+    return elem.ident.originalName;
+  } else if (kind2 === "literal") {
+    return elem.value;
+  } else if (kind2 === "translate-time-feature") {
+    return elem.name;
+  } else if (kind2 === "parenthesized-expression") {
+    return `(${expressionToString(elem.expression)})`;
+  } else if (kind2 === "component-expression") {
+    return `${expressionToString(elem.base)}[${elem.access}]`;
+  } else if (kind2 === "component-member-expression") {
+    return `${expressionToString(elem.base)}.${elem.access}`;
+  } else if (kind2 === "call-expression") {
+    return `${elem.function.ident.originalName}(${elem.arguments.map(expressionToString).join(", ")})`;
+  } else {
+    assertUnreachable(kind2);
+  }
+}
+function emitDirective(e, ctx) {
+  const { directive } = e;
+  const { kind: kind2 } = directive;
+  if (kind2 === "diagnostic") {
+    ctx.srcBuilder.add(
+      `diagnostic${diagnosticControlToString(directive.severity, directive.rule)};`,
+      e.start,
+      e.end
+    );
+  } else if (kind2 === "enable") {
+    ctx.srcBuilder.add(
+      `enable ${directive.extensions.map((v) => v.name).join(", ")};`,
+      e.start,
+      e.end
+    );
+  } else if (kind2 === "requires") {
+    ctx.srcBuilder.add(
+      `requires ${directive.extensions.map((v) => v.name).join(", ")};`,
+      e.start,
+      e.end
+    );
+  } else {
+    assertUnreachable(kind2);
+  }
+}
+function displayName(declIdent) {
+  if (isGlobal(declIdent)) {
+    assertThatDebug(
+      declIdent.mangledName,
+      `ERR: mangled name not found for decl ident ${identToString(declIdent)}`
+    );
+    return declIdent.mangledName;
+  }
+  return declIdent.mangledName || declIdent.originalName;
+}
+function findDecl(ident2) {
+  let i = ident2;
+  do {
+    if (i.kind === "decl") {
+      return i;
+    }
+    i = i.refersTo;
+  } while (i);
+  throw new Error(`unresolved identifer: ${ident2.originalName}`);
+}
+function conditionsValid(elem, conditions) {
+  const attrElem = elem;
+  const { kind: kind2 } = attrElem;
+  switch (kind2) {
+    case "alias":
+    case "assert":
+    case "const":
+    case "directive":
+    case "member":
+    case "var":
+    case "let":
+    case "statement":
+    case "switch-clause":
+    case "override":
+    case "gvar":
+    case "fn":
+    case "struct":
+    case "param":
+      return elementValid(attrElem);
+  }
+  return true;
+}
+function importToString(tree) {
+  return importToStringImpl(tree) + ";";
+}
+function importToStringImpl(tree) {
+  return [
+    ...tree.segments.map((s) => s.name),
+    segmentToString(tree.finalSegment)
+  ].join("::");
+}
+function segmentToString(segment) {
+  if (segment.kind === "import-item") {
+    const { name: name2, as } = segment;
+    const asMsg = as ? ` as ${as}` : "";
+    return `${name2}${asMsg}`;
+  } else if (segment.kind === "import-collection") {
+    return `{${segment.subtrees.map((s) => importToStringImpl(s)).join(", ")}}`;
+  } else {
+    assertUnreachable$1(segment);
+  }
+}
+const maxLineLength = 150;
+function astToString(elem, indent = 0) {
+  const { kind: kind2 } = elem;
+  const str = new LineWrapper(indent, maxLineLength);
+  str.add(kind2);
+  addElemFields(elem, str);
+  let childStrings = [];
+  if ("contents" in elem) {
+    childStrings = elem.contents.map((e) => astToString(e, indent + 2));
+  }
+  if (childStrings.length) {
+    str.nl();
+    str.addBlock(childStrings.join("\n"), false);
+  }
+  return str.result;
+}
+function addElemFields(elem, str) {
+  const { kind: kind2 } = elem;
+  if (kind2 === "text") {
+    const { srcModule, start, end } = elem;
+    str.add(` '${srcModule.src.slice(start, end)}'`);
+  } else if (kind2 === "var" || kind2 === "let" || kind2 === "gvar" || kind2 === "const" || kind2 === "override") {
+    addTypedDeclIdent(elem.name, str);
+    listAttributeElems(elem.attributes, str);
+  } else if (kind2 === "struct") {
+    str.add(" " + elem.name.ident.originalName);
+  } else if (kind2 === "member") {
+    const { name: name2, typeRef, attributes } = elem;
+    listAttributeElems(attributes, str);
+    str.add(" " + name2.name);
+    str.add(": " + typeRefElemToString(typeRef));
+  } else if (kind2 === "name") {
+    str.add(" " + elem.name);
+  } else if (kind2 === "memberRef") {
+    const { extraComponents } = elem;
+    const extraText = extraComponents ? debugContentsToString(extraComponents) : "";
+    str.add(` ${elem.name.ident.originalName}.${elem.member.name}${extraText}`);
+  } else if (kind2 === "fn") {
+    addFnFields(elem, str);
+  } else if (kind2 === "alias") {
+    const { name: name2, typeRef } = elem;
+    const prefix = name2.ident.kind === "decl" ? "%" : "";
+    str.add(" " + prefix + name2.ident.originalName);
+    str.add("=" + typeRefElemToString(typeRef));
+  } else if (kind2 === "attribute") {
+    addAttributeFields(elem.attribute, str);
+  } else if (kind2 === "expression") {
+    const contents = elem.contents.map((e) => {
+      if (e.kind === "text") {
+        return "'" + e.srcModule.src.slice(e.start, e.end) + "'";
+      } else {
+        return astToString(e);
+      }
+    }).join(" ");
+    str.add(" " + contents);
+  } else if (kind2 === "type") {
+    const { name: name2 } = elem;
+    const nameStr = typeof name2 === "string" ? name2 : name2.originalName;
+    str.add(" " + nameStr);
+    if (elem.templateParams !== void 0) {
+      const paramStrs = elem.templateParams.map(templateParamToString).join(", ");
+      str.add("<" + paramStrs + ">");
+    }
+  } else if (kind2 === "synthetic") {
+    str.add(` '${elem.text}'`);
+  } else if (kind2 === "import") {
+    str.add(" " + importToString(elem.imports));
+  } else if (kind2 === "ref") {
+    str.add(" " + elem.ident.originalName);
+  } else if (kind2 === "typeDecl") {
+    addTypedDeclIdent(elem, str);
+  } else if (kind2 === "decl") {
+    const { ident: ident2 } = elem;
+    str.add(" %" + ident2.originalName);
+  } else if (kind2 === "assert") ;
+  else if (kind2 === "module") ;
+  else if (kind2 === "param") ;
+  else if (kind2 === "stuff") ;
+  else if (kind2 === "directive") {
+    addDirective(elem, str);
+  } else if (kind2 === "statement") {
+    listAttributeElems(elem.attributes, str);
+  } else if (kind2 === "switch-clause") ;
+  else {
+    assertUnreachable$1(kind2);
+  }
+}
+function addAttributeFields(attr, str) {
+  const { kind: kind2 } = attr;
+  if (kind2 === "@attribute") {
+    const { name: name2, params } = attr;
+    str.add(" @" + name2);
+    if (params && params.length > 0) {
+      str.add("(");
+      str.add(params.map(unknownExpressionToString).join(", "));
+      str.add(")");
+    }
+  } else if (kind2 === "@builtin") {
+    str.add(` @builtin(${attr.param.name})`);
+  } else if (kind2 === "@diagnostic") {
+    str.add(
+      ` @diagnostic${diagnosticControlToString(attr.severity, attr.rule)}`
+    );
+  } else if (kind2 === "@if") {
+    str.add(" @if");
+    str.add("(");
+    str.add(expressionToString(attr.param.expression));
+    str.add(")");
+  } else if (kind2 === "@interpolate") {
+    str.add(` @interpolate(${attr.params.map((v) => v.name).join(", ")})`);
+  } else {
+    assertUnreachable$1(kind2);
+  }
+}
+function attributeToString$1(attr) {
+  const str = new LineWrapper(0, maxLineLength);
+  addAttributeFields(attr, str);
+  return str.result;
+}
+function addTypedDeclIdent(elem, str) {
+  const { decl, typeRef } = elem;
+  str.add(" %" + decl.ident.originalName);
+  if (typeRef) {
+    str.add(" : " + typeRefElemToString(typeRef));
+  }
+}
+function addFnFields(elem, str) {
+  const { name: name2, params, returnType, attributes } = elem;
+  str.add(" " + name2.ident.originalName);
+  str.add("(");
+  const paramStrs = params.map(
+    (p) => {
+      const { name: name22 } = p;
+      const { originalName } = name22.decl.ident;
+      const typeRef = typeRefElemToString(name22.typeRef);
+      return originalName + ": " + typeRef;
+    }
+  ).join(", ");
+  str.add(paramStrs);
+  str.add(")");
+  listAttributeElems(attributes, str);
+  if (returnType) {
+    str.add(" -> " + typeRefElemToString(returnType));
+  }
+}
+function listAttributeElems(attributes, str) {
+  attributes == null ? void 0 : attributes.forEach((a) => str.add(" " + attributeName(a.attribute)));
+}
+function attributeName(attr) {
+  const { kind: kind2 } = attr;
+  if (kind2 === "@attribute") {
+    return "@" + attr.name;
+  } else {
+    return kind2;
+  }
+}
+function addDirective(elem, str) {
+  const { directive, attributes } = elem;
+  const { kind: kind2 } = directive;
+  if (kind2 === "diagnostic") {
+    const { severity, rule } = directive;
+    const control = diagnosticControlToString(severity, rule);
+    str.add(` diagnostic${control}`);
+  } else if (kind2 === "enable" || kind2 === "requires") {
+    str.add(` ${kind2} ${directive.extensions.map((v) => v.name).join(", ")}`);
+  } else {
+    assertUnreachable$1(kind2);
+  }
+  listAttributeElems(attributes, str);
+}
+function unknownExpressionToString(elem) {
+  if ("contents" in elem) {
+    const contents = elem.contents.map((e) => {
+      if (e.kind === "text") {
+        return "'" + e.srcModule.src.slice(e.start, e.end) + "'";
+      } else {
+        return astToString(e);
+      }
+    }).join(" ");
+    return contents;
+  }
+  return astToString(elem);
+}
+function templateParamToString(p) {
+  if (typeof p === "string") {
+    return p;
+  } else if (p.kind === "type") {
+    return typeRefElemToString(p);
+  } else if (p.kind === "expression") {
+    return unknownExpressionToString(p);
+  } else {
+    console.log("unknown template parameter type", p);
+    return "??";
+  }
+}
+function typeRefElemToString(elem) {
+  if (!elem) return "?type?";
+  const { name: name2 } = elem;
+  const nameStr = typeof name2 === "string" ? name2 : name2.originalName;
+  let params = "";
+  if (elem.templateParams !== void 0) {
+    const paramStrs = elem.templateParams.map(templateParamToString).join(", ");
+    params = "<" + paramStrs + ">";
+  }
+  return nameStr + params;
+}
+function debugContentsToString(elem) {
+  const parts = elem.contents.map((c) => {
+    const { kind: kind2 } = c;
+    if (kind2 === "text") {
+      return c.srcModule.src.slice(c.start, c.end);
+    } else if (kind2 === "ref") {
+      return c.ident.originalName;
+    } else {
+      return `?${c.kind}?`;
+    }
+  });
+  return parts.join(" ");
+}
+class LinkedWesl {
+  constructor(sourceMap) {
+    this.sourceMap = sourceMap;
+  }
+  /**
+   * Creates a {@link GPUShaderModule}.
+   * When errors occur, they will point at the original WESL source code.
+   *
+   * The compilation info {@link GPUShaderModule.getCompilationInfo}
+   * can be remapped with {@link mapGPUCompilationInfo}
+   * @param device GPUDevice. Preferably a {@link WeslDevice} for better error reporting.
+   * @param descriptor - Description of the {@link GPUShaderModule} to create.
+   */
+  createShaderModule(device, descriptor) {
+    if (!("injectError" in device)) {
+      return device.createShaderModule({
+        ...descriptor,
+        code: this.dest
+      });
+    }
+    device.pushErrorScope("validation");
+    const module = device.createShaderModule({
+      ...descriptor,
+      code: this.dest
+    });
+    device.popErrorScope();
+    let { promise, resolve } = Promise.withResolvers();
+    device.injectError("validation", promise);
+    module.getCompilationInfo().then((compilationInfo) => {
+      if (compilationInfo.messages.length === 0) {
+        resolve(null);
+        return;
+      }
+      const mappedCompilationInfo = this.mapGPUCompilationInfo(compilationInfo);
+      const errorMessage = compilationInfoToErrorMessage(
+        mappedCompilationInfo,
+        module
+      );
+      assertThat(errorMessage !== null);
+      const error = new GPUValidationError(
+        errorMessage
+      );
+      error.cause = new Error("createShaderModule failed");
+      error.compilationInfo = mappedCompilationInfo;
+      resolve(error);
+    });
+    return module;
+  }
+  /**
+   * Use {@link LinkedWesl.createShaderModule} for a
+   * better error reporting experience.
+   */
+  get dest() {
+    return this.sourceMap.dest.text;
+  }
+  /** Turns raw compilation info into compilation info
+   * that points at the WESL sources. */
+  mapGPUCompilationInfo(compilationInfo) {
+    return {
+      __brand: compilationInfo.__brand,
+      messages: compilationInfo.messages.map(
+        (v) => this.mapGPUCompilationMessage(v)
+      )
+    };
+  }
+  mapGPUCompilationMessage(message) {
+    const srcMap = this.sourceMap;
+    const srcPosition = srcMap.destToSrc(message.offset);
+    const srcEndPosition = message.length > 0 ? srcMap.destToSrc(message.offset + message.length) : srcPosition;
+    const length = srcEndPosition.position - srcPosition.position;
+    let [lineNum, linePos] = offsetToLineNumber(
+      srcPosition.position,
+      srcPosition.src.text
+    );
+    return {
+      __brand: message.__brand,
+      type: message.type,
+      message: message.message,
+      offset: srcPosition.position,
+      length,
+      lineNum,
+      linePos,
+      module: {
+        url: srcPosition.src.path ?? "",
+        text: srcPosition.src.text
+      }
+    };
+  }
+}
+function compilationInfoToErrorMessage(compilationInfo, shaderModule) {
+  if (compilationInfo.messages.length === 0) return null;
+  let result = `Compilation log for [Invalid ShaderModule (${shaderModule.label || "unlabled"})]:
+`;
+  let errorCount = compilationInfo.messages.filter(
+    (v) => v.type === "error"
+  ).length;
+  if (errorCount > 0) {
+    result += `${errorCount} error(s) generated while compiling the shader:
+`;
+  }
+  for (const message of compilationInfo.messages) {
+    const { lineNum, linePos } = message;
+    result += `${message.module.url}:${lineNum}:${linePos}`;
+    result += ` ${message.type}: ${message.message}
+`;
+    const source = message.module.text;
+    if (source) {
+      result += errorHighlight(source, [
+        message.offset,
+        message.offset + message.length
+      ]).join("\n");
+    }
+  }
+  return result;
+}
+function normalize(path) {
+  const segments = path.split("/");
+  const noDots = segments.filter((s) => s !== ".");
+  const noDbl = [];
+  noDots.forEach((s) => {
+    if (s !== "") {
+      if (s === ".." && noDbl.length && noDbl[noDbl.length - 1] !== "..") {
+        noDbl.pop();
+      } else {
+        noDbl.push(s);
+      }
+    }
+  });
+  return noDbl.join("/");
+}
+function noSuffix(path) {
+  const lastSlash = path.lastIndexOf("/");
+  const lastStart = lastSlash === -1 ? 0 : lastSlash + 1;
+  const suffix = path.indexOf(".", lastStart);
+  const suffixStart = suffix === -1 ? path.length : suffix;
+  return path.slice(0, suffixStart);
+}
+function parsedRegistry() {
+  resetScopeIds();
+  return { modules: {} };
+}
+function registryToString(registry) {
+  return `modules: ${[...Object.keys(registry.modules)]}`;
+}
+function parseWeslSrc(src) {
+  const parsedEntries = Object.entries(src).map(([path, src2]) => {
+    const weslAST = parseWESL(src2);
+    return [path, weslAST];
+  });
+  return { modules: Object.fromEntries(parsedEntries) };
+}
+function selectModule(parsed, selectPath, packageName = "package") {
+  let modulePath;
+  if (selectPath.includes("::")) {
+    modulePath = selectPath;
+  } else if (selectPath.includes("/") || selectPath.endsWith(".wesl") || selectPath.endsWith(".wgsl")) {
+    modulePath = fileToModulePath(selectPath, packageName);
+  } else {
+    modulePath = packageName + "::" + selectPath;
+  }
+  return parsed.modules[modulePath];
+}
+function parseIntoRegistry(srcFiles, registry, packageName = "package", debugWeslRoot) {
+  if (debugWeslRoot === void 0) {
+    debugWeslRoot = "";
+  } else if (!debugWeslRoot.endsWith("/")) {
+    debugWeslRoot += "/";
+  }
+  const srcModules = Object.entries(srcFiles).map(
+    ([filePath, src]) => {
+      const modulePath = fileToModulePath(filePath, packageName);
+      return { modulePath, debugFilePath: debugWeslRoot + filePath, src };
+    }
+  );
+  srcModules.forEach((mod) => {
+    const parsed = parseSrcModule(mod);
+    if (registry.modules[mod.modulePath]) {
+      throw new Error(`duplicate module path: '${mod.modulePath}'`);
+    }
+    registry.modules[mod.modulePath] = parsed;
+  });
+}
+function parseLibsIntoRegistry(libs, registry) {
+  libs.forEach(
+    ({ modules, name: name2 }) => parseIntoRegistry(modules, registry, name2)
+  );
+}
+const libRegex = /^lib\.w[eg]sl$/i;
+function fileToModulePath(filePath, packageName) {
+  if (filePath.includes("::")) {
+    return filePath;
+  }
+  if (packageName !== "package" && libRegex.test(filePath)) {
+    return packageName;
+  }
+  const strippedPath = noSuffix(normalize(filePath));
+  const moduleSuffix = strippedPath.replaceAll("/", "::");
+  const modulePath = packageName + "::" + moduleSuffix;
+  return modulePath;
+}
+async function link(params) {
+  const { weslSrc, debugWeslRoot, libs = [] } = params;
+  const registry = parsedRegistry();
+  parseIntoRegistry(weslSrc, registry, "package", debugWeslRoot);
+  parseLibsIntoRegistry(libs, registry);
+  return new LinkedWesl(linkRegistry({ registry, ...params }));
+}
+function linkRegistry(params) {
+  const bound = bindAndTransform(params);
+  const { transformedAst, newDecls, newStatements } = bound;
+  return SrcMapBuilder.build(
+    emitWgsl(
+      transformedAst.moduleElem,
+      transformedAst.srcModule,
+      newDecls,
+      newStatements,
+      params.conditions
+    )
+  );
+}
+function bindAndTransform(params) {
+  const { registry, mangler } = params;
+  const { rootModuleName = "main", conditions = {} } = params;
+  const rootAst = getRootModule(registry, rootModuleName);
+  const { constants, config } = params;
+  let { virtualLibs } = params;
+  if (constants) {
+    virtualLibs = { ...virtualLibs, constants: constantsGenerator(constants) };
+  }
+  let virtuals = virtualLibs && mapValues(virtualLibs, (fn2) => ({ fn: fn2 }));
+  const bindParams = { rootAst, registry, conditions, virtuals, mangler };
+  const bindResults = bindIdents(bindParams);
+  const { globalNames, decls: newDecls, newStatements } = bindResults;
+  const transformedAst = applyTransformPlugins(rootAst, globalNames, config);
+  return { transformedAst, newDecls, newStatements };
+}
+function constantsGenerator(constants) {
+  return () => Object.entries(constants).map(([name2, value]) => `const ${name2} = ${value};`).join("\n");
+}
+function getRootModule(parsed, rootModuleName) {
+  const rootModule = selectModule(parsed, rootModuleName);
+  if (!rootModule) {
+    throw new Error(`Root module not found: ${rootModuleName}`);
+  }
+  return rootModule;
+}
+function applyTransformPlugins(rootModule, globalNames, config) {
+  const { moduleElem, srcModule } = rootModule;
+  const startAst = { moduleElem, srcModule, globalNames, notableElems: {} };
+  const plugins = (config == null ? void 0 : config.plugins) ?? [];
+  const transforms = filterMap(plugins, (plugin) => plugin.transform);
+  const transformedAst = transforms.reduce(
+    (ast, transform) => transform(ast),
+    startAst
+  );
+  return transformedAst;
+}
+function emitWgsl(rootModuleElem, srcModule, newDecls, newStatements, conditions = {}) {
+  const prologueBuilders = newStatements.map((s) => {
+    const { elem, srcModule: srcModule2 } = s;
+    const { src: text2, debugFilePath: path } = srcModule2;
+    const builder = new SrcMapBuilder({ text: text2, path });
+    lowerAndEmit(builder, [elem], conditions);
+    builder.addNl();
+    return builder;
+  });
+  const rootBuilder = new SrcMapBuilder({
+    text: srcModule.src,
+    path: srcModule.debugFilePath
+  });
+  lowerAndEmit(rootBuilder, [rootModuleElem], conditions, false);
+  const declBuilders = newDecls.map((decl) => {
+    const builder = new SrcMapBuilder({
+      text: decl.srcModule.src,
+      path: decl.srcModule.debugFilePath
+    });
+    lowerAndEmit(builder, [decl.declElem], conditions);
+    return builder;
+  });
+  return [...prologueBuilders, rootBuilder, ...declBuilders];
+}
+function visitAst(elem, visitor) {
+  visitor(elem);
+  if (elem.contents) {
+    const container = elem;
+    container.contents.forEach((child) => visitAst(child, visitor));
+  }
+}
+function attributeToString(e) {
+  const { kind: kind2 } = e.attribute;
+  if (kind2 === "@attribute") {
+    const { params } = e.attribute;
+    if (params === void 0 || params.length === 0) {
+      return "@" + e.attribute.name;
+    } else {
+      return `@${e.attribute.name}(${params.map((param) => contentsToString(param)).join(", ")})`;
+    }
+  } else if (kind2 === "@builtin") {
+    return "@builtin(" + e.attribute.param.name + ")";
+  } else if (kind2 === "@diagnostic") {
+    return "@diagnostic" + diagnosticControlToString(e.attribute.severity, e.attribute.rule);
+  } else if (kind2 === "@if") {
+    return `@if(${expressionToString(e.attribute.param.expression)})`;
+  } else if (kind2 === "@interpolate") {
+    return `@interpolate(${e.attribute.params.map((v) => v.name).join(", ")})`;
+  } else {
+    assertUnreachable(kind2);
+  }
+}
+function typeListToString(params) {
+  return `<${params.map(typeParamToString).join(", ")}>`;
+}
+function typeParamToString(param) {
+  if (param === void 0) return "?";
+  if (typeof param === "string") return param;
+  if (param.kind === "expression") return contentsToString(param);
+  if (param.kind === "type") return typeRefToString(param);
+  assertUnreachable(param);
+}
+function typeRefToString(t) {
+  if (!t) return "?";
+  const { name: name2, templateParams } = t;
+  const params = templateParams ? typeListToString(templateParams) : "";
+  return `${refToString(name2)}${params}`;
+}
+function refToString(ref) {
+  if (typeof ref === "string") return ref;
+  if (ref.std) return ref.originalName;
+  const decl = findDecl(ref);
+  return decl.mangledName || decl.originalName;
+}
+function contentsToString(elem) {
+  if (elem.kind === "translate-time-expression") {
+    throw new Error("Not supported");
+  } else if (elem.kind === "expression" || elem.kind === "stuff") {
+    const parts = elem.contents.map((c) => {
+      const { kind: kind2 } = c;
+      if (kind2 === "text") {
+        return c.srcModule.src.slice(c.start, c.end);
+      } else if (kind2 === "ref") {
+        return refToString(c.ident);
+      } else {
+        return `?${c.kind}?`;
+      }
+    });
+    return parts.join(" ");
+  } else if (elem.kind === "name") {
+    return elem.name;
+  } else {
+    assertUnreachable(elem);
+  }
+}
+const textureStorage = matchOneOf(textureStorageTypes);
+matchOneOf(sampledTextureTypes);
+matchOneOf(multisampledTextureTypes);
+function bindingStructsPlugin() {
+  return {
+    transform: lowerBindingStructs
+  };
+}
+function lowerBindingStructs(ast) {
+  const clonedAst = structuredClone(ast);
+  const { moduleElem, globalNames, notableElems } = clonedAst;
+  const bindingStructs = markBindingStructs(moduleElem);
+  markEntryTypes(moduleElem, bindingStructs);
+  const newVars = bindingStructs.flatMap(
+    (s) => transformBindingStruct(s, globalNames)
+  );
+  const bindingRefs = findRefsToBindingStructs(moduleElem);
+  bindingRefs.forEach(
+    ({ memberRef, struct }) => transformBindingReference(memberRef, struct)
+  );
+  bindingRefs.forEach(
+    ({ intermediates }) => intermediates.forEach((e) => e.contents = [])
+  );
+  const contents = removeBindingStructs(moduleElem);
+  moduleElem.contents = [...newVars, ...contents];
+  notableElems.bindingStructs = bindingStructs;
+  return { ...clonedAst, moduleElem };
+}
+function markEntryTypes(moduleElem, bindingStructs) {
+  const fns = moduleElem.contents.filter((e) => e.kind === "fn");
+  const fnFound = fnReferencesBindingStruct(fns, bindingStructs);
+  if (fnFound) {
+    const { fn: fn2, struct } = fnFound;
+    struct.entryFn = fn2;
+  }
+}
+function fnReferencesBindingStruct(fns, bindingStructs) {
+  var _a, _b, _c;
+  for (const fn2 of fns) {
+    const { params } = fn2;
+    for (const p of params) {
+      const ref = (_b = (_a = p.name) == null ? void 0 : _a.typeRef) == null ? void 0 : _b.name;
+      const referencedElem = (_c = ref == null ? void 0 : ref.refersTo) == null ? void 0 : _c.declElem;
+      const struct = bindingStructs.find((s) => s === referencedElem);
+      if (struct) {
+        return { fn: fn2, struct };
+      }
+    }
+  }
+}
+function removeBindingStructs(moduleElem) {
+  return moduleElem.contents.filter(
+    (elem) => elem.kind !== "struct" || !elem.bindingStruct
+  );
+}
+function markBindingStructs(moduleElem) {
+  const structs = moduleElem.contents.filter((elem) => elem.kind === "struct");
+  const bindingStructs = structs.filter(containsBinding);
+  bindingStructs.forEach((struct) => struct.bindingStruct = true);
+  return bindingStructs;
+}
+function containsBinding(struct) {
+  return struct.members.some(({ attributes }) => bindingAttribute(attributes));
+}
+function bindingAttribute(attributes) {
+  if (!attributes) return false;
+  return attributes.some(
+    ({ attribute }) => attribute.kind === "@attribute" && (attribute.name === "binding" || attribute.name === "group")
+  );
+}
+function transformBindingStruct(s, globalNames) {
+  return s.members.map((member) => {
+    var _a;
+    const { typeRef, name: memberName } = member;
+    const { name: typeName } = typeRef;
+    const typeParameters = typeRef == null ? void 0 : typeRef.templateParams;
+    const varName = minimallyMangledName(memberName.name, globalNames);
+    member.mangledVarName = varName;
+    globalNames.add(varName);
+    const attributes = ((_a = member.attributes) == null ? void 0 : _a.map(attributeToString).join(" ")) ?? "";
+    const varTypes = lowerPtrMember(member, typeName, typeParameters) ?? lowerStdTypeMember(typeName, typeParameters) ?? lowerStorageTextureMember(typeName, typeParameters);
+    if (!varTypes) {
+      console.log("unhandled case transforming member", typeName);
+      return syntheticVar(attributes, varName, "", "??");
+    }
+    const { storage: storageType, varType } = varTypes;
+    return syntheticVar(attributes, varName, storageType, varType);
+  });
+}
+function lowerPtrMember(member, typeName, typeParameters, varName) {
+  if (typeName.originalName === "ptr") {
+    const origParams = typeParameters ?? [];
+    const newParams = [origParams[0]];
+    if (origParams[2]) newParams.push(origParams[2]);
+    const storage = typeListToString(newParams);
+    const varType = typeParamToString(origParams == null ? void 0 : origParams[1]);
+    return { storage, varType };
+  }
+}
+function lowerStdTypeMember(typeName, typeParameters) {
+  if (typeof typeName !== "string") {
+    const varBaseType = typeName.std ? typeName.originalName : "??";
+    const params = typeParameters ? typeListToString(typeParameters) : "";
+    const varType = varBaseType + params;
+    return { varType, storage: "" };
+  }
+}
+function lowerStorageTextureMember(typeName, typeParameters) {
+  if (textureStorage.test(typeName.originalName)) {
+    const params = typeParameters ? typeListToString(typeParameters) : "";
+    const varType = typeName + params;
+    return { varType, storage: "" };
+  }
+}
+function syntheticVar(attributes, varName, storageTemplate, varType) {
+  const varText = `${attributes} var${storageTemplate} ${varName} : ${varType};
+`;
+  const elem = {
+    kind: "synthetic",
+    text: varText
+  };
+  return elem;
+}
+function findRefsToBindingStructs(moduleElem) {
+  const members = [];
+  visitAst(moduleElem, (elem) => {
+    if (elem.kind === "memberRef") members.push(elem);
+  });
+  return filterMap(members, refersToBindingStruct);
+}
+function refersToBindingStruct(memberRef) {
+  const found = traceToStruct(memberRef.name.ident);
+  if (found && found.struct.bindingStruct) {
+    return { memberRef, ...found };
+  }
+}
+function traceToStruct(ident2) {
+  const decl = findDecl(ident2);
+  const declElem = decl.declElem;
+  if (declElem && declElem.kind === "param") {
+    const name2 = declElem.name.typeRef.name;
+    if (typeof name2 !== "string") {
+      if (name2.std) {
+        return void 0;
+      }
+      const paramDecl = findDecl(name2);
+      const structElem = paramDecl.declElem;
+      if ((structElem == null ? void 0 : structElem.kind) === "struct") {
+        return { struct: structElem, intermediates: [declElem] };
+      }
+      return void 0;
+    }
+  }
+}
+function transformBindingReference(memberRef, struct) {
+  const refName = memberRef.member.name;
+  const structMember = struct.members.find((m) => m.name.name === refName);
+  if (!structMember || !structMember.mangledVarName) {
+    return { kind: "synthetic", text: refName };
+  }
+  const { extraComponents } = memberRef;
+  const extraText = extraComponents ? contentsToString(extraComponents) : "";
+  const text2 = structMember.mangledVarName + extraText;
+  const synthElem = { kind: "synthetic", text: text2 };
+  memberRef.contents = [synthElem];
+  return synthElem;
+}
+export {
+  LinkedWesl,
+  WeslParseError,
+  WeslStream,
+  astToString,
+  attributeToString$1 as attributeToString,
+  bindAndTransform,
+  bindingStructsPlugin,
+  blankWeslParseState,
+  debugContentsToString,
+  findRefsToBindingStructs,
+  flatImports,
+  identToString,
+  link,
+  linkRegistry,
+  lowerBindingStructs,
+  makeWeslDevice,
+  markBindingStructs,
+  markEntryTypes,
+  noSuffix,
+  normalize,
+  parseIntoRegistry,
+  parseLibsIntoRegistry,
+  parseSrcModule,
+  parseWESL,
+  parseWeslSrc,
+  parsedRegistry,
+  registryToString,
+  scopeToString,
+  scopeToStringLong,
+  selectModule,
+  syntheticWeslParseState,
+  throwClickableError,
+  transformBindingReference,
+  transformBindingStruct
+};
+//# sourceMappingURL=index.js.map