wesl 0.6.0-pre10

package/dist/minified.js

@@ -0,0 +1,3426 @@
+var me = (t) => {
+  throw TypeError(t);
+};
+var he = (t, e, n) => e.has(t) || me("Cannot " + n);
+var g = (t, e, n) => (he(t, e, "read from private field"), n ? n.call(t) : e.get(t)), I = (t, e, n) => e.has(t) ? me("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, n), B = (t, e, n, r) => (he(t, e, "write to private field"), r ? r.call(t, n) : e.set(t, n), n);
+function qn(t, e) {
+  if (!t)
+    throw new Error(e);
+}
+function Tt(t) {
+  throw new Un("Unreachable value", { data: t });
+}
+let Un = class extends Error {
+  constructor(e, n) {
+    super(e, n), this.data = n == null ? void 0 : n.data;
+  }
+}, Wn = console.log;
+function Me(t, e, ...n) {
+  Vn(Wn, t, e, ...n);
+}
+function Ce(t) {
+  return t ? `'${t.replace(/\n/g, "\\n")}'` : "";
+}
+function Vn(t, e, n, ...r) {
+  if (typeof e == "string") {
+    ge(t, e, n, ...r);
+    return;
+  }
+  const { src: s, positions: o } = zn(e, n);
+  ge(t, s.text, o, ...r);
+}
+function zn(t, e) {
+  var o, i, a, l;
+  const n = t.mapPositions(...[e].flat()), { src: r } = n[0];
+  let s;
+  return ((i = (o = n[1]) == null ? void 0 : o.src) == null ? void 0 : i.path) === r.path && ((l = (a = n[1]) == null ? void 0 : a.src) == null ? void 0 : l.text) === r.text ? s = n.map((c) => c.position) : s = n[0].position, { src: r, positions: s };
+}
+function ge(t, e, n, ...r) {
+  t(...r);
+  const { line: s, lineNum: o, linePos: i, linePos2: a } = Xn(e, n);
+  t(s, `  Ln ${o}`);
+  const l = Gn(i, a);
+  t(l);
+}
+function Gn(t, e) {
+  const n = " ".repeat(t) + "^";
+  let r = "";
+  return e && e > t && (r = " ".repeat(e - t - 1) + "^"), n + r;
+}
+const be = /* @__PURE__ */ new Map();
+function Xn(t, e) {
+  let n, r;
+  typeof e == "number" ? n = e : [n, r] = e;
+  const s = Jn(t);
+  let o = 0, i = s.length - 1;
+  for (n >= s[i] && (o = i); o + 1 < i; ) {
+    const d = o + i >> 1;
+    n >= s[d] ? o = d : i = d;
+  }
+  let a;
+  r !== void 0 && r >= s[o] && r < s[i] && (a = r - s[o]);
+  const l = t.slice(s[o], s[o + 1] || t.length);
+  return { line: l.slice(-1) === `
+` ? l.slice(0, -1) : l, linePos: n - s[o], linePos2: a, lineNum: o + 1 };
+}
+function Jn(t) {
+  const e = be.get(t);
+  if (e) return e;
+  const n = [...t.matchAll(/\n/g)].map((r) => r.index + 1);
+  return n.unshift(0), be.set(t, n), n;
+}
+function Kn(t) {
+  const e = t.checkpoint(), n = t.nextToken();
+  return t.reset(e), n;
+}
+function st(t, e) {
+  return G(
+    `token '${t}' ${Ce(e)}`,
+    function(r) {
+      const s = r.stream.checkpoint(), o = r.stream.nextToken();
+      return o === null ? null : o.kind !== t || o.text !== e ? (r.stream.reset(s), null) : { value: o };
+    }
+  );
+}
+function bt(t, e) {
+  return G(
+    `tokenOf '${t}'`,
+    function(r) {
+      const s = r.stream.checkpoint(), o = r.stream.nextToken();
+      return o === null ? null : o.kind !== t || !e.includes(o.text) ? (r.stream.reset(s), null) : { value: o };
+    }
+  );
+}
+function Ae(t) {
+  return G(
+    `tokenKind '${t}'`,
+    function(n) {
+      const r = n.stream.checkpoint(), s = n.stream.nextToken();
+      return s === null ? null : s.kind !== t ? (n.stream.reset(r), null) : { value: s };
+    }
+  );
+}
+function zt(t) {
+  return G(
+    `kind '${t}'`,
+    function(n) {
+      const r = n.stream.checkpoint(), s = n.stream.nextToken();
+      return s === null ? null : s.kind !== t ? (n.stream.reset(r), null) : { value: s.text };
+    }
+  );
+}
+function Pt(t) {
+  return G(
+    `${Ce(t)}`,
+    function(n) {
+      const r = n.stream.checkpoint(), s = n.stream.nextToken();
+      return s === null ? null : s.text !== t ? (n.stream.reset(r), null) : { value: s.text };
+    }
+  );
+}
+function u(...t) {
+  const e = t.map(k), n = y("seq", function(s) {
+    const o = [];
+    for (const i of e) {
+      const a = i._run(s);
+      if (a === null)
+        return null;
+      o.push(a.value);
+    }
+    return { value: o };
+  });
+  return Ht(n, ...e), n;
+}
+function Hn(t) {
+  const e = Object.entries(t).map(
+    ([r, s]) => [r, k(s)]
+  ), n = y("seqObj", function(s) {
+    const o = {};
+    for (const [i, a] of e) {
+      const l = a._run(s);
+      if (l === null)
+        return null;
+      o[i] = l.value;
+    }
+    return { value: o };
+  });
+  return Ht(n, ...e.map((r) => r[1])), n;
+}
+function Yn(t) {
+  return t.collect({ before: sr, after: or });
+}
+function N(t, e) {
+  const n = k(t), r = k(e);
+  return y(
+    "preceded",
+    function(i) {
+      return n._run(i) === null ? null : r._run(i);
+    }
+  );
+}
+function Dt(t, e) {
+  const n = k(t), r = k(e);
+  return y(
+    "terminated",
+    function(i) {
+      const a = n._run(i);
+      return a === null || r._run(i) === null ? null : a;
+    }
+  );
+}
+function q(t, e, n) {
+  const r = k(t), s = k(e), o = k(n);
+  return y(
+    "delimited",
+    function(l) {
+      if (r._run(l) === null) return null;
+      const d = s._run(l);
+      return d === null || o._run(l) === null ? null : d;
+    }
+  );
+}
+function Zn(t, e, n) {
+  const r = k(t), s = k(e), o = k(n);
+  return y(
+    "terminated",
+    function(l) {
+      const c = r._run(l);
+      if (c === null || s._run(l) === null) return null;
+      const p = o._run(l);
+      return p === null ? null : { value: [c.value, p.value] };
+    }
+  );
+}
+function m(...t) {
+  const e = t.map(k), n = y("or", function(s) {
+    const o = s.stream.checkpoint();
+    for (const i of e) {
+      s.stream.reset(o);
+      const a = i._run(s);
+      if (a !== null)
+        return a;
+    }
+    return null;
+  });
+  return Ht(n, ...e), n;
+}
+function b(t) {
+  const e = k(t);
+  return y(
+    "opt",
+    function(s) {
+      const o = s.stream.checkpoint(), i = e._run(s);
+      return i === null ? (s.stream.reset(o), { value: null }) : i;
+    }
+  );
+}
+function T(t) {
+  const e = k(t);
+  return y("repeat", Qn(e));
+}
+function L(t) {
+  const e = k(t);
+  return u(e, T(e)).map((r) => [r[0], ...r[1]]).setTraceName("repeatPlus");
+}
+function Qn(t, e = () => !0) {
+  return function(r) {
+    const s = [];
+    for (; ; ) {
+      const o = r.stream.checkpoint(), i = Le(r, t);
+      if (i === null)
+        return r.stream.reset(o), { value: s };
+      if (!e(i))
+        return { value: s };
+      s.push(i.value);
+    }
+  };
+}
+function Gt(t) {
+  const e = k(t);
+  return y("span", function(s) {
+    var l, c;
+    const o = ((c = (l = Kn(s.stream)) == null ? void 0 : l.span) == null ? void 0 : c[0]) ?? null, i = e._run(s);
+    if (i === null) return null;
+    const a = s.stream.checkpoint();
+    return {
+      value: {
+        value: i.value,
+        span: [o ?? a, a]
+      }
+    };
+  });
+}
+function tr() {
+  return G("eof", function(e) {
+    const n = e.stream.checkpoint();
+    return e.stream.nextToken() !== null ? (e.stream.reset(n), null) : { value: !0 };
+  });
+}
+function f(t, e) {
+  const n = k(t);
+  return y("req", function(o) {
+    const i = n._run(o);
+    if (i === null)
+      throw new H(e, o.stream.checkpoint());
+    return i;
+  });
+}
+function xt() {
+  return G("yes", function() {
+    return { value: null };
+  });
+}
+function tt(t, e, n = {}) {
+  const { trailing: r = !0, requireOne: s = !1 } = n, o = k(e), i = k(t);
+  return y("withSep", function(l) {
+    const c = [], d = l.stream.checkpoint(), p = o._run(l);
+    if (p === null)
+      return l.stream.reset(d), s ? null : {
+        value: c
+      };
+    for (c.push(p.value); ; ) {
+      const h = l.stream.checkpoint();
+      if (i._run(l) === null) {
+        l.stream.reset(h);
+        break;
+      }
+      const P = l.stream.checkpoint(), R = o._run(l);
+      if (R === null) {
+        r ? l.stream.reset(P) : l.stream.reset(h);
+        break;
+      }
+      c.push(R.value);
+    }
+    return {
+      value: c
+    };
+  });
+}
+function $t(t, e) {
+  return tt(t, e, { requireOne: !0 }).setTraceName("withSepPlus");
+}
+function Re(t) {
+  return G(
+    "withStreamAction",
+    function(n) {
+      const r = t(n.stream);
+      return r === null ? null : { value: r };
+    }
+  );
+}
+function k(t) {
+  return typeof t == "string" ? Pt(t) : t instanceof Ie ? t : z(t);
+}
+function z(t) {
+  return y(
+    "fn()",
+    function(r) {
+      if (!t)
+        throw new H(
+          "fn parser called before definition",
+          r.stream.checkpoint()
+        );
+      return t()._run(r);
+    }
+  );
+}
+function er(t, e, n) {
+  const r = e.after ?? e, s = e.before;
+  let o = r;
+  n && (o = (l) => {
+    const c = r(l);
+    return c != null && Jt(l.tags, n, c), c;
+  });
+  const i = n ? `${t.debugName}-${n}` : `${t.debugName}`;
+  return y(
+    "collect",
+    function(c) {
+      const d = c.stream.checkpoint();
+      return s && Nt(c, d, s, `${i}.before`), Xt(t, c, o, i);
+    }
+  );
+}
+function _(t) {
+  const e = k(t);
+  return y(
+    "tagScope",
+    function(s) {
+      const o = s.stream.checkpoint();
+      let i;
+      return Nt(
+        s,
+        o,
+        (a) => {
+          i = nr(a.tags), a.tags = {};
+        },
+        `scope.before ${e.debugName}`
+      ), Xt(
+        e,
+        s,
+        (a) => {
+          a.tags = i;
+        },
+        "tagScope"
+      );
+    }
+  );
+}
+function nr(t) {
+  const e = Object.entries(t).map(([n, r]) => [n, [...r]]);
+  return Object.fromEntries(e);
+}
+function rr(t, e) {
+  return y(
+    "ctag",
+    function(s) {
+      return Xt(
+        t,
+        s,
+        (o) => {
+          const i = Kt(o._values);
+          Jt(o.tags, e, i.value);
+        },
+        `ctag ${e}`
+      );
+    }
+  );
+}
+function Xt(t, e, n, r = "") {
+  const s = e.stream.checkpoint(), o = t._run(e);
+  return o && Nt(e, s, n, r), o;
+}
+function Nt(t, e, n, r) {
+  const s = cr(t.stream, e);
+  t._collect.push({
+    srcPosition: s,
+    collectFn: n,
+    debugName: r
+  });
+}
+function sr(t) {
+  t._values.push({ value: null, openArray: [] });
+}
+function or(t) {
+  const e = Kt(t._values);
+  e.openArray === void 0 && console.log("---closeArray: no open array"), t._values.pop(), Be(t, e.openArray);
+}
+function ir(t, e) {
+  return y(
+    "ptag",
+    function(s) {
+      const o = s.stream.checkpoint(), i = t._run(s);
+      return i && Nt(s, o, (l) => Jt(l.tags, e, i.value), `ptag ${e}`), i;
+    }
+  );
+}
+function Jt(t, e, n) {
+  t[e] === void 0 && (t[e] = []), t[e].push(n);
+}
+function ar(t, e, n) {
+  const r = {}, { src: s } = n, i = {
+    tags: r,
+    src: s,
+    start: -1,
+    end: -1,
+    app: e,
+    _values: [{ value: null, openArray: void 0 }]
+  };
+  t.forEach((a) => {
+    const { collectFn: l, srcPosition: c } = a;
+    i.start = c.start, i.end = c.end;
+    const d = l(i);
+    Be(i, d);
+  });
+}
+function Be(t, e) {
+  if (e !== void 0) {
+    const n = Kt(t._values);
+    n || console.log("----saveCollectValue: no valueEntry"), n && (n.value = e), (n == null ? void 0 : n.openArray) !== void 0 && n.openArray.push(e);
+  }
+}
+function Kt(t) {
+  return t[t.length - 1];
+}
+function cr(t, e) {
+  const n = t.checkpoint();
+  t.reset(e);
+  const r = lr(t);
+  return t.reset(n), { start: r, end: n };
+}
+function lr(t) {
+  const e = t.nextToken();
+  return e === null || t.reset(e.span[0]), t.checkpoint();
+}
+class H extends Error {
+  constructor(e, n) {
+    super(e), this.position = n;
+  }
+}
+class Ie {
+  constructor(e) {
+    this.fn = e.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(e) {
+    {
+      const n = e.app.context, r = e._collect.length, s = this.fn(e);
+      return s === null && (e.app.context = n, e._collect.length = r), s;
+    }
+  }
+  /** tag parse results */
+  ptag(e) {
+    return ir(this, e);
+  }
+  /** tag collect results */
+  ctag(e) {
+    return rr(this, e);
+  }
+  /** record a name for debug tracing */
+  setTraceName(e) {
+    return this;
+  }
+  /** trigger tracing for this parser (and by default also this parsers descendants) */
+  setTrace(e = {}) {
+    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(e) {
+    return ur(this, e);
+  }
+  /** map results to a new value.
+   */
+  map(e) {
+    return dr(this, e);
+  }
+  /** 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(e, n) {
+    return er(this, e, n);
+  }
+  /** switch next parser based on results */
+  toParser(e) {
+    return fr(this, e);
+  }
+  /**
+   * start parsing
+   *
+   * @throws {ParseError} when a combinator like `req` fails
+   */
+  parse(e) {
+    const { stream: n, appState: r = { context: {}, stable: [] } } = e, s = [], o = this._run({
+      stream: n,
+      app: r,
+      _collect: s
+    });
+    return o && ar(s, r, n), o;
+  }
+  /** name of this parser for debugging/tracing */
+  get debugName() {
+    return "parser";
+  }
+}
+function y(t, e, n) {
+  return new Ie({ fn: e, traceName: t, terminal: n });
+}
+function G(t, e) {
+  return y(t, e, !0);
+}
+function ur(t, e) {
+  return y(
+    "mapExtended",
+    function(s) {
+      const o = Le(s, t);
+      if (!o) return null;
+      const i = e(o);
+      return i === null ? null : { value: i };
+    }
+  );
+}
+function dr(t, e) {
+  return y(
+    "map",
+    function(s) {
+      const o = t._run(s);
+      return o === null ? null : { value: e(o.value) };
+    }
+  );
+}
+function fr(t, e) {
+  return y(
+    "toParser",
+    function(s) {
+      const o = t._run(s);
+      if (o === null) return null;
+      const i = e(o);
+      return i === null ? o : i._run(s);
+    }
+  );
+}
+function Le(t, e) {
+  const n = t.stream.checkpoint(), r = e._run(t);
+  if (r === null)
+    return t.stream.reset(n), null;
+  const { app: s } = t;
+  return { ...r, app: s };
+}
+function Ht(t, ...e) {
+}
+class Yt {
+  constructor(e, n = []) {
+    this.dest = e, this.entries = n;
+  }
+  /** add a new mapping from src to dest ranges.
+   * entries must be non-overlapping in the destination
+   */
+  addEntries(e) {
+    this.entries.push(...e);
+  }
+  /** given positions in the dest string,
+   * @return corresponding positions in the src strings */
+  mapPositions(...e) {
+    return e.map((n) => this.destToSrc(n));
+  }
+  /** internally compress adjacent entries where possible */
+  compact() {
+    if (!this.entries.length) return;
+    let e = this.entries[0];
+    const n = [e];
+    for (let r = 1; r < this.entries.length; r++) {
+      const s = this.entries[r];
+      s.src.path === e.src.path && s.src.text === e.src.text && e.destEnd === s.destStart && e.srcEnd === s.srcStart ? (e.destEnd = s.destEnd, e.srcEnd = s.srcEnd) : (n.push(s), e = s);
+    }
+    this.entries = n;
+  }
+  /** sort in destination order */
+  sort() {
+    this.entries.sort((e, n) => e.destStart - n.destStart);
+  }
+  /** This SrcMap's destination is a src for the other srcmap,
+   * so combine the two and return the result.
+   */
+  merge(e) {
+    if (e === this) return this;
+    const n = e.entries.filter(
+      (i) => i.src.path === this.dest.path && i.src.text === this.dest.text
+    );
+    if (n.length === 0)
+      return console.log("other source map does not link to this one"), e;
+    pr(n);
+    const r = n.map((i) => {
+      const { src: a, position: l } = this.destToSrc(i.srcStart), { src: c, position: d } = this.destToSrc(i.srcEnd);
+      if (c !== a) throw new Error("NYI, need to split");
+      return {
+        src: a,
+        srcStart: l,
+        srcEnd: d,
+        destStart: i.destStart,
+        destEnd: i.destEnd
+      };
+    }), s = e.entries.filter(
+      (i) => i.src.path !== this.dest.path || i.src.text !== this.dest.text
+    ), o = new Yt(e.dest, [...s, ...r]);
+    return o.sort(), o;
+  }
+  /**
+   * @param entries should be sorted in destStart order
+   * @return the source position corresponding to a provided destination position
+   *
+   */
+  destToSrc(e) {
+    const n = this.entries.find(
+      (r) => r.destStart <= e && r.destEnd >= e
+    );
+    return n ? {
+      src: n.src,
+      position: n.srcStart + e - n.destStart
+    } : {
+      src: this.dest,
+      position: e
+    };
+  }
+}
+function pr(t) {
+  t.sort((e, n) => e.srcStart - n.srcStart);
+}
+var Y, O, W;
+class ht {
+  constructor(e) {
+    I(this, Y, []);
+    I(this, O, 0);
+    I(this, W, []);
+    this.source = e;
+  }
+  /** append a string fragment to the destination string */
+  add(e, n, r) {
+    const s = g(this, O);
+    B(this, O, g(this, O) + e.length);
+    const o = g(this, O);
+    g(this, Y).push(e), g(this, W).push({
+      src: this.source,
+      srcStart: n,
+      srcEnd: r,
+      destStart: s,
+      destEnd: o
+    });
+  }
+  /**
+   * 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(e) {
+    var r;
+    const n = ((r = g(this, W).at(-1)) == null ? void 0 : r.destEnd) ?? 0;
+    this.add(e, n, n + e.length);
+  }
+  addSynthetic(e, n, r, s) {
+    const o = g(this, O);
+    B(this, O, g(this, O) + e.length);
+    const i = g(this, O);
+    g(this, Y).push(e), g(this, W).push({
+      src: { text: n },
+      srcStart: r,
+      srcEnd: s,
+      destStart: o,
+      destEnd: i
+    });
+  }
+  /** append a synthetic newline, mapped to previous source location */
+  addNl() {
+    const e = g(this, W).at(-1) ?? { srcStart: 0, srcEnd: 0 }, { srcStart: n, srcEnd: r } = e;
+    this.add(`
+`, n, r);
+  }
+  /** copy a string fragment from the src to the destination string */
+  addCopy(e, n) {
+    const r = this.source.text.slice(e, n);
+    this.add(r, e, n);
+  }
+  /** return a SrcMap */
+  static build(e) {
+    const n = new Yt(
+      { text: e.map((r) => g(r, Y).join("")).join("") },
+      e.flatMap((r) => g(r, W))
+    );
+    return n.compact(), n;
+  }
+}
+Y = new WeakMap(), O = new WeakMap(), W = new WeakMap();
+class mr {
+  constructor(e) {
+    this.inner = e, this.cache = new hr(5);
+  }
+  checkpoint() {
+    return this.inner.checkpoint();
+  }
+  reset(e) {
+    this.inner.reset(e);
+  }
+  nextToken() {
+    const e = this.checkpoint(), n = this.cache.get(e);
+    if (n !== void 0)
+      return this.reset(n.checkpoint), n.token;
+    {
+      const r = this.inner.nextToken(), s = this.checkpoint();
+      return this.cache.set(e, { token: r, checkpoint: s }), r;
+    }
+  }
+  get src() {
+    return this.inner.src;
+  }
+}
+class hr extends Map {
+  constructor(e) {
+    super(), this.max = e;
+  }
+  set(e, n) {
+    if (this.size > this.max) {
+      const r = this.keys().next().value;
+      r && this.delete(r);
+    }
+    return super.set(e, n);
+  }
+}
+function gr(t) {
+  const [e, n] = t;
+  if (typeof n == "string") {
+    const r = `(${je(n)})`;
+    return xe(e, new RegExp(r)), r;
+  } else
+    return xe(e, n), `(${n.source})`;
+}
+function xe(t, e) {
+  if (new RegExp("|" + e.source).exec("").length > 1)
+    throw new Error(
+      `match expression groups must be non-capturing: ${t}: /${e.source}/. Use (?:...) instead.`
+    );
+}
+const br = /[$+*.?|(){}[\]\\/^]/g;
+function je(t) {
+  return t.replace(br, "\\$&");
+}
+function Mt(t) {
+  const n = t.split(/\s+/).sort((r, s) => s.length - r.length).filter((r) => r).map(je);
+  return new RegExp(n.join("|"));
+}
+class xr {
+  constructor(e, n) {
+    this.text = e, this.matchers = n, this.position = 0;
+  }
+  checkpoint() {
+    return this.position;
+  }
+  reset(e) {
+    this.position = e;
+  }
+  nextToken() {
+    const e = this.matchers.execAt(this.text, this.position);
+    return e === null ? null : (this.position = e.span[1], e);
+  }
+  get src() {
+    return this.text;
+  }
+}
+class kr {
+  constructor(e) {
+    this.groups = Object.keys(e);
+    const n = Object.entries(e).map(gr).join("|");
+    this.exp = new RegExp(n, "dyu");
+  }
+  execAt(e, n) {
+    this.exp.lastIndex = n;
+    const r = this.exp.exec(e), s = _r(r == null ? void 0 : r.indices);
+    if (s) {
+      const { span: o, groupDex: i } = s;
+      return {
+        kind: this.groups[i],
+        span: o,
+        text: e.slice(o[0], o[1])
+      };
+    } else
+      return null;
+  }
+}
+function _r(t) {
+  if (t !== void 0)
+    for (let e = 1; e < t.length; e++) {
+      const n = t[e];
+      if (n !== void 0)
+        return { span: n, groupDex: e - 1 };
+    }
+}
+function j(t) {
+  throw new vr("Unreachable value", { data: t });
+}
+class vr extends Error {
+  constructor(e, n) {
+    super(e, n), this.data = n == null ? void 0 : n.data;
+  }
+}
+function yr(t) {
+  return t[t.length - 1];
+}
+function Zt(t, e) {
+  const n = [];
+  for (const r of t) {
+    const s = e(r);
+    s && n.push(s);
+  }
+  return n;
+}
+function Er(t, e) {
+  for (const n of t) {
+    const r = e(n);
+    if (r) return r;
+  }
+}
+function Sr(t, e) {
+  return Object.fromEntries(Object.entries(t).map(([n, r]) => [n, e(r)]));
+}
+function Qt(t, e) {
+  t = Math.min(e.length, Math.max(0, t));
+  let n = 0, r = 1;
+  for (; ; ) {
+    const s = e.indexOf(`
+`, n);
+    if (s === -1 || t <= s) {
+      const o = 1 + (t - n);
+      return [r, o];
+    } else
+      n = s + 1, r += 1;
+  }
+}
+function De(t, e) {
+  let n = t.lastIndexOf(`
+`, e[0]);
+  n === -1 && (n = 0);
+  let r = t.indexOf(`
+`, e[0]);
+  r === -1 && (r = t.length);
+  const s = e[1] - e[0], o = Math.max(1, s), i = e[0] - n;
+  return [
+    t.slice(n, r),
+    " ".repeat(i) + "^".repeat(o)
+  ];
+}
+function Oe(t, e) {
+  const n = t.attributes;
+  if (!n) return !0;
+  const r = Er(n, wr);
+  return !r || qe(r);
+}
+function Fe(t, e) {
+  const { ifAttribute: n } = t;
+  return n ? qe(n) : !0;
+}
+function wr(t) {
+  const { attribute: e } = t;
+  return e.kind === "@if" ? e : void 0;
+}
+function qe(t, e) {
+  return K(t.param.expression);
+}
+function K(t, e) {
+  const { kind: n } = t;
+  if (n == "unary-expression")
+    return t.operator.value, !K(t.expression);
+  if (n == "binary-expression") {
+    const r = t.operator.value, s = K(t.left);
+    if (r === "||")
+      return s || K(t.right);
+    if (r === "&&")
+      return s && K(t.right);
+    j(r);
+  } else if (n == "literal") {
+    const { value: r } = t;
+    return r === "true";
+  } else {
+    if (n == "parenthesized-expression")
+      return K(t.expression);
+    throw new Error("unexpected @if expression ${expression}");
+  }
+}
+function ke(t, e) {
+  t.kind, e.kind, t.parent, e.parent, e.ifAttribute, t.contents = t.contents.concat(e.contents);
+}
+function Tr() {
+  Ue = 0, We = 0;
+}
+let Ue = 0, We = 0;
+function te() {
+  return We++;
+}
+function Ve(t, e = "scope") {
+  return { id: Ue++, kind: e, parent: t, contents: [] };
+}
+function Pr(t) {
+  const { kind: e } = t;
+  return e === "partial" || e === "scope";
+}
+function ze(t, e, n) {
+  for (const r of t.contents) {
+    if (r.kind === "decl" && r.originalName === e)
+      return r;
+    if (r.kind === "partial" && Fe(r)) {
+      const s = ze(r, e);
+      if (s) return s;
+    }
+  }
+}
+var F, V, ct, lt, Z, ut;
+class ee {
+  constructor(e = 0, n = 60, r = 2) {
+    I(this, F, []);
+    I(this, V, 0);
+    I(this, ct);
+    I(this, lt, !0);
+    I(this, Z, !1);
+    I(this, ut);
+    this.indent = e, this.maxWidth = n, this.hangingIndent = r, B(this, ct, " ".repeat(e)), B(this, ut, " ".repeat(r));
+  }
+  /** add a new line to the constructed string */
+  nl() {
+    g(this, F).push(`
+`), B(this, V, 0), B(this, lt, !1), B(this, Z, !1);
+  }
+  /** add a string, wrapping to the next line if necessary */
+  add(e) {
+    g(this, V) + $r(e) > this.maxWidth && this.hangingNl(), g(this, V) === 0 && (g(this, F).push(g(this, ct)), g(this, Z) && g(this, F).push(g(this, ut)), B(this, V, this.indent)), g(this, F).push(e), B(this, V, g(this, V) + e.length);
+  }
+  /** add a raw block of text with no wrapping */
+  addBlock(e, n = !0) {
+    g(this, F).push(e), n && this.nl();
+  }
+  /** @return the constructed string */
+  get result() {
+    return g(this, F).join("");
+  }
+  /** true if the result contains no newlines */
+  get oneLine() {
+    return g(this, lt);
+  }
+  hangingNl() {
+    this.nl(), B(this, Z, !0);
+  }
+}
+F = new WeakMap(), V = new WeakMap(), ct = new WeakMap(), lt = new WeakMap(), Z = new WeakMap(), ut = new WeakMap();
+function $r(t) {
+  const e = t.indexOf(`
+`);
+  return e === -1 ? t.length : e;
+}
+function Ge(t, e = 0, n = !0) {
+  const { contents: r, kind: s, ifAttribute: o } = t, i = new ee(e), a = o && si(o);
+  a && i.add(a + " "), s === "partial" && i.add("-"), i.add("{ ");
+  const l = r.length - 1;
+  let c = !1, d = !1;
+  return r.forEach((p, h) => {
+    if (Pr(p)) {
+      const P = Ge(p, e + 2, n);
+      !c && i.nl(), i.addBlock(P), c = !0, d = !0;
+    } else {
+      c && i.add("  "), c = !1;
+      const x = p;
+      n ? i.add(Nr(x)) : i.add(Ct(x)), h < l && i.add(" ");
+    }
+  }), !d && i.oneLine ? i.add(" }") : (d && !c && i.nl(), i.add("}")), i.add(` #${t.id}`), i.result;
+}
+function Wi(t) {
+  return Ge(t, 0, !1);
+}
+function Nr(t) {
+  const { kind: e, originalName: n } = t;
+  return `${e === "decl" ? "%" : ""}${n}`;
+}
+function Ct(t) {
+  if (!t) return JSON.stringify(t);
+  const { kind: e, originalName: n } = t, r = t.id ? `#${t.id}` : "";
+  if (e === "ref") {
+    const s = Ct(t.refersTo);
+    return `${n} ${r} -> ${s}`;
+  } else {
+    const { mangledName: s } = t, o = s ? `(${s})` : "";
+    return `%${n}${o} ${r} `;
+  }
+}
+function Xe(t = null) {
+  return { decls: /* @__PURE__ */ new Map(), parent: t };
+}
+function Mr(t, e, n, r) {
+  return Je(n, r);
+}
+function Je(t, e) {
+  let n = t, r = 0;
+  for (; e.has(n); )
+    n = t + r++;
+  return n;
+}
+function Cr(t) {
+  return e([], [], t.segments, t.finalSegment);
+  function e(n, r, s, o) {
+    if (s.length > 0) {
+      const [i, ...a] = s, l = [...n, i.name], c = [...r, i.name];
+      return e(l, c, a, o);
+    } else {
+      if (o.kind === "import-collection")
+        return o.subtrees.flatMap((i) => e(
+          n,
+          r,
+          i.segments,
+          i.finalSegment
+        ));
+      if (o.kind === "import-item") {
+        const i = [
+          ...n,
+          o.as ?? o.name
+        ], a = [...r, o.name];
+        return [{ importPath: i, modulePath: a }];
+      } else
+        j(o);
+    }
+  }
+}
+var Ar = Br((t) => " ".repeat(t)), Rr = 20;
+"" + Ar(Rr + 3);
+function Br(t) {
+  const e = /* @__PURE__ */ new Map();
+  return function(...n) {
+    const r = JSON.stringify(n);
+    if (e.has(r))
+      return e.get(r);
+    {
+      const s = t(...n);
+      return e.set(r, s), s;
+    }
+  };
+}
+typeof DOMRect > "u" && (globalThis.DOMRect = function() {
+});
+function Ir(t) {
+  var n;
+  const e = (n = t.tags.owo) == null ? void 0 : n[0];
+  for (const r of e)
+    t.app.stable.imports.push(r.imports), et(t, r);
+}
+function et(t, e) {
+  const n = t.app.context, { openElems: r } = n;
+  r && r.length && r[r.length - 1].contents.push(e);
+}
+function dt(t) {
+  const { src: e, start: n, end: r } = t, s = t.app, { srcModule: o } = s.stable, i = e.slice(n, r), a = "ref", l = {
+    kind: a,
+    originalName: i,
+    ast: t.app.stable,
+    id: te(),
+    refIdentElem: null
+    // set below
+  }, c = { kind: a, start: n, end: r, srcModule: o, ident: l };
+  return l.refIdentElem = c, Ye(t, c), et(t, c), c;
+}
+function Ke(t) {
+  return He(t, !1);
+}
+function At(t) {
+  return He(t, !0);
+}
+function He(t, e) {
+  const { src: n, start: r, end: s } = t, o = t.app, { scope: i } = o.context, { srcModule: a } = o.stable, l = n.slice(r, s), c = "decl", p = {
+    declElem: null,
+    kind: c,
+    originalName: l,
+    scope: i,
+    isGlobal: e,
+    id: te(),
+    srcModule: a
+  }, h = { kind: c, start: r, end: s, srcModule: a, ident: p };
+  return Ye(t, h), et(t, h), h;
+}
+const ne = S(
+  "typeDecl",
+  (t, e) => {
+    var i, a;
+    const n = (i = t.tags.decl_elem) == null ? void 0 : i[0], r = (a = t.tags.typeRefElem) == null ? void 0 : a[0], s = { ...e, decl: n, typeRef: r };
+    return A(s, t);
+  }
+);
+function Ye(t, e) {
+  const { ident: n } = e;
+  n.id = te(), t.app.context.scope.contents.push(n);
+}
+function Lr(t) {
+  Ze("scope", t);
+}
+function jr(t) {
+  Ze("partial", t);
+}
+function Ze(t, e) {
+  const { scope: n } = e.app.context, r = Ve(n, t);
+  n.contents.push(r), e.app.context.scope = r;
+}
+function Qe(t) {
+  const e = t.app.context, n = e.scope, r = Dr(t), { parent: s } = n;
+  return s && (e.scope = s), n.ifAttribute = r == null ? void 0 : r[0], n;
+}
+function Dr(t) {
+  const e = t.tags.attribute;
+  return tn(e);
+}
+function tn(t) {
+  if (t)
+    return Zt(
+      t,
+      (e) => e.attribute.kind === "@if" ? e.attribute : void 0
+    );
+}
+function kt(t) {
+  return S(t, (e, n) => {
+    var l, c;
+    const r = (l = e.tags.var_name) == null ? void 0 : l[0], s = (c = e.tags.decl_scope) == null ? void 0 : c[0], o = e.tags.attribute, i = { ...n, name: r, attributes: o }, a = A(i, e);
+    return r.decl.ident.declElem = a, r.decl.ident.scope = s, a;
+  });
+}
+const Or = S(
+  "alias",
+  (t, e) => {
+    var l, c, d, p;
+    const n = (l = t.tags.alias_name) == null ? void 0 : l[0], r = (c = t.tags.alias_scope) == null ? void 0 : c[0], s = (d = t.tags.typeRefElem) == null ? void 0 : d[0], o = ((p = t.tags.attributes) == null ? void 0 : p.flat()) ?? [], i = { ...e, name: n, attributes: o, typeRef: s }, a = A(i, t);
+    return n.ident.scope = r, n.ident.declElem = a, a;
+  }
+), Fr = S(
+  "fn",
+  (t, e) => {
+    var U;
+    const n = qr(t), { name: r, headerScope: s, returnScope: o, bodyScope: i, body: a, params: l } = n, { attributes: c, returnAttributes: d, returnType: p, fnScope: h } = n, x = {
+      ...e,
+      name: r,
+      attributes: c,
+      params: l,
+      returnAttributes: d,
+      body: a,
+      returnType: p
+    };
+    h.ifAttribute = (U = tn(c)) == null ? void 0 : U[0];
+    const P = s;
+    o && ke(P, o), ke(P, i);
+    const R = [];
+    for (const w of h.contents)
+      w === s || w == o || (w === i ? R.push(P) : R.push(w));
+    return h.contents = R, r.ident.declElem = x, r.ident.scope = P, x;
+  }
+);
+function qr(t) {
+  const { fn_attributes: e, fn_name: n, fn_param: r, return_attributes: s } = t.tags, { return_type: o } = t.tags, { header_scope: i, return_scope: a, body_scope: l, body_statement: c } = t.tags, { fn_partial_scope: d } = t.tags, p = n == null ? void 0 : n[0], h = i == null ? void 0 : i[0], x = a == null ? void 0 : a[0], P = l == null ? void 0 : l[0], R = c == null ? void 0 : c[0], U = (r == null ? void 0 : r.flat(3)) ?? [], w = e == null ? void 0 : e.flat(), Dn = s == null ? void 0 : s.flat(), On = o == null ? void 0 : o.flat(3)[0], Fn = d == null ? void 0 : d[0];
+  return {
+    name: p,
+    headerScope: h,
+    returnScope: x,
+    bodyScope: P,
+    body: R,
+    params: U,
+    attributes: w,
+    returnAttributes: Dn,
+    returnType: On,
+    fnScope: Fn
+  };
+}
+const Ur = S(
+  "param",
+  (t, e) => {
+    var i, a;
+    const n = (i = t.tags.param_name) == null ? void 0 : i[0], r = ((a = t.tags.attributes) == null ? void 0 : a.flat()) ?? [], s = { ...e, name: n, attributes: r }, o = A(s, t);
+    return n.decl.ident.declElem = o, o;
+  }
+), Wr = S(
+  "struct",
+  (t, e) => {
+    var a, l, c;
+    const n = (a = t.tags.type_name) == null ? void 0 : a[0], r = t.tags.members, s = ((l = t.tags.attributes) == null ? void 0 : l.flat()) ?? [];
+    n.ident.scope = (c = t.tags.struct_scope) == null ? void 0 : c[0];
+    const o = { ...e, name: n, attributes: s, members: r }, i = A(o, t);
+    return n.ident.declElem = i, i;
+  }
+), Vr = S(
+  "member",
+  (t, e) => {
+    var i, a, l;
+    const n = (i = t.tags.nameElem) == null ? void 0 : i[0], r = (a = t.tags.typeRefElem) == null ? void 0 : a[0], s = (l = t.tags.attribute) == null ? void 0 : l.flat(3), o = { ...e, name: n, attributes: s, typeRef: r };
+    return A(o, t);
+  }
+), en = S(
+  "attribute",
+  (t, e) => {
+    var s;
+    const n = (s = t.tags.attr_variant) == null ? void 0 : s[0];
+    return { ...e, attribute: n };
+  }
+), zr = re("assert"), ot = re("statement"), Gr = re("switch-clause");
+function re(t) {
+  return S(t, (e, n) => {
+    var o;
+    const r = (o = e.tags.attribute) == null ? void 0 : o.flat(3), s = { ...n, attributes: r };
+    return A(s, e);
+  });
+}
+const Xr = S(
+  "attribute",
+  (t, e) => {
+    var a;
+    const n = t.tags.attrParam, o = { kind: "@attribute", name: (a = t.tags.name) == null ? void 0 : a[0], params: n };
+    return { ...e, attribute: o };
+  }
+), Jr = S(
+  "type",
+  // @ts-ignore
+  (t, e) => {
+    var i, a;
+    let n = (i = t.tags.templateParam) == null ? void 0 : i.flat(3);
+    const r = (a = t.tags.typeRefName) == null ? void 0 : a[0], s = typeof r == "string" ? r : r.ident, o = {
+      ...e,
+      name: s,
+      templateParams: n
+    };
+    return A(o, t);
+  }
+), nn = S(
+  "expression",
+  (t, e) => {
+    const n = { ...e };
+    return A(n, t);
+  }
+);
+function Kr(t) {
+  var r;
+  const e = (r = t.tags.const_assert) == null ? void 0 : r.flat()[0], n = t.app.stable;
+  n.moduleAsserts || (n.moduleAsserts = []), n.moduleAsserts.push(e);
+}
+const Hr = S(
+  "stuff",
+  (t, e) => {
+    const n = { ...e };
+    return A(n, t);
+  }
+), Yr = S(
+  "memberRef",
+  (t, e) => {
+    const { component: n, structRef: r, extra_components: s } = t.tags, o = n[0], i = r == null ? void 0 : r.flat()[0], a = s == null ? void 0 : s.flat()[0], l = {
+      ...e,
+      name: i,
+      member: o,
+      extraComponents: a
+    };
+    return A(l, t);
+  }
+);
+function rn(t) {
+  const { start: e, end: n, src: r, app: s } = t, o = r.slice(e, n), i = { kind: "name", start: e, end: n, name: o };
+  return et(t, i), i;
+}
+const Zr = S(
+  "module",
+  (t, e) => {
+    const n = { ...t, start: 0, end: t.src.length }, r = A(e, n), s = t.app.stable;
+    return s.moduleElem = r, r;
+  }
+);
+function Qr(t) {
+  var a, l;
+  const { start: e, end: n } = t, r = (a = t.tags.directive) == null ? void 0 : a.flat()[0], i = { kind: "directive", attributes: (l = t.tags.attribute) == null ? void 0 : l.flat(), start: e, end: n, directive: r };
+  return et(t, i), i;
+}
+const C = {
+  before: Lr,
+  after: Qe
+}, sn = {
+  before: jr,
+  after: Qe
+};
+function S(t, e) {
+  return {
+    before: (n) => {
+      const r = { kind: t, contents: [] };
+      n.app.context.openElems.push(r);
+    },
+    after: (n) => {
+      const s = n.app.context.openElems.pop();
+      console.assert(s && s.kind === t);
+      const o = e(n, { ...s, start: n.start, end: n.end });
+      return o && et(n, o), o;
+    }
+  };
+}
+function A(t, e) {
+  const n = ts(e, t);
+  return { ...t, contents: n };
+}
+function ts(t, e) {
+  let { start: n } = t;
+  const r = t.app.stable, { contents: s, end: o } = e, i = s.sort((c, d) => c.start - d.start), a = [];
+  for (const c of i)
+    n < c.start && a.push(l(c.start)), a.push(c), n = c.end;
+  return n < o && a.push(l(o)), a;
+  function l(c) {
+    return { kind: "text", start: n, end: c, srcModule: r.srcModule };
+  }
+}
+const M = zt("word");
+zt("keyword");
+const ft = $t("::", m(M, "package", "super")), es = zt("number");
+function Ot(t, e) {
+  return { kind: "import-statement", segments: t, finalSegment: e };
+}
+function _t(t) {
+  return { kind: "import-segment", name: t };
+}
+function ns(t) {
+  return {
+    kind: "import-collection",
+    subtrees: t
+  };
+}
+function _e(t, e) {
+  return { kind: "import-item", name: t, as: e };
+}
+function on(t, e) {
+  return e.segments = t.concat(e.segments), e;
+}
+let se = null;
+const oe = u(
+  M,
+  m(
+    N(
+      "::",
+      f(
+        m(
+          z(() => se),
+          z(() => oe)
+        ),
+        "invalid import, expected '{' or name"
+      )
+    ),
+    N("as", f(M, "invalid alias, expected name")).map(
+      (t) => _e("", t)
+    ),
+    xt().map(() => _e(""))
+    // Optional
+  )
+).map(([t, e]) => {
+  if (e.kind === "import-collection")
+    return Ot([_t(t)], e);
+  if (e.kind === "import-statement")
+    return on([_t(t)], e);
+  if (e.kind === "import-item")
+    return e.name = t, Ot([], e);
+  j(e);
+});
+se = q(
+  "{",
+  $t(",", () => oe).map(ns),
+  f("}", "invalid import collection, expected }")
+);
+const rs = m(
+  Dt("package", f("::", "invalid import, expected '::'")).map((t) => [
+    _t(t)
+  ]),
+  L(
+    Dt("super", f("::", "invalid import, expected '::'")).map(
+      _t
+    )
+  )
+), ss = Gt(
+  q(
+    "import",
+    Hn({
+      relative: b(rs),
+      collection_or_statement: f(
+        m(se, oe),
+        "invalid import, expected { or name"
+      )
+    }).map(({ relative: t, collection_or_statement: e }) => e.kind === "import-statement" ? on(t ?? [], e) : Ot(t ?? [], e)),
+    f(";", "invalid import, expected ';'")
+  )
+).map(
+  (t) => ({
+    kind: "import",
+    imports: t.value,
+    start: t.span[0],
+    end: t.span[1]
+  })
+), os = _(
+  T(ss).ptag("owo").collect(Ir)
+), is = `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+/), as = `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+/
+), cs = /[ \t\n\v\f\r\u{0085}\u{200E}\u{200F}\u{2028}\u{2029}]+/u, ls = "& && -> @ / ! [ ] { } :: : , == = != >>= >> >= > <<= << <= < % - -- . + ++ | || ( ) ; * ~ ^ // /* */ += -= *= /= %= &= |= ^= _", us = /(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))/u, ds = new Set(is.concat(as)), fs = 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
+), ps = /\/\/|\/\*/, ms = new kr({
+  word: us,
+  number: fs,
+  blankspaces: cs,
+  commentStart: ps,
+  symbol: Mt(ls),
+  invalid: /[^]/
+});
+class hs {
+  constructor(e) {
+    this.src = e, this.eolPattern = /[\n\v\f\u{0085}\u{2028}\u{2029}]|\r\n?/gu, this.blockCommentPattern = /\/\*|\*\//g, this.stream = new mr(new xr(e, ms));
+  }
+  checkpoint() {
+    return this.stream.checkpoint();
+  }
+  reset(e) {
+    this.stream.reset(e);
+  }
+  nextToken() {
+    for (; ; ) {
+      const e = this.stream.nextToken();
+      if (e === null) return null;
+      const n = e.kind;
+      if (n !== "blankspaces")
+        if (n === "commentStart")
+          e.text === "//" ? this.stream.reset(this.skipToEol(e.span[1])) : this.stream.reset(this.skipBlockComment(e.span[1]));
+        else if (n === "word") {
+          let r = e;
+          return ds.has(e.text) && (r.kind = "keyword"), r;
+        } else {
+          if (n === "invalid")
+            throw new H(
+              "Invalid token " + e.text,
+              this.stream.checkpoint()
+            );
+          return e;
+        }
+    }
+  }
+  skipToEol(e) {
+    return this.eolPattern.lastIndex = e, this.eolPattern.exec(this.src) === null ? this.src.length : this.eolPattern.lastIndex;
+  }
+  skipBlockComment(e) {
+    for (; ; ) {
+      this.blockCommentPattern.lastIndex = e;
+      const n = this.blockCommentPattern.exec(this.src);
+      if (n === null)
+        throw new H("Unclosed block comment!", e);
+      if (n[0] === "*/")
+        return this.blockCommentPattern.lastIndex;
+      if (n[0] === "/*")
+        e = 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 e = this.stream.checkpoint(), n = this.nextToken();
+    return this.stream.reset(e), n === null || n.kind !== "symbol" ? null : n.text === "<" ? this.isTemplateStart(n.span[1]) ? (this.stream.reset(n.span[1]), n) : (this.stream.reset(e), null) : null;
+  }
+  nextTemplateEndToken() {
+    const e = this.stream.checkpoint(), n = this.nextToken();
+    if (this.stream.reset(e), n === null) return null;
+    if (n.kind === "symbol" && n.text[0] === ">") {
+      const r = n.span[0];
+      return this.stream.reset(r + 1), {
+        kind: "symbol",
+        span: [r, r + 1],
+        text: ">"
+      };
+    } else
+      return null;
+  }
+  isTemplateStart(e) {
+    this.stream.reset(e);
+    let n = 1;
+    for (; ; ) {
+      const r = this.stream.nextToken();
+      if (r === null) return !1;
+      if (r.kind === "symbol") {
+        if (r.text === "<")
+          n += 1;
+        else if (r.text[0] === ">") {
+          if (r.text === ">" || r.text == ">=")
+            n -= 1;
+          else if (r.text === ">>=" || r.text === ">>")
+            n -= 2;
+          else
+            throw new Error(
+              "This case should never be reached, looks like we forgot one of the tokens that start with >"
+            );
+          if (n <= 0)
+            return !0;
+        } else if (r.text === "(")
+          this.skipBracketsTo(")");
+        else if (r.text === "[")
+          this.skipBracketsTo("]");
+        else if (r.text === "==" || r.text === "!=" || r.text === ";" || r.text === "{" || r.text === ":" || r.text === "&&" || r.text === "||")
+          return !1;
+      }
+    }
+  }
+  /**
+   * Call this after consuming an opening bracket.
+   * Skips until a closing bracket. This also consumes the closing bracket.
+   */
+  skipBracketsTo(e) {
+    for (; ; ) {
+      const n = this.stream.nextToken();
+      if (n === null)
+        throw new H("Unclosed bracket!", this.stream.checkpoint());
+      if (n.kind === "symbol") {
+        if (n.text === "(")
+          this.skipBracketsTo(")");
+        else if (n.text === "[")
+          this.skipBracketsTo("]");
+        else if (n.text === e)
+          return;
+      }
+    }
+  }
+}
+const gs = Re((t) => t.nextTemplateStartToken()), bs = Re((t) => t.nextTemplateEndToken()), pt = b(
+  u(
+    gs,
+    $t(",", () => $s),
+    f(bs, "invalid template, expected '>'")
+  )
+), xs = u(
+  ft.collect(dt),
+  pt
+), ks = m("true", "false", es), _s = u(
+  "(",
+  () => v,
+  f(")", "invalid expression, expected ')'")
+), vs = m(
+  ks,
+  _s,
+  u(xs, b(z(() => ln)))
+), vt = L(
+  m(
+    N(".", M),
+    Yn(
+      q(
+        "[",
+        () => v,
+        f("]", "invalid expression, expected ']'")
+      )
+    )
+  )
+), an = _(
+  u(
+    ft.collect(dt, "structRef"),
+    u(".", M.collect(rn, "component")),
+    b(vt.collect(Hr, "extra_components"))
+  ).collect(Yr)
+), $ = m(
+  u(bt("symbol", ["!", "&", "*", "-", "~"]), () => $),
+  m(
+    an,
+    u(vs, b(vt))
+  )
+), ys = m(
+  // LATER I can skip template list discovery in these cases, because a&b<c cannot be a comparison. Must be a template
+  L(u("&", $)),
+  L(u("^", $)),
+  L(u("|", $))
+), ve = m("%", "*", "/"), Es = m("+", "-"), ye = (t) => {
+  const e = u("<<", $), n = u(">>", $), r = u(
+    T(u(ve, $)),
+    T(
+      u(
+        Es,
+        $,
+        T(u(ve, $))
+      )
+    )
+  );
+  return t ? m(e, r) : m(e, n, r);
+}, It = (t) => u(
+  ye(t),
+  b(
+    u(
+      // '<' is unambiguous, since templates were already caught by the primary expression inside of the previous unary_expression!
+      t ? bt("symbol", ["<", "<=", "!=", "=="]) : bt("symbol", [">", ">=", "<", "<=", "!=", "=="]),
+      // LATER I can skip template list discovery in this cases, because a>=b<c cannot be a comparison. Must be a template
+      $,
+      ye(t)
+    )
+  )
+), cn = (t) => u(
+  $,
+  m(
+    ys,
+    u(
+      It(t),
+      t ? (
+        // Don't accept || or && in template mode
+        xt()
+      ) : m(
+        L(
+          u("||", u($, It(!1)))
+        ),
+        L(
+          u("&&", u($, It(!1)))
+        ),
+        xt().map(() => [])
+      )
+    )
+  )
+);
+let Ss = !1;
+const v = cn(Ss);
+let ws = !0;
+const Ts = cn(ws), Ps = u(
+  ft.collect(dt, "typeRefName"),
+  () => pt
+).collect(Jr), J = _(
+  Ps
+).ctag("typeRefElem"), $s = m(
+  // LATER Remove this, it's wrong. This should instead be done by inspecting the syntax tree.
+  J.ctag("templateParam"),
+  Ts.collect(nn, "templateParam")
+), ln = u(
+  "(",
+  tt(",", v),
+  f(")", "invalid fn arguments, expected ')'")
+), it = Ae("word").map(bo), Ns = u(
+  it,
+  b(N(".", f(it, "invalid diagnostic rule name, expected name")))
+), un = q(
+  "(",
+  f(
+    Zn(it, ",", Ns),
+    "invalid diagnostic control, expected rule name"
+  ),
+  u(b(","), f(")", "invalid diagnostic control, expected ')'"))
+), Ft = tt(",", it, { requireOne: !0 }), dn = _(
+  N(
+    "@",
+    m(
+      // These attributes have no arguments
+      m("compute", "const", "fragment", "invariant", "must_use", "vertex").map((t) => uo([t, []])),
+      // These attributes have arguments, but the argument doesn't have any identifiers
+      N("interpolate", f(q("(", Ft, ")"), "invalid @interpolate, expected '('")).map(fo),
+      N("builtin", f(q("(", it, ")"), "invalid @builtin, expected '('")).map(po),
+      N("diagnostic", f(un, "invalid @diagnostic, expected '('")).map(mo)
+    ).ptag("attr_variant")
+  ).collect(en)
+), Ms = _(
+  N(
+    u("@", "if"),
+    Gt(
+      q(
+        "(",
+        z(() => pn),
+        u(b(","), ")")
+      )
+    ).map(go)
+  ).map(ho).ptag("attr_variant").collect(en)
+), fn = _(
+  N(
+    "@",
+    m(
+      // These are normal attributes, with required arguments
+      u(
+        m(
+          "workgroup_size",
+          "align",
+          "binding",
+          "blend_src",
+          "group",
+          "id",
+          "location",
+          "size"
+        ).ptag("name"),
+        f(() => Ee, "invalid attribute, expected '('")
+      ),
+      // Everything else is also a normal attribute, optional expression list
+      u(
+        // 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
+        M.ptag("name"),
+        b(() => Ee)
+      )
+    )
+  ).collect(Xr)
+), Ee = q(
+  "(",
+  tt(
+    ",",
+    Gt(z(() => v)).collect(nn, "attrParam")
+    // LATER These unknown expressions have decls inside of them, that's why they're tough to replace!
+  ),
+  f(")", "invalid attribute arguments, expected ')'")
+), Cs = m(
+  dn,
+  fn
+).ctag("attribute"), As = m(
+  Ms,
+  dn,
+  fn
+).ctag("attribute"), E = T(As), qt = T(Cs), Rs = f(
+  M.collect(At, "type_name"),
+  "invalid type name, expected a name"
+), Bs = f(
+  M.collect(At, "fn_name"),
+  "missing fn name"
+), Is = _(
+  u(
+    M.collect(Ke, "decl_elem"),
+    b(u(":", J))
+  ).collect(ne)
+).ctag("var_name"), Ut = f(Is, "invalid ident"), Wt = _(
+  f(
+    u(
+      M.collect(At, "decl_elem"),
+      b(u(":", J))
+    ).collect(ne),
+    "expected identifier"
+  )
+).ctag("var_name"), Ls = _(
+  u(
+    E,
+    M.collect(rn, "nameElem"),
+    f(":", "invalid struct member, expected ':'"),
+    f(J, "invalid struct member, expected type specifier")
+  ).collect(Vr)
+).ctag("members"), js = u(
+  E.collect((t) => t.tags.attribute, "attributes"),
+  "struct",
+  f(Rs, "invalid struct, expected name"),
+  u(
+    f("{", "invalid struct, expected '{'"),
+    $t(",", Ls),
+    f("}", "invalid struct, expected '}'")
+  ).collect(C, "struct_scope")
+).collect(Wr), ie = u(
+  ft.collect(dt),
+  () => pt,
+  ln
+), Ds = _(
+  u(
+    E.collect((t) => t.tags.attribute, "attributes"),
+    M.collect(Ke, "decl_elem"),
+    b(u(":", f(J, "invalid fn parameter, expected type specifier"))).collect(ne, "param_name")
+  ).collect(Ur)
+).ctag("fn_param"), Os = u("(", tt(",", Ds), ")"), Fs = u(
+  "var",
+  () => pt,
+  Ut,
+  b(u("=", () => v))
+  // no decl_scope, but I think that's ok
+).collect(kt("var")), qs = u(
+  "var",
+  () => pt,
+  Wt,
+  // TODO shouldn't decl_scope include the ident type?
+  b(u("=", () => v.collect(C, "decl_scope")))
+), Us = m(
+  bt("keyword", ["true", "false"]).map(xo),
+  q(
+    st("symbol", "("),
+    z(() => pn),
+    st("symbol", ")")
+  ).map(_o),
+  Ae("word").map(ko)
+), gt = m(
+  u(
+    st("symbol", "!").map(vo),
+    z(() => gt)
+  ).map(yo),
+  Us
+), pn = u(
+  gt,
+  m(
+    L(
+      u(
+        st("symbol", "||").map(Se),
+        f(
+          gt,
+          "invalid expression, expected expression"
+        )
+      )
+    ),
+    L(
+      u(
+        st("symbol", "&&").map(Se),
+        f(
+          gt,
+          "invalid expression, expected expression"
+        )
+      )
+    ),
+    xt().map(() => [])
+  )
+).map(Eo), mn = u(
+  E,
+  Pt("{"),
+  T(() => yt),
+  f("}", "invalid block, expected }")
+).collect(ot), X = _(
+  u(
+    E,
+    u(
+      Pt("{"),
+      T(() => yt),
+      f("}", "invalid block, expected '}'")
+    ).collect(C)
+  ).collect(ot)
+), Ws = u(
+  E,
+  m(
+    ie,
+    () => gn,
+    () => ae
+  )
+), Vs = u(
+  E,
+  m(ie, () => ae)
+), zs = u(
+  // LATER consider allowing @if on for_init, expression and for_update
+  "for",
+  u(
+    f("(", "invalid for loop, expected '('"),
+    b(Ws),
+    f(";", "invalid for loop, expected ';'"),
+    b(v),
+    f(";", "invalid for loop, expected ';'"),
+    b(Vs),
+    f(")", "invalid for loop, expected ')'"),
+    mn
+  ).collect(C)
+), Gs = u(
+  "if",
+  f(u(v, X), "invalid if statement"),
+  T(
+    u(
+      "else",
+      "if",
+      f(u(v, X), "invalid else if branch")
+    )
+  ),
+  b(
+    u("else", f(X, "invalid else branch, expected '{'"))
+  )
+), Xs = u(
+  "loop",
+  qt,
+  f(
+    u(
+      "{",
+      T(() => yt),
+      b(
+        _(
+          u(
+            E,
+            "continuing",
+            qt,
+            "{",
+            T(() => yt),
+            _(
+              b(
+                u(
+                  E,
+                  u("break", "if", v, ";")
+                ).collect(ot)
+              )
+            ),
+            "}"
+          ).collect(ot).collect(C)
+        )
+      ),
+      "}"
+    ),
+    "invalid loop statement"
+  )
+).collect(C), Js = m("default", v), Ks = _(
+  u(
+    E,
+    m(
+      u(
+        "case",
+        tt(",", Js, { requireOne: !0 }),
+        b(":"),
+        X
+      ),
+      u("default", b(":"), X)
+    ).collect(Gr)
+  )
+), Hs = u(E, "{", L(Ks), "}"), Ys = u("switch", v, Hs), Zs = u("while", v, X), hn = m(
+  zs,
+  Gs,
+  Xs,
+  Ys,
+  Zs,
+  u("break", ";"),
+  // ambiguous with break if
+  u("continue", f(";", "invalid statement, expected ';'")),
+  u(";"),
+  // LATER this one cannot have attributes in front of it
+  () => bn,
+  u("discard", f(";", "invalid statement, expected ';'")),
+  u("return", b(v), f(";", "invalid statement, expected ';'")),
+  u(ie, f(";", "invalid statement, expected ';'")),
+  u(
+    () => gn,
+    f(";", "invalid statement, expected ';'")
+  ),
+  u(
+    () => ae,
+    f(";", "invalid statement, expected ';'")
+  )
+), Qs = _(
+  u(
+    E,
+    hn
+  ).collect(ot).collect(sn)
+), to = _(
+  u(
+    qt,
+    hn
+  )
+), yt = m(
+  X,
+  to,
+  Qs
+), nt = m(
+  an,
+  u(
+    ft.collect(dt),
+    b(vt)
+  ),
+  u(
+    "(",
+    () => nt,
+    ")",
+    b(vt)
+    // LATER this doesn't find member references.
+  ),
+  u("&", () => nt),
+  u("*", () => nt)
+), gn = _(
+  // LATER consider collecting these as var elems and scopes
+  m(
+    // Also covers the = expression case
+    Fs,
+    u("const", Ut, f("=", "invalid const declaration, expected '='"), v),
+    u(
+      "let",
+      Ut,
+      f("=", "invalid let declaration, expected '='"),
+      v
+    )
+  )
+), ae = m(
+  u(
+    nt,
+    m("=", "<<=", ">>=", "%=", "&=", "*=", "+=", "-=", "/=", "^=", "|="),
+    v
+  ),
+  u(nt, m("++", "--")),
+  u("_", "=", v)
+), eo = u(
+  _(
+    E.collect((t) => t.tags.attribute || [])
+  ).ctag("fn_attributes"),
+  Pt("fn"),
+  f(Bs, "invalid fn, expected function name"),
+  u(
+    f(Os, "invalid fn, expected function parameters").collect(C, "header_scope"),
+    b(u(
+      "->",
+      E.collect((t) => t.tags.attribute, "return_attributes"),
+      J.ctag("return_type").collect(C, "return_scope")
+    )),
+    f(
+      mn,
+      "invalid fn, expected function body"
+    ).ctag("body_statement").collect(C, "body_scope")
+  )
+).collect(sn, "fn_partial_scope").collect(Fr), no = m(
+  u(
+    E,
+    "override",
+    Wt,
+    u(b(u("=", v.collect(C, "decl_scope")))),
+    // TODO partial scopes for decl_scopes?
+    ";"
+  ).collect(kt("override")),
+  u(
+    E,
+    "const",
+    Wt,
+    "=",
+    u(v).collect(C, "decl_scope"),
+    ";"
+  ).collect(kt("const"))
+), ro = u(
+  E.collect((t) => t.tags.attribute, "attributes"),
+  "alias",
+  f(M, "invalid alias, expected name").collect(At, "alias_name"),
+  f("=", "invalid alias, expected '='"),
+  f(J, "invalid alias, expected type").collect(C, "alias_scope"),
+  f(";", "invalid alias, expected ';'")
+).collect(Or), bn = _(
+  u(
+    E,
+    "const_assert",
+    f(v, "invalid const_assert, expected expression"),
+    f(";", "invalid statement, expected ';'")
+  ).collect(zr)
+).ctag("const_assert"), so = _(
+  u(
+    E,
+    Dt(
+      m(
+        N("diagnostic", un).map(ao),
+        N("enable", Ft).map(co),
+        N("requires", Ft).map(lo)
+      ).ptag("directive"),
+      ";"
+    )
+  ).collect(Qr)
+), oo = _(
+  m(
+    eo,
+    u(
+      E,
+      qs,
+      ";"
+    ).collect(kt("gvar")),
+    no,
+    ";",
+    ro,
+    bn.collect(Kr),
+    js
+  )
+), io = u(
+  os,
+  T(so),
+  T(oo),
+  f(tr(), "invalid WESL, expected EOF")
+).collect(Zr, "collectModule");
+function ao([t, e]) {
+  return { kind: "diagnostic", severity: t, rule: e };
+}
+function co(t) {
+  return { kind: "enable", extensions: t };
+}
+function lo(t) {
+  return { kind: "requires", extensions: t };
+}
+function uo([t, e]) {
+  return {
+    kind: "@attribute",
+    name: t,
+    params: e
+  };
+}
+function fo(t) {
+  return {
+    kind: "@interpolate",
+    params: t
+  };
+}
+function po(t) {
+  return {
+    kind: "@builtin",
+    param: t
+  };
+}
+function mo([t, e]) {
+  return {
+    kind: "@diagnostic",
+    severity: t,
+    rule: e
+  };
+}
+function ho(t) {
+  return {
+    kind: "@if",
+    param: t
+  };
+}
+function go(t) {
+  return {
+    kind: "translate-time-expression",
+    expression: t.value,
+    span: t.span
+  };
+}
+function bo(t) {
+  return {
+    kind: "name",
+    name: t.text,
+    start: t.span[0],
+    end: t.span[1]
+  };
+}
+function xo(t) {
+  return {
+    kind: "literal",
+    value: t.text,
+    span: t.span
+  };
+}
+function ko(t) {
+  return {
+    kind: "translate-time-feature",
+    name: t.text,
+    span: t.span
+  };
+}
+function _o(t) {
+  return {
+    kind: "parenthesized-expression",
+    expression: t
+  };
+}
+function vo(t) {
+  return {
+    value: t.text,
+    span: t.span
+  };
+}
+function Se(t) {
+  return {
+    value: t.text,
+    span: t.span
+  };
+}
+function yo([t, e]) {
+  return {
+    kind: "unary-expression",
+    operator: t,
+    expression: e
+  };
+}
+function Eo([t, e]) {
+  let n = t;
+  for (const [r, s] of e)
+    n = So([n, r, s]);
+  return n;
+}
+function So([t, e, n]) {
+  return {
+    kind: "binary-expression",
+    operator: e,
+    left: t,
+    right: n
+  };
+}
+/*!
+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 xn = {};
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("").forEach(function(t, e) {
+  xn[e] = t;
+});
+function we(t) {
+  if (typeof t == "number")
+    return Te(t);
+  let e = "";
+  for (let n = 0; n < t.length; n += 1)
+    e += Te(t[n]);
+  return e;
+}
+function Te(t) {
+  let e = "";
+  t < 0 ? t = -t << 1 | 1 : t <<= 1;
+  do {
+    let n = t & 31;
+    t >>>= 5, t > 0 && (n |= 32), e += xn[n];
+  } while (t > 0);
+  return e;
+}
+function Vi(t) {
+  const e = [];
+  t.injectError = (r, s) => {
+    const o = e.findLast((i) => i.filter === r);
+    o !== void 0 ? o.errors.push(s) : s.then((i) => {
+      i !== null && n(i);
+    });
+  };
+  function n(r) {
+    t.addEventListener(
+      "uncapturederror",
+      (s) => {
+        if (!s.defaultPrevented)
+          if ("compilationInfo" in s.error) {
+            const o = s.error;
+            if (o.compilationInfo)
+              for (const i of o.compilationInfo.messages)
+                kn({
+                  url: i.module.url,
+                  text: i.module.text ?? null,
+                  lineNumber: i.lineNum,
+                  lineColumn: i.linePos,
+                  length: i.length,
+                  error: new Error(i.type + ": " + i.message)
+                });
+            else
+              console.error(s.error.message);
+          } else
+            console.error(s.error.message);
+      },
+      {
+        // This event listener should only happen for this event!
+        once: !0
+      }
+    ), t.dispatchEvent(
+      new GPUUncapturedErrorEvent("uncapturederror", { error: r })
+    );
+  }
+  return t.pushErrorScope = /* @__PURE__ */ ((r) => function(s) {
+    return e.push({
+      filter: s,
+      errors: []
+    }), r.call(this, s);
+  })(t.pushErrorScope), t.popErrorScope = /* @__PURE__ */ ((r) => function() {
+    const s = e.pop();
+    if (s === void 0)
+      throw new DOMException(
+        "popErrorScope called on empty error scope stack",
+        "OperationError"
+      );
+    return s.errors.push(r.call(this)), Promise.all(s.errors).then(
+      (i) => i.find((a) => a !== null) ?? null
+    );
+  })(t.popErrorScope), t;
+}
+function kn({
+  url: t,
+  text: e,
+  lineNumber: n,
+  lineColumn: r,
+  length: s,
+  error: o
+}) {
+  let i = we([
+    0,
+    0,
+    Math.max(0, n - 1),
+    Math.max(0, r - 1)
+  ]) + "," + // Sadly no browser makes use of this info to map the error properly
+  we([
+    18,
+    // Arbitrary number that is high enough
+    0,
+    Math.max(0, n - 1),
+    Math.max(0, r - 1) + s
+  ]);
+  const a = {
+    version: 3,
+    file: null,
+    sources: [t],
+    sourcesContent: [e ?? null],
+    names: [],
+    mappings: i
+  };
+  let l = `throw new Error(${JSON.stringify(o.message + "")})`;
+  l += `
+//# sourceMappingURL=data:application/json;base64,` + btoa(unescape(encodeURIComponent(JSON.stringify(a)))), l += `
+//# sourceURL=` + a.sources[0];
+  let c = 0;
+  "stackTraceLimit" in Error && (c = Error.stackTraceLimit, Error.stackTraceLimit = 1);
+  try {
+    (0, eval)(l);
+  } catch (d) {
+    throw "stackTraceLimit" in Error && (Error.stackTraceLimit = c), o.message = "", d.cause = o, d;
+  }
+}
+class wo extends Error {
+  constructor(e) {
+    const n = e.src.src, [r, s] = Qt(e.cause.position, n);
+    let o = `${e.src.debugFilePath}:${r}:${s}`;
+    o += ` error: ${e.cause.message}
+`, o += De(n, [
+      e.cause.position,
+      e.cause.position + 1
+    ]).join(`
+`), super(o, {
+      cause: e.cause
+    }), this.position = e.cause.position, this.src = e.src;
+  }
+}
+function ce(t, e) {
+  const n = new hs(t.src), r = _n(t), s = { stream: n, appState: r };
+  try {
+    if (io.parse(s) === null)
+      throw new Error("parseWESL failed");
+  } catch (o) {
+    if (o instanceof H) {
+      const [i, a] = Qt(
+        o.position,
+        t.src
+      ), l = new wo({ cause: o, src: t });
+      kn({
+        url: t.debugFilePath,
+        text: t.src,
+        error: l,
+        lineNumber: i,
+        lineColumn: a,
+        length: 1
+      });
+    } else
+      throw o;
+  }
+  return r.stable;
+}
+function To(t, e) {
+  return ce({
+    modulePath: "package::test",
+    // TODO this ought not be used outside of tests
+    debugFilePath: "./test.wesl",
+    src: t
+  });
+}
+function _n(t) {
+  const e = Ve(null);
+  return {
+    context: { scope: e, openElems: [] },
+    stable: { srcModule: t, imports: [], rootScope: e, moduleElem: null }
+  };
+}
+function zi() {
+  return _n({
+    modulePath: "package::test",
+    debugFilePath: "./test.wesl",
+    src: ""
+  });
+}
+function Po(t) {
+  if (t._flatImports) return t._flatImports;
+  const e = t.imports.flatMap(Cr);
+  return t._flatImports = e, e;
+}
+const $o = `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+/), vn = `
+  texture_1d texture_2d texture_2d_array texture_3d 
+  texture_cube texture_cube_array
+`, yn = `
+  texture_multisampled_2d texture_depth_multisampled_2d
+`, En = `
+  texture_storage_1d texture_storage_2d texture_storage_2d_array 
+  texture_storage_3d
+`, No = `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
+  ${vn}
+  ${yn}
+  texture_external
+  ${En}
+  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+/), Mo = `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 Sn(t) {
+  return No.includes(t);
+}
+function Co(t) {
+  return $o.includes(t) || Sn(t);
+}
+function Ao(t) {
+  return Mo.includes(t);
+}
+function Ro(t) {
+  const { rootAst: e, registry: n, virtuals: r } = t, { conditions: s = {}, mangler: o = Mr } = t, { rootScope: i } = e, a = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), c = le(i);
+  c.forEach((w) => {
+    w.mangledName = w.originalName, a.add(w.originalName), l.add(w);
+  });
+  const d = /* @__PURE__ */ new Map(), p = {
+    registry: n,
+    conditions: s,
+    knownDecls: l,
+    foundScopes: /* @__PURE__ */ new Set(),
+    globalNames: a,
+    globalStatements: d,
+    virtuals: r,
+    mangler: o
+  }, h = c.map((w) => [w.originalName, w]), x = { decls: new Map(h), parent: null }, R = Et(i, p, x, !0).filter(Rt), U = [...d.values()];
+  return { decls: R, globalNames: a, newStatements: U };
+}
+function le(t, e) {
+  const n = [];
+  for (const r of t.contents)
+    r.kind === "decl" ? (r.declElem, Oe(r.declElem) && n.push(r)) : r.kind === "partial" && n.push(...le(r));
+  return n;
+}
+function Et(t, e, n, r = !1) {
+  const { conditions: s, foundScopes: o } = e;
+  if (o.has(t)) return [];
+  o.add(t);
+  const i = [], a = [];
+  t.contents.forEach((c) => {
+    const { kind: d } = c;
+    if (d === "decl") {
+      const p = c;
+      r || n.decls.set(p.originalName, p);
+    } else if (d === "ref") {
+      const p = Bo(c, n, e);
+      p && i.push(p);
+    } else {
+      const p = Io(c, n, e);
+      p && a.push(...p);
+    }
+  });
+  const l = i.flatMap((c) => {
+    const d = c.scope, p = jo(c);
+    {
+      const h = Xe(p);
+      return Et(d, e, h);
+    }
+  });
+  return [i, a, l].flat();
+}
+function Bo(t, e, n) {
+  const { registry: r, conditions: s } = n, { virtuals: o } = n;
+  if (!t.refersTo && !t.std) {
+    const i = wn(t, e) ?? qo(t, r, s, o);
+    if (i)
+      return t.refersTo = i.decl, Lo(t, i, n);
+    Fo(t.originalName) ? t.std = !0 : Do(t);
+  }
+}
+function Io(t, e, n) {
+  if (!Fe(t)) return;
+  const { kind: r } = t;
+  if (r === "scope") {
+    const s = Xe(e);
+    return Et(t, n, s);
+  } else if (r === "partial")
+    return Et(t, n, e);
+}
+function Lo(t, e, n) {
+  const { decl: r, moduleAst: s } = e, { knownDecls: o, globalNames: i, mangler: a, globalStatements: l } = n;
+  if (!o.has(r)) {
+    o.add(r);
+    const { srcModule: c } = r, d = t.originalName;
+    if (Oo(d, r, i, c, a), Rt(r)) {
+      const { moduleAsserts: p } = s, h = p == null ? void 0 : p.map((x) => ({ srcModule: c, elem: x }));
+      return h == null || h.forEach((x) => l.set(x.elem, x)), r;
+    }
+  }
+}
+function jo(t, e) {
+  t.isGlobal, Ct(t);
+  let n = t.scope;
+  for (; n.parent; )
+    n = n.parent;
+  const s = le(n).map((i) => [i.originalName, i]);
+  return { decls: new Map(s) };
+}
+function Do(t) {
+  const { refIdentElem: e } = t;
+  if (e) {
+    const { srcModule: n, start: r, end: s } = e, { debugFilePath: o } = n, i = `unresolved identifier '${t.originalName}' in file: ${o}`;
+    throw Me(n.src, [r, s], i), new Error(i);
+  }
+}
+function Oo(t, e, n, r, s) {
+  if (!e.mangledName) {
+    let o;
+    if (Rt(e)) {
+      const i = t.lastIndexOf("::"), a = i === -1 ? t : t.slice(i + 2);
+      o = s(e, r, a, n);
+    } else
+      o = e.originalName;
+    e.mangledName = o, n.add(o);
+  }
+}
+function Fo(t) {
+  return Sn(t) || Co(t) || Ao(t);
+}
+function wn(t, e) {
+  const { originalName: n } = t, r = e.decls.get(n);
+  if (r)
+    return { decl: r, moduleAst: t.ast };
+  const { parent: s } = e;
+  if (s)
+    return wn(t, s);
+}
+function qo(t, e, n, r) {
+  const s = Po(t.ast), o = t.originalName.split("::"), i = Wo(o, s) ?? Uo(o);
+  if (i) {
+    const { srcModule: a } = t.ast;
+    return Vo(i, a, e, n, r);
+  }
+}
+function Uo(t) {
+  if (t.length > 1) return t;
+}
+function Wo(t, e) {
+  for (const n of e)
+    if (n.importPath.at(-1) === t.at(0))
+      return [...n.modulePath, ...t.slice(1)];
+}
+function Vo(t, e, n, r = {}, s) {
+  const i = zo(t, e).slice(0, -1).join("::"), a = n.modules[i] ?? Go(t[0], r, s);
+  if (!a) {
+    console.log(`ident ${t.join("::")}, but module not found`);
+    return;
+  }
+  const l = yr(t), c = ze(a.rootScope, l);
+  if (c)
+    return { decl: c, moduleAst: a };
+}
+function zo(t, e) {
+  const n = t.findLastIndex((r) => r === "super");
+  if (n > -1) {
+    const s = e.modulePath.split("::").slice(0, -(n + 1)), o = t.slice(n + 1);
+    return [...s, ...o];
+  }
+  return t;
+}
+function Go(t, e = {}, n) {
+  if (!n) return;
+  const r = n[t];
+  if (r) {
+    const { ast: s, fn: o } = r;
+    if (s) return s;
+    const i = o(e), a = {
+      modulePath: t,
+      debugFilePath: t,
+      src: i
+    };
+    return r.ast = ce(a), r.ast;
+  }
+}
+function Rt(t) {
+  const { declElem: e } = t;
+  return e ? ["alias", "const", "override", "fn", "struct", "gvar"].includes(
+    e.kind
+  ) : !1;
+}
+function Lt(t, e, n, r = !0) {
+  const s = { conditions: n, srcBuilder: t, extracting: r };
+  e.forEach((o) => ue(o, s));
+}
+function ue(t, e) {
+  if (fe(t, e.conditions))
+    switch (t.kind) {
+      // import statements are dropped from from emitted text
+      case "import":
+        return;
+      // terminal elements copy strings to the output
+      case "text":
+        return Xo(t, e);
+      case "name":
+        return Jo(t, e);
+      case "synthetic":
+        return Zo(t, e);
+      // identifiers are copied to the output, but with potentially mangled names
+      case "ref":
+        return Qo(t, e);
+      case "decl":
+        return de(t, e);
+      // 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 at(t, e);
+      // root level container elements get some extra newlines to make the output prettier
+      case "override":
+      case "const":
+      case "assert":
+      case "alias":
+      case "gvar":
+        return jt(e), at(t, e);
+      case "fn":
+        return jt(e), Ko(t, e);
+      case "struct":
+        return jt(e), Ho(t, e);
+      case "attribute":
+        return Tn(t, e);
+      case "directive":
+        return ti(t, e);
+      default:
+        j(t);
+    }
+}
+function jt(t) {
+  t.extracting && (t.srcBuilder.addNl(), t.srcBuilder.addNl());
+}
+function Xo(t, e) {
+  e.srcBuilder.addCopy(t.start, t.end);
+}
+function Jo(t, e) {
+  e.srcBuilder.add(t.name, t.start, t.end);
+}
+function Ko(t, e) {
+  const { attributes: n, name: r, params: s, returnAttributes: o, returnType: i, body: a } = t, { conditions: l, srcBuilder: c } = e;
+  Pe(n, e), c.add("fn ", r.start - 3, r.start), de(r, e), c.appendNext("(");
+  const d = s.filter((p) => fe(p));
+  d.forEach((p, h) => {
+    Vt(p, e), h < d.length - 1 && c.appendNext(", ");
+  }), c.appendNext(") "), i && (c.appendNext("-> "), Pe(o, e), at(i, e), c.appendNext(" ")), at(a, e);
+}
+function Pe(t, e) {
+  t == null || t.forEach((n) => {
+    Tn(n, e), e.srcBuilder.add(" ", n.start, n.end);
+  });
+}
+function Ho(t, e) {
+  const { name: n, members: r, start: s, end: o } = t, { srcBuilder: i } = e, a = r.filter((c) => fe(c, e.conditions)), l = a.length;
+  if (l === 0) {
+    Yo(t);
+    return;
+  }
+  i.add("struct ", s, n.start), de(n, e), l === 1 ? (i.add(" { ", n.end, r[0].start), Vt(a[0], e), i.add(` }
+`, o - 1, o)) : (i.add(` {
+`, n.end, r[0].start), a.forEach((c) => {
+    i.add("  ", c.start - 1, c.start), Vt(c, e), i.add(",", c.end, c.end + 1), i.addNl();
+  }), i.add(`}
+`, o - 1, o));
+}
+function Yo(t) {
+  const { name: e, members: n } = t, r = n.length ? "(with current conditions)" : "", { debugFilePath: s } = e.srcModule;
+  Me(
+    e.srcModule.src,
+    t.start,
+    `struct ${e.ident.originalName} in ${s} has no members ${r}`
+  );
+}
+function Zo(t, e) {
+  const { text: n } = t;
+  e.srcBuilder.addSynthetic(n, n, 0, n.length);
+}
+function at(t, e) {
+  t.contents.forEach((n) => ue(n, e));
+}
+function Vt(t, e) {
+  t.contents.forEach((n) => {
+    if (n.kind === "text") {
+      const { srcModule: r, start: s, end: o } = n;
+      if (r.src.slice(s, o).trim() === "")
+        return;
+    }
+    ue(n, e);
+  });
+}
+function Qo(t, e) {
+  if (t.ident.std)
+    e.srcBuilder.add(t.ident.originalName, t.start, t.end);
+  else {
+    const n = St(t.ident), r = Pn(n);
+    e.srcBuilder.add(r, t.start, t.end);
+  }
+}
+function de(t, e) {
+  const n = Pn(t.ident);
+  e.srcBuilder.add(n, t.start, t.end);
+}
+function Tn(t, e) {
+  const { kind: n } = t.attribute;
+  if (n === "@attribute") {
+    const { params: r } = t.attribute;
+    if (!r || r.length === 0)
+      e.srcBuilder.add("@" + t.attribute.name, t.start, t.end);
+    else {
+      e.srcBuilder.add(
+        "@" + t.attribute.name + "(",
+        t.start,
+        r[0].start
+      );
+      for (let s = 0; s < r.length; s++)
+        at(r[s], e), s < r.length - 1 && e.srcBuilder.add(",", r[s].end, r[s + 1].start);
+      e.srcBuilder.add(")", r[r.length - 1].end, t.end);
+    }
+  } else n === "@builtin" ? e.srcBuilder.add(
+    "@builtin(" + t.attribute.param.name + ")",
+    t.start,
+    t.end
+  ) : n === "@diagnostic" ? e.srcBuilder.add(
+    "@diagnostic" + mt(t.attribute.severity, t.attribute.rule),
+    t.start,
+    t.end
+  ) : n === "@if" || (n === "@interpolate" ? e.srcBuilder.add(
+    `@interpolate(${t.attribute.params.map((r) => r.name).join(", ")})`,
+    t.start,
+    t.end
+  ) : j(n));
+}
+function mt(t, e) {
+  const n = e[0].name + (e[1] !== null ? "." + e[1].name : "");
+  return `(${t.name}, ${n})`;
+}
+function D(t) {
+  const { kind: e } = t;
+  if (e === "binary-expression")
+    return `${D(t.left)} ${t.operator.value} ${D(t.right)}`;
+  if (e === "unary-expression")
+    return `${t.operator.value}${D(t.expression)}`;
+  if (e === "ref")
+    return t.ident.originalName;
+  if (e === "literal")
+    return t.value;
+  if (e === "translate-time-feature")
+    return t.name;
+  if (e === "parenthesized-expression")
+    return `(${D(t.expression)})`;
+  if (e === "component-expression")
+    return `${D(t.base)}[${t.access}]`;
+  if (e === "component-member-expression")
+    return `${D(t.base)}.${t.access}`;
+  if (e === "call-expression")
+    return `${t.function.ident.originalName}(${t.arguments.map(D).join(", ")})`;
+  j(e);
+}
+function ti(t, e) {
+  const { directive: n } = t, { kind: r } = n;
+  r === "diagnostic" ? e.srcBuilder.add(
+    `diagnostic${mt(n.severity, n.rule)};`,
+    t.start,
+    t.end
+  ) : r === "enable" ? e.srcBuilder.add(
+    `enable ${n.extensions.map((s) => s.name).join(", ")};`,
+    t.start,
+    t.end
+  ) : r === "requires" ? e.srcBuilder.add(
+    `requires ${n.extensions.map((s) => s.name).join(", ")};`,
+    t.start,
+    t.end
+  ) : j(r);
+}
+function Pn(t) {
+  return Rt(t) ? (t.mangledName, `${Ct(t)}`, t.mangledName) : t.mangledName || t.originalName;
+}
+function St(t) {
+  let e = t;
+  do {
+    if (e.kind === "decl")
+      return e;
+    e = e.refersTo;
+  } while (e);
+  throw new Error(`unresolved identifer: ${t.originalName}`);
+}
+function fe(t, e) {
+  const n = t, { kind: r } = n;
+  switch (r) {
+    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 Oe(n);
+  }
+  return !0;
+}
+function ei(t) {
+  return $n(t) + ";";
+}
+function $n(t) {
+  return [
+    ...t.segments.map((e) => e.name),
+    ni(t.finalSegment)
+  ].join("::");
+}
+function ni(t) {
+  if (t.kind === "import-item") {
+    const { name: e, as: n } = t, r = n ? ` as ${n}` : "";
+    return `${e}${r}`;
+  } else {
+    if (t.kind === "import-collection")
+      return `{${t.subtrees.map((e) => $n(e)).join(", ")}}`;
+    Tt(t);
+  }
+}
+const Nn = 150;
+function wt(t, e = 0) {
+  const { kind: n } = t, r = new ee(e, Nn);
+  r.add(n), ri(t, r);
+  let s = [];
+  return "contents" in t && (s = t.contents.map((o) => wt(o, e + 2))), s.length && (r.nl(), r.addBlock(s.join(`
+`), !1)), r.result;
+}
+function ri(t, e) {
+  const { kind: n } = t;
+  if (n === "text") {
+    const { srcModule: r, start: s, end: o } = t;
+    e.add(` '${r.src.slice(s, o)}'`);
+  } else if (n === "var" || n === "let" || n === "gvar" || n === "const" || n === "override")
+    $e(t.name, e), rt(t.attributes, e);
+  else if (n === "struct")
+    e.add(" " + t.name.ident.originalName);
+  else if (n === "member") {
+    const { name: r, typeRef: s, attributes: o } = t;
+    rt(o, e), e.add(" " + r.name), e.add(": " + Q(s));
+  } else if (n === "name")
+    e.add(" " + t.name);
+  else if (n === "memberRef") {
+    const { extraComponents: r } = t, s = r ? ci(r) : "";
+    e.add(` ${t.name.ident.originalName}.${t.member.name}${s}`);
+  } else if (n === "fn")
+    oi(t, e);
+  else if (n === "alias") {
+    const { name: r, typeRef: s } = t, o = r.ident.kind === "decl" ? "%" : "";
+    e.add(" " + o + r.ident.originalName), e.add("=" + Q(s));
+  } else if (n === "attribute")
+    Mn(t.attribute, e);
+  else if (n === "expression") {
+    const r = t.contents.map((s) => s.kind === "text" ? "'" + s.srcModule.src.slice(s.start, s.end) + "'" : wt(s)).join(" ");
+    e.add(" " + r);
+  } else if (n === "type") {
+    const { name: r } = t, s = typeof r == "string" ? r : r.originalName;
+    if (e.add(" " + s), t.templateParams !== void 0) {
+      const o = t.templateParams.map(An).join(", ");
+      e.add("<" + o + ">");
+    }
+  } else if (n === "synthetic")
+    e.add(` '${t.text}'`);
+  else if (n === "import")
+    e.add(" " + ei(t.imports));
+  else if (n === "ref")
+    e.add(" " + t.ident.originalName);
+  else if (n === "typeDecl")
+    $e(t, e);
+  else if (n === "decl") {
+    const { ident: r } = t;
+    e.add(" %" + r.originalName);
+  } else n === "assert" || n === "module" || n === "param" || n === "stuff" || (n === "directive" ? ai(t, e) : n === "statement" ? rt(t.attributes, e) : n === "switch-clause" || Tt(n));
+}
+function Mn(t, e) {
+  const { kind: n } = t;
+  if (n === "@attribute") {
+    const { name: r, params: s } = t;
+    e.add(" @" + r), s && s.length > 0 && (e.add("("), e.add(s.map(Cn).join(", ")), e.add(")"));
+  } else n === "@builtin" ? e.add(` @builtin(${t.param.name})`) : n === "@diagnostic" ? e.add(
+    ` @diagnostic${mt(t.severity, t.rule)}`
+  ) : n === "@if" ? (e.add(" @if"), e.add("("), e.add(D(t.param.expression)), e.add(")")) : n === "@interpolate" ? e.add(` @interpolate(${t.params.map((r) => r.name).join(", ")})`) : Tt(n);
+}
+function si(t) {
+  const e = new ee(0, Nn);
+  return Mn(t, e), e.result;
+}
+function $e(t, e) {
+  const { decl: n, typeRef: r } = t;
+  e.add(" %" + n.ident.originalName), r && e.add(" : " + Q(r));
+}
+function oi(t, e) {
+  const { name: n, params: r, returnType: s, attributes: o } = t;
+  e.add(" " + n.ident.originalName), e.add("(");
+  const i = r.map(
+    (a) => {
+      const { name: l } = a, { originalName: c } = l.decl.ident, d = Q(l.typeRef);
+      return c + ": " + d;
+    }
+  ).join(", ");
+  e.add(i), e.add(")"), rt(o, e), s && e.add(" -> " + Q(s));
+}
+function rt(t, e) {
+  t == null || t.forEach((n) => e.add(" " + ii(n.attribute)));
+}
+function ii(t) {
+  const { kind: e } = t;
+  return e === "@attribute" ? "@" + t.name : e;
+}
+function ai(t, e) {
+  const { directive: n, attributes: r } = t, { kind: s } = n;
+  if (s === "diagnostic") {
+    const { severity: o, rule: i } = n, a = mt(o, i);
+    e.add(` diagnostic${a}`);
+  } else s === "enable" || s === "requires" ? e.add(` ${s} ${n.extensions.map((o) => o.name).join(", ")}`) : Tt(s);
+  rt(r, e);
+}
+function Cn(t) {
+  return "contents" in t ? t.contents.map((n) => n.kind === "text" ? "'" + n.srcModule.src.slice(n.start, n.end) + "'" : wt(n)).join(" ") : wt(t);
+}
+function An(t) {
+  return typeof t == "string" ? t : t.kind === "type" ? Q(t) : t.kind === "expression" ? Cn(t) : (console.log("unknown template parameter type", t), "??");
+}
+function Q(t) {
+  if (!t) return "?type?";
+  const { name: e } = t, n = typeof e == "string" ? e : e.originalName;
+  let r = "";
+  return t.templateParams !== void 0 && (r = "<" + t.templateParams.map(An).join(", ") + ">"), n + r;
+}
+function ci(t) {
+  return t.contents.map((n) => {
+    const { kind: r } = n;
+    return r === "text" ? n.srcModule.src.slice(n.start, n.end) : r === "ref" ? n.ident.originalName : `?${n.kind}?`;
+  }).join(" ");
+}
+class li {
+  constructor(e) {
+    this.sourceMap = e;
+  }
+  /**
+   * 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(e, n) {
+    if (!("injectError" in e))
+      return e.createShaderModule({
+        ...n,
+        code: this.dest
+      });
+    e.pushErrorScope("validation");
+    const r = e.createShaderModule({
+      ...n,
+      code: this.dest
+    });
+    e.popErrorScope();
+    let { promise: s, resolve: o } = Promise.withResolvers();
+    return e.injectError("validation", s), r.getCompilationInfo().then((i) => {
+      if (i.messages.length === 0) {
+        o(null);
+        return;
+      }
+      const a = this.mapGPUCompilationInfo(i), l = ui(
+        a,
+        r
+      );
+      qn(l !== null);
+      const c = new GPUValidationError(
+        l
+      );
+      c.cause = new Error("createShaderModule failed"), c.compilationInfo = a, o(c);
+    }), r;
+  }
+  /**
+   * 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(e) {
+    return {
+      __brand: e.__brand,
+      messages: e.messages.map(
+        (n) => this.mapGPUCompilationMessage(n)
+      )
+    };
+  }
+  mapGPUCompilationMessage(e) {
+    const n = this.sourceMap, r = n.destToSrc(e.offset), o = (e.length > 0 ? n.destToSrc(e.offset + e.length) : r).position - r.position;
+    let [i, a] = Qt(
+      r.position,
+      r.src.text
+    );
+    return {
+      __brand: e.__brand,
+      type: e.type,
+      message: e.message,
+      offset: r.position,
+      length: o,
+      lineNum: i,
+      linePos: a,
+      module: {
+        url: r.src.path ?? "",
+        text: r.src.text
+      }
+    };
+  }
+}
+function ui(t, e) {
+  if (t.messages.length === 0) return null;
+  let n = `Compilation log for [Invalid ShaderModule (${e.label || "unlabled"})]:
+`, r = t.messages.filter(
+    (s) => s.type === "error"
+  ).length;
+  r > 0 && (n += `${r} error(s) generated while compiling the shader:
+`);
+  for (const s of t.messages) {
+    const { lineNum: o, linePos: i } = s;
+    n += `${s.module.url}:${o}:${i}`, n += ` ${s.type}: ${s.message}
+`;
+    const a = s.module.text;
+    a && (n += De(a, [
+      s.offset,
+      s.offset + s.length
+    ]).join(`
+`));
+  }
+  return n;
+}
+function di(t) {
+  const n = t.split("/").filter((s) => s !== "."), r = [];
+  return n.forEach((s) => {
+    s !== "" && (s === ".." && r.length && r[r.length - 1] !== ".." ? r.pop() : r.push(s));
+  }), r.join("/");
+}
+function fi(t) {
+  const e = t.lastIndexOf("/"), n = e === -1 ? 0 : e + 1, r = t.indexOf(".", n), s = r === -1 ? t.length : r;
+  return t.slice(0, s);
+}
+function pi() {
+  return Tr(), { modules: {} };
+}
+function Gi(t) {
+  return `modules: ${[...Object.keys(t.modules)]}`;
+}
+function Xi(t) {
+  const e = Object.entries(t).map(([n, r]) => {
+    const s = To(r);
+    return [n, s];
+  });
+  return { modules: Object.fromEntries(e) };
+}
+function mi(t, e, n = "package") {
+  let r;
+  return e.includes("::") ? r = e : e.includes("/") || e.endsWith(".wesl") || e.endsWith(".wgsl") ? r = Bn(e, n) : r = n + "::" + e, t.modules[r];
+}
+function Rn(t, e, n = "package", r) {
+  r === void 0 ? r = "" : r.endsWith("/") || (r += "/"), Object.entries(t).map(
+    ([o, i]) => ({ modulePath: Bn(o, n), debugFilePath: r + o, src: i })
+  ).forEach((o) => {
+    const i = ce(o);
+    if (e.modules[o.modulePath])
+      throw new Error(`duplicate module path: '${o.modulePath}'`);
+    e.modules[o.modulePath] = i;
+  });
+}
+function hi(t, e) {
+  t.forEach(
+    ({ modules: n, name: r }) => Rn(n, e, r)
+  );
+}
+const gi = /^lib\.w[eg]sl$/i;
+function Bn(t, e) {
+  if (t.includes("::"))
+    return t;
+  if (e !== "package" && gi.test(t))
+    return e;
+  const r = fi(di(t)).replaceAll("/", "::");
+  return e + "::" + r;
+}
+async function Ji(t) {
+  const { weslSrc: e, debugWeslRoot: n, libs: r = [] } = t, s = pi();
+  return Rn(e, s, "package", n), hi(r, s), new li(bi({ registry: s, ...t }));
+}
+function bi(t) {
+  const e = xi(t), { transformedAst: n, newDecls: r, newStatements: s } = e;
+  return ht.build(
+    yi(
+      n.moduleElem,
+      n.srcModule,
+      r,
+      s,
+      t.conditions
+    )
+  );
+}
+function xi(t) {
+  const { registry: e, mangler: n } = t, { rootModuleName: r = "main", conditions: s = {} } = t, o = _i(e, r), { constants: i, config: a } = t;
+  let { virtualLibs: l } = t;
+  i && (l = { ...l, constants: ki(i) });
+  let c = l && Sr(l, (U) => ({ fn: U }));
+  const p = Ro({ rootAst: o, registry: e, conditions: s, virtuals: c, mangler: n }), { globalNames: h, decls: x, newStatements: P } = p;
+  return { transformedAst: vi(o, h, a), newDecls: x, newStatements: P };
+}
+function ki(t) {
+  return () => Object.entries(t).map(([e, n]) => `const ${e} = ${n};`).join(`
+`);
+}
+function _i(t, e) {
+  const n = mi(t, e);
+  if (!n)
+    throw new Error(`Root module not found: ${e}`);
+  return n;
+}
+function vi(t, e, n) {
+  const { moduleElem: r, srcModule: s } = t, o = { moduleElem: r, srcModule: s, globalNames: e, notableElems: {} }, i = (n == null ? void 0 : n.plugins) ?? [];
+  return Zt(i, (c) => c.transform).reduce(
+    (c, d) => d(c),
+    o
+  );
+}
+function yi(t, e, n, r, s = {}) {
+  const o = r.map((l) => {
+    const { elem: c, srcModule: d } = l, { src: p, debugFilePath: h } = d, x = new ht({ text: p, path: h });
+    return Lt(x, [c], s), x.addNl(), x;
+  }), i = new ht({
+    text: e.src,
+    path: e.debugFilePath
+  });
+  Lt(i, [t], s, !1);
+  const a = n.map((l) => {
+    const c = new ht({
+      text: l.srcModule.src,
+      path: l.srcModule.debugFilePath
+    });
+    return Lt(c, [l.declElem], s), c;
+  });
+  return [...o, i, ...a];
+}
+function In(t, e) {
+  e(t), t.contents && t.contents.forEach((r) => In(r, e));
+}
+function Ei(t) {
+  const { kind: e } = t.attribute;
+  if (e === "@attribute") {
+    const { params: n } = t.attribute;
+    return n === void 0 || n.length === 0 ? "@" + t.attribute.name : `@${t.attribute.name}(${n.map((r) => pe(r)).join(", ")})`;
+  } else {
+    if (e === "@builtin")
+      return "@builtin(" + t.attribute.param.name + ")";
+    if (e === "@diagnostic")
+      return "@diagnostic" + mt(t.attribute.severity, t.attribute.rule);
+    if (e === "@if")
+      return `@if(${D(t.attribute.param.expression)})`;
+    if (e === "@interpolate")
+      return `@interpolate(${t.attribute.params.map((n) => n.name).join(", ")})`;
+    j(e);
+  }
+}
+function Bt(t) {
+  return `<${t.map(Ln).join(", ")}>`;
+}
+function Ln(t) {
+  if (t === void 0) return "?";
+  if (typeof t == "string") return t;
+  if (t.kind === "expression") return pe(t);
+  if (t.kind === "type") return Si(t);
+  j(t);
+}
+function Si(t) {
+  if (!t) return "?";
+  const { name: e, templateParams: n } = t, r = n ? Bt(n) : "";
+  return `${jn(e)}${r}`;
+}
+function jn(t) {
+  if (typeof t == "string") return t;
+  if (t.std) return t.originalName;
+  const e = St(t);
+  return e.mangledName || e.originalName;
+}
+function pe(t) {
+  if (t.kind === "translate-time-expression")
+    throw new Error("Not supported");
+  if (t.kind === "expression" || t.kind === "stuff")
+    return t.contents.map((n) => {
+      const { kind: r } = n;
+      return r === "text" ? n.srcModule.src.slice(n.start, n.end) : r === "ref" ? jn(n.ident) : `?${n.kind}?`;
+    }).join(" ");
+  if (t.kind === "name")
+    return t.name;
+  j(t);
+}
+const wi = Mt(En);
+Mt(vn);
+Mt(yn);
+function Ki() {
+  return {
+    transform: Ti
+  };
+}
+function Ti(t) {
+  const e = structuredClone(t), { moduleElem: n, globalNames: r, notableElems: s } = e, o = Mi(n);
+  Pi(n, o);
+  const i = o.flatMap(
+    (c) => Ri(c, r)
+  ), a = ji(n);
+  a.forEach(
+    ({ memberRef: c, struct: d }) => Fi(c, d)
+  ), a.forEach(
+    ({ intermediates: c }) => c.forEach((d) => d.contents = [])
+  );
+  const l = Ni(n);
+  return n.contents = [...i, ...l], s.bindingStructs = o, { ...e, moduleElem: n };
+}
+function Pi(t, e) {
+  const n = t.contents.filter((s) => s.kind === "fn"), r = $i(n, e);
+  if (r) {
+    const { fn: s, struct: o } = r;
+    o.entryFn = s;
+  }
+}
+function $i(t, e) {
+  var n, r, s;
+  for (const o of t) {
+    const { params: i } = o;
+    for (const a of i) {
+      const l = (r = (n = a.name) == null ? void 0 : n.typeRef) == null ? void 0 : r.name, c = (s = l == null ? void 0 : l.refersTo) == null ? void 0 : s.declElem, d = e.find((p) => p === c);
+      if (d)
+        return { fn: o, struct: d };
+    }
+  }
+}
+function Ni(t) {
+  return t.contents.filter(
+    (e) => e.kind !== "struct" || !e.bindingStruct
+  );
+}
+function Mi(t) {
+  const n = t.contents.filter((r) => r.kind === "struct").filter(Ci);
+  return n.forEach((r) => r.bindingStruct = !0), n;
+}
+function Ci(t) {
+  return t.members.some(({ attributes: e }) => Ai(e));
+}
+function Ai(t) {
+  return t ? t.some(
+    ({ attribute: e }) => e.kind === "@attribute" && (e.name === "binding" || e.name === "group")
+  ) : !1;
+}
+function Ri(t, e) {
+  return t.members.map((n) => {
+    var h;
+    const { typeRef: r, name: s } = n, { name: o } = r, i = r == null ? void 0 : r.templateParams, a = Je(s.name, e);
+    n.mangledVarName = a, e.add(a);
+    const l = ((h = n.attributes) == null ? void 0 : h.map(Ei).join(" ")) ?? "", c = Bi(n, o, i) ?? Ii(o, i) ?? Li(o, i);
+    if (!c)
+      return console.log("unhandled case transforming member", o), Ne(l, a, "", "??");
+    const { storage: d, varType: p } = c;
+    return Ne(l, a, d, p);
+  });
+}
+function Bi(t, e, n, r) {
+  if (e.originalName === "ptr") {
+    const s = n ?? [], o = [s[0]];
+    s[2] && o.push(s[2]);
+    const i = Bt(o), a = Ln(s == null ? void 0 : s[1]);
+    return { storage: i, varType: a };
+  }
+}
+function Ii(t, e) {
+  if (typeof t != "string") {
+    const n = t.std ? t.originalName : "??", r = e ? Bt(e) : "";
+    return { varType: n + r, storage: "" };
+  }
+}
+function Li(t, e) {
+  if (wi.test(t.originalName)) {
+    const n = e ? Bt(e) : "";
+    return { varType: t + n, storage: "" };
+  }
+}
+function Ne(t, e, n, r) {
+  return {
+    kind: "synthetic",
+    text: `${t} var${n} ${e} : ${r};
+`
+  };
+}
+function ji(t) {
+  const e = [];
+  return In(t, (n) => {
+    n.kind === "memberRef" && e.push(n);
+  }), Zt(e, Di);
+}
+function Di(t) {
+  const e = Oi(t.name.ident);
+  if (e && e.struct.bindingStruct)
+    return { memberRef: t, ...e };
+}
+function Oi(t) {
+  const n = St(t).declElem;
+  if (n && n.kind === "param") {
+    const r = n.name.typeRef.name;
+    if (typeof r != "string") {
+      if (r.std)
+        return;
+      const o = St(r).declElem;
+      return (o == null ? void 0 : o.kind) === "struct" ? { struct: o, intermediates: [n] } : void 0;
+    }
+  }
+}
+function Fi(t, e) {
+  const n = t.member.name, r = e.members.find((l) => l.name.name === n);
+  if (!r || !r.mangledVarName)
+    return { kind: "synthetic", text: n };
+  const { extraComponents: s } = t, o = s ? pe(s) : "", a = { kind: "synthetic", text: r.mangledVarName + o };
+  return t.contents = [a], a;
+}
+export {
+  li as LinkedWesl,
+  wo as WeslParseError,
+  hs as WeslStream,
+  wt as astToString,
+  si as attributeToString,
+  xi as bindAndTransform,
+  Ki as bindingStructsPlugin,
+  _n as blankWeslParseState,
+  ci as debugContentsToString,
+  ji as findRefsToBindingStructs,
+  Po as flatImports,
+  Ct as identToString,
+  Ji as link,
+  bi as linkRegistry,
+  Ti as lowerBindingStructs,
+  Vi as makeWeslDevice,
+  Mi as markBindingStructs,
+  Pi as markEntryTypes,
+  fi as noSuffix,
+  di as normalize,
+  Rn as parseIntoRegistry,
+  hi as parseLibsIntoRegistry,
+  ce as parseSrcModule,
+  To as parseWESL,
+  Xi as parseWeslSrc,
+  pi as parsedRegistry,
+  Gi as registryToString,
+  Ge as scopeToString,
+  Wi as scopeToStringLong,
+  mi as selectModule,
+  zi as syntheticWeslParseState,
+  kn as throwClickableError,
+  Fi as transformBindingReference,
+  Ri as transformBindingStruct
+};
+//# sourceMappingURL=minified.js.map