wesl 0.6.0-pre2

package/dist/index.cjs

@@ -0,0 +1,2617 @@
+"use strict";
+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, _column, _spc, _oneLine, _isHanging, _hangingSpc, _fragments2, _destLength, _entries;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class ImportTree {
+  /** segments in path order */
+  constructor(segments) {
+    this.segments = segments;
+  }
+}
+class SimpleSegment {
+  constructor(name, as, args) {
+    this.name = name;
+    this.as = as;
+    this.args = args;
+  }
+}
+class SegmentList {
+  constructor(list) {
+    this.list = list;
+  }
+}
+function importToString(tree) {
+  return tree.segments.map((s) => segmentToString(s)).join("/");
+}
+function segmentToString(segment) {
+  if (segment instanceof SimpleSegment) {
+    const { name, as, args } = segment;
+    const asMsg = as ? ` as ${as}` : "";
+    const argsMsg = args ? `(${args.join(", ")})` : "";
+    return `${name}${argsMsg}${asMsg}`;
+  }
+  if (segment instanceof SegmentList) {
+    return `{${segment.list.map((s) => segmentToString(s)).join(", ")}}`;
+  }
+  if (segment instanceof ImportTree) {
+    return `(${importToString(segment)})`;
+  }
+  return `|unknown segment type ${segment.constructor.name}|`;
+}
+class LineWrapper {
+  constructor(indent = 0, maxWidth = 60, hangingIndent = 2) {
+    __privateAdd(this, _fragments, []);
+    __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, _fragments).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) + s.length > this.maxWidth) {
+      this.hangingNl();
+    }
+    if (__privateGet(this, _column) === 0) {
+      __privateGet(this, _fragments).push(__privateGet(this, _spc));
+      if (__privateGet(this, _isHanging)) {
+        __privateGet(this, _fragments).push(__privateGet(this, _hangingSpc));
+      }
+      __privateSet(this, _column, this.indent);
+    }
+    __privateGet(this, _fragments).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, _fragments).push(s);
+    if (andNewLine) this.nl();
+  }
+  /** @return the constructed string */
+  get result() {
+    return __privateGet(this, _fragments).join("");
+  }
+  /** true if the result contains no newlines */
+  get oneLine() {
+    return __privateGet(this, _oneLine);
+  }
+  hangingNl() {
+    this.nl();
+    __privateSet(this, _isHanging, true);
+  }
+}
+_fragments = new WeakMap();
+_column = new WeakMap();
+_spc = new WeakMap();
+_oneLine = new WeakMap();
+_isHanging = new WeakMap();
+_hangingSpc = new WeakMap();
+function astToString(elem, indent = 0) {
+  const { kind: kind2, contents } = elem;
+  const str = new LineWrapper(indent);
+  str.add(kind2);
+  addElemFields(elem, str);
+  let childStrings = [];
+  if (contents) {
+    childStrings = contents.map((e) => astToString(e, indent + 2));
+  }
+  if (childStrings.length) {
+    str.nl();
+    str.addBlock(childStrings.join("\n"), false);
+  }
+  return str.result;
+}
+function elemToString(elem) {
+  const { kind: kind2 } = elem;
+  const str = new LineWrapper();
+  str.add(kind2);
+  addElemFields(elem, str);
+  let childStrings = [];
+  if (childStrings.length) {
+    str.nl();
+    str.addBlock(childStrings.join("\n"), false);
+  }
+  return str.result;
+}
+function addElemFields(elem, str) {
+  addTextFields(elem, str) || addVarishFields(elem, str) || addStructFields(elem, str) || addNameFields(elem, str) || addFnFields(elem, str) || addAliasFields(elem, str) || addImport(elem, str) || addRefIdent(elem, str) || addDeclIdent(elem, str);
+}
+function addVarishFields(elem, str) {
+  const { kind: kind2 } = elem;
+  if (kind2 === "var" || kind2 === "gvar" || kind2 === "const" || kind2 === "override") {
+    str.add(" " + elem.name.ident.originalName);
+    if (elem.typeRef) {
+      str.add(":" + elem.typeRef.ident.originalName);
+    }
+    return true;
+  }
+}
+function addTextFields(elem, str) {
+  if (elem.kind === "text") {
+    const { srcModule, start, end: end2 } = elem;
+    str.add(` '${srcModule.src.slice(start, end2)}'`);
+    return true;
+  }
+}
+function addRefIdent(elem, str) {
+  if (elem.kind === "ref") {
+    str.add(" " + elem.ident.originalName);
+    return true;
+  }
+}
+function addDeclIdent(elem, str) {
+  if (elem.kind === "decl") {
+    str.add(" %" + elem.ident.originalName);
+    return true;
+  }
+}
+function addAliasFields(elem, str) {
+  if (elem.kind === "alias") {
+    const { name, typeRef } = elem;
+    const prefix = name.ident.kind === "decl" ? "%" : "";
+    str.add(" " + prefix + name.ident.originalName);
+    str.add("=" + typeRef.ident.originalName);
+    return true;
+  }
+}
+function addStructFields(elem, str) {
+  if (elem.kind === "struct") {
+    str.add(" " + elem.name.ident.originalName);
+    return true;
+  }
+}
+function addImport(elem, str) {
+  if (elem.kind === "import") {
+    str.add(" " + importToString(elem.imports));
+    return true;
+  }
+}
+function addNameFields(elem, str) {
+  if (elem.kind === "name") {
+    str.add(" " + elem.name);
+    return true;
+  }
+}
+function addFnFields(elem, str) {
+  if (elem.kind === "fn") {
+    const { name, params, returnType } = elem;
+    str.add(" " + name.ident.originalName);
+    str.add("(");
+    const paramStrs = params.map((p) => p.name.ident.originalName + ": " + p.typeRef.ident.originalName).join(", ");
+    str.add(paramStrs);
+    str.add(")");
+    if (returnType) {
+      str.add(" -> " + returnType.ident.originalName);
+    }
+    return true;
+  }
+}
+function scopeToString(scope, indent = 0) {
+  const { children } = scope;
+  let childStrings = [];
+  if (children.length)
+    childStrings = children.map((c) => scopeToString(c, indent + 2));
+  const identStrings = scope.idents.map(({ kind: kind2, originalName }) => {
+    const prefix = kind2 === "decl" ? "%" : "";
+    return `${prefix}${originalName}`;
+  });
+  const str = new LineWrapper(indent);
+  str.add("{ ");
+  const last2 = identStrings.length - 1;
+  identStrings.forEach((s, i) => {
+    const element = i < last2 ? s + ", " : s;
+    str.add(element);
+  });
+  if (childStrings.length) {
+    str.nl();
+    str.addBlock(childStrings.join("\n"));
+  }
+  if (str.oneLine) {
+    str.add(" }");
+  } else {
+    if (!childStrings.length) str.nl();
+    str.add("}");
+  }
+  return str.result;
+}
+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 {
+    return `%${originalName} ${idStr} (${ident2.mangledName})`;
+  }
+}
+function mergeTags(a, b) {
+  const aKeys = Reflect.ownKeys(a);
+  const sharedKeys = aKeys.filter((k) => b[k]);
+  const sharedEntries = sharedKeys.map((k) => [
+    k,
+    [...a[k] ?? [], ...b[k] ?? []]
+  ]);
+  const shared = Object.fromEntries(sharedEntries);
+  return { ...a, ...b, ...shared };
+}
+class ParseError extends Error {
+  constructor(msg) {
+    super(msg);
+  }
+}
+function kind(kindStr) {
+  return simpleParser(
+    `kind '${kindStr}'`,
+    (state) => {
+      const next = state.lexer.next();
+      return (next == null ? void 0 : next.kind) === kindStr ? next.text : null;
+    }
+  );
+}
+function text(value) {
+  return simpleParser(
+    `${quotedText(value)}`,
+    (state) => {
+      const next = state.lexer.next();
+      return (next == null ? void 0 : next.text) === value ? next.text : null;
+    }
+  );
+}
+function seq(...args) {
+  const parsers = args.map(parserArg);
+  const seqParser = parser("seq", (ctx) => {
+    const values = [];
+    let tagged = {};
+    let failed = false;
+    for (const p of parsers) {
+      const result = p._run(ctx);
+      if (result === null) {
+        failed = true;
+        break;
+      }
+      tagged = mergeTags(tagged, result.tags);
+      values.push(result.value);
+    }
+    if (failed) return null;
+    return { value: values, tags: tagged };
+  }).collect({ before: pushOpenArray, after: closeArray });
+  trackChildren(seqParser, ...parsers);
+  return seqParser;
+}
+function or(...args) {
+  const parsers = args.map(parserArg);
+  const orParser = parser("or", (state) => {
+    for (const p of parsers) {
+      const result = p._run(state);
+      if (result !== null) {
+        return result;
+      }
+    }
+    return null;
+  });
+  trackChildren(orParser, ...parsers);
+  return orParser;
+}
+const undefinedResult = {
+  value: void 0,
+  tags: {}
+};
+function opt(arg) {
+  const p = parserArg(arg);
+  const optParser = parser(
+    "opt",
+    (state) => {
+      const result = p._run(state);
+      return result || undefinedResult;
+    }
+  );
+  return optParser;
+}
+function not(arg) {
+  const p = parserArg(arg);
+  const notParser = parser("not", (state) => {
+    const pos = state.lexer.position();
+    const result = p._run(state);
+    if (!result) {
+      return { value: true, tags: {} };
+    }
+    state.lexer.position(pos);
+    return null;
+  });
+  return notParser;
+}
+function any() {
+  return simpleParser("any", (state) => {
+    const next = state.lexer.next();
+    return next || null;
+  });
+}
+function anyNot(arg) {
+  return seq(not(arg), any()).map((r) => r.value[1]).traceName("anyNot");
+}
+function anyThrough(arg) {
+  const p = parserArg(arg);
+  const anyParser = seq(repeat(anyNot(p)), p).traceName(
+    `anyThrough ${p.debugName}`
+  );
+  return anyParser;
+}
+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.value[0], ...r.value[1]]).traceName("repeatPlus");
+  return repeatParser;
+}
+function repeatWhileFilter(p, filterFn = () => true) {
+  return (ctx) => {
+    const values = [];
+    let tags = {};
+    for (; ; ) {
+      const result = runExtended(ctx, p);
+      if (result !== null && filterFn(result)) {
+        values.push(result.value);
+        tags = mergeTags(tags, result.tags);
+      } else {
+        const r = { value: values, tags };
+        return r;
+      }
+    }
+  };
+}
+function eof() {
+  return simpleParser(
+    "eof",
+    (state) => state.lexer.eof() || null
+  );
+}
+function req(arg, msg) {
+  const p = parserArg(arg);
+  const reqParser = parser("req", (ctx) => {
+    const result = p._run(ctx);
+    if (result === null) {
+      const deepName = ctx._debugNames.join(" > ");
+      ctxLog(ctx, msg ?? `expected ${p.debugName} ${deepName}`);
+      throw new ParseError();
+    }
+    return result;
+  });
+  return reqParser;
+}
+function yes() {
+  return simpleParser("yes", () => true);
+}
+function withSep(sep, p, opts = {}) {
+  const { trailing = true, requireOne = false } = opts;
+  const parser2 = parserArg(p);
+  const sepParser = parserArg(sep);
+  const pTagged = or(parser2).tag("_sepTag");
+  const first = requireOne ? pTagged : opt(pTagged);
+  const last2 = trailing ? opt(sepParser) : yes();
+  const withSepParser = seq(first, repeat(seq(sepParser, pTagged)), last2).map((r) => {
+    const result = r.tags._sepTag;
+    delete r.tags._sepTag;
+    return result;
+  }).traceName("withSep");
+  return withSepParser;
+}
+function withSepPlus(sep, p) {
+  return withSep(sep, p, { requireOne: true }).traceName("withSepPlus");
+}
+function tokens(matcher, arg) {
+  const p = parserArg(arg);
+  const tokensParser = parser(
+    `tokens ${matcher._debugName}`,
+    (state) => {
+      return state.lexer.withMatcher(matcher, () => {
+        return p._run(state);
+      });
+    }
+  );
+  return tokensParser;
+}
+function makeEolf(matcher, ws) {
+  return tokens(
+    matcher,
+    tokenSkipSet(
+      null,
+      // disable automatic ws skipping so we can match newline
+      seq(
+        opt(kind(ws)),
+        or("\n", eof())
+      )
+    )
+  ).traceName("eolf");
+}
+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()", (state) => {
+    if (!fn2) {
+      const deepName = state._debugNames.join(".");
+      throw new Error(`fn parser called before definition: ${deepName}`);
+    }
+    const stage = fn2();
+    return stage._run(state);
+  });
+  return fp;
+}
+function collect(p, collectFn2, ctag2) {
+  const origAfter = collectFn2.after ?? collectFn2;
+  const beforeFn = collectFn2.before;
+  let afterFn = origAfter;
+  if (ctag2) {
+    afterFn = (cc) => {
+      const result = origAfter(cc);
+      addTagValue(cc.tags, ctag2, result);
+      return result;
+    };
+  }
+  const debugName = ctag2 ? `${p.debugName}-${ctag2}` : `${p.debugName}`;
+  const collectParser = parser(
+    `collect`,
+    (ctx) => {
+      const origStart = ctx.lexer.position();
+      if (beforeFn) {
+        queueCollectFn(ctx, origStart, beforeFn, `${debugName}.before`);
+      }
+      return runAndCollectAfter(p, ctx, afterFn, debugName);
+    }
+  );
+  collectParser._collection = true;
+  return collectParser;
+}
+function tagScope(arg) {
+  const p = parserArg(arg);
+  const sp = parser(
+    `tagScope`,
+    (ctx) => {
+      const origStart = ctx.lexer.position();
+      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, name) {
+  const cp = parser(`ctag`, (ctx) => {
+    return runAndCollectAfter(
+      p,
+      ctx,
+      (cc) => {
+        const valueEntry = last$1(cc._values);
+        addTagValue(cc.tags, name, valueEntry.value);
+      },
+      `ctag ${name}`
+    );
+  });
+  return cp;
+}
+function runAndCollectAfter(p, ctx, collectFn2, debugName = "") {
+  const origStart = ctx.lexer.position();
+  const result = p._run(ctx);
+  if (result) {
+    queueCollectFn(ctx, origStart, collectFn2, debugName);
+  }
+  return result;
+}
+function queueCollectFn(ctx, origStart, collectFn2, debugName) {
+  const srcPosition = refinePosition(ctx.lexer, origStart);
+  ctx._collect.push({
+    srcPosition,
+    collectFn: collectFn2,
+    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, name) {
+  const cp = parser(`ptag`, (ctx) => {
+    const origStart = ctx.lexer.position();
+    const result = p._run(ctx);
+    if (result) {
+      const tagFn = (ctx2) => addTagValue(ctx2.tags, name, result.value);
+      queueCollectFn(ctx, origStart, tagFn, `ptag ${name}`);
+    }
+    return result;
+  });
+  return cp;
+}
+function addTagValue(tags, name, value) {
+  if (tags[name] === void 0) {
+    tags[name] = [];
+  }
+  tags[name].push(value);
+}
+function runCollection(_collect, app, lexer) {
+  const tags = {};
+  const { src } = lexer;
+  const _values = [{ value: null, openArray: void 0 }];
+  const collectContext = {
+    tags,
+    src,
+    start: -1,
+    end: -1,
+    app,
+    _values
+  };
+  _collect.forEach((entry) => {
+    const { collectFn: collectFn2, srcPosition } = entry;
+    collectContext.start = srcPosition.start;
+    collectContext.end = srcPosition.end;
+    const collectResult = collectFn2(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(lexer, origStart) {
+  const end2 = lexer.position();
+  lexer.position(origStart);
+  const start = lexer.skipIgnored();
+  lexer.position(end2);
+  return { start, end: end2 };
+}
+class Parser {
+  constructor(args) {
+    this._traceName = args.traceName;
+    this.tagName = args.tag;
+    this.traceOptions = args.trace;
+    this.terminal = args.terminal;
+    this.traceSrc = args.traceSrc;
+    this.preDisabled = args.preDisabled;
+    this._collection = args._collection;
+    this._children = args._children;
+    this.fn = args.fn;
+  }
+  /** copy this parser with slightly different settings */
+  _cloneWith(p) {
+    return new Parser({
+      traceName: this._traceName,
+      traceSrc: this.traceSrc,
+      tag: this.tagName,
+      trace: this.traceOptions,
+      terminal: this.terminal,
+      preDisabled: this.preDisabled,
+      _collection: this._collection,
+      _children: this._children,
+      fn: this.fn,
+      ...p
+    });
+  }
+  /** run the parser given an already created parsing context */
+  _run(context) {
+    return runParser(this, context);
+  }
+  /**
+   * tag results with a name,
+   *
+   * tagged results can be retrived with map(r => r.tags.myName)
+   * note that tagged results are collected into an array,
+   * multiple matches with the same name (even from different nested parsers) accumulate
+   */
+  tag(name) {
+    const p = this._cloneWith({
+      tag: name,
+      traceSrc: this,
+      traceName: void 0
+    });
+    return p;
+  }
+  /** tag parse results */
+  ptag(name) {
+    return ptag(this, name);
+  }
+  /** tag collect results */
+  ctag(name) {
+    return ctag(this, name);
+  }
+  /** record a name for debug tracing */
+  traceName(name) {
+    return this._cloneWith({ traceName: name });
+  }
+  /** trigger tracing for this parser (and by default also this parsers descendants) */
+  trace(opts = {}) {
+    return this._cloneWith({ trace: opts });
+  }
+  /** map results to a new value, or add to app state as a side effect.
+   * Return null to cause the parser to fail.
+   */
+  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 */
+  parse(init) {
+    try {
+      const {
+        lexer,
+        maxParseCount,
+        srcMap,
+        appState: app = { context: {}, stable: [] }
+      } = init;
+      const _collect = [];
+      const result = this._run({
+        lexer,
+        app,
+        srcMap,
+        _preParse: [],
+        _parseCount: 0,
+        _preCacheFails: /* @__PURE__ */ new Map(),
+        maxParseCount,
+        _collect,
+        _debugNames: []
+      });
+      if (result) runCollection(_collect, app, lexer);
+      return result;
+    } catch (e) {
+      if (e instanceof ParseError) {
+        return null;
+      }
+      throw e;
+    }
+  }
+  /** name of this parser for debugging/tracing */
+  get debugName() {
+    var _a, _b;
+    return this._traceName ?? ((_a = this.traceSrc) == null ? void 0 : _a._traceName) ?? ((_b = this.tagName) == null ? void 0 : _b.toString()) ?? "parser";
+  }
+}
+function parser(traceName, fn2, terminal) {
+  const terminalArg = terminal ? { terminal } : {};
+  return new Parser({ fn: fn2, traceName, ...terminalArg });
+}
+function simpleParser(traceName, fn2) {
+  const parserFn = (ctx) => {
+    const r = fn2(ctx);
+    if (r == null || r === void 0) return null;
+    return { value: r, tags: {} };
+  };
+  return parser(traceName, parserFn, true);
+}
+function runParser(p, context) {
+  const { lexer, _parseCount = 0, maxParseCount } = context;
+  context._parseCount = _parseCount + 1;
+  if (maxParseCount && _parseCount > maxParseCount) {
+    srcLog(lexer.src, lexer.position(), "infinite loop? ", p.debugName);
+    return null;
+  }
+  const origAppContext = context.app.context;
+  const result = withTraceLogging()(
+    context,
+    p.traceOptions,
+    runInContext
+  );
+  return result;
+  function runInContext(ctx) {
+    var _a;
+    const origPosition = lexer.position();
+    const origCollectLength = ctx._collect.length;
+    (_a = ctx._trace) == null ? void 0 : _a.successOnly;
+    if (!p.terminal && tracing)
+      ;
+    const savePreParse = ctx._preParse;
+    if (!p.preDisabled) {
+      execPreParsers(ctx);
+    } else {
+      ctx._preParse = [];
+    }
+    let result2 = p.fn(ctx);
+    if (result2 === null || result2 === void 0) {
+      lexer.position(origPosition);
+      context.app.context = origAppContext;
+      result2 = null;
+      ctx._collect.length = origCollectLength;
+    } else {
+      const value = result2.value;
+      let tags;
+      if (p.tagName && result2.value !== void 0) {
+        tags = mergeTags(result2.tags, {
+          [p.tagName]: [result2.value]
+        });
+      } else {
+        tags = result2.tags;
+      }
+      result2 = { value, tags };
+    }
+    ctx._preParse = savePreParse;
+    return result2;
+  }
+}
+function execPreParsers(ctx) {
+  const { _preParse, lexer } = ctx;
+  const ctxNoPre = { ...ctx, _preParse: [] };
+  _preParse.forEach((pre) => {
+    const checkedCache = getPreParserCheckedCache(ctx, pre);
+    let position;
+    let preResult;
+    do {
+      position = lexer.position();
+      if (checkedCache.has(position)) break;
+      preResult = pre._run(ctxNoPre);
+    } while (preResult !== null && preResult !== void 0);
+    checkedCache.add(position);
+    lexer.position(position);
+  });
+}
+function getPreParserCheckedCache(ctx, pre) {
+  let cache = ctx._preCacheFails.get(pre);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Set();
+    ctx._preCacheFails.set(pre, cache);
+  }
+  return cache;
+}
+function map(p, fn2) {
+  const mapParser = parser(
+    `map`,
+    (ctx) => {
+      const extended = runExtended(ctx, p);
+      if (!extended) return null;
+      const mappedValue = fn2(extended);
+      if (mappedValue === null) return null;
+      return { value: mappedValue, tags: extended.tags };
+    }
+  );
+  return mapParser;
+}
+function toParser(p, toParserFn) {
+  const newParser = parser(
+    "toParser",
+    (ctx) => {
+      const extended = runExtended(ctx, p);
+      if (!extended) return null;
+      const newParser2 = toParserFn(extended);
+      if (newParser2 === void 0) {
+        return extended;
+      }
+      const nextResult = newParser2._run(ctx);
+      return nextResult;
+    }
+  );
+  return newParser;
+}
+const emptySet = /* @__PURE__ */ new Set();
+function tokenSkipSet(ignore, p) {
+  const ignoreSet = ignore ?? emptySet;
+  const ignoreValues = [...ignoreSet.values()].toString() || "(null)";
+  const ignoreParser = parser(
+    `tokenSkipSet ${ignoreValues}`,
+    (ctx) => ctx.lexer.withIgnore(ignoreSet, () => p._run(ctx))
+  );
+  return ignoreParser;
+}
+function preParse(pre, p) {
+  const newParser = parser(
+    "preParse",
+    (ctx) => {
+      const newCtx = { ...ctx, _preParse: [pre, ...ctx._preParse] };
+      return p._run(newCtx);
+    }
+  );
+  return newParser;
+}
+function disablePreParse(arg) {
+  const parser2 = parserArg(arg);
+  return parser2._cloneWith({ preDisabled: true });
+}
+function runExtended(ctx, p) {
+  const origStart = ctx.lexer.position();
+  const origResults = p._run(ctx);
+  if (origResults === null) {
+    ctx.lexer.position(origStart);
+    return null;
+  }
+  const end2 = ctx.lexer.position();
+  const src = ctx.lexer.src;
+  ctx.lexer.position(origStart);
+  const start = ctx.lexer.skipIgnored();
+  ctx.lexer.position(end2);
+  const { app, srcMap } = ctx;
+  return { ...origResults, start, end: end2, app, src, srcMap, ctx };
+}
+function trackChildren(p, ...args) {
+}
+let tracing = false;
+let logger = console.log;
+const withTraceLogging = () => stubTraceLogging;
+function stubTraceLogging(ctx, trace, fn2) {
+  return fn2(ctx);
+}
+function srcLog(src, pos, ...msgs) {
+  logInternal(logger, src, pos, ...msgs);
+}
+function resultLog(result, ...msgs) {
+  const { src, srcMap, start, end: end2 } = result;
+  srcLog(srcMap ?? src, [start, end2 - 1], ...msgs);
+}
+function ctxLog(ctx, ...msgs) {
+  const src = ctx.srcMap ?? ctx.lexer.src;
+  srcLog(src, ctx.lexer.position(), ...msgs);
+}
+function logInternal(log, srcOrSrcMap, destPos, ...msgs) {
+  if (typeof srcOrSrcMap === "string") {
+    logInternalSrc(log, srcOrSrcMap, destPos, ...msgs);
+    return;
+  }
+  const { src, positions } = mapSrcPositions(srcOrSrcMap, destPos);
+  logInternalSrc(log, src, positions, ...msgs);
+}
+function mapSrcPositions(srcMap, destPos) {
+  var _a;
+  const srcPos = srcMap.mapPositions(...[destPos].flat());
+  const { src } = srcPos[0];
+  let positions;
+  if (((_a = srcPos[1]) == null ? void 0 : _a.src) === src) {
+    positions = srcPos.map((p) => p.position);
+  } else {
+    positions = srcPos[0].position;
+  }
+  return { src, positions };
+}
+function logInternalSrc(log, src, pos, ...msgs) {
+  log(...msgs);
+  const { line, lineNum, linePos, linePos2 } = srcLine(src, pos);
+  {
+    log(line, `  Ln ${lineNum}`);
+  }
+  const caret = carets(linePos, linePos2);
+  log(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 end2 = starts.length - 1;
+  if (pos >= starts[end2]) {
+    start = end2;
+  }
+  while (start + 1 < end2) {
+    const mid = start + end2 >> 1;
+    if (pos >= starts[mid]) {
+      start = mid;
+    } else {
+      end2 = mid;
+    }
+  }
+  let linePos2;
+  if (pos2 !== void 0 && pos2 >= starts[start] && pos2 < starts[end2]) {
+    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 matchingLexer(src, rootMatcher, ignore = /* @__PURE__ */ new Set(["ws"]), srcMap) {
+  let matcher = rootMatcher;
+  const matcherStack = [];
+  matcher.start(src);
+  function next() {
+    matcher.position();
+    const { token } = toNextToken();
+    return token;
+  }
+  function skipIgnored() {
+    const { p } = toNextToken();
+    matcher.position(p);
+    return p;
+  }
+  function toNextToken() {
+    let p = matcher.position();
+    if (eof2()) return { p };
+    let token = matcher.next();
+    while (token && ignore.has(token.kind)) {
+      p = matcher.position();
+      if (eof2()) return { p };
+      token = matcher.next();
+    }
+    return { p, token };
+  }
+  function pushMatcher(newMatcher, newIgnore) {
+    const position2 = matcher.position();
+    matcherStack.push({ matcher, ignore });
+    newMatcher.start(src, position2);
+    matcher = newMatcher;
+    ignore = newIgnore;
+  }
+  function popMatcher() {
+    const position2 = matcher.position();
+    const elem = matcherStack.pop();
+    if (!elem) {
+      console.error("too many pops");
+      return;
+    }
+    matcher = elem.matcher;
+    ignore = elem.ignore;
+    matcher.position(position2);
+  }
+  function position(pos) {
+    if (pos !== void 0) {
+      matcher.start(src, pos);
+    }
+    return matcher.position();
+  }
+  function withMatcher(newMatcher, fn2) {
+    return withMatcherIgnore(newMatcher, ignore, fn2);
+  }
+  function withIgnore(newIgnore, fn2) {
+    return withMatcherIgnore(matcher, newIgnore, fn2);
+  }
+  function withMatcherIgnore(tokenMatcher2, ignore2, fn2) {
+    pushMatcher(tokenMatcher2, ignore2);
+    const result = fn2();
+    popMatcher();
+    return result;
+  }
+  function eof2() {
+    return matcher.position() === src.length;
+  }
+  return {
+    next,
+    position,
+    withMatcher,
+    withIgnore,
+    eof: eof2,
+    skipIgnored,
+    src
+  };
+}
+function quotedText(text2) {
+  return text2 ? `'${text2.replace(/\n/g, "\\n")}'` : "";
+}
+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 === prev.src && 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 === this.dest);
+    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 !== this.dest);
+    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() {
+    __privateAdd(this, _fragments2, []);
+    __privateAdd(this, _destLength, 0);
+    __privateAdd(this, _entries, []);
+  }
+  /** append a string fragment to the destination string */
+  // TODO allow for src file name not just string (e.g. SrcModule)
+  add(fragment, src, srcStart, srcEnd) {
+    const destStart = __privateGet(this, _destLength);
+    __privateSet(this, _destLength, __privateGet(this, _destLength) + fragment.length);
+    const destEnd = __privateGet(this, _destLength);
+    __privateGet(this, _fragments2).push(fragment);
+    __privateGet(this, _entries).push({ src, srcStart, srcEnd, destStart, destEnd });
+  }
+  /** append a synthetic newline, mapped to previous source location */
+  addNl() {
+    const lastEntry = __privateGet(this, _entries).slice(-1)[0] ?? {};
+    const { src = "?", srcStart = 0, srcEnd = 0 } = lastEntry;
+    this.add("\n", src, srcStart, srcEnd);
+  }
+  /** copy a string fragment from the src to the destination string */
+  addCopy(src, srcStart, srcEnd) {
+    const fragment = src.slice(srcStart, srcEnd);
+    this.add(fragment, src, srcStart, srcEnd);
+  }
+  /** return a SrcMap */
+  build() {
+    const map2 = new SrcMap(__privateGet(this, _fragments2).join(""), __privateGet(this, _entries));
+    map2.compact();
+    return map2;
+  }
+}
+_fragments2 = new WeakMap();
+_destLength = new WeakMap();
+_entries = new WeakMap();
+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 tokenMatcher(matchers, debugName = "matcher") {
+  const groups = Object.keys(matchers);
+  let src;
+  const cache = new Cache(5);
+  const expParts = Object.entries(matchers).map(toRegexSource).join("|");
+  const exp = new RegExp(expParts, "midgu");
+  function start(text2, position2 = 0) {
+    if (src !== text2) {
+      cache.clear();
+    }
+    src = text2;
+    exp.lastIndex = position2;
+  }
+  function next() {
+    if (src === void 0) {
+      throw new Error("start() first");
+    }
+    const startPos = exp.lastIndex;
+    const found = cache.get(startPos);
+    if (found) {
+      exp.lastIndex += found.text.length;
+      return found;
+    }
+    const matches = exp.exec(src);
+    const matchedIndex = findGroupDex(matches == null ? void 0 : matches.indices);
+    if (matchedIndex) {
+      const { startEnd, groupDex } = matchedIndex;
+      const kind2 = groups[groupDex];
+      const text2 = src.slice(startEnd[0], startEnd[1]);
+      const token = { kind: kind2, text: text2 };
+      if (startPos != startEnd[0]) {
+        srcLog(
+          src,
+          startPos,
+          `tokens ${debugName} skipped: '${src.slice(startPos, startEnd[0])}' to get to: '${text2}'`
+        );
+        throw new Error("token matcher should match all input");
+      }
+      cache.set(startPos, token);
+      return token;
+    }
+  }
+  function position(pos) {
+    if (pos !== void 0) {
+      exp.lastIndex = pos;
+    }
+    return exp.lastIndex;
+  }
+  const keyEntries = groups.map((k) => [k, k]);
+  const keys = Object.fromEntries(keyEntries);
+  return {
+    ...keys,
+    start,
+    next,
+    position,
+    _debugName: debugName
+  };
+}
+function findGroupDex(indices) {
+  if (indices) {
+    for (let i = 1; i < indices.length; i++) {
+      const startEnd = indices[i];
+      if (startEnd) {
+        return { startEnd, groupDex: i - 1 };
+      }
+    }
+  }
+}
+function toRegexSource(nameExp) {
+  const [name, e] = nameExp;
+  if (typeof e === "string") {
+    const expSrc = `(${escapeRegex(e)})`;
+    verifyNonCapturing(name, new RegExp(expSrc));
+    return expSrc;
+  } else {
+    verifyNonCapturing(name, e);
+    return `(${e.source})`;
+  }
+}
+function verifyNonCapturing(name, 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: ${name}: /${exp.source}/. Use (?:...) instead.`
+    );
+  }
+}
+const regexSpecials = /[$+*.?|(){}[\]\\/^]/g;
+function escapeRegex(s) {
+  return s.replace(regexSpecials, "\\$&");
+}
+function matchOneOf(syms) {
+  const symbolList = syms.split(" ").sort((a, b) => b.length - a.length);
+  const escaped = symbolList.filter((s) => s).map(escapeRegex);
+  return new RegExp(escaped.join("|"));
+}
+const eol = /[\n\v\f\u{0085}\u{2028}\u{2029}]|\r\n?/u;
+const blankspaces = /[ \t\n\v\f\r\u{0085}\u{200E}\u{200F}\u{2028}\u{2029}]+/u;
+const directive = /#[a-zA-Z_]\w*/;
+const symbolSet = "& && -> @ / ! [ ] { } :: : , == = != >>= >> >= > <<= << <= < % - -- . + ++ | || ( ) ; * ~ ^ // /* */ += -= *= /= %= &= |= ^= _";
+const symbol = matchOneOf(symbolSet);
+const quote = /["']/;
+const ident = /(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))/u;
+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 textureStorage = matchOneOf(
+  "texture_strorage_1d texture_storage_2d texture_storage_2d_array texture_storage_3d"
+);
+const mainTokens = tokenMatcher(
+  {
+    directive,
+    textureStorage,
+    ident,
+    digits,
+    symbol,
+    quote,
+    ws: blankspaces
+  },
+  "main"
+);
+const bracketTokens = tokenMatcher(
+  {
+    bracket: /<|>/,
+    ws: blankspaces,
+    other: /[^<>]+/
+  },
+  "bracket"
+);
+const lineCommentTokens = tokenMatcher(
+  {
+    ws: /[ \t]+/,
+    // note ws must be before notEol
+    notEol: /[^\n]+/,
+    eol
+  },
+  "lineComment"
+);
+const argsTokens = tokenMatcher(
+  {
+    directive,
+    quote,
+    relPath: /[.][/\w._-]+/,
+    arg: /[\w._-]+/,
+    symbol,
+    ws: /[ \t]+/,
+    // don't include \n, so we can find eol separately
+    eol
+  },
+  "argsTokens"
+);
+tokenMatcher(
+  {
+    blanks: /\s+/,
+    other: /[^\s]+/
+  },
+  "rootWs"
+);
+function resetScopeIds() {
+  scopeId = 0;
+}
+let scopeId = 0;
+function makeScope(s) {
+  return { ...s, id: scopeId++ };
+}
+function emptyScope(kind2) {
+  return makeScope({ idents: [], parent: null, children: [], kind: kind2 });
+}
+function emptyBodyScope(parent) {
+  return makeScope({ kind: "body-scope", idents: [], parent, children: [] });
+}
+function exportDecl(scope, name) {
+  for (const ident2 of scope.idents) {
+    if (ident2.originalName === name && ident2.kind === "decl") {
+      return ident2;
+    }
+  }
+}
+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: end2 } = cc;
+  const app = cc.app;
+  const { scope } = app.context;
+  const { srcModule } = app.stable;
+  const originalName = src.slice(start, end2);
+  const kind2 = "ref";
+  const ident2 = { kind: kind2, originalName, ast: cc.app.stable, scope };
+  const identElem = { kind: kind2, start, end: end2, srcModule, ident: ident2 };
+  ident2.refIdentElem = identElem;
+  saveIdent(cc, identElem);
+  return identElem;
+}
+function declIdentElem(cc) {
+  const { src, start, end: end2 } = cc;
+  const app = cc.app;
+  const { srcModule } = app.stable;
+  const originalName = src.slice(start, end2);
+  const kind2 = "decl";
+  const declElem = null;
+  const ident2 = { kind: kind2, originalName, scope: null, declElem };
+  const identElem = { kind: kind2, start, end: end2, srcModule, ident: ident2 };
+  saveIdent(cc, identElem);
+  return identElem;
+}
+let identId = 0;
+function saveIdent(cc, identElem) {
+  const { ident: ident2 } = identElem;
+  ident2.id = identId++;
+  const weslContext = cc.app.context;
+  weslContext.scope.idents.push(ident2);
+  addToOpenElem(cc, identElem);
+}
+function startScope(cc) {
+  const { scope } = cc.app.context;
+  const newScope = emptyBodyScope(scope);
+  scope.children.push(newScope);
+  cc.app.context.scope = newScope;
+}
+function completeScope(cc) {
+  const weslContext = cc.app.context;
+  const completedScope = weslContext.scope;
+  const { parent } = completedScope;
+  if (parent) {
+    weslContext.scope = parent;
+  }
+  return completedScope;
+}
+function collectVarLike(kind2) {
+  return collectElem(kind2, (cc, openElem) => {
+    var _a, _b, _c;
+    const name = (_a = cc.tags.declIdent) == null ? void 0 : _a[0];
+    const typeRef = (_b = cc.tags.typeRef) == null ? void 0 : _b[0];
+    const decl_scope = (_c = cc.tags.decl_scope) == null ? void 0 : _c[0];
+    const partElem = { ...openElem, name, typeRef };
+    const varElem = withTextCover(partElem, cc);
+    name.ident.declElem = varElem;
+    name.ident.scope = decl_scope;
+    return varElem;
+  });
+}
+function collectFn() {
+  return collectElem("fn", (cc, openElem) => {
+    var _a, _b, _c, _d;
+    const name = (_a = cc.tags.fnName) == null ? void 0 : _a[0];
+    const body_scope = (_b = cc.tags.body_scope) == null ? void 0 : _b[0];
+    const params = ((_c = cc.tags.fnParam) == null ? void 0 : _c.flat(3)) ?? [];
+    const returnType = (_d = cc.tags.returnType) == null ? void 0 : _d.flat(3)[0];
+    const partElem = { ...openElem, name, params, returnType };
+    const fnElem = withTextCover(partElem, cc);
+    name.ident.declElem = fnElem;
+    name.ident.scope = body_scope;
+    return fnElem;
+  });
+}
+function collectFnParam() {
+  return collectElem(
+    "param",
+    (cc, openElem) => {
+      var _a, _b;
+      const name = (_a = cc.tags.paramName) == null ? void 0 : _a[0];
+      const typeRef = (_b = cc.tags.typeRef) == null ? void 0 : _b[0];
+      const elem = { ...openElem, name, typeRef };
+      const paramElem = withTextCover(elem, cc);
+      name.ident.declElem = paramElem;
+      return paramElem;
+    }
+  );
+}
+function collectStruct() {
+  return collectElem(
+    "struct",
+    (cc, openElem) => {
+      var _a, _b;
+      const name = (_a = cc.tags.typeName) == null ? void 0 : _a[0];
+      const members = cc.tags.members;
+      const structElem = { ...openElem, name, members };
+      const elem = withTextCover(structElem, cc);
+      name.ident.declElem = elem;
+      name.ident.scope = (_b = cc.tags.struct_scope) == null ? void 0 : _b[0];
+      return elem;
+    }
+  );
+}
+function collectStructMember() {
+  return collectElem(
+    "member",
+    (cc, openElem) => {
+      var _a, _b;
+      const name = (_a = cc.tags.nameElem) == null ? void 0 : _a[0];
+      const typeRef = (_b = cc.tags.typeRef) == null ? void 0 : _b[0];
+      const partElem = { ...openElem, name, typeRef };
+      return withTextCover(partElem, cc);
+    }
+  );
+}
+function collectNameElem(cc) {
+  const { start, end: end2, src, app } = cc;
+  const { srcModule } = app.stable;
+  const name = src.slice(start, end2);
+  const elem = { kind: "name", srcModule, start, end: end2, name };
+  addToOpenElem(cc, elem);
+  return elem;
+}
+function collectModule() {
+  return 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 importList(cc) {
+  const list = cc.tags.list;
+  return new SegmentList(list);
+}
+function importSegment(cc) {
+  var _a, _b;
+  const segOrig = (_a = cc.tags.segment) == null ? void 0 : _a[0];
+  const seg = segOrig === "." ? "package" : segOrig;
+  return new SimpleSegment(seg, (_b = cc.tags.as) == null ? void 0 : _b[0]);
+}
+function importTree(cc) {
+  var _a;
+  const path = (_a = cc.tags.p) == null ? void 0 : _a.flat();
+  return new ImportTree(path);
+}
+function importElem() {
+  return collectElem(
+    "import",
+    (cc, openElem) => {
+      const path = cc.tags.p;
+      const imports = new ImportTree(path);
+      const partialElem = { ...openElem, imports };
+      const importElem2 = withTextCover(partialElem, cc);
+      cc.app.stable.imports.push(imports);
+      return importElem2;
+    }
+  );
+}
+function scopeCollect() {
+  return {
+    before: startScope,
+    after: completeScope
+  };
+}
+function collectSimpleElem(kind2) {
+  return collectElem(kind2, (cc, part) => withTextCover(part, cc));
+}
+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 });
+      addToOpenElem(cc, elem);
+      return elem;
+    }
+  };
+}
+function withTextCover(elem, cc) {
+  const contents = coverWithText(cc, elem.contents);
+  return { ...elem, contents };
+}
+function coverWithText(cc, existing) {
+  let { start: pos } = cc;
+  const { end: end2, app } = cc;
+  const ast = app.stable;
+  const sorted = existing.sort((a, b) => a.start - b.start);
+  const elems = sorted.flatMap((elem) => {
+    const result = pos < elem.start ? [makeTextElem(elem.start), elem] : [elem];
+    pos = elem.end;
+    return result;
+  });
+  if (pos < end2) {
+    elems.push(makeTextElem(end2));
+  }
+  return elems;
+  function makeTextElem(end22) {
+    return { kind: "text", start: pos, end: end22, srcModule: ast.srcModule };
+  }
+}
+const skipWsSet = /* @__PURE__ */ new Set(["ws"]);
+function skipWs(p) {
+  return tokenSkipSet(skipWsSet, p);
+}
+function noSkipWs(p) {
+  return tokenSkipSet(null, p);
+}
+const importSymbolSet = "/ { } , ( ) .. . * ; @ #";
+const importSymbol = matchOneOf(importSymbolSet);
+const importTokens = tokenMatcher({
+  ws: /\s+/,
+  importSymbol,
+  ident,
+  // TODO allow '-' in pkg names?
+  digits
+});
+const eolTokens = tokenMatcher({
+  ws: /[ \t]+/,
+  // don't include \n, for eolf
+  eol
+});
+const eolf$1 = disablePreParse(makeEolf(eolTokens, importTokens.ws));
+const wordToken = kind(importTokens.ident);
+let packagePath = null;
+const simpleSegment = tagScope(
+  wordToken.ptag("segment").collect(importSegment)
+);
+const lastSimpleSegment = tagScope(
+  seq(
+    wordToken.ptag("segment"),
+    skipWs(opt(seq("as", wordToken.ptag("as"))))
+  ).collect(importSegment)
+);
+const collectionItem = or(
+  tagScope(or(() => packagePath).collect(importTree)),
+  lastSimpleSegment
+);
+const importCollection = tagScope(
+  seq(
+    "{",
+    skipWs(
+      seq(
+        withSepPlus(",", () => collectionItem.ctag("list")),
+        "}"
+      )
+    )
+  ).collect(importList)
+);
+const relativeSegment = tagScope(
+  seq(or(".", "..").ptag("segment"), "/").collect(importSegment)
+).ctag("p");
+const lastSegment = or(lastSimpleSegment, importCollection);
+const packageTail = seq(
+  repeat(seq(simpleSegment.ctag("p"), "/")),
+  lastSegment.ctag("p")
+);
+const relativePath$1 = seq(repeatPlus(relativeSegment), packageTail);
+const packagePrefix = tagScope(
+  seq(wordToken.ptag("segment"), "/").collect(importSegment)
+).ctag("p");
+packagePath = seq(packagePrefix, packageTail);
+const fullPath = noSkipWs(
+  seq(kind(importTokens.ws), or(relativePath$1, packagePath))
+);
+const weslImport = tagScope(
+  tokens(
+    importTokens,
+    seq("import", fullPath, opt(";"), eolf$1).collect(importElem())
+  )
+);
+any().map((r) => {
+  const { kind: kind2, text: text2 } = r.value;
+  const deepName = r.ctx._debugNames.join(" > ");
+  resultLog(r, `??? ${kind2}: '${text2}'  ${deepName}`);
+});
+const eolf = disablePreParse(
+  makeEolf(argsTokens, argsTokens.ws)
+);
+const skipToEol = tokens(lineCommentTokens, anyThrough(eolf));
+const blockComment = seq(
+  "/*",
+  repeat(or(() => blockComment, anyNot("*/"))),
+  req("*/")
+);
+const lineComment = seq(tokens(mainTokens, "//"), skipToEol);
+const comment = or(() => lineComment, blockComment).trace({
+  hide: true
+});
+const word = or(
+  kind(mainTokens.ident),
+  kind(mainTokens.textureStorage)
+);
+withSepPlus("::", word);
+const diagnostic_rule_name = withSep(".", word, { requireOne: true });
+const diagnostic_control = seq(
+  "(",
+  word,
+  ",",
+  diagnostic_rule_name,
+  opt(","),
+  ")"
+);
+const word_list = seq("(", withSep(",", word, { requireOne: true }), ")");
+const attribute = seq(
+  "@",
+  req(
+    or(
+      // These attributes have no arguments
+      or("compute", "const", "fragment", "invariant", "must_use", "vertex"),
+      // These attributes have arguments, but the argument doesn't have any identifiers
+      seq(
+        or("interpolate", "builtin"),
+        req(() => word_list)
+      ),
+      seq("diagnostic", diagnostic_control),
+      // These are normal attributes
+      seq(
+        or(
+          "workgroup_size",
+          "align",
+          "binding",
+          "blend_src",
+          "group",
+          "id",
+          "location",
+          "size"
+        ),
+        req(() => argument_expression_list)
+      ),
+      // Everything else is also a normal attribute, it might have an expression list
+      seq(
+        word,
+        opt(() => argument_expression_list)
+      )
+    )
+  )
+);
+const argument_expression_list = seq(
+  "(",
+  withSep(",", () => expression),
+  req(")")
+);
+const opt_attributes = repeat(attribute);
+const typeNameDecl = req(word.collect(declIdentElem, "typeName"));
+const fnNameDecl = req(
+  word.collect(declIdentElem, "fnName"),
+  "missing fn name"
+);
+const std_type_specifier = seq(
+  word.collect(refIdent, "typeRef"),
+  () => opt_template_list
+);
+const texture_storage_type = seq(
+  kind(mainTokens.textureStorage),
+  () => opt_template_words
+);
+const ptr_type = seq(
+  "ptr",
+  req("<"),
+  word,
+  req(","),
+  () => template_arg_expression,
+  opt(seq(",", word)),
+  req(">")
+);
+const type_specifier = or(
+  texture_storage_type,
+  ptr_type,
+  std_type_specifier
+);
+const optionally_typed_ident = seq(
+  word.collect(declIdentElem, "declIdent"),
+  opt(seq(":", type_specifier))
+);
+const req_optionally_typed_ident = req(optionally_typed_ident);
+const struct_member = seq(
+  opt_attributes,
+  word.collect(collectNameElem, "nameElem"),
+  ":",
+  req(type_specifier)
+).collect(collectStructMember());
+const struct_decl = seq(
+  "struct",
+  req(typeNameDecl),
+  seq(
+    req("{"),
+    withSepPlus(",", struct_member).ptag("members"),
+    req("}")
+  ).collect(scopeCollect(), "struct_scope")
+).collect(collectStruct());
+const fn_call = seq(
+  word.collect(refIdent, "fn_call.refIdent"),
+  // we collect this in fnDecl, to attach to FnElem
+  () => opt_template_list,
+  argument_expression_list
+);
+const fnParam = tagScope(
+  seq(
+    opt_attributes,
+    word.collect(declIdentElem, "paramName"),
+    opt(seq(":", req(type_specifier)))
+  ).collect(collectFnParam())
+).ctag("fnParam");
+const fnParamList = seq("(", withSep(",", fnParam), ")");
+const local_variable_decl = seq(
+  "var",
+  () => opt_template_list,
+  req_optionally_typed_ident,
+  opt(seq("=", () => expression))
+).collect(collectVarLike("var"), "variable_decl");
+const global_variable_decl = seq(
+  "var",
+  () => opt_template_words,
+  req_optionally_typed_ident,
+  opt(seq("=", () => expression.collect(scopeCollect(), "decl_scope")))
+);
+const opt_template_list = opt(
+  seq(
+    tokens(bracketTokens, "<"),
+    withSepPlus(",", () => template_arg_expression),
+    tokens(bracketTokens, ">")
+  )
+);
+const opt_template_words = opt(
+  seq(
+    tokens(bracketTokens, "<"),
+    withSepPlus(",", () => word),
+    tokens(bracketTokens, ">")
+  )
+);
+const template_elaborated_ident = seq(
+  word.collect(refIdent),
+  opt_template_list
+);
+const literal = or("true", "false", kind(mainTokens.digits));
+const paren_expression = seq("(", () => expression, req(")"));
+const call_expression = seq(
+  template_elaborated_ident,
+  argument_expression_list
+);
+const primary_expression = or(
+  literal,
+  paren_expression,
+  call_expression,
+  template_elaborated_ident
+);
+const component_or_swizzle = repeatPlus(
+  or(
+    seq(".", word),
+    seq("[", () => expression, req("]"))
+  )
+);
+const makeExpressionOperator = (isTemplate) => {
+  const allowedOps = ("& | ^ << <= < != == % * / + -" + (isTemplate ? "" : " && || >> >= >")).split(" ");
+  return or(...allowedOps);
+};
+const unary_expression = or(
+  seq(or(..."! & * - ~".split(" ")), () => unary_expression),
+  seq(primary_expression, opt(component_or_swizzle))
+);
+const makeExpression = (isTemplate) => {
+  return seq(
+    unary_expression,
+    repeat(seq(makeExpressionOperator(isTemplate), unary_expression))
+  );
+};
+const expression = makeExpression(false);
+const template_arg_expression = makeExpression(true);
+const unscoped_compound_statement = seq(
+  opt_attributes,
+  text("{"),
+  repeat(() => statement),
+  req("}")
+);
+const compound_statement = seq(
+  opt_attributes,
+  seq(
+    text("{"),
+    repeat(() => statement),
+    req("}")
+  ).collect(scopeCollect())
+);
+const for_init = or(
+  fn_call,
+  () => variable_or_value_statement,
+  () => variable_updating_statement
+);
+const for_update = or(fn_call, () => variable_updating_statement);
+const for_statement = seq(
+  opt_attributes,
+  "for",
+  seq(
+    req("("),
+    opt(for_init),
+    req(";"),
+    opt(expression),
+    req(";"),
+    opt(for_update),
+    req(")"),
+    unscoped_compound_statement
+  ).collect(scopeCollect())
+);
+const if_statement = seq(
+  opt_attributes,
+  "if",
+  req(seq(expression, compound_statement)),
+  repeat(seq("else", "if", req(seq(expression, compound_statement)))),
+  opt(seq("else", req(compound_statement)))
+);
+const loop_statement = seq(
+  opt_attributes,
+  "loop",
+  opt_attributes,
+  req(
+    seq(
+      "{",
+      repeat(() => statement),
+      opt(
+        seq(
+          "continuing",
+          opt_attributes,
+          "{",
+          repeat(() => statement),
+          opt(seq("break", "if", expression, ";")),
+          "}"
+        )
+      ),
+      "}"
+    )
+  )
+);
+const case_selector = or("default", expression);
+const switch_clause = or(
+  seq(
+    "case",
+    withSep(",", case_selector, { requireOne: true }),
+    opt(":"),
+    compound_statement
+  ),
+  seq("default", opt(":"), compound_statement)
+);
+const switch_body = seq(opt_attributes, "{", repeatPlus(switch_clause), "}");
+const switch_statement = seq(opt_attributes, "switch", expression, switch_body);
+const while_statement = seq(
+  opt_attributes,
+  "while",
+  expression,
+  compound_statement
+);
+const statement = or(
+  for_statement,
+  if_statement,
+  loop_statement,
+  switch_statement,
+  while_statement,
+  compound_statement,
+  seq("break", ";"),
+  seq("continue", ";"),
+  seq(";"),
+  () => const_assert,
+  seq("discard", ";"),
+  seq("return", opt(expression), ";"),
+  seq(fn_call, ";"),
+  seq(() => variable_or_value_statement, ";"),
+  seq(() => variable_updating_statement, ";")
+);
+const lhs_expression = or(
+  seq(word.collect(refIdent), opt(component_or_swizzle)),
+  seq("(", () => lhs_expression, ")", opt(component_or_swizzle)),
+  seq("&", () => lhs_expression),
+  seq("*", () => lhs_expression)
+);
+const variable_or_value_statement = or(
+  // Also covers the = expression case
+  local_variable_decl,
+  seq("const", req_optionally_typed_ident, req("="), expression),
+  seq("let", req_optionally_typed_ident, req("="), expression)
+);
+const variable_updating_statement = or(
+  seq(
+    lhs_expression,
+    or("=", "<<=", ">>=", "%=", "&=", "*=", "+=", "-=", "/=", "^=", "|="),
+    // TODO: try making this a lexer rule instead of a parser rule
+    expression
+  ),
+  seq(lhs_expression, or("++", "--")),
+  seq("_", "=", expression)
+);
+const fn_decl = seq(
+  opt_attributes,
+  text("fn"),
+  req(fnNameDecl),
+  seq(
+    req(fnParamList),
+    opt(seq("->", opt_attributes, type_specifier.ctag("returnType"))),
+    req(unscoped_compound_statement)
+  ).collect(scopeCollect(), "body_scope")
+).collect(collectFn());
+const global_value_decl = or(
+  seq(
+    opt_attributes,
+    "override",
+    optionally_typed_ident,
+    seq(opt(seq("=", expression.collect(scopeCollect(), "decl_scope")))),
+    ";"
+  ).collect(collectVarLike("override")),
+  seq(
+    "const",
+    optionally_typed_ident,
+    "=",
+    seq(expression).collect(scopeCollect(), "decl_scope"),
+    ";"
+  ).collect(collectVarLike("const"))
+);
+const global_alias = seq(
+  "alias",
+  req(word).collect(declIdentElem, "declIdent"),
+  req("="),
+  req(type_specifier).collect(scopeCollect(), "decl_scope"),
+  req(";")
+).collect(collectVarLike("alias"), "global_alias");
+const const_assert = seq("const_assert", req(expression), ";").collect(
+  collectSimpleElem("assert")
+);
+const global_directive = seq(
+  or(
+    seq("diagnostic", diagnostic_control),
+    seq("enable", withSep(",", word, { requireOne: true })),
+    seq("requires", withSep(",", word, { requireOne: true }))
+  ),
+  ";"
+);
+const global_decl = tagScope(
+  or(
+    fn_decl,
+    seq(opt_attributes, global_variable_decl, ";").collect(
+      collectVarLike("gvar"),
+      "g_variable_decl"
+    ),
+    global_value_decl,
+    ";",
+    global_alias,
+    const_assert,
+    struct_decl
+  )
+);
+const end = tokenSkipSet(null, seq(repeat(kind(mainTokens.ws)), eof()));
+const weslRoot = preParse(
+  comment,
+  seq(
+    repeat(weslImport),
+    repeat(or(global_directive, weslImport)),
+    repeat(or(global_decl, weslImport)),
+    req(end)
+  ).collect(collectModule(), "collectModule")
+);
+function flattenTreeImport(imp) {
+  return recursiveResolve([], [], imp.segments);
+  function recursiveResolve(resolvedImportPath, resolvedExportPath, remainingPath) {
+    const [segment, ...rest] = remainingPath;
+    if (segment === void 0) {
+      throw new Error(`undefined segment ${imp.segments}`);
+    }
+    if (segment instanceof SimpleSegment) {
+      const importPath = [...resolvedImportPath, segment.as || segment.name];
+      const modulePath = [...resolvedExportPath, segment.name];
+      if (rest.length) {
+        return recursiveResolve(importPath, modulePath, rest);
+      } else {
+        return [{ importPath, modulePath }];
+      }
+    }
+    if (segment instanceof SegmentList) {
+      return segment.list.flatMap((elem) => {
+        const rPath = [elem, ...rest];
+        return recursiveResolve(resolvedImportPath, resolvedExportPath, rPath);
+      });
+    } else if (segment instanceof ImportTree) {
+      return recursiveResolve(
+        resolvedImportPath,
+        resolvedExportPath,
+        segment.segments
+      );
+    }
+    return [];
+  }
+}
+function parseSrcModule(srcModule, srcMap, maxParseCount = void 0) {
+  resetScopeIds();
+  const lexer = matchingLexer(srcModule.src, mainTokens);
+  const appState = blankWeslParseState(srcModule);
+  const init = { lexer, appState, srcMap, maxParseCount };
+  const parseResult = weslRoot.parse(init);
+  if (parseResult === null) {
+    throw new Error("parseWESL failed");
+  }
+  return appState.stable;
+}
+function parseWESL(src, srcMap, maxParseCount = void 0) {
+  const srcModule = {
+    modulePath: "package::test",
+    filePath: "./test.wesl",
+    src
+  };
+  return parseSrcModule(srcModule, srcMap, maxParseCount);
+}
+function blankWeslParseState(srcModule) {
+  const rootScope = emptyScope("module-scope");
+  const moduleElem = null;
+  return {
+    context: { scope: rootScope, openElems: [] },
+    stable: { srcModule, imports: [], rootScope, moduleElem }
+  };
+}
+function syntheticWeslParseState() {
+  const srcModule = {
+    modulePath: "package::test",
+    filePath: "./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 dot4UI8Packed dot4I8Packed 
+  exp exp2 extractBits faceForward firstLeadingBit firstTrailingBit 
+  floor fma fract frexp inserBits 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 
+  fwdithCoarse fwidthFine
+  textureDimensions textureGather textureGatherCompare textureLoad
+  textureNumLayers textureNumLevels textureNumSamples
+  textureSample textureSampleBias textureSampleCompare textureSampleCompareLevel
+  textureSampleGrad textureSampleLevel textureSampleBaseClampToEdge
+  textureStore
+  atomicLoad atomicStore atomicAdd atomicSub atomicMax atomicMin
+  atomicOr atomicXor atomicExchange atomicCompareExchangeWeak
+  pack4x8snorm pack4x8unorm pack4xI8 pack4xU8 pack4xI8Clamp pack4xU8Clamp
+  pack2x16snorm pack2x16unorm pack2x16float
+  unpack4x8snorm unpack4x8unorm unpack4xI8 unpack4xU8 
+  unpack2x16snorm unpack2x16unorm unpack2x16float
+  storageBarrier textureBarrier workgroupBarrier workgroupUniformLoad
+  `.split(/\s+/);
+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
+  texture_1d texture_2d texture_2d_array texture_3d 
+  texture_cube texture_cube_array
+  texture_multisampled_2d texture_depth_multisampled_2d
+  texture_external
+  texture_storage_1d texture_storage_2d texture_storage_2d_array
+  texture_storage_3d
+  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 
+  function uniform
+  `.split(/\s+/);
+function stdType(name) {
+  return stdTypes.includes(name);
+}
+function stdFn(name) {
+  return stdFns.includes(name) || stdType(name);
+}
+function multiKeySet(m, a, b, v) {
+  const bMap = m.get(a) || /* @__PURE__ */ new Map();
+  m.set(a, bMap);
+  bMap.set(b, v);
+}
+const tokenRegex = /\b(\w+)\b/gi;
+function replaceWords(text2, replace) {
+  return text2.replaceAll(tokenRegex, (s) => s in replace ? replace[s] : s);
+}
+function grouped(a, size, stride = size) {
+  const groups = [];
+  for (let i = 0; i < a.length; i += stride) {
+    groups.push(a.slice(i, i + size));
+  }
+  return groups;
+}
+function groupBy(a, key) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of a) {
+    const k = key(t);
+    const group = groups.get(k) || [];
+    group.push(t);
+    groups.set(k, group);
+  }
+  return groups;
+}
+function partition(a, partFn) {
+  const yesPart = [];
+  const noPart = [];
+  for (const t of a) {
+    if (partFn(t)) yesPart.push(t);
+    else noPart.push(t);
+  }
+  return [yesPart, noPart];
+}
+function scan(array, fn2, zero) {
+  const result = [zero];
+  let current = zero;
+  for (let i = 0; i < array.length; i++) {
+    current = fn2(array[i], current);
+    result.push(current);
+  }
+  return result;
+}
+function mapForward(a, b) {
+  const combined = Object.entries(a).map(([key, value]) => {
+    const mappedValue = value in b ? b[value] : value;
+    return [key, mappedValue];
+  });
+  return Object.fromEntries(combined);
+}
+function last(a) {
+  return a[a.length - 1];
+}
+function overlapTail(a, b) {
+  let overlapSize = Math.min(a.length, b.length);
+  while (overlapSize > 0) {
+    const suffix = a.slice(-overlapSize);
+    const prefix = b.slice(0, overlapSize);
+    if (arrayEquals(suffix, prefix)) {
+      break;
+    } else {
+      overlapSize--;
+    }
+  }
+  if (overlapSize) {
+    return b.slice(overlapSize);
+  }
+}
+function arrayEquals(a, b) {
+  return a.length === b.length && a.every((val, index) => val === b[index]);
+}
+function bindIdents(ast, parsed, conditions) {
+  const { rootScope } = ast;
+  const globalNames = /* @__PURE__ */ new Set();
+  const knownDecls = /* @__PURE__ */ new Set();
+  rootScope.idents.forEach((ident2) => {
+    if (ident2.kind === "decl") {
+      ident2.mangledName = ident2.originalName;
+      globalNames.add(ident2.originalName);
+      knownDecls.add(ident2);
+    }
+  });
+  const bindContext = {
+    parsed,
+    conditions,
+    knownDecls,
+    foundScopes: /* @__PURE__ */ new Set(),
+    globalNames
+  };
+  const decls = bindIdentsRecursive(rootScope, bindContext);
+  return decls.flatMap(
+    (d) => d.declElem && isGlobal(d.declElem) ? [d.declElem] : []
+  );
+}
+function bindIdentsRecursive(scope, bindContext) {
+  const { foundScopes } = bindContext;
+  if (foundScopes.has(scope)) return [];
+  foundScopes.add(scope);
+  const { parsed, conditions } = bindContext;
+  const { globalNames, knownDecls } = bindContext;
+  const newDecls = [];
+  scope.idents.forEach((ident2) => {
+    if (ident2.kind === "ref") {
+      if (!ident2.refersTo && !ident2.std) {
+        if (stdWgsl(ident2.originalName)) {
+          ident2.std = true;
+        } else {
+          let foundDecl = findDeclInModule(ident2.scope, ident2) ?? findDeclImport(ident2, parsed);
+          if (foundDecl) {
+            ident2.refersTo = foundDecl;
+            if (!knownDecls.has(foundDecl)) {
+              knownDecls.add(foundDecl);
+              setDisplayName(ident2.originalName, foundDecl, globalNames);
+              if (foundDecl.declElem && isGlobal(foundDecl.declElem)) {
+                newDecls.push(foundDecl);
+              }
+            }
+          } else {
+            const { refIdentElem } = ident2;
+            if (refIdentElem) {
+              const { srcModule, start, end: end2 } = refIdentElem;
+              const { filePath } = srcModule;
+              const msg = `unresolved identifier in file: ${filePath}`;
+              srcLog(srcModule.src, [start, end2], msg);
+            }
+          }
+        }
+      }
+    }
+  });
+  const newFromChildren = scope.children.flatMap((child) => {
+    return bindIdentsRecursive(child, bindContext);
+  });
+  const newFromRefs = newDecls.flatMap((decl) => {
+    return bindIdentsRecursive(decl.scope, bindContext);
+  });
+  return [newDecls, newFromChildren, newFromRefs].flat();
+}
+function setDisplayName(proposedName, decl, globalNames) {
+  if (!decl.mangledName) {
+    if (decl.declElem && isGlobal(decl.declElem)) {
+      decl.mangledName = declUniqueName(proposedName, globalNames);
+    } else {
+      decl.mangledName = decl.originalName;
+    }
+  }
+}
+function stdWgsl(name) {
+  return stdType(name) || stdFn(name);
+}
+function findDeclInModule(scope, ident2) {
+  const { parent } = scope;
+  const { originalName } = ident2;
+  const found = scope.idents.find(
+    (i) => i.kind === "decl" && i.originalName === originalName
+  );
+  if (found) return found;
+  if (parent) {
+    return findDeclInModule(parent, ident2);
+  }
+}
+function findDeclImport(refIdent2, parsed) {
+  const flatImps = flatImports(refIdent2.ast);
+  const modulePathParts = matchingImport(refIdent2, flatImps);
+  if (modulePathParts) {
+    return findExport(modulePathParts, parsed);
+  }
+}
+function matchingImport(ident2, flatImports2) {
+  const identParts = ident2.originalName.split("::");
+  for (const flat of flatImports2) {
+    const impTail = overlapTail(flat.importPath, identParts);
+    if (impTail) {
+      return [...flat.modulePath, ...impTail];
+    }
+  }
+}
+function findExport(modulePathParts, parsed) {
+  const legacyConvert = modulePathParts.map((p) => p === "." ? "package" : p);
+  const modulePath = legacyConvert.slice(0, -1).join("::");
+  const module2 = parsed.modules[modulePath];
+  if (!module2) {
+    console.log(
+      `ident ${modulePathParts.join("::")} in import statement, but module not found`
+    );
+  }
+  return exportDecl(module2.rootScope, last(modulePathParts));
+}
+function declUniqueName(proposedName, rootNames) {
+  const displayName2 = uniquifyName(proposedName, rootNames);
+  rootNames.add(displayName2);
+  return displayName2;
+}
+function uniquifyName(proposedName, rootNames) {
+  let renamed = proposedName;
+  let conflicts = 0;
+  while (rootNames.has(renamed)) {
+    renamed = proposedName + conflicts++;
+  }
+  return renamed;
+}
+function isGlobal(elem) {
+  return ["alias", "const", "override", "fn", "struct", "gvar"].includes(
+    elem.kind
+  );
+}
+function lowerAndEmit(srcBuilder, rootElems, conditions, extracting = true) {
+  const emitContext = { conditions, srcBuilder, extracting };
+  lowerAndEmitRecursive(rootElems, emitContext);
+}
+function lowerAndEmitRecursive(elems, emitContext) {
+  const validElems = elems.filter(
+    (e) => conditionsValid()
+  );
+  validElems.forEach((e) => lowerAndEmitElem(e, emitContext));
+}
+function lowerAndEmitElem(e, ctx) {
+  switch (e.kind) {
+    case "import":
+      return;
+    // drop imports statements from emitted text
+    case "fn":
+    case "struct":
+    case "override":
+    case "const":
+    case "assert":
+    case "alias":
+    case "gvar":
+      if (ctx.extracting) {
+        ctx.srcBuilder.addNl();
+        ctx.srcBuilder.addNl();
+      }
+      return emitContents(e, ctx);
+    case "text":
+      return emitText(e, ctx);
+    case "ref":
+    case "decl":
+      return emitIdent(e, ctx);
+    case "param":
+    case "var":
+    case "module":
+    case "member":
+      return emitContents(e, ctx);
+    case "name":
+      return emitName(e, ctx);
+    default:
+      const kind2 = e.kind;
+      console.log("NYI for emit, elem kind:", kind2);
+      throw new Error(`NYI emit elem kind: ${kind2}`);
+  }
+}
+function emitText(e, ctx) {
+  ctx.srcBuilder.addCopy(e.srcModule.src, e.start, e.end);
+}
+function emitName(e, ctx) {
+  ctx.srcBuilder.add(e.name, e.srcModule.src, e.start, e.end);
+}
+function emitContents(elem, ctx) {
+  elem.contents.forEach((e) => lowerAndEmitElem(e, ctx));
+}
+function emitIdent(e, ctx) {
+  if (e.ident.std) {
+    ctx.srcBuilder.add(e.ident.originalName, e.srcModule.src, e.start, e.end);
+  } else {
+    const declIdent = findDecl(e.ident);
+    const mangledName = displayName(declIdent);
+    ctx.srcBuilder.add(mangledName, e.srcModule.src, e.start, e.end);
+  }
+}
+function displayName(declIdent) {
+  if (declIdent.declElem && isGlobal(declIdent.declElem)) {
+    const mangledName = declIdent.mangledName;
+    return 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 ident: ${ident2.originalName} (bug in bindIdents?)`
+  );
+}
+function conditionsValid(elem, conditions) {
+  return true;
+}
+function relativePath(srcPath, reqPath) {
+  if (!srcPath) return reqPath;
+  const srcDir = dirname(srcPath);
+  const relative = join(srcDir, reqPath);
+  return relative;
+}
+function dirname(path) {
+  const lastSlash = path.lastIndexOf("/");
+  if (lastSlash === -1) return ".";
+  return path.slice(0, lastSlash);
+}
+function join(a, b) {
+  const joined = b.startsWith("/") ? a + b : a + "/" + b;
+  return normalize(joined);
+}
+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() {
+  return { 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("/")) {
+    modulePath = fileToModulePath(selectPath, packageName);
+  } else {
+    modulePath = packageName + "::" + selectPath;
+  }
+  return parsed.modules[modulePath];
+}
+function parseIntoRegistry(srcFiles, registry, packageName = "package", maxParseCount) {
+  const srcModules = Object.entries(srcFiles).map(
+    ([filePath, src]) => {
+      const modulePath = fileToModulePath(filePath, packageName);
+      return { modulePath, filePath, src };
+    }
+  );
+  srcModules.forEach((mod) => {
+    const parsed = parseSrcModule(mod, void 0, maxParseCount);
+    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 }) => parseIntoRegistry(modules, registry, name)
+  );
+}
+const libExp = /^lib\.w[eg]sl$/i;
+function fileToModulePath(filePath, packageName) {
+  if (packageName !== "package" && libExp.test(filePath)) {
+    return packageName;
+  }
+  const strippedPath = noSuffix(normalize(filePath));
+  const moduleSuffix = strippedPath.replaceAll("/", "::");
+  const modulePath = packageName + "::" + moduleSuffix;
+  return modulePath;
+}
+function linkWesl(weslSrc, rootModuleName = "main", conditions = {}) {
+  const parsed = parseWeslSrc(weslSrc);
+  return linkRegistry(parsed, rootModuleName, conditions);
+}
+function linkWeslFiles(weslSrc, rootModuleName = "main", conditions = {}, libs = [], maxParseCount) {
+  const registry = parsedRegistry();
+  parseIntoRegistry(weslSrc, registry, "package", maxParseCount);
+  parseLibsIntoRegistry(libs, registry);
+  return linkRegistry(registry, rootModuleName, conditions);
+}
+function linkRegistry(parsed, rootModuleName = "main", conditions = {}) {
+  const found = selectModule(parsed, rootModuleName);
+  if (!found) {
+    throw new Error(`Root module not found: ${rootModuleName}`);
+  }
+  const { moduleElem: rootModule } = found;
+  const newDecls = bindIdents(found, parsed, conditions);
+  const srcBuilder = new SrcMapBuilder();
+  lowerAndEmit(srcBuilder, [rootModule], conditions, false);
+  lowerAndEmit(srcBuilder, newDecls, conditions);
+  return srcBuilder.build();
+}
+exports.astToString = astToString;
+exports.blankWeslParseState = blankWeslParseState;
+exports.dirname = dirname;
+exports.elemToString = elemToString;
+exports.flatImports = flatImports;
+exports.groupBy = groupBy;
+exports.grouped = grouped;
+exports.identToString = identToString;
+exports.join = join;
+exports.last = last;
+exports.linkRegistry = linkRegistry;
+exports.linkWesl = linkWesl;
+exports.linkWeslFiles = linkWeslFiles;
+exports.mapForward = mapForward;
+exports.multiKeySet = multiKeySet;
+exports.noSuffix = noSuffix;
+exports.normalize = normalize;
+exports.overlapTail = overlapTail;
+exports.parseSrcModule = parseSrcModule;
+exports.parseWESL = parseWESL;
+exports.partition = partition;
+exports.relativePath = relativePath;
+exports.replaceWords = replaceWords;
+exports.scan = scan;
+exports.scopeToString = scopeToString;
+exports.syntheticWeslParseState = syntheticWeslParseState;
+//# sourceMappingURL=index.cjs.map