@wonderyard/vivarium 0.1.0

package/dist/webgpu/setup.js

@@ -0,0 +1,4348 @@
+import { a as Pa, j as Sa, U as Q, o as Ia, c as mn, C as ka, u as Ma, p as Aa, b as Ft, l as Et, s as Oa, K as Qt, r as Ga, d as Ba, V as $e, e as re, h as D, Z as lr, f as Oe, t as kr, g as Mr } from "../compiler-CEYR17Vv.js";
+import { a8 as de, $ as Ae, a9 as We, U as f, aa as Fa, ab as Ca, ac as Na, ad as La, ae as Da, af as Wa, ag as za, ah as ze, ai as J, l as Ya, aj as yn, m as Ra, F as Re, p as dr, w as cr, ak as qa, al as ja, J as pr, T as wn, am as gn, x as bn, d as Va, f as ut, u as lt, e as ie, y as be, an as vn, ao as _n, ap as xn, aq as Ja, c as Za, ar as Tn, as as Xa, at as Qa, au as Ka, av as Ha, aw as es, ax as ts, ay as rs, az as ns, aA as as, aB as ss, aC as is, aD as os, aE as us, aF as ls, aG as ds, aH as cs, aI as ps, aJ as hs, aK as fs, aL as ms, aM as ys, aN as $n, aO as ws, V as m, aP as gs, aQ as bs, aR as vs, aS as _s, aT as xs, aU as Ts, aV as $s, aW as Es, aX as Us, aY as Ps, aZ as Ss, a_ as Is, a$ as ks, b0 as Ms, b1 as As, b2 as Os, b3 as Gs, b4 as Bs, b5 as En, b6 as _, b7 as Ke, b8 as K, a3 as ne, b9 as Un, ba as S, bb as He, bc as Ue, R as Ut, bd as Pn, X as O, be as et, bf as te, bg as ue, bh as Fs, bi as Sn, i as c, bj as j, t as g, h as F, bk as Cs, bl as Ar, bm as Me, bn as Or, bo as Gr, bp as Ns, N as ht, bq as Ls, I as Ds, br as Ws, H as Vt, bs as Pt, bt as zs, bu as tt, bv as C, bw as hr, bx as St, by as Br, bz as rt, bA as Y, bB as Ys, bC as In, bD as Pe, bE as Ct, bF as d, o as u, bG as Rs, Y as qs, bH as js, W as Vs, bI as Js, bJ as Zs, bK as p, a as kn, bL as Fr, bM as Nt, bN as fr, bO as Mn, bP as Xs, bQ as Qs, bR as Ks, bS as Hs, bT as Kt, bU as De, D as ei, bV as Cr, bW as Nr, B as ti, bX as ri, bY as ni, bZ as ai, b_ as Lr, b$ as It, c0 as E, q as M, c1 as Z, c2 as ft, E as Dr, c3 as kt, Q as mr, k as A, c4 as yr, c5 as wr, c6 as gr, c7 as br, c8 as si, c9 as vr, r as I, j as An, ca as ii, cb as oi, cc as ui, cd as li, ce as di, cf as Ht, a6 as _e, A as Ve, a4 as Wr, a5 as ci, a2 as pi, a1 as hi } from "../constants-Ry69vZz5.js";
+const W = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Void: de,
+  align: Pa,
+  alignmentOf: Sa,
+  arrayOf: Q,
+  atomic: Ia,
+  bool: Ae,
+  builtin: mn,
+  disarrayOf: ka,
+  f16: We,
+  f32: f,
+  float16: Fa,
+  float16x2: Ca,
+  float16x4: Na,
+  float32: La,
+  float32x2: Da,
+  float32x3: Wa,
+  float32x4: za,
+  formatToWGSLType: ze,
+  i32: J,
+  interpolate: Ma,
+  invariant: Aa,
+  isAlignAttrib: Ya,
+  isAtomic: yn,
+  isBuiltin: Ft,
+  isBuiltinAttrib: Ra,
+  isData: Re,
+  isDecorated: dr,
+  isDisarray: cr,
+  isInterpolateAttrib: qa,
+  isLocationAttrib: ja,
+  isLooseData: pr,
+  isLooseDecorated: wn,
+  isPackedData: gn,
+  isPtr: bn,
+  isSizeAttrib: Va,
+  isUnstruct: ut,
+  isWgslArray: lt,
+  isWgslData: ie,
+  isWgslStruct: be,
+  location: Et,
+  mat2x2f: vn,
+  mat3x3f: _n,
+  mat4x4f: xn,
+  matToArray: Ja,
+  packedFormats: Za,
+  ptrFn: Tn,
+  ptrHandle: Xa,
+  ptrPrivate: Qa,
+  ptrStorage: Ka,
+  ptrUniform: Ha,
+  ptrWorkgroup: es,
+  sint16: ts,
+  sint16x2: rs,
+  sint16x4: ns,
+  sint32: as,
+  sint32x2: ss,
+  sint32x3: is,
+  sint32x4: os,
+  sint8: us,
+  sint8x2: ls,
+  sint8x4: ds,
+  size: Oa,
+  sizeOf: Qt,
+  snorm16: cs,
+  snorm16x2: ps,
+  snorm16x4: hs,
+  snorm8: fs,
+  snorm8x2: ms,
+  snorm8x4: ys,
+  struct: $n,
+  u16: ws,
+  u32: m,
+  uint16: gs,
+  uint16x2: bs,
+  uint16x4: vs,
+  uint32: _s,
+  uint32x2: xs,
+  uint32x3: Ts,
+  uint32x4: $s,
+  uint8: Es,
+  uint8x2: Us,
+  uint8x4: Ps,
+  unorm10_10_10_2: Ss,
+  unorm16: Is,
+  unorm16x2: ks,
+  unorm16x4: Ms,
+  unorm8: As,
+  unorm8x2: Os,
+  unorm8x4: Gs,
+  unorm8x4_bgra: Bs,
+  unstruct: Ga,
+  vec2b: En,
+  vec2f: _,
+  vec2h: Ke,
+  vec2i: K,
+  vec2u: ne,
+  vec3b: Un,
+  vec3f: S,
+  vec3h: He,
+  vec3i: Ue,
+  vec3u: Ut,
+  vec4b: Pn,
+  vec4f: O,
+  vec4h: et,
+  vec4i: te,
+  vec4u: ue
+}, Symbol.toStringTag, { value: "Module" }));
+var On = Object.defineProperty, fi = (e, t, r) => t in e ? On(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, mi = (e, t) => {
+  for (var r in t)
+    On(e, r, { get: t[r], enumerable: !0 });
+}, U = (e, t, r) => fi(e, typeof t != "symbol" ? t + "" : t, r), yi = {};
+mi(yi, {
+  BufferReader: () => Ee,
+  BufferWriter: () => Se,
+  MaxValue: () => R,
+  Measurer: () => N,
+  UnresolvedReferenceError: () => ke,
+  ValidationError: () => Lt,
+  arrayOf: () => _i,
+  bool: () => Ti,
+  byte: () => Ii,
+  chars: () => Yi,
+  concat: () => Vi,
+  dynamicArrayOf: () => Zi,
+  f16: () => Li,
+  f32: () => Wi,
+  f32Array: () => po,
+  f64Array: () => ho,
+  generic: () => qi,
+  genericEnum: () => ji,
+  i16: () => Mi,
+  i16Array: () => lo,
+  i32: () => Bi,
+  i32Array: () => co,
+  i8: () => Pi,
+  i8Array: () => uo,
+  keyed: () => Ki,
+  object: () => Ri,
+  optional: () => eo,
+  string: () => Ei,
+  tupleOf: () => no,
+  u16: () => Oi,
+  u16Array: () => io,
+  u32: () => Ci,
+  u32Array: () => oo,
+  u8: () => Nn,
+  u8Array: () => ao,
+  u8ClampedArray: () => so
+});
+var ke = class Gn extends Error {
+  constructor(t) {
+    super(t), Object.setPrototypeOf(this, Gn.prototype);
+  }
+}, Lt = class Bn extends Error {
+  constructor(t) {
+    super(t), Object.setPrototypeOf(this, Bn.prototype);
+  }
+}, wi = class {
+  constructor() {
+    U(this, "size", Number.NaN), U(this, "unbounded", this), U(this, "isUnbounded", !0);
+  }
+  add() {
+    return this;
+  }
+  fork() {
+    return this;
+  }
+}, gi = new wi(), N = class Fn {
+  constructor() {
+    U(this, "size", 0), U(this, "unbounded", gi), U(this, "isUnbounded", !1);
+  }
+  add(t) {
+    return this.size += t, this;
+  }
+  fork() {
+    const t = new Fn();
+    return t.size = this.size, t;
+  }
+}, R = Symbol(
+  "The biggest (in amount of bytes needed) value a schema can represent"
+), X = class {
+  constructor() {
+    U(this, "__unwrapped");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  resolveReferences(e) {
+  }
+  seekProperty(e, t) {
+    return null;
+  }
+}, bi = class {
+  constructor(e) {
+    this.key = e;
+  }
+}, Ze = {
+  STRING: "string",
+  ENUM: "enum"
+}, vi = class extends X {
+  constructor(e, t) {
+    super(), this._unstableElementSchema = e, this.length = t, U(this, "elementSchema"), this.elementSchema = e;
+  }
+  resolveReferences(e) {
+    this.elementSchema = e.resolve(this._unstableElementSchema);
+  }
+  write(e, t) {
+    if (t.length !== this.length)
+      throw new Lt(
+        `Expected array of length ${this.length}, got ${t.length}`
+      );
+    for (const r of t)
+      this.elementSchema.write(e, r);
+  }
+  read(e) {
+    const t = [];
+    for (let r = 0; r < this.length; ++r)
+      t.push(this.elementSchema.read(e));
+    return t;
+  }
+  /**
+   * Returns the maximum number of bytes this schema can take up.
+   *
+   * Returns `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize() {
+    return this.elementSchema.measure(R).size * this.length;
+  }
+  measure(e, t = new N()) {
+    for (let r = 0; r < this.length; ++r)
+      this.elementSchema.measure(
+        e === R ? R : e[r],
+        t
+      );
+    return t;
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function _i(e, t) {
+  return new vi(e, t);
+}
+var xi = class extends X {
+  constructor() {
+    super(...arguments), U(this, "maxSize", 1);
+  }
+  read(e) {
+    return e.readBool();
+  }
+  write(e, t) {
+    e.writeBool(t);
+  }
+  measure(e, t = new N()) {
+    return t.add(1);
+  }
+}, Ti = new xi(), Cn = class Je extends X {
+  static get _encoder() {
+    return Je._cachedEncoder || (Je._cachedEncoder = new TextEncoder()), Je._cachedEncoder;
+  }
+  read(t) {
+    return t.readString();
+  }
+  write(t, r) {
+    t.writeString(r);
+  }
+  measure(t, r = new N()) {
+    if (t === R)
+      return r.unbounded;
+    const n = Je._encoder.encode(t);
+    return r.add(n.byteLength + 1);
+  }
+};
+U(Cn, "_cachedEncoder");
+var $i = Cn, Ei = new $i(), Ui = class extends X {
+  constructor() {
+    super(...arguments), U(this, "maxSize", 1);
+  }
+  read(e) {
+    return e.readInt8();
+  }
+  write(e, t) {
+    e.writeInt8(t);
+  }
+  measure(e, t = new N()) {
+    return t.add(1);
+  }
+}, Pi = new Ui(), Si = class extends X {
+  constructor() {
+    super(...arguments), U(this, "maxSize", 1);
+  }
+  read(e) {
+    return e.readUint8();
+  }
+  write(e, t) {
+    e.writeUint8(t);
+  }
+  measure(e, t = new N()) {
+    return t.add(1);
+  }
+}, Nn = new Si(), Ii = Nn, ki = class extends X {
+  constructor() {
+    super(...arguments), U(this, "maxSize", 2);
+  }
+  read(e) {
+    return e.readInt16();
+  }
+  write(e, t) {
+    e.writeInt16(t);
+  }
+  measure(e, t = new N()) {
+    return t.add(2);
+  }
+}, Mi = new ki(), Ai = class extends X {
+  constructor() {
+    super(...arguments), U(this, "maxSize", 2);
+  }
+  read(e) {
+    return e.readUint16();
+  }
+  write(e, t) {
+    e.writeUint16(t);
+  }
+  measure(e, t = new N()) {
+    return t.add(2);
+  }
+}, Oi = new Ai(), Gi = class extends X {
+  constructor() {
+    super(...arguments), U(this, "maxSize", 4);
+  }
+  read(e) {
+    return e.readInt32();
+  }
+  write(e, t) {
+    e.writeInt32(t);
+  }
+  measure(e, t = new N()) {
+    return t.add(4);
+  }
+}, Bi = new Gi(), Fi = class extends X {
+  constructor() {
+    super(...arguments), U(this, "maxSize", 4);
+  }
+  read(e) {
+    return e.readUint32();
+  }
+  write(e, t) {
+    e.writeUint32(t);
+  }
+  measure(e, t = new N()) {
+    return t.add(4);
+  }
+}, Ci = new Fi(), Ni = class extends X {
+  constructor() {
+    super(...arguments), U(this, "maxSize", 2);
+  }
+  read(e) {
+    return e.readFloat16();
+  }
+  write(e, t) {
+    e.writeFloat16(t);
+  }
+  measure(e, t = new N()) {
+    return t.add(2);
+  }
+}, Li = new Ni(), Di = class extends X {
+  constructor() {
+    super(...arguments), U(this, "maxSize", 4);
+  }
+  read(e) {
+    return e.readFloat32();
+  }
+  write(e, t) {
+    e.writeFloat32(t);
+  }
+  measure(e, t = new N()) {
+    return t.add(4);
+  }
+}, Wi = new Di(), zi = class extends X {
+  constructor(e) {
+    super(), this.length = e;
+  }
+  write(e, t) {
+    if (t.length !== this.length)
+      throw new Lt(
+        `Expected char-string of length ${this.length}, got ${t.length}`
+      );
+    for (let r = 0; r < t.length; ++r)
+      e.writeUint8(t.charCodeAt(r));
+  }
+  read(e) {
+    let t = "";
+    for (let r = 0; r < this.length; ++r)
+      t += String.fromCharCode(e.readByte());
+    return t;
+  }
+  measure(e, t = new N()) {
+    return t.add(this.length);
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function Yi(e) {
+  return new zi(e);
+}
+// @__NO_SIDE_EFFECTS__
+function Te(e) {
+  return Object.entries(e);
+}
+// @__NO_SIDE_EFFECTS__
+function Ln(e, t) {
+  const r = {};
+  for (const [n, a] of /* @__PURE__ */ Te(t))
+    r[n] = e.resolve(a);
+  return r;
+}
+var _r = class extends X {
+  constructor(e) {
+    super(), this._properties = e, U(this, "properties"), this.properties = e;
+  }
+  resolveReferences(e) {
+    this.properties = /* @__PURE__ */ Ln(e, this._properties);
+  }
+  write(e, t) {
+    for (const [r, n] of /* @__PURE__ */ Te(this.properties))
+      n.write(e, t[r]);
+  }
+  read(e) {
+    const t = {};
+    for (const [r, n] of /* @__PURE__ */ Te(this.properties))
+      t[r] = n.read(e);
+    return t;
+  }
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Is `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize() {
+    const e = new N();
+    for (const t of Object.values(this.properties))
+      t.measure(R, e);
+    return e.size;
+  }
+  measure(e, t = new N()) {
+    for (const [r, n] of /* @__PURE__ */ Te(this.properties))
+      n.measure(
+        e === R ? R : e[r],
+        t
+      );
+    return t;
+  }
+  seekProperty(e, t) {
+    let r = 0;
+    for (const [n, a] of /* @__PURE__ */ Te(this.properties)) {
+      if (n === t)
+        return {
+          bufferOffset: r,
+          schema: a
+        };
+      r += a.measure(e).size;
+    }
+    return null;
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function Ri(e) {
+  return new _r(e);
+}
+var Dn = class extends X {
+  constructor(e, t, r) {
+    super(), this.keyedBy = e, this._subTypeMap = r, U(this, "_baseObject"), U(this, "subTypeMap"), this._baseObject = new _r(t), this.subTypeMap = r;
+  }
+  resolveReferences(e) {
+    this._baseObject.resolveReferences(e), this.subTypeMap = /* @__PURE__ */ Ln(e, this._subTypeMap);
+  }
+  write(e, t) {
+    const r = t.type, n = this.subTypeMap[r] || null;
+    if (n === null)
+      throw new Error(
+        `Unknown sub-type '${r.toString()}' in among '${JSON.stringify(
+          Object.keys(this.subTypeMap)
+        )}'`
+      );
+    this.keyedBy === Ze.ENUM ? e.writeUint8(t.type) : e.writeString(t.type), this._baseObject.write(e, t);
+    for (const [a, s] of /* @__PURE__ */ Te(
+      n.properties
+    ))
+      s.write(e, t[a]);
+  }
+  read(e) {
+    const t = this.keyedBy === Ze.ENUM ? e.readByte() : e.readString(), r = this.subTypeMap[t] || null;
+    if (r === null)
+      throw new Error(
+        `Unknown sub-type '${t}' in among '${JSON.stringify(
+          Object.keys(this.subTypeMap)
+        )}'`
+      );
+    const n = this._baseObject.read(e);
+    if (n.type = t, r !== null)
+      for (const [a, s] of /* @__PURE__ */ Te(
+        r.properties
+      ))
+        n[a] = s.read(e);
+    return n;
+  }
+  measure(e, t = new N()) {
+    if (this._baseObject.measure(
+      e,
+      t
+    ), this.keyedBy === Ze.ENUM)
+      t.add(1);
+    else if (e !== R)
+      t.add(e.type.length + 1);
+    else
+      return t.unbounded;
+    if (e === R) {
+      const r = Object.values(this.subTypeMap).map((n) => {
+        const a = t.fork();
+        for (const s of Object.values(n.properties))
+          s.measure(R, a);
+        return [n, a.size];
+      }).reduce((n, a) => n[1] > a[1] ? n : a)[0];
+      for (const n of Object.values(r.properties))
+        n.measure(R, t);
+    } else {
+      const r = e.type, n = this.subTypeMap[r] || null;
+      if (n === null)
+        throw new Error(
+          `Unknown sub-type '${r.toString()}', expected one of '${JSON.stringify(
+            Object.keys(this.subTypeMap)
+          )}'`
+        );
+      for (const [a, s] of /* @__PURE__ */ Te(n.properties))
+        s.measure(e[a], t);
+    }
+    return t;
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function qi(e, t) {
+  return new Dn(Ze.STRING, e, t);
+}
+// @__NO_SIDE_EFFECTS__
+function ji(e, t) {
+  return new Dn(Ze.ENUM, e, t);
+}
+// @__NO_SIDE_EFFECTS__
+function Vi(e) {
+  return new _r(
+    Object.fromEntries(
+      e.flatMap(({ properties: t }) => Object.entries(t))
+    )
+  );
+}
+var Ji = class extends X {
+  constructor(e) {
+    super(), this._unstableElementType = e, U(this, "elementType"), this.elementType = e;
+  }
+  resolveReferences(e) {
+    this.elementType = e.resolve(this._unstableElementType);
+  }
+  write(e, t) {
+    e.writeUint32(t.length);
+    for (const r of t)
+      this.elementType.write(e, r);
+  }
+  read(e) {
+    const t = [], r = e.readUint32();
+    for (let n = 0; n < r; ++n)
+      t.push(this.elementType.read(e));
+    return t;
+  }
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Is `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize() {
+    return this.measure(R).size;
+  }
+  measure(e, t = new N()) {
+    if (e === R)
+      return t.unbounded;
+    t.add(4);
+    for (const r of e)
+      this.elementType.measure(r, t);
+    return t;
+  }
+  seekProperty(e, t) {
+    if (typeof t == "symbol")
+      return null;
+    const r = Number.parseInt(String(t), 10);
+    if (Number.isNaN(r))
+      return null;
+    if (e === R)
+      return {
+        bufferOffset: this.elementType.measure(R).size * r,
+        schema: this.elementType
+      };
+    if (r >= e.length)
+      return null;
+    const n = new N();
+    for (let a = 0; a < r; ++a)
+      this.elementType.measure(e[a], n);
+    return {
+      bufferOffset: n.size,
+      schema: this.elementType
+    };
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function Zi(e) {
+  return new Ji(e);
+}
+var Wn = class {
+  constructor(e) {
+    U(this, "__unwrapped"), U(this, "ref"), this.ref = new bi(e);
+  }
+  resolveReferences() {
+    throw new ke(
+      "Tried to resolve a reference directly. Do it through a RefResolver instead."
+    );
+  }
+  read() {
+    throw new ke(
+      "Tried to read a reference directly. Resolve it instead."
+    );
+  }
+  write() {
+    throw new ke(
+      "Tried to write a reference directly. Resolve it instead."
+    );
+  }
+  measure() {
+    throw new ke(
+      "Tried to measure size of a reference directly. Resolve it instead."
+    );
+  }
+  seekProperty() {
+    throw new ke(
+      "Tried to seek property of a reference directly. Resolve it instead."
+    );
+  }
+}, Xi = class {
+  constructor() {
+    U(this, "registry", {});
+  }
+  hasKey(e) {
+    return this.registry[e] !== void 0;
+  }
+  register(e, t) {
+    this.registry[e] = t;
+  }
+  resolve(e) {
+    if (e instanceof Wn) {
+      const r = e.ref.key;
+      if (this.registry[r] !== void 0)
+        return this.registry[r];
+      throw new ke(
+        `Couldn't resolve reference to ${r}. Unknown key.`
+      );
+    }
+    return e.resolveReferences(this), e;
+  }
+}, Qi = class {
+  constructor(e, t) {
+    this.key = e, U(this, "__unwrapped"), U(this, "__keyDefinition"), U(this, "innerType"), this.innerType = t(new Wn(e)), this.resolveReferences(new Xi());
+  }
+  resolveReferences(e) {
+    e.hasKey(this.key) || (e.register(this.key, this.innerType), this.innerType.resolveReferences(e));
+  }
+  read(e) {
+    return this.innerType.read(e);
+  }
+  write(e, t) {
+    this.innerType.write(e, t);
+  }
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Is `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize() {
+    return this.measure(R).size;
+  }
+  measure(e, t = new N()) {
+    return this.innerType.measure(e, t);
+  }
+  seekProperty(e, t) {
+    return this.innerType.seekProperty(e, t);
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function Ki(e, t) {
+  return new Qi(e, t);
+}
+var Hi = class extends X {
+  constructor(e) {
+    super(), this._innerUnstableSchema = e, U(this, "innerSchema"), this.innerSchema = e;
+  }
+  resolveReferences(e) {
+    this.innerSchema = e.resolve(this._innerUnstableSchema);
+  }
+  write(e, t) {
+    t != null ? (e.writeBool(!0), this.innerSchema.write(e, t)) : e.writeBool(!1);
+  }
+  read(e) {
+    if (e.readBool())
+      return this.innerSchema.read(e);
+  }
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Is `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize() {
+    return this.measure(R).size;
+  }
+  measure(e, t = new N()) {
+    return e !== void 0 && this.innerSchema.measure(e, t), t.add(1);
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function eo(e) {
+  return new Hi(e);
+}
+// @__NO_SIDE_EFFECTS__
+function to(e, t) {
+  return t.map((r) => e.resolve(r));
+}
+var ro = class extends X {
+  constructor(e) {
+    super(), this._unstableSchemas = e, U(this, "schemas"), this.schemas = e;
+  }
+  resolveReferences(e) {
+    this.schemas = /* @__PURE__ */ to(e, this._unstableSchemas);
+  }
+  write(e, t) {
+    if (t.length !== this.schemas.length)
+      throw new Lt(
+        `Expected tuple of length ${this.schemas.length}, got ${t.length}`
+      );
+    for (let r = 0; r < this.schemas.length; ++r)
+      this.schemas[r].write(e, t[r]);
+  }
+  read(e) {
+    const t = [];
+    for (let r = 0; r < this.schemas.length; ++r)
+      t.push(
+        this.schemas[r].read(e)
+      );
+    return t;
+  }
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Is `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize() {
+    return this.measure(R).size;
+  }
+  measure(e, t = new N()) {
+    for (let r = 0; r < this.schemas.length; ++r)
+      this.schemas[r].measure(
+        e === R ? R : e[r],
+        t
+      );
+    return t;
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function no(e) {
+  return new ro(e);
+}
+var ve = class extends X {
+  constructor(e, t) {
+    super(), this.length = e, this._arrayConstructor = t, U(this, "byteLength"), this.byteLength = e * t.BYTES_PER_ELEMENT;
+  }
+  write(e, t) {
+    e.writeSlice(t);
+  }
+  read(e) {
+    const t = new ArrayBuffer(this.byteLength), r = new this._arrayConstructor(t, 0, this.length);
+    return e.readSlice(r, 0, this.byteLength), r;
+  }
+  measure(e, t = new N()) {
+    return t.add(this.byteLength);
+  }
+}, ao = /* @__NO_SIDE_EFFECTS__ */ (e) => new ve(e, Uint8Array), so = /* @__NO_SIDE_EFFECTS__ */ (e) => new ve(e, Uint8ClampedArray), io = /* @__NO_SIDE_EFFECTS__ */ (e) => new ve(e, Uint16Array), oo = /* @__NO_SIDE_EFFECTS__ */ (e) => new ve(e, Uint32Array), uo = /* @__NO_SIDE_EFFECTS__ */ (e) => new ve(e, Int8Array), lo = /* @__NO_SIDE_EFFECTS__ */ (e) => new ve(e, Int16Array), co = /* @__NO_SIDE_EFFECTS__ */ (e) => new ve(e, Int32Array), po = /* @__NO_SIDE_EFFECTS__ */ (e) => new ve(e, Float32Array), ho = /* @__NO_SIDE_EFFECTS__ */ (e) => new ve(e, Float64Array);
+// @__NO_SIDE_EFFECTS__
+function fo() {
+  const e = new Uint8Array(4), t = new Uint32Array(e.buffer);
+  return t[0] = 1, e[0] === 0;
+}
+// @__NO_SIDE_EFFECTS__
+function zn() {
+  return /* @__PURE__ */ fo() ? "big" : "little";
+}
+// @__NO_SIDE_EFFECTS__
+function xr(e) {
+  let t = 0, r = e;
+  return r && "buffer" in r && "byteOffset" in r && (t += r.byteOffset, r = r.buffer), { buffer: r, byteOffset: t, byteLength: e.byteLength };
+}
+var Yn = class {
+  constructor(e, t) {
+    U(this, "dataView"), U(this, "littleEndian"), U(this, "byteOffset", 0), U(this, "endianness");
+    const { byteOffset: r = 0, endianness: n = "system" } = t ?? {};
+    this.byteOffset = r;
+    const a = /* @__PURE__ */ zn();
+    this.endianness = n === "system" ? a : n, this.littleEndian = this.endianness === "little";
+    const s = /* @__PURE__ */ xr(e);
+    this.byteOffset += s.byteOffset, this.dataView = new DataView(s.buffer);
+  }
+  get currentByteOffset() {
+    return this.byteOffset;
+  }
+  seekTo(e) {
+    this.byteOffset = e;
+  }
+  skipBytes(e) {
+    this.byteOffset += e;
+  }
+};
+function mo(e) {
+  if (e === 0) return 0;
+  if (Number.isNaN(e)) return 32256;
+  if (!Number.isFinite(e)) return e > 0 ? 31744 : 64512;
+  const t = e < 0 ? 1 : 0, r = Math.abs(e), n = Math.floor(Math.log2(r)), a = r / 2 ** n - 1, s = n + 15, i = Math.floor(a * 1024);
+  return t << 15 | s << 10 | i;
+}
+function yo(e) {
+  const t = (e & 32768) >> 15, r = (e & 31744) >> 10, n = e & 1023;
+  return r === 0 ? t === 0 ? n / 1024 : -n / 1024 : r === 31 ? n === 0 ? t === 0 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY : Number.NaN : (t === 0 ? 1 : -1) * (1 + n / 1024) * 2 ** (r - 15);
+}
+var Ee = class extends Yn {
+  constructor() {
+    super(...arguments), U(this, "_cachedTextDecoder");
+  }
+  get _textDecoder() {
+    return this._cachedTextDecoder || (this._cachedTextDecoder = new TextDecoder(void 0, { fatal: !0 })), this._cachedTextDecoder;
+  }
+  readBool() {
+    return this.dataView.getUint8(this.byteOffset++) !== 0;
+  }
+  readByte() {
+    return this.dataView.getUint8(this.byteOffset++);
+  }
+  readInt8() {
+    return this.dataView.getInt8(this.byteOffset++);
+  }
+  readUint8() {
+    return this.dataView.getUint8(this.byteOffset++);
+  }
+  readInt16() {
+    const e = this.dataView.getInt16(this.byteOffset, this.littleEndian);
+    return this.byteOffset += 2, e;
+  }
+  readUint16() {
+    const e = this.dataView.getUint16(this.byteOffset, this.littleEndian);
+    return this.byteOffset += 2, e;
+  }
+  readInt32() {
+    const e = this.dataView.getInt32(this.byteOffset, this.littleEndian);
+    return this.byteOffset += 4, e;
+  }
+  readUint32() {
+    const e = this.dataView.getUint32(this.byteOffset, this.littleEndian);
+    return this.byteOffset += 4, e;
+  }
+  readFloat16() {
+    const e = this.dataView.getUint16(this.byteOffset, this.littleEndian);
+    return this.byteOffset += 2, yo(e);
+  }
+  readFloat32() {
+    const e = this.dataView.getFloat32(this.byteOffset, this.littleEndian);
+    return this.byteOffset += 4, e;
+  }
+  readString() {
+    let e = 0;
+    for (; this.byteOffset + e < this.dataView.byteLength && this.dataView.getUint8(this.byteOffset + e++) !== 0; )
+      ;
+    const t = this._textDecoder.decode(
+      new Uint8Array(this.dataView.buffer, this.byteOffset, e - 1)
+    );
+    return this.byteOffset += e, t;
+  }
+  readSlice(e, t, r) {
+    const n = /* @__PURE__ */ xr(e), a = new Uint8Array(
+      n.buffer,
+      n.byteOffset + t
+    );
+    for (let s = 0; s < r; ++s)
+      a[s] = this.dataView.getUint8(this.byteOffset++);
+  }
+}, Se = class extends Yn {
+  constructor() {
+    super(...arguments), U(this, "_cachedTextEncoder");
+  }
+  get _textEncoder() {
+    return this._cachedTextEncoder || (this._cachedTextEncoder = new TextEncoder()), this._cachedTextEncoder;
+  }
+  writeBool(e) {
+    this.dataView.setUint8(this.byteOffset++, e ? 1 : 0);
+  }
+  writeByte(e) {
+    this.dataView.setUint8(this.byteOffset++, e);
+  }
+  writeInt8(e) {
+    this.dataView.setInt8(this.byteOffset++, e);
+  }
+  writeUint8(e) {
+    this.dataView.setUint8(this.byteOffset++, e);
+  }
+  writeInt16(e) {
+    this.dataView.setInt16(this.byteOffset, e, this.littleEndian), this.byteOffset += 2;
+  }
+  writeUint16(e) {
+    this.dataView.setUint16(this.byteOffset, e, this.littleEndian), this.byteOffset += 2;
+  }
+  writeInt32(e) {
+    this.dataView.setInt32(this.byteOffset, e, this.littleEndian), this.byteOffset += 4;
+  }
+  writeUint32(e) {
+    this.dataView.setUint32(this.byteOffset, e, this.littleEndian), this.byteOffset += 4;
+  }
+  writeFloat16(e) {
+    this.dataView.setUint16(
+      this.byteOffset,
+      mo(e),
+      this.littleEndian
+    ), this.byteOffset += 2;
+  }
+  writeFloat32(e) {
+    this.dataView.setFloat32(this.byteOffset, e, this.littleEndian), this.byteOffset += 4;
+  }
+  writeString(e) {
+    const t = this._textEncoder.encodeInto(
+      e,
+      new Uint8Array(this.dataView.buffer, this.byteOffset)
+    );
+    this.byteOffset += t.written, this.dataView.setUint8(this.byteOffset++, 0);
+  }
+  writeSlice(e) {
+    const t = /* @__PURE__ */ xr(e), r = new Uint8Array(
+      t.buffer,
+      t.byteOffset,
+      t.byteLength
+    );
+    for (const n of r)
+      this.dataView.setUint8(this.byteOffset++, n);
+  }
+};
+function wo(e) {
+  if (typeof e?.[j] == "function") return e[j].bind(e);
+}
+var qe = { get(e, t) {
+  if (t in e) return Reflect.get(e, t);
+  if (t !== Me) return t === "toString" || t === Symbol.toStringTag || t === Symbol.toPrimitive ? () => e.toString() : new Proxy({ [c]: !0, "~resolve": (r) => `${r.resolve(e)}.${String(t)}`, toString: () => `.value(...).${String(t)}:${g(e) ?? "<unnamed>"}`, [C]: Vs(e[C], String(t)) }, qe);
+} };
+function Tr(e, t) {
+  let r = t, n;
+  for (; n = wo(r); ) r = n(e);
+  return r;
+}
+function go(e, t) {
+  return new bo(e, t);
+}
+var bo = class {
+  constructor(t, r) {
+    this.dataType = t, this.#e = r;
+  }
+  [c] = {};
+  #e;
+  $name(t) {
+    return F(this, t), this;
+  }
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), n = t.resolve(this.#e, this.dataType), a = t.resolve(this.dataType);
+    return t.addDeclaration(`const ${r}: ${a} = ${n};`), r;
+  }
+  toString() {
+    return `const:${g(this) ?? "<unnamed>"}`;
+  }
+  [j]() {
+    return new Proxy({ [c]: !0, "~resolve": (t) => t.resolve(this), toString: () => `.value:${g(this) ?? "<unnamed>"}`, [C]: this.dataType }, qe);
+  }
+  get value() {
+    return hr() ? this[j]() : this.#e;
+  }
+  get $() {
+    return this.value;
+  }
+};
+function Xe(e, t) {
+  for (let [r, n] of Object.entries(t)) e[r] = n, Ct(n) && g(n) === void 0 && n.$name(r);
+}
+function vo(e, t, r) {
+  let n = [...e.matchAll(/:\s*(?<arg>.*?)\s*[,)]/g)].map((a) => a ? a[1] : void 0);
+  r(Object.fromEntries(t.flatMap((a, s) => {
+    let i = n ? n[s] : void 0;
+    return be(a) && i !== void 0 ? [[i, a]] : [];
+  })));
+}
+function Rn(e, t, r) {
+  let n = e.match(/->\s(?<output>[\w\d_]+)\s{/), a = n ? n[1]?.trim() : void 0;
+  be(t) && a && !/\s/g.test(a) && r({ [a]: t });
+}
+function _o(e) {
+  return new RegExp(`(?<![\\w\\$_.])${e.replaceAll(".", "\\.").replaceAll("$", "\\$")}(?![\\w\\$_])`, "g");
+}
+function Dt(e, t, r) {
+  return Object.entries(t).reduce((n, [a, s]) => js(s) || pr(s) ? n.replaceAll(_o(a), e.resolve(s)) : s !== null && typeof s == "object" ? ([...r.matchAll(new RegExp(`${a.replaceAll(".", "\\.").replaceAll("$", "\\$")}\\.(?<prop>.*?)(?![\\w\\$_])`, "g"))].map((i) => i[1]) ?? []).reduce((i, l) => l && l in s ? Dt(e, { [`${a}.${l}`]: s[l] }, i) : i, n) : n, r);
+}
+function xo(e) {
+  return new To(e);
+}
+var To = class {
+  constructor(t) {
+    this.declaration = t;
+  }
+  [c] = !0;
+  externalsToApply = [];
+  $uses(t) {
+    return this.externalsToApply.push(t), this;
+  }
+  "~resolve"(t) {
+    let r = {};
+    for (let a of this.externalsToApply) Xe(r, a);
+    let n = Dt(t, r, this.declaration);
+    return t.addDeclaration(n), "";
+  }
+  toString() {
+    return `declare: ${this.declaration}`;
+  }
+};
+function $o(e) {
+  let { strippedCode: t, argRange: r } = Eo(e), n = new qn(t);
+  n.consume("(");
+  let a = [];
+  for (; !n.isAt(")"); ) {
+    let i = [];
+    for (; n.isAt("@"); ) n.parseUntil(zr, Yr), n.consume(")"), i.push(n.lastParsed);
+    n.parseUntil(Po);
+    let l = n.lastParsed, o;
+    n.isAt(":") && (n.consume(":"), n.parseUntil(So, ko), o = n.lastParsed), a.push({ identifier: l, attributes: i, type: o }), n.isAt(",") && n.consume(",");
+  }
+  n.consume(")");
+  let s;
+  if (n.isAt("->")) {
+    n.consume("->");
+    let i = [];
+    for (; n.isAt("@"); ) n.parseUntil(zr, Yr), n.consume(")"), i.push(n.lastParsed);
+    s = { type: n.str.slice(n.pos), attributes: i };
+  }
+  return { args: a, ret: s, range: { begin: r[0], end: r[1] } };
+}
+function Eo(e) {
+  let t = new qn(e), r = "", n;
+  for (; !t.isFinished(); ) {
+    if (t.isAt(Uo)) {
+      t.advanceBy(1);
+      continue;
+    }
+    if (t.isAt("//")) {
+      t.consume("//"), t.parseUntil(jn), t.advanceBy(1);
+      continue;
+    }
+    if (t.isAt("/*")) {
+      t.parseUntil(Io, Mo), t.consume("*/");
+      continue;
+    }
+    if (t.isAt("{")) return { strippedCode: r, argRange: [n, t.pos] };
+    t.isAt("(") && n === void 0 && (n = t.pos), n !== void 0 && (r += t.str[t.pos]), t.advanceBy(1);
+  }
+  throw new Error("Invalid wgsl code!");
+}
+var qn = class {
+  constructor(t) {
+    this.str = t, this.#t = 0;
+  }
+  #e;
+  #t;
+  get pos() {
+    return this.#t;
+  }
+  get lastParsed() {
+    if (this.#e === void 0) throw new Error("Parse was not called yet!");
+    return this.str.slice(this.#e, this.pos);
+  }
+  isFinished() {
+    return this.#t >= this.str.length;
+  }
+  isAt(t) {
+    if (typeof t == "string") {
+      for (let r = 0; r < t.length; r++) if (this.str[this.#t + r] !== t[r]) return !1;
+      return !0;
+    }
+    for (let r of t) if (this.isAt(r)) return !0;
+    return !1;
+  }
+  parseUntil(t, r) {
+    this.#e = this.#t;
+    let n = 0;
+    for (; this.#t < this.str.length; ) {
+      if (r && this.isAt(r[0]) && (n += 1), r && this.isAt(r[1]) && (n -= 1), n === 0 && this.isAt(t)) return this.#t;
+      this.#t += 1;
+    }
+    throw new Error("Reached the end of the string without finding a match!");
+  }
+  advanceBy(t) {
+    this.#t += t;
+  }
+  consume(t) {
+    if (!this.isAt(t)) throw new Error(`Expected '${t}' at position ${this.#t}, but found '${this.str.slice(this.#t, this.#t + t.length)}'`);
+    this.advanceBy(t.length);
+  }
+}, jn = /* @__PURE__ */ new Set([`
+`, "\v", "\f", "\r", "…", "\u2028", "\u2029"]), Uo = /* @__PURE__ */ new Set([...jn, " ", "	", "‎", "‏"]), zr = /* @__PURE__ */ new Set([")"]), Po = /* @__PURE__ */ new Set([":", ",", ")"]), So = /* @__PURE__ */ new Set([",", ")"]), Io = /* @__PURE__ */ new Set(["*/"]), Yr = ["(", ")"], ko = ["<", ">"], Mo = ["/*", "*/"];
+function Wt(e, t = "") {
+  let r = [], n = { applyExternals(s) {
+    r.push(s);
+  }, resolve(s, i, l) {
+    let o = {};
+    for (let h of r) Xe(o, h);
+    let y = s.names.makeUnique(g(this));
+    if (typeof e == "string") {
+      let h = Dt(s, o, e), w = "", b = "";
+      if (t !== "") {
+        let v = be(i[0]) ? `(in: ${s.resolve(i[0])})` : "()", x = ie(l) ? lr(l) : "", P = l !== de ? be(l) ? `-> ${s.resolve(l)}` : `-> ${x !== "" ? x : "@location(0)"} ${s.resolve(l)}` : "";
+        w = `${v} ${P} `, b = h;
+      } else {
+        let v = $o(h);
+        if (v.args.length !== i.length) throw new Error(`WGSL implementation has ${v.args.length} arguments, while the shell has ${i.length} arguments.`);
+        let x = v.args.map(($, k) => `${$.identifier}: ${Rr(s, `parameter ${$.identifier}`, $.type, i[k])}`).join(", "), P = l === de ? "" : `-> ${Rr(s, "return type", v.ret?.type, l)}`;
+        w = `(${x}) ${P}`, b = h.slice(v.range.end);
+      }
+      s.addDeclaration(`${t}fn ${y}${w}${b}`);
+    } else {
+      let h = Qs(e);
+      if (h?.externals) {
+        let $ = Object.fromEntries(Object.entries(h.externals).filter(([k]) => !(k in o)));
+        Xe(o, $);
+      }
+      let w = h?.ast;
+      if (!w) throw new Error("Missing metadata for tgpu.fn function body (either missing 'kernel' directive, or misconfigured `unplugin-typegpu`)");
+      let b = w.externalNames.filter(($) => !($ in o));
+      if (b.length > 0) throw new Ks(g(this), b);
+      let v = w.params[1];
+      v && v.type === "i" && t !== "" && Xe(o, { [v.name]: Hs(l) });
+      let { head: x, body: P } = s.fnToWgsl({ args: i.map(($, k) => u(w.params[k]?.type === kr.identifier ? w.params[k].name : `_arg_${k}`, $)), argAliases: Object.fromEntries(w.params.flatMap(($, k) => $.type === kr.destructuredObject ? $.props.map(({ name: L, alias: ee }) => [ee, u(`_arg_${k}.${L}`, i[k].propTypes[L])]) : [])), returnType: l, body: w.body, externalMap: o });
+      s.addDeclaration(`${t}fn ${y}${s.resolve(x)}${s.resolve(P)}`);
+    }
+    return y;
+  } }, a = g(e);
+  return a !== void 0 && F(n, a), n;
+}
+function Rr(e, t, r, n) {
+  let a = e.resolve(n).replace(/\s/g, "");
+  if (!r) return a;
+  let s = r.replace(/\s/g, "");
+  if (s !== a) throw new Error(`Type mismatch between TGPU shell and WGSL code string: ${t}, JS type "${a}", WGSL type "${s}".`);
+  return r;
+}
+function Ao(e, t = {}) {
+  let r = 0, n = /* @__PURE__ */ new Set();
+  return Object.fromEntries(Object.entries(e ?? {}).map(([a, s]) => {
+    let i = Pe(s);
+    if (i !== void 0) {
+      if (n.has(i)) throw new Error("Duplicate custom location attributes found");
+      n.add(i);
+    }
+    return [a, s];
+  }).map(([a, s]) => {
+    if (Ft(s)) return [a, s];
+    if (Pe(s) !== void 0) return [a, s];
+    if (t[a]) return [a, Et(t[a], s)];
+    for (; n.has(r); ) r++;
+    return [a, Et(r++, s)];
+  }));
+}
+function dt(e, t = {}) {
+  return Re(e) ? In(e) || Pe(e) !== void 0 ? e : Et(0, e) : $n(Ao(e, t));
+}
+function zt(e, ...t) {
+  return Oo(e) ? Go(e, ...t) : e;
+}
+function Oo(e) {
+  return Array.isArray(e) && "raw" in e && Array.isArray(e.raw) && e.raw.every((t) => typeof t == "string");
+}
+function Go(e, ...t) {
+  return e.slice(1).reduce((r, n, a) => `${r}${t[a]}${n}`, e[0]);
+}
+function Bo(e) {
+  let t = { argTypes: e.in && Object.keys(e.in).length !== 0 ? [dt(e.in)] : [], returnType: de, workgroupSize: [e.workgroupSize[0] ?? 1, e.workgroupSize[1] ?? 1, e.workgroupSize[2] ?? 1], isEntry: !0 }, r = (n, ...a) => Fo(t, e.workgroupSize, zt(n, ...a));
+  return Object.assign(Object.assign(r, t), { does: r });
+}
+function Fo(e, t, r) {
+  let n = Wt(r, `@compute @workgroup_size(${t.join(", ")}) `), a = e.argTypes[0];
+  return { shell: e, $uses(s) {
+    return n.applyExternals(s), this;
+  }, [c]: !0, [Y]: n, $name(s) {
+    return F(n, s), Ct(a) && a.$name(`${s}_Input`), this;
+  }, "~resolve"(s) {
+    return n.resolve(s, e.argTypes, e.returnType);
+  }, toString() {
+    return `computeFn:${g(n) ?? "<unnamed>"}`;
+  } };
+}
+function qr(e, t) {
+  let r = { [c]: !0, argTypes: e, returnType: t ?? de, isEntry: !1 };
+  return Object.assign((n, ...a) => Lo(r, zt(n, ...a)), r);
+}
+function Co(e) {
+  return !!e?.[c] && e?.resourceType === "function";
+}
+function No([e, t]) {
+  return `${g(e) ?? "<unnamed>"}=${t}`;
+}
+function Lo(e, t) {
+  let r = Wt(t, ""), n = { shell: e, resourceType: "function", $uses(i) {
+    return r.applyExternals(i), this;
+  }, [Y]: r, $name(i) {
+    return F(r, i), this;
+  }, with(i, l) {
+    return Vn(s, [[Nt(i) ? i.slot : i, l]]);
+  }, "~resolve"(i) {
+    return typeof t == "string" && (vo(t, e.argTypes, r.applyExternals), Rn(t, e.returnType, r.applyExternals)), r.resolve(i, e.argTypes, e.returnType);
+  } }, a = d((...i) => Rs(() => {
+    try {
+      if (typeof t == "string") throw new Error("Cannot execute on the CPU functions constructed with raw WGSL");
+      let l = i.map((o, y) => kn(e.argTypes[y], o));
+      return t(...l);
+    } catch (l) {
+      throw l instanceof Fr ? l.appendToTrace(s) : new Fr(l, [s]);
+    }
+  }), (...i) => u(new Jn(s, i), e.returnType), "tgpuFnCall", e.argTypes), s = Object.assign(a, n);
+  return s[c].implementation = t, Object.defineProperty(s, "toString", { value() {
+    return `fn:${g(r) ?? "<unnamed>"}`;
+  } }), s;
+}
+function Vn(e, t) {
+  let r = { resourceType: "function", shell: e.shell, [Me]: { inner: e, pairs: t }, $uses(s) {
+    return e.$uses(s), this;
+  }, [Y]: e, $name(s) {
+    return e.$name(s), this;
+  }, with(s, i) {
+    return Vn(a, [...t, [Nt(s) ? s.slot : s, i]]);
+  } }, n = d((...s) => e(...s), (...s) => u(new Jn(a, s), e.shell.returnType), "tgpuFnCall", e.shell.argTypes), a = Object.assign(n, r);
+  return a[c].implementation = e[c].implementation, Object.defineProperty(a, "toString", { value() {
+    return `fn:${g(e) ?? "<unnamed>"}[${t.map(No).join(", ")}]`;
+  } }), a[c].implementation = e[c].implementation, a;
+}
+var Jn = class {
+  [c] = !0;
+  [Y];
+  #e;
+  #t;
+  constructor(t, r) {
+    this.#e = t, this.#t = r, this[Y] = t;
+  }
+  "~resolve"(t) {
+    return t.withResetIndentLevel(() => p`${t.resolve(this.#e)}(${this.#t})`);
+  }
+  toString() {
+    return `call:${g(this) ?? "<unnamed>"}`;
+  }
+};
+function Do(e) {
+  let t = { in: e.in, out: e.out, returnType: dt(e.out), isEntry: !0 }, r = (n, ...a) => Wo(t, zt(n, ...a));
+  return Object.assign(Object.assign(r, t), { does: r });
+}
+function Wo(e, t) {
+  let r = Wt(t, "@fragment "), n = e.returnType;
+  return typeof t == "string" && Rn(t, n, (a) => r.applyExternals(a)), { shell: e, outputType: n, $uses(a) {
+    return r.applyExternals(a), this;
+  }, [c]: !0, [Y]: r, $name(a) {
+    return F(r, a), Ct(n) && n.$name(`${a}_Output`), this;
+  }, "~resolve"(a) {
+    let s = e.in ? dt(e.in, a.varyingLocations).$name(`${g(this) ?? ""}_Input`) : void 0;
+    return s && r.applyExternals({ In: s }), r.applyExternals({ Out: n }), r.resolve(a, s ? [s] : [], e.returnType);
+  }, toString() {
+    return `fragmentFn:${g(r) ?? "<unnamed>"}`;
+  } };
+}
+function zo(e) {
+  if (Object.keys(e.out).length === 0) throw new Error("A vertexFn output cannot be empty since it must include the 'position' builtin.");
+  let t = { in: e.in, out: e.out, argTypes: e.in && Object.keys(e.in).length !== 0 ? [dt(e.in)] : [], isEntry: !0 }, r = (n, ...a) => Yo(t, zt(n, ...a));
+  return Object.assign(Object.assign(r, t), { does: r });
+}
+function Yo(e, t) {
+  let r = Wt(t, "@vertex "), n = e.argTypes[0];
+  return { shell: e, $uses(a) {
+    return r.applyExternals(a), this;
+  }, [c]: !0, [Y]: r, $name(a) {
+    return F(r, a), Ct(n) && n.$name(`${a}_Input`), this;
+  }, "~resolve"(a) {
+    let s = dt(e.out, a.varyingLocations).$name(`${g(this) ?? ""}_Output`);
+    return typeof t == "string" && (n && r.applyExternals({ In: n }), r.applyExternals({ Out: s })), r.resolve(a, e.argTypes, s);
+  }, toString() {
+    return `vertexFn:${g(r) ?? "<unnamed>"}`;
+  } };
+}
+var $r = class {
+  lastUniqueId = 0;
+  makeUnique(e) {
+    let t;
+    return e ? (t = e.replaceAll(/\s/g, "_"), t = t.replaceAll(/[^\w\d]/g, "")) : t = "item", `${t}_${this.lastUniqueId++}`;
+  }
+}, Yt = class {
+  _usedNames = /* @__PURE__ */ new Set();
+  makeUnique(t) {
+    if (t === void 0) throw new Error("Unnamed item found when using a strict name registry");
+    let r = 0, n = t;
+    for (; this._usedNames.has(n); ) r++, n = `${t}_${r}`;
+    return this._usedNames.add(n), n;
+  }
+};
+function Rt(e) {
+  return typeof e?.format == "string";
+}
+function Ro(e, t) {
+  let r = [];
+  if (Re(e)) {
+    if (!Rt(t)) throw new Error("Shader expected a single attribute, not a record of attributes to be passed in.");
+    return r.push(t._layout), { usedVertexLayouts: r, bufferDefinitions: [{ arrayStride: t._layout.stride, stepMode: t._layout.stepMode, attributes: [{ format: t.format, offset: t.offset, shaderLocation: Pe(e) ?? 0 }] }] };
+  }
+  let n = [], a = /* @__PURE__ */ new WeakMap(), s = 0;
+  for (let [i, l] of Object.entries(e)) {
+    if (Ft(l)) continue;
+    let o = t[i];
+    if (!o) throw new Error(`An attribute by the name of '${i}' was not provided to the shader.`);
+    let y = o._layout, h = a.get(y);
+    h || (r.push(y), h = [], n.push({ arrayStride: y.stride, stepMode: y.stepMode, attributes: h }), a.set(y, h)), s = Pe(l) ?? s, h.push({ format: o.format, offset: o.offset, shaderLocation: s++ });
+  }
+  return { usedVertexLayouts: r, bufferDefinitions: n };
+}
+var qo = ["bool", "f32", "f16", "i32", "u32", "vec2f", "vec3f", "vec4f", "vec2h", "vec3h", "vec4h", "vec2i", "vec3i", "vec4i", "vec2u", "vec3u", "vec4u", "vec2<bool>", "vec3<bool>", "vec4<bool>", "mat2x2f", "mat3x3f", "mat4x4f"];
+function jo(e) {
+  return qo.includes(e.type);
+}
+function er(e, [t, r]) {
+  return `  ${lr(r)}${t}: ${e.resolve(r)},
+`;
+}
+function Vo(e, t) {
+  if (t[c].isAbstruct) throw new Error("Cannot resolve abstract struct types to WGSL.");
+  let r = e.names.makeUnique(g(t));
+  return e.addDeclaration(`struct ${r} {
+${Object.entries(t.propTypes).map((n) => er(e, n)).join("")}}`), r;
+}
+function Jo(e, t) {
+  let r = e.names.makeUnique(g(t));
+  return e.addDeclaration(`struct ${r} {
+${Object.entries(t.propTypes).map((n) => Rt(n[1]) ? er(e, [n[0], ze[n[1].format]]) : er(e, n)).join("")}
+}`), r;
+}
+function Zo(e, t) {
+  let r = e.resolve(t.elementType);
+  return t.elementCount === 0 ? `array<${r}>` : `array<${r}, ${t.elementCount}>`;
+}
+function Xo(e, t) {
+  let r = e.resolve(Rt(t.elementType) ? ze[t.elementType.format] : t.elementType);
+  return t.elementCount === 0 ? `array<${r}>` : `array<${r}, ${t.elementCount}>`;
+}
+function Zn(e, t) {
+  if (pr(t)) return t.type === "unstruct" ? Jo(e, t) : t.type === "disarray" ? Xo(e, t) : t.type === "loose-decorated" ? e.resolve(Rt(t.inner) ? ze[t.inner.format] : t.inner) : e.resolve(ze[t.type]);
+  if (jo(t)) return t.type;
+  if (t.type === "struct") return Vo(e, t);
+  if (t.type === "array") return Zo(e, t);
+  if (t.type === "atomic") return `atomic<${Zn(e, t.inner)}>`;
+  if (t.type === "decorated") return e.resolve(t.inner);
+  if (t.type === "ptr") return t.addressSpace === "storage" ? `ptr<storage, ${e.resolve(t.inner)}, ${t.access === "read-write" ? "read_write" : t.access}>` : `ptr<${t.addressSpace}, ${e.resolve(t.inner)}>`;
+  if (t.type === "abstractInt" || t.type === "abstractFloat" || t.type === "void" || t.type === "u16") throw new Error(`${t.type} has no representation in WGSL`);
+  rt(t, "resolveData");
+}
+var Xn = class tr {
+  constructor(t) {
+    this.bindings = t;
+  }
+  with(t, r) {
+    return new tr([...this.bindings, [Nt(t) ? t.slot : t, r]]);
+  }
+  pipe(t) {
+    let r = t(this);
+    return new tr([...this.bindings, ...r.bindings]);
+  }
+};
+function* Qo(e) {
+  let t = 0;
+  for (; ; ) e.has(t) || (yield t), t++;
+}
+function Ko(e, t) {
+  let r = "size" in e ? e.size : e.currentByteOffset, n = t - 1, a = r & n;
+  "skipBytes" in e ? e.skipBytes(t - a & n) : e.add(t - a & n);
+}
+var V = Ko, jr = /* @__PURE__ */ new WeakMap();
+function Qn(e) {
+  let t = jr.get(e);
+  if (t) return t;
+  let r = new N(), n = {}, a;
+  for (let s in e.propTypes) {
+    let i = e.propTypes[s];
+    if (i === void 0) throw new Error(`Property ${s} is undefined in struct`);
+    let l = r.size;
+    V(r, ut(e) ? Oe(i) : re(i)), a && (a.padding = r.size - l);
+    let o = D(i);
+    n[s] = { offset: r.size, size: o }, a = n[s], r.add(o);
+  }
+  return a && (a.padding = $e(D(e), re(e)) - r.size), jr.set(e, n), n;
+}
+var Ho = (() => {
+  try {
+    return new Function("return true"), !0;
+  } catch {
+    return !1;
+  }
+})(), Jt = /* @__PURE__ */ new WeakMap(), mt = { u32: "u32", vec2u: "u32", vec3u: "u32", vec4u: "u32", u16: "u16", i32: "i32", vec2i: "i32", vec3i: "i32", vec4i: "i32", f32: "f32", vec2f: "f32", vec3f: "f32", vec4f: "f32", f16: "f16", vec2h: "f16", vec3h: "f16", vec4h: "f16", mat2x2f: "f32", mat3x3f: "f32", mat4x4f: "f32" }, eu = { uint8: "u8", uint8x2: "u8", uint8x4: "u8", sint8: "i8", sint8x2: "i8", sint8x4: "i8", unorm8: "u8", unorm8x2: "u8", unorm8x4: "u8", snorm8: "i8", snorm8x2: "i8", snorm8x4: "i8", uint16: "u16", uint16x2: "u16", uint16x4: "u16", sint16: "i16", sint16x2: "i16", sint16x4: "i16", unorm16: "u16", unorm16x2: "u16", unorm16x4: "u16", snorm16: "i16", snorm16x2: "i16", snorm16x4: "i16", float16: "f16", float16x2: "f16", float16x4: "f16", float32: "f32", float32x2: "f32", float32x3: "f32", float32x4: "f32", uint32: "u32", uint32x2: "u32", uint32x3: "u32", uint32x4: "u32", sint32: "i32", sint32x2: "i32", sint32x3: "i32", sint32x4: "i32" }, yt = { u32: "setUint32", i32: "setInt32", f32: "setFloat32", u16: "setUint16", i16: "setInt16", f16: "setFloat16", u8: "setUint8", i8: "setInt8" }, tu = { unorm8: (e) => `Math.round(${e} * 255)`, unorm8x2: (e) => `Math.round(${e} * 255)`, unorm8x4: (e) => `Math.round(${e} * 255)`, snorm8: (e) => `Math.round(${e} * 127)`, snorm8x2: (e) => `Math.round(${e} * 127)`, snorm8x4: (e) => `Math.round(${e} * 127)`, unorm16: (e) => `Math.round(${e} * 65535)`, unorm16x2: (e) => `Math.round(${e} * 65535)`, unorm16x4: (e) => `Math.round(${e} * 65535)`, snorm16: (e) => `Math.round(${e} * 32767)`, snorm16x2: (e) => `Math.round(${e} * 32767)`, snorm16x4: (e) => `Math.round(${e} * 32767)` }, Vr = { "unorm10-10-10-2": { writeFunction: "setUint32", generator: (e, t) => `output.setUint32(${e}, ((${t}.x*1023&0x3FF)<<22)|((${t}.y*1023&0x3FF)<<12)|((${t}.z*1023&0x3FF)<<2)|(${t}.w*3&3), littleEndian);
+` }, "unorm8x4-bgra": { writeFunction: "setUint8", generator: (e, t) => {
+  let r = ["z", "y", "x", "w"], n = "";
+  for (let a = 0; a < 4; a++) n += `output.setUint8((${e} + ${a}), Math.round(${t}.${r[a]} * 255), littleEndian);
+`;
+  return n;
+} } };
+function bt(e, t, r) {
+  if (yn(e) || dr(e)) return bt(e.inner, t, r);
+  if (be(e) || ut(e)) {
+    let a = Qn(e), s = "";
+    for (let [i, l] of Object.entries(a)) {
+      let o = e.propTypes[i];
+      o && (s += bt(o, `(${t} + ${l.offset})`, `${r}.${i}`));
+    }
+    return s;
+  }
+  if (lt(e) || cr(e)) {
+    let a = $e(D(e.elementType), re(e)), s = "";
+    return s += `for (let i = 0; i < ${e.elementCount}; i++) {
+`, s += bt(e.elementType, `(${t} + i * ${a})`, `${r}[i]`), s += `}
+`, s;
+  }
+  if (ei(e)) {
+    let a = mt[e.type], s = "", i = yt[a], l = ["x", "y", "z", "w"], o = Cr(e) ? 2 : Nr(e) ? 3 : 4;
+    for (let y = 0; y < o; y++) s += `output.${i}((${t} + ${y * 4}), ${r}.${l[y]}, littleEndian);
+`;
+    return s;
+  }
+  if (ti(e)) {
+    let a = mt[e.type], s = yt[a], i = ri(e) ? 2 : ni(e) ? 3 : 4, l = i * i, o = $e(i * 4, 8), y = "";
+    for (let h = 0; h < l; h++) {
+      let w = Math.floor(h / i), b = h % i, v = w * o + b * 4;
+      y += `output.${s}((${t} + ${v}), ${r}.columns[${w}].${["x", "y", "z", "w"][b]}, littleEndian);
+`;
+    }
+    return y;
+  }
+  if (gn(e)) {
+    let a = e.type;
+    if (a in Vr) return Vr[a].generator(t, r);
+    let s = eu[a], i = yt[s], l = ze[a], o = ai(l) ? 4 : Nr(l) ? 3 : Cr(l) ? 2 : 1, y = s === "u8" || s === "i8" ? 1 : s === "u16" || s === "i16" || s === "f16" ? 2 : 4, h = ["x", "y", "z", "w"], w = tu[a], b = "";
+    for (let v = 0; v < o; v++) {
+      let x = o === 1 ? r : `${r}.${h[v]}`, P = w ? w(x) : x;
+      b += `output.${i}((${t} + ${v * y}), ${P}, littleEndian);
+`;
+    }
+    return b;
+  }
+  if (!Object.hasOwn(mt, e.type)) throw new Error(`Primitive ${e.type} is unsupported by compiled writer`);
+  let n = mt[e.type];
+  return `output.${yt[n]}(${t}, ${r}, littleEndian);
+`;
+}
+function Jr(e) {
+  if (!Ho) {
+    console.warn("This environment does not allow eval - using default writer as fallback");
+    return;
+  }
+  if (Jt.has(e)) return Jt.get(e);
+  try {
+    let t = bt(e, "offset", "value"), r = new Function("output", "offset", "value", "littleEndian=true", t);
+    return Jt.set(e, r), r;
+  } catch (t) {
+    console.warn(`Failed to compile writer for schema: ${e}
+Reason: ${t instanceof Error ? t.message : String(t)}
+Falling back to default writer`);
+  }
+}
+var Le = { bool() {
+  throw new Error("Booleans are not host-shareable");
+}, f32(e, t, r) {
+  e.writeFloat32(r);
+}, f16(e, t, r) {
+  e.writeFloat16(r);
+}, i32(e, t, r) {
+  e.writeInt32(r);
+}, u32(e, t, r) {
+  e.writeUint32(r);
+}, u16(e, t, r) {
+  e.writeUint16(r);
+}, vec2f(e, t, r) {
+  e.writeFloat32(r.x), e.writeFloat32(r.y);
+}, vec2h(e, t, r) {
+  e.writeFloat16(r.x), e.writeFloat16(r.y);
+}, vec2i(e, t, r) {
+  e.writeInt32(r.x), e.writeInt32(r.y);
+}, vec2u(e, t, r) {
+  e.writeUint32(r.x), e.writeUint32(r.y);
+}, "vec2<bool>"() {
+  throw new Error("Booleans are not host-shareable");
+}, vec3f(e, t, r) {
+  e.writeFloat32(r.x), e.writeFloat32(r.y), e.writeFloat32(r.z);
+}, vec3h(e, t, r) {
+  e.writeFloat16(r.x), e.writeFloat16(r.y), e.writeFloat16(r.z);
+}, vec3i(e, t, r) {
+  e.writeInt32(r.x), e.writeInt32(r.y), e.writeInt32(r.z);
+}, vec3u(e, t, r) {
+  e.writeUint32(r.x), e.writeUint32(r.y), e.writeUint32(r.z);
+}, "vec3<bool>"() {
+  throw new Error("Booleans are not host-shareable");
+}, vec4f(e, t, r) {
+  e.writeFloat32(r.x), e.writeFloat32(r.y), e.writeFloat32(r.z), e.writeFloat32(r.w);
+}, vec4h(e, t, r) {
+  e.writeFloat16(r.x), e.writeFloat16(r.y), e.writeFloat16(r.z), e.writeFloat16(r.w);
+}, vec4i(e, t, r) {
+  e.writeInt32(r.x), e.writeInt32(r.y), e.writeInt32(r.z), e.writeInt32(r.w);
+}, vec4u(e, t, r) {
+  e.writeUint32(r.x), e.writeUint32(r.y), e.writeUint32(r.z), e.writeUint32(r.w);
+}, "vec4<bool>"() {
+  throw new Error("Booleans are not host-shareable");
+}, mat2x2f(e, t, r) {
+  for (let n = 0; n < r.length; ++n) e.writeFloat32(r[n]);
+}, mat3x3f(e, t, r) {
+  for (let n = 0; n < r.length; ++n) e.writeFloat32(r[n]);
+}, mat4x4f(e, t, r) {
+  for (let n = 0; n < r.length; ++n) e.writeFloat32(r[n]);
+}, struct(e, t, r) {
+  let n = re(t);
+  V(e, n);
+  for (let [a, s] of Object.entries(t.propTypes)) V(e, re(s)), nt(e, s, r[a]);
+  V(e, n);
+}, array(e, t, r) {
+  if (t.elementCount === 0) throw new Error("Cannot write using a runtime-sized schema.");
+  let n = re(t);
+  V(e, n);
+  let a = e.currentByteOffset;
+  for (let s = 0; s < Math.min(t.elementCount, r.length); s++) V(e, n), nt(e, t.elementType, r[s]);
+  e.seekTo(a + D(t));
+}, ptr() {
+  throw new Error("Pointers are not host-shareable");
+}, atomic(e, t, r) {
+  Le[t.inner.type]?.(e, t, r);
+}, decorated(e, t, r) {
+  let n = Oe(t);
+  V(e, n);
+  let a = e.currentByteOffset;
+  Le[t.inner?.type]?.(e, t.inner, r), e.seekTo(a + D(t));
+}, uint8(e, t, r) {
+  e.writeUint8(r);
+}, uint8x2(e, t, r) {
+  e.writeUint8(r.x), e.writeUint8(r.y);
+}, uint8x4(e, t, r) {
+  e.writeUint8(r.x), e.writeUint8(r.y), e.writeUint8(r.z), e.writeUint8(r.w);
+}, sint8(e, t, r) {
+  e.writeInt8(r);
+}, sint8x2(e, t, r) {
+  e.writeInt8(r.x), e.writeInt8(r.y);
+}, sint8x4(e, t, r) {
+  e.writeInt8(r.x), e.writeInt8(r.y), e.writeInt8(r.z), e.writeInt8(r.w);
+}, unorm8(e, t, r) {
+  e.writeUint8(Math.round(r * 255));
+}, unorm8x2(e, t, r) {
+  e.writeUint8(Math.round(r.x * 255)), e.writeUint8(Math.round(r.y * 255));
+}, unorm8x4(e, t, r) {
+  e.writeUint8(Math.round(r.x * 255)), e.writeUint8(Math.round(r.y * 255)), e.writeUint8(Math.round(r.z * 255)), e.writeUint8(Math.round(r.w * 255));
+}, snorm8(e, t, r) {
+  e.writeInt8(Math.round(r * 127));
+}, snorm8x2(e, t, r) {
+  e.writeInt8(Math.round(r.x * 127)), e.writeInt8(Math.round(r.y * 127));
+}, snorm8x4(e, t, r) {
+  e.writeInt8(Math.round(r.x * 127)), e.writeInt8(Math.round(r.y * 127)), e.writeInt8(Math.round(r.z * 127)), e.writeInt8(Math.round(r.w * 127));
+}, uint16(e, t, r) {
+  e.writeUint16(r);
+}, uint16x2(e, t, r) {
+  e.writeUint16(r.x), e.writeUint16(r.y);
+}, uint16x4(e, t, r) {
+  e.writeUint16(r.x), e.writeUint16(r.y), e.writeUint16(r.z), e.writeUint16(r.w);
+}, sint16(e, t, r) {
+  e.writeInt16(r);
+}, sint16x2(e, t, r) {
+  e.writeInt16(r.x), e.writeInt16(r.y);
+}, sint16x4(e, t, r) {
+  e.writeInt16(r.x), e.writeInt16(r.y), e.writeInt16(r.z), e.writeInt16(r.w);
+}, unorm16(e, t, r) {
+  e.writeUint16(r * 65535);
+}, unorm16x2(e, t, r) {
+  e.writeUint16(r.x * 65535), e.writeUint16(r.y * 65535);
+}, unorm16x4(e, t, r) {
+  e.writeUint16(r.x * 65535), e.writeUint16(r.y * 65535), e.writeUint16(r.z * 65535), e.writeUint16(r.w * 65535);
+}, snorm16(e, t, r) {
+  e.writeInt16(Math.round(r * 32767));
+}, snorm16x2(e, t, r) {
+  e.writeInt16(Math.round(r.x * 32767)), e.writeInt16(Math.round(r.y * 32767));
+}, snorm16x4(e, t, r) {
+  e.writeInt16(Math.round(r.x * 32767)), e.writeInt16(Math.round(r.y * 32767)), e.writeInt16(Math.round(r.z * 32767)), e.writeInt16(Math.round(r.w * 32767));
+}, float16(e, t, r) {
+  e.writeFloat16(r);
+}, float16x2(e, t, r) {
+  e.writeFloat16(r.x), e.writeFloat16(r.y);
+}, float16x4(e, t, r) {
+  e.writeFloat16(r.x), e.writeFloat16(r.y), e.writeFloat16(r.z), e.writeFloat16(r.w);
+}, float32(e, t, r) {
+  e.writeFloat32(r);
+}, float32x2(e, t, r) {
+  e.writeFloat32(r.x), e.writeFloat32(r.y);
+}, float32x3(e, t, r) {
+  e.writeFloat32(r.x), e.writeFloat32(r.y), e.writeFloat32(r.z);
+}, float32x4(e, t, r) {
+  e.writeFloat32(r.x), e.writeFloat32(r.y), e.writeFloat32(r.z), e.writeFloat32(r.w);
+}, uint32(e, t, r) {
+  e.writeUint32(r);
+}, uint32x2(e, t, r) {
+  e.writeUint32(r.x), e.writeUint32(r.y);
+}, uint32x3(e, t, r) {
+  e.writeUint32(r.x), e.writeUint32(r.y), e.writeUint32(r.z);
+}, uint32x4(e, t, r) {
+  e.writeUint32(r.x), e.writeUint32(r.y), e.writeUint32(r.z), e.writeUint32(r.w);
+}, sint32(e, t, r) {
+  e.writeInt32(r);
+}, sint32x2(e, t, r) {
+  e.writeInt32(r.x), e.writeInt32(r.y);
+}, sint32x3(e, t, r) {
+  e.writeInt32(r.x), e.writeInt32(r.y), e.writeInt32(r.z);
+}, sint32x4(e, t, r) {
+  e.writeInt32(r.x), e.writeInt32(r.y), e.writeInt32(r.z), e.writeInt32(r.w);
+}, "unorm10-10-10-2"(e, t, r) {
+  let n = 0;
+  n |= (r.x * 1023 & 1023) << 22, n |= (r.y * 1023 & 1023) << 12, n |= (r.z * 1023 & 1023) << 2, n |= r.w * 3 & 3, e.writeUint32(n);
+}, "unorm8x4-bgra"(e, t, r) {
+  e.writeUint8(r.z * 255), e.writeUint8(r.y * 255), e.writeUint8(r.x * 255), e.writeUint8(r.w * 255);
+}, disarray(e, t, r) {
+  let n = re(t);
+  V(e, n);
+  let a = e.currentByteOffset;
+  for (let s = 0; s < Math.min(t.elementCount, r.length); s++) V(e, n), Le[t.elementType?.type]?.(e, t.elementType, r[s]);
+  e.seekTo(a + D(t));
+}, unstruct(e, t, r) {
+  let n = t.propTypes;
+  for (let [a, s] of Object.entries(n)) Le[s.type]?.(e, s, r[a]);
+}, "loose-decorated"(e, t, r) {
+  let n = Oe(t);
+  V(e, n);
+  let a = e.currentByteOffset, s = Le[t.inner?.type];
+  return s?.(e, t.inner, r), e.seekTo(a + D(t)), r;
+} };
+function nt(e, t, r) {
+  let n = Le[t.type];
+  if (!n) throw new Error(`Cannot write data of type '${t.type}'.`);
+  n(e, t, r);
+}
+var ru = { bool() {
+  throw new Error("Booleans are not host-shareable");
+}, f32(e) {
+  return e.readFloat32();
+}, f16(e) {
+  return e.readFloat16();
+}, i32(e) {
+  return e.readInt32();
+}, u32(e) {
+  return e.readUint32();
+}, u16(e) {
+  return e.readUint16();
+}, vec2f(e) {
+  return _(e.readFloat32(), e.readFloat32());
+}, vec3f(e) {
+  return S(e.readFloat32(), e.readFloat32(), e.readFloat32());
+}, vec4f(e) {
+  return O(e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32());
+}, vec2h(e) {
+  return Ke(e.readFloat16(), e.readFloat16());
+}, vec3h(e) {
+  return He(e.readFloat16(), e.readFloat16(), e.readFloat16());
+}, vec4h(e) {
+  return et(e.readFloat16(), e.readFloat16(), e.readFloat16(), e.readFloat16());
+}, vec2i(e) {
+  return K(e.readInt32(), e.readInt32());
+}, vec3i(e) {
+  return Ue(e.readInt32(), e.readInt32(), e.readInt32());
+}, vec4i(e) {
+  return te(e.readInt32(), e.readInt32(), e.readInt32(), e.readInt32());
+}, vec2u(e) {
+  return ne(e.readUint32(), e.readUint32());
+}, vec3u(e) {
+  return Ut(e.readUint32(), e.readUint32(), e.readUint32());
+}, vec4u(e) {
+  return ue(e.readUint32(), e.readUint32(), e.readUint32(), e.readUint32());
+}, "vec2<bool>"() {
+  throw new Error("Booleans are not host-shareable");
+}, "vec3<bool>"() {
+  throw new Error("Booleans are not host-shareable");
+}, "vec4<bool>"() {
+  throw new Error("Booleans are not host-shareable");
+}, mat2x2f(e) {
+  return vn(e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32());
+}, mat3x3f(e) {
+  let t = () => {
+    let r = e.readFloat32();
+    return e.readFloat32(), r;
+  };
+  return _n(e.readFloat32(), e.readFloat32(), t(), e.readFloat32(), e.readFloat32(), t(), e.readFloat32(), e.readFloat32(), t());
+}, mat4x4f(e) {
+  return xn(e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32());
+}, struct(e, t) {
+  let r = re(t);
+  V(e, r);
+  let n = {}, a = t.propTypes;
+  for (let [s, i] of Object.entries(a)) V(e, re(i)), n[s] = ce(e, i);
+  return V(e, r), n;
+}, array(e, t) {
+  if (t.elementCount === 0) throw new Error("Cannot read using a runtime-sized schema.");
+  let r = re(t), n = [];
+  for (let a = 0; a < t.elementCount; a++) {
+    V(e, r);
+    let s = t.elementType, i = ce(e, s);
+    n.push(i);
+  }
+  return V(e, r), n;
+}, ptr() {
+  throw new Error("Pointers are not host-shareable");
+}, atomic(e, t) {
+  return ce(e, t.inner);
+}, decorated(e, t) {
+  let r = Oe(t);
+  V(e, r);
+  let n = e.currentByteOffset, a = ce(e, t.inner);
+  return e.seekTo(n + D(t)), a;
+}, uint8: (e) => e.readUint8(), uint8x2: (e) => ne(e.readUint8(), e.readUint8()), uint8x4: (e) => ue(e.readUint8(), e.readUint8(), e.readUint8(), e.readUint8()), sint8: (e) => e.readInt8(), sint8x2: (e) => K(e.readInt8(), e.readInt8()), sint8x4: (e) => te(e.readInt8(), e.readInt8(), e.readInt8(), e.readInt8()), unorm8: (e) => e.readUint8() / 255, unorm8x2: (e) => _(e.readUint8() / 255, e.readUint8() / 255), unorm8x4: (e) => O(e.readUint8() / 255, e.readUint8() / 255, e.readUint8() / 255, e.readUint8() / 255), snorm8: (e) => e.readInt8() / 127, snorm8x2: (e) => _(e.readInt8() / 127, e.readInt8() / 127), snorm8x4: (e) => O(e.readInt8() / 127, e.readInt8() / 127, e.readInt8() / 127, e.readInt8() / 127), uint16: (e) => e.readUint16(), uint16x2: (e) => ne(e.readUint16(), e.readUint16()), uint16x4: (e) => ue(e.readUint16(), e.readUint16(), e.readUint16(), e.readUint16()), sint16: (e) => e.readInt16(), sint16x2: (e) => K(e.readInt16(), e.readInt16()), sint16x4: (e) => te(e.readInt16(), e.readInt16(), e.readInt16(), e.readInt16()), unorm16: (e) => e.readUint16() / 65535, unorm16x2: (e) => _(e.readUint16() / 65535, e.readUint16() / 65535), unorm16x4: (e) => O(e.readUint16() / 65535, e.readUint16() / 65535, e.readUint16() / 65535, e.readUint16() / 65535), snorm16: (e) => e.readInt16() / 32767, snorm16x2: (e) => _(e.readInt16() / 32767, e.readInt16() / 32767), snorm16x4: (e) => O(e.readInt16() / 32767, e.readInt16() / 32767, e.readInt16() / 32767, e.readInt16() / 32767), float16(e) {
+  return e.readFloat16();
+}, float16x2: (e) => _(e.readFloat16(), e.readFloat16()), float16x4: (e) => O(e.readFloat16(), e.readFloat16(), e.readFloat16(), e.readFloat16()), float32: (e) => e.readFloat32(), float32x2: (e) => _(e.readFloat32(), e.readFloat32()), float32x3: (e) => S(e.readFloat32(), e.readFloat32(), e.readFloat32()), float32x4: (e) => O(e.readFloat32(), e.readFloat32(), e.readFloat32(), e.readFloat32()), uint32: (e) => e.readUint32(), uint32x2: (e) => ne(e.readUint32(), e.readUint32()), uint32x3: (e) => Ut(e.readUint32(), e.readUint32(), e.readUint32()), uint32x4: (e) => ue(e.readUint32(), e.readUint32(), e.readUint32(), e.readUint32()), sint32: (e) => e.readInt32(), sint32x2: (e) => K(e.readInt32(), e.readInt32()), sint32x3: (e) => Ue(e.readInt32(), e.readInt32(), e.readInt32()), sint32x4: (e) => te(e.readInt32(), e.readInt32(), e.readInt32(), e.readInt32()), "unorm10-10-10-2"(e) {
+  let t = e.readUint32(), r = (t >> 22) / 1023, n = (t >> 12 & 1023) / 1023, a = (t >> 2 & 1023) / 1023, s = (t & 3) / 3;
+  return O(r, n, a, s);
+}, "unorm8x4-bgra"(e) {
+  let t = e.readByte() / 255, r = e.readByte() / 255, n = e.readByte() / 255, a = e.readByte() / 255;
+  return O(n, r, t, a);
+}, unstruct(e, t) {
+  let r = {}, n = t.propTypes;
+  for (let [a, s] of Object.entries(n)) r[a] = ce(e, s);
+  return r;
+}, disarray(e, t) {
+  let r = re(t), n = [];
+  for (let a = 0; a < t.elementCount; a++) V(e, r), n.push(ce(e, t.elementType));
+  return V(e, r), n;
+}, "loose-decorated"(e, t) {
+  V(e, Oe(t));
+  let r = e.currentByteOffset, n = ce(e, t.inner);
+  return e.seekTo(r + D(t)), n;
+} };
+function ce(e, t) {
+  let r = ru[t.type];
+  if (!r) throw new Error(`Cannot read data of type '${t.type}'.`);
+  return r(e, t);
+}
+function nu(e, t) {
+  let r = D(e);
+  if (r === 0 || t === void 0 || t === null) return [];
+  let n = new ArrayBuffer(r), a = new Se(n), s = [];
+  function i(y, h, w, b) {
+    if (h != null) {
+      if (be(y) || ut(y)) {
+        let v = Qn(y);
+        for (let [x, P] of Object.entries(v)) {
+          let $ = y.propTypes[x];
+          if (!$) continue;
+          let k = h[x];
+          k !== void 0 && i($, k, w + P.offset, P.padding ?? b);
+        }
+        return;
+      }
+      if (lt(y) || cr(y)) {
+        let v = y, x = $e(D(v.elementType), re(v.elementType));
+        if (!Array.isArray(h)) throw new Error("Partial value for array must be an array");
+        let P = h ?? [];
+        P.sort(($, k) => $.idx - k.idx);
+        for (let { idx: $, value: k } of P) i(v.elementType, k, w + $ * x, x - D(v.elementType));
+      } else {
+        let v = D(y);
+        a.seekTo(w), nt(a, y, h), s.push({ start: w, end: w + v, padding: b });
+      }
+    }
+  }
+  if (i(e, t, 0), s.length === 0) return [];
+  let l = [], o = s[0];
+  for (let y = 1; y < s.length; y++) {
+    let h = s[y];
+    if (!h || !o) throw new Error("Internal error: missing segment");
+    h.start === o.end + (o.padding ?? 0) ? (o.end = h.end, o.padding = h.padding) : (l.push({ data: new Uint8Array(n, o.start, o.end - o.start) }), o = h);
+  }
+  if (!o) throw new Error("Internal error: missing segment");
+  return l.push({ data: new Uint8Array(n, o.start, o.end - o.start) }), l;
+}
+function Mt(e) {
+  return !!e?.usableAsStorage;
+}
+var Zr = class Kn extends Error {
+  constructor(t) {
+    super(`Resource '${g(t) ?? "<unnamed>"}' cannot be bound as 'storage'. Use .$usage('storage') to allow it.`), Object.setPrototypeOf(this, Kn.prototype);
+  }
+};
+function Hn(e) {
+  return !!e.usableAsUniform;
+}
+var ea = { uniform: "uniform", mutable: "storage, read_write", readonly: "storage, read" }, Er = class {
+  constructor(t, r) {
+    this.usage = t, this.buffer = r, this[c] = { dataType: r.dataType }, this[Y] = r;
+  }
+  resourceType = "buffer-usage";
+  [c];
+  [Y];
+  $name(t) {
+    return this.buffer.$name(t), this;
+  }
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), { group: n, binding: a } = t.allocateFixedEntry(this.usage === "uniform" ? { uniform: this.buffer.dataType } : { storage: this.buffer.dataType, access: this.usage }, this.buffer), s = ea[this.usage];
+    return t.addDeclaration(`@group(${n}) @binding(${a}) var<${s}> ${r}: ${t.resolve(this.buffer.dataType)};`), r;
+  }
+  toString() {
+    return `${this.usage}:${g(this) ?? "<unnamed>"}`;
+  }
+  [j]() {
+    return new Proxy({ [c]: !0, "~resolve": (t) => t.resolve(this), toString: () => `.value:${g(this) ?? "<unnamed>"}`, [C]: this.buffer.dataType }, qe);
+  }
+  get $() {
+    let t = St(), r = It();
+    if (t.type === "normal") throw new Lr(r ? `Cannot access ${String(this.buffer)}. TypeGPU functions that depends on GPU resources need to be part of a compute dispatch, draw call or simulation` : ".$ and .value are inaccessible during normal JS execution. Try `.read()`");
+    return t.type === "codegen" ? this[j]() : t.type === "simulate" ? (t.buffers.has(this.buffer) || t.buffers.set(this.buffer, kn(this.buffer.dataType, this.buffer.initial)), t.buffers.get(this.buffer)) : rt(t, "bufferUsage.ts#TgpuFixedBufferImpl/$");
+  }
+  get value() {
+    return this.$;
+  }
+  set $(t) {
+    let r = St(), n = It();
+    if (r.type === "normal") throw new Lr(n ? `Cannot access ${String(this.buffer)}. TypeGPU functions that depends on GPU resources need to be part of a compute dispatch, draw call or simulation` : ".$ and .value are inaccessible during normal JS execution. Try `.write()`");
+    if (r.type === "codegen") throw new Error("Unreachable bufferUsage.ts#TgpuFixedBufferImpl/$");
+    if (r.type === "simulate") {
+      r.buffers.set(this.buffer, t);
+      return;
+    }
+    rt(r, "bufferUsage.ts#TgpuFixedBufferImpl/$");
+  }
+  set value(t) {
+    this.$ = t;
+  }
+}, Xr = class {
+  constructor(t, r, n) {
+    this.usage = t, this.dataType = r, this._membership = n, this[c] = { dataType: r }, F(this, n.key);
+  }
+  resourceType = "buffer-usage";
+  [c];
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), n = t.allocateLayoutEntry(this._membership.layout), a = ea[this.usage];
+    return t.addDeclaration(`@group(${n}) @binding(${this._membership.idx}) var<${a}> ${r}: ${t.resolve(this.dataType)};`), r;
+  }
+  toString() {
+    return `${this.usage}:${g(this) ?? "<unnamed>"}`;
+  }
+  [j]() {
+    return new Proxy({ [c]: !0, "~resolve": (t) => t.resolve(this), toString: () => `.value:${g(this) ?? "<unnamed>"}`, [C]: this.dataType }, qe);
+  }
+  get $() {
+    if (hr()) return this[j]();
+    throw new Error("Direct access to buffer values is possible only as part of a compute dispatch or draw call. Try .read() or .write() instead");
+  }
+  get value() {
+    return this.$;
+  }
+}, Qr = /* @__PURE__ */ new WeakMap();
+function au(e) {
+  if (!Mt(e)) throw new Error(`Cannot pass ${e} to asMutable, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`);
+  let t = Qr.get(e);
+  return t || (t = new Er("mutable", e), Qr.set(e, t)), t;
+}
+var Kr = /* @__PURE__ */ new WeakMap();
+function su(e) {
+  if (!Mt(e)) throw new Error(`Cannot pass ${e} to asReadonly, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`);
+  let t = Kr.get(e);
+  return t || (t = new Er("readonly", e), Kr.set(e, t)), t;
+}
+var Hr = /* @__PURE__ */ new WeakMap();
+function iu(e) {
+  if (!Hn(e)) throw new Error(`Cannot pass ${e} to asUniform, as it is not allowed to be used as a uniform. To allow it, call .$usage('uniform') when creating the buffer.`);
+  let t = Hr.get(e);
+  return t || (t = new Er("uniform", e), Hr.set(e, t)), t;
+}
+var ou = { uniform: iu, mutable: au, readonly: su };
+function wt(e, t, r) {
+  return ie(t) ? new en(e, t, r) : new en(e, t, r, ["storage", "uniform"]);
+}
+function Qe(e) {
+  return e.resourceType === "buffer";
+}
+var uu = /* @__PURE__ */ zn(), en = class {
+  constructor(t, r, n, a) {
+    this._group = t, this.dataType = r, this.initialOrBuffer = n, this._disallowedUsages = a, Kt(n) ? (this._ownBuffer = !1, this._buffer = n) : (this._ownBuffer = !0, this.initial = n);
+  }
+  [c] = !0;
+  resourceType = "buffer";
+  flags = GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC;
+  _buffer = null;
+  _ownBuffer;
+  _destroyed = !1;
+  _hostBuffer;
+  initial;
+  usableAsUniform = !1;
+  usableAsStorage = !1;
+  usableAsVertex = !1;
+  usableAsIndex = !1;
+  get buffer() {
+    let t = this._group.device;
+    if (this._destroyed) throw new Error("This buffer has been destroyed");
+    if (!this._buffer && (this._buffer = t.createBuffer({ size: D(this.dataType), usage: this.flags, mappedAtCreation: !!this.initial, label: g(this) ?? "<unnamed>" }), this.initial)) {
+      let r = new Se(this._buffer.getMappedRange());
+      nt(r, this.dataType, this.initial), this._buffer.unmap();
+    }
+    return this._buffer;
+  }
+  get destroyed() {
+    return this._destroyed;
+  }
+  $name(t) {
+    return F(this, t), this._buffer && (this._buffer.label = t), this;
+  }
+  $usage(...t) {
+    for (let r of t) {
+      if (this._disallowedUsages?.includes(r)) throw new Error(`Buffer of type ${this.dataType.type} cannot be used as ${r}`);
+      this.flags |= r === "uniform" ? GPUBufferUsage.UNIFORM : 0, this.flags |= r === "storage" ? GPUBufferUsage.STORAGE : 0, this.flags |= r === "vertex" ? GPUBufferUsage.VERTEX : 0, this.flags |= r === "index" ? GPUBufferUsage.INDEX : 0, this.usableAsUniform = this.usableAsUniform || r === "uniform", this.usableAsStorage = this.usableAsStorage || r === "storage", this.usableAsVertex = this.usableAsVertex || r === "vertex", this.usableAsIndex = this.usableAsIndex || r === "index";
+    }
+    return this;
+  }
+  $addFlags(t) {
+    if (!this._ownBuffer) throw new Error("Cannot add flags to a buffer that is not managed by TypeGPU.");
+    return t & GPUBufferUsage.MAP_READ ? (this.flags = GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, this) : t & GPUBufferUsage.MAP_WRITE ? (this.flags = GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, this) : (this.flags |= t, this);
+  }
+  compileWriter() {
+    Jr(this.dataType);
+  }
+  _writeToTarget(t, r) {
+    let n = Jr(this.dataType);
+    if (n) try {
+      n(new DataView(t), 0, r, uu === "little");
+      return;
+    } catch (a) {
+      console.error(`Error when using compiled writer for buffer ${g(this) ?? "<unnamed>"} - this is likely a bug, please submit an issue at https://github.com/software-mansion/TypeGPU/issues
+Using fallback writer instead.`, a);
+    }
+    nt(new Se(t), this.dataType, r);
+  }
+  write(t) {
+    let r = this.buffer, n = this._group.device;
+    if (r.mapState === "mapped") {
+      let s = r.getMappedRange();
+      this._writeToTarget(s, t);
+      return;
+    }
+    let a = D(this.dataType);
+    this._hostBuffer || (this._hostBuffer = new ArrayBuffer(a)), this._group.flush(), this._writeToTarget(this._hostBuffer, t), n.queue.writeBuffer(r, 0, this._hostBuffer, 0, a);
+  }
+  writePartial(t) {
+    let r = this.buffer, n = this._group.device, a = nu(this.dataType, t);
+    if (r.mapState === "mapped") {
+      let s = r.getMappedRange(), i = new Uint8Array(s);
+      for (let l of a) i.set(l.data, l.data.byteOffset);
+    } else for (let s of a) n.queue.writeBuffer(r, s.data.byteOffset, s.data, 0, s.data.byteLength);
+  }
+  copyFrom(t) {
+    if (this.buffer.mapState === "mapped") throw new Error("Cannot copy to a mapped buffer.");
+    let r = D(this.dataType);
+    this._group.commandEncoder.copyBufferToBuffer(t.buffer, 0, this.buffer, 0, r);
+  }
+  async read() {
+    this._group.flush();
+    let t = this.buffer, r = this._group.device;
+    if (t.mapState === "mapped") {
+      let i = t.getMappedRange();
+      return ce(new Ee(i), this.dataType);
+    }
+    if (t.usage & GPUBufferUsage.MAP_READ) {
+      await t.mapAsync(GPUMapMode.READ);
+      let i = t.getMappedRange(), l = ce(new Ee(i), this.dataType);
+      return t.unmap(), l;
+    }
+    let n = (globalThis.__TYPEGPU_AUTONAME__ ?? ((i) => i))(r.createBuffer({ size: D(this.dataType), usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }), "n"), a = r.createCommandEncoder();
+    a.copyBufferToBuffer(t, 0, n, 0, D(this.dataType)), r.queue.submit([a.finish()]), await r.queue.onSubmittedWorkDone(), await n.mapAsync(GPUMapMode.READ, 0, D(this.dataType));
+    let s = ce(new Ee(n.getMappedRange()), this.dataType);
+    return n.unmap(), n.destroy(), s;
+  }
+  as(t) {
+    return ou[t]?.(this);
+  }
+  destroy() {
+    this._destroyed || (this._destroyed = !0, this._ownBuffer && this._buffer?.destroy());
+  }
+  toString() {
+    return `buffer:${g(this) ?? "<unnamed>"}`;
+  }
+};
+function lu(e) {
+  return new hu(e);
+}
+function du(e) {
+  return new fu(e);
+}
+function ta(e) {
+  let t = e;
+  return t?.resourceType === "sampler" && !!t[c];
+}
+function ra(e) {
+  let t = e;
+  return t?.resourceType === "sampler-comparison" && !!t[c];
+}
+var cu = class {
+  constructor(t) {
+    this._membership = t, this[C] = this, this[c] = {}, F(this, t.key);
+  }
+  [C];
+  [c];
+  resourceType = "sampler";
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), n = t.allocateLayoutEntry(this._membership.layout);
+    return t.addDeclaration(`@group(${n}) @binding(${this._membership.idx}) var ${r}: sampler;`), r;
+  }
+  toString() {
+    return `${this.resourceType}:${g(this) ?? "<unnamed>"}`;
+  }
+}, pu = class {
+  constructor(t) {
+    this._membership = t, this[C] = this, this[c] = {}, F(this, t.key);
+  }
+  [C];
+  [c];
+  resourceType = "sampler-comparison";
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), n = t.allocateLayoutEntry(this._membership.layout);
+    return t.addDeclaration(`@group(${n}) @binding(${this._membership.idx}) var ${r}: sampler_comparison;`), r;
+  }
+  toString() {
+    return `${this.resourceType}:${g(this) ?? "<unnamed>"}`;
+  }
+}, hu = class {
+  constructor(t) {
+    this._props = t, this[C] = this, this[c] = { unwrap: (r) => (this._sampler || (this._sampler = r.device.createSampler({ ...this._props, label: g(this) ?? "<unnamed>" })), this._sampler) }, this._filtering = t.minFilter === "linear" || t.magFilter === "linear" || t.mipmapFilter === "linear";
+  }
+  [C];
+  [c];
+  resourceType = "sampler";
+  _filtering;
+  _sampler = null;
+  $name(t) {
+    return F(this, t), this;
+  }
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), { group: n, binding: a } = t.allocateFixedEntry({ sampler: this._filtering ? "filtering" : "non-filtering" }, this);
+    return t.addDeclaration(`@group(${n}) @binding(${a}) var ${r}: sampler;`), r;
+  }
+  toString() {
+    return `${this.resourceType}:${g(this) ?? "<unnamed>"}`;
+  }
+}, fu = class {
+  constructor(t) {
+    this._props = t, this[C] = this, this[c] = { unwrap: (r) => (this._sampler || (this._sampler = r.device.createSampler({ ...this._props, label: g(this) ?? "<unnamed>" })), this._sampler) };
+  }
+  [C];
+  [c];
+  resourceType = "sampler-comparison";
+  _sampler = null;
+  $name(t) {
+    return F(this, t), this;
+  }
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), { group: n, binding: a } = t.allocateFixedEntry({ sampler: "comparison" }, this);
+    return t.addDeclaration(`@group(${n}) @binding(${a}) var ${r}: sampler_comparison;`), r;
+  }
+  toString() {
+    return `${this.resourceType}:${g(this) ?? "<unnamed>"}`;
+  }
+}, mu = class {
+  constructor(t) {
+    this._membership = t, F(this, t.key);
+  }
+  [c] = !0;
+  resourceType = "external-texture";
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), n = t.allocateLayoutEntry(this._membership.layout);
+    return t.addDeclaration(`@group(${n}) @binding(${this._membership.idx}) var ${r}: texture_external;`), r;
+  }
+  toString() {
+    return `${this.resourceType}:${g(this) ?? "<unnamed>"}`;
+  }
+}, yu = { r8unorm: f, r8snorm: f, r8uint: m, r8sint: J, r16uint: m, r16sint: J, r16float: f, rg8unorm: f, rg8snorm: f, rg8uint: m, rg8sint: J, r32uint: m, r32sint: J, r32float: f, rg16uint: m, rg16sint: J, rg16float: f, rgba8unorm: f, "rgba8unorm-srgb": f, rgba8snorm: f, rgba8uint: m, rgba8sint: J, bgra8unorm: f, "bgra8unorm-srgb": f, rgb9e5ufloat: f, rgb10a2uint: m, rgb10a2unorm: f, rg11b10ufloat: f, rg32uint: m, rg32sint: J, rg32float: f, rgba16uint: m, rgba16sint: J, rgba16float: f, rgba32uint: m, rgba32sint: J, rgba32float: f, stencil8: f, depth16unorm: f, depth24plus: f, "depth24plus-stencil8": f, depth32float: f, "depth32float-stencil8": f, "bc1-rgba-unorm": f, "bc1-rgba-unorm-srgb": f, "bc2-rgba-unorm": f, "bc2-rgba-unorm-srgb": f, "bc3-rgba-unorm": f, "bc3-rgba-unorm-srgb": f, "bc4-r-unorm": f, "bc4-r-snorm": f, "bc5-rg-unorm": f, "bc5-rg-snorm": f, "bc6h-rgb-ufloat": f, "bc6h-rgb-float": f, "bc7-rgba-unorm": f, "bc7-rgba-unorm-srgb": f, "etc2-rgb8unorm": f, "etc2-rgb8unorm-srgb": f, "etc2-rgb8a1unorm": f, "etc2-rgb8a1unorm-srgb": f, "etc2-rgba8unorm": f, "etc2-rgba8unorm-srgb": f, "eac-r11unorm": f, "eac-r11snorm": f, "eac-rg11unorm": f, "eac-rg11snorm": f, "astc-4x4-unorm": f, "astc-4x4-unorm-srgb": f, "astc-5x4-unorm": f, "astc-5x4-unorm-srgb": f, "astc-5x5-unorm": f, "astc-5x5-unorm-srgb": f, "astc-6x5-unorm": f, "astc-6x5-unorm-srgb": f, "astc-6x6-unorm": f, "astc-6x6-unorm-srgb": f, "astc-8x5-unorm": f, "astc-8x5-unorm-srgb": f, "astc-8x6-unorm": f, "astc-8x6-unorm-srgb": f, "astc-8x8-unorm": f, "astc-8x8-unorm-srgb": f, "astc-10x5-unorm": f, "astc-10x5-unorm-srgb": f, "astc-10x6-unorm": f, "astc-10x6-unorm-srgb": f, "astc-10x8-unorm": f, "astc-10x8-unorm-srgb": f, "astc-10x10-unorm": f, "astc-10x10-unorm-srgb": f, "astc-12x10-unorm": f, "astc-12x10-unorm-srgb": f, "astc-12x12-unorm": f, "astc-12x12-unorm-srgb": f, r16snorm: f, r16unorm: f, rg16unorm: f, rg16snorm: f, rgba16unorm: f, rgba16snorm: f }, At = { rgba8unorm: O, rgba8snorm: O, rgba8uint: ue, rgba8sint: te, rgba16uint: ue, rgba16sint: te, rgba16float: O, r32uint: ue, r32sint: te, r32float: O, rg32uint: ue, rg32sint: te, rg32float: O, rgba32uint: ue, rgba32sint: te, rgba32float: O, bgra8unorm: O }, wu = { f32: "float", u32: "uint", i32: "sint" }, gu = { float: f, "unfilterable-float": f, uint: m, sint: J, depth: f };
+function bu(e, t) {
+  return new vu(e, t);
+}
+function at(e) {
+  return e?.resourceType === "texture" && !!e[c];
+}
+function na(e) {
+  return e?.resourceType === "texture-storage-view" && !!e[c];
+}
+function aa(e) {
+  return e?.resourceType === "texture-sampled-view" && !!e[c];
+}
+var sa = { mutable: "read_write", readonly: "read", writeonly: "write" }, vu = class {
+  constructor(t, r) {
+    this.props = t, this._branch = r, this[c] = { unwrap: () => {
+      if (this._destroyed) throw new Error("This texture has been destroyed");
+      return this._texture || (this._texture = this._branch.device.createTexture({ label: g(this) ?? "<unnamed>", format: this.props.format, size: this.props.size, usage: this._flags, dimension: this.props.dimension ?? "2d", viewFormats: this.props.viewFormats ?? [], mipLevelCount: this.props.mipLevelCount ?? 1, sampleCount: this.props.sampleCount ?? 1 })), this._texture;
+    } };
+  }
+  [c];
+  resourceType = "texture";
+  usableAsSampled = !1;
+  usableAsStorage = !1;
+  usableAsRender = !1;
+  _destroyed = !1;
+  _flags = GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC;
+  _texture = null;
+  $name(t) {
+    return F(this, t), this;
+  }
+  $usage(...t) {
+    let r = t.includes("storage"), n = t.includes("sampled"), a = t.includes("render");
+    return this._flags |= n ? GPUTextureUsage.TEXTURE_BINDING : 0, this._flags |= r ? GPUTextureUsage.STORAGE_BINDING : 0, this._flags |= a ? GPUTextureUsage.RENDER_ATTACHMENT : 0, this.usableAsStorage ||= r, this.usableAsSampled ||= n, this.usableAsRender ||= a, this;
+  }
+  createView(t, r) {
+    if (t === "sampled") return this._asSampled(r);
+    let n = r;
+    switch (t) {
+      case "mutable":
+        return this._asMutable(n);
+      case "readonly":
+        return this._asReadonly(n);
+      case "writeonly":
+        return this._asWriteonly(n);
+    }
+  }
+  _asStorage(t, r) {
+    if (!this.usableAsStorage) throw new Error("Unusable as storage");
+    let n = t?.format ?? this.props.format, a = At[n];
+    return Pt(!!a, `Unsupported storage texture format: ${n}`), new _u(t ?? {}, r, this);
+  }
+  _asReadonly(t) {
+    return this._asStorage(t, "readonly");
+  }
+  _asWriteonly(t) {
+    return this._asStorage(t, "writeonly");
+  }
+  _asMutable(t) {
+    return this._asStorage(t, "mutable");
+  }
+  _asSampled(t) {
+    if (!this.usableAsSampled) throw new Error("Unusable as sampled");
+    let r = t?.format ?? this.props.format;
+    if (!At[r]) throw new Error(`Unsupported storage texture format: ${r}`);
+    return new Tu(t, this);
+  }
+  destroy() {
+    this._destroyed || (this._destroyed = !0, this._texture?.destroy());
+  }
+}, qt = { "1d": "1d", "2d": "2d", "2d-array": "2d_array", cube: "cube", "cube-array": "cube_array", "3d": "3d" }, _u = class {
+  constructor(t, r, n) {
+    this.access = r, this._texture = n, this[C] = this, this[c] = { unwrap: () => (this._view || (this._view = this._texture[c].unwrap().createView({ label: `${g(this) ?? "<unnamed>"} - View`, format: this._format, dimension: this.dimension })), this._view) }, this[Y] = n, this.dimension = t?.dimension ?? n.props.dimension ?? "2d", this._format = t?.format ?? n.props.format, this.texelDataType = At[this._format];
+  }
+  [C];
+  [c];
+  [Y];
+  resourceType = "texture-storage-view";
+  texelDataType;
+  dimension;
+  _view;
+  _format;
+  $name(t) {
+    return this._texture.$name(t), this;
+  }
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), { group: n, binding: a } = t.allocateFixedEntry({ storageTexture: this._format, access: this.access, viewDimension: this.dimension }, this), s = `texture_storage_${qt[this.dimension]}`;
+    return t.addDeclaration(`@group(${n}) @binding(${a}) var ${r}: ${s}<${this._format}, ${sa[this.access]}>;`), r;
+  }
+  toString() {
+    return `${this.resourceType}:${g(this) ?? "<unnamed>"}`;
+  }
+}, xu = class {
+  constructor(t, r, n, a) {
+    this._format = t, this.dimension = r, this.access = n, this._membership = a, this[C] = this, this[c] = {}, this.texelDataType = At[this._format], F(this, a.key);
+  }
+  [C];
+  [c];
+  resourceType = "texture-storage-view";
+  texelDataType;
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), n = t.allocateLayoutEntry(this._membership.layout), a = `texture_storage_${qt[this.dimension]}`;
+    return t.addDeclaration(`@group(${n}) @binding(${this._membership.idx}) var ${r}: ${a}<${this._format}, ${sa[this.access]}>;`), r;
+  }
+  toString() {
+    return `${this.resourceType}:${g(this) ?? "<unnamed>"}`;
+  }
+}, Tu = class {
+  constructor(t, r) {
+    this._props = t, this._texture = r, this[C] = this, this[c] = { unwrap: () => (this._view || (this._view = this._texture[c].unwrap().createView({ label: `${g(this) ?? "<unnamed>"} - View`, ...this._props })), this._view) }, this[Y] = r, this.dimension = t?.dimension ?? r.props.dimension ?? "2d", this._format = t?.format ?? r.props.format, this.channelDataType = yu[this._format];
+  }
+  [C];
+  [c];
+  [Y];
+  resourceType = "texture-sampled-view";
+  channelDataType;
+  dimension;
+  _format;
+  _view;
+  $name(t) {
+    return this._texture.$name(t), this;
+  }
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), n = (this._texture.props.sampleCount ?? 1) > 1, { group: a, binding: s } = t.allocateFixedEntry({ texture: wu[this.channelDataType.type], viewDimension: this.dimension, multisampled: n }, this), i = n ? "texture_multisampled_2d" : `texture_${qt[this.dimension]}`;
+    return t.addDeclaration(`@group(${a}) @binding(${s}) var ${r}: ${i}<${t.resolve(this.channelDataType)}>;`), r;
+  }
+  toString() {
+    return `${this.resourceType}:${g(this) ?? "<unnamed>"}`;
+  }
+}, $u = class {
+  constructor(t, r, n, a) {
+    this.dimension = r, this._multisampled = n, this._membership = a, this[C] = this, this[c] = {}, F(this, a.key), this.channelDataType = gu[t];
+  }
+  [C];
+  [c];
+  resourceType = "texture-sampled-view";
+  channelDataType;
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this)), n = t.allocateLayoutEntry(this._membership.layout), a = this._multisampled ? "texture_multisampled_2d" : `texture_${qt[this.dimension]}`;
+    return t.addDeclaration(`@group(${n}) @binding(${this._membership.idx}) var ${r}: ${a}<${t.resolve(this.channelDataType)}>;`), r;
+  }
+  toString() {
+    return `${this.resourceType}:${g(this) ?? "<unnamed>"}`;
+  }
+};
+function Eu(e) {
+  return !!e?.usableAsSampled;
+}
+var Uu = class ia extends Error {
+  constructor(t) {
+    super(`Resource '${g(t) ?? "<unnamed>"}' cannot be bound as 'sampled'. Use .$usage('sampled') to allow it.`), Object.setPrototypeOf(this, ia.prototype);
+  }
+};
+function oa(e) {
+  return new Su(e);
+}
+function ua(e) {
+  return !!e && e.resourceType === "bind-group-layout";
+}
+function tn(e) {
+  return !!e && e.resourceType === "bind-group";
+}
+var Pu = class la extends Error {
+  constructor(t, r) {
+    super(`Bind group '${t ?? "<unnamed>"}' is missing a required binding '${r}'`), Object.setPrototypeOf(this, la.prototype);
+  }
+}, rn = ["compute"], Ne = ["compute", "vertex", "fragment"], Su = class {
+  constructor(e) {
+    this.entries = e;
+    let t = 0;
+    for (let [r, n] of Object.entries(e)) {
+      if (n === null) {
+        t++;
+        continue;
+      }
+      let a = { layout: this, key: r, idx: t };
+      if ("uniform" in n && (this.bound[r] = new Xr("uniform", n.uniform, a)), "storage" in n) {
+        let s = "type" in n.storage ? n.storage : n.storage(0);
+        this.bound[r] = new Xr(n.access ?? "readonly", s, a);
+      }
+      "texture" in n && (this.bound[r] = new $u(n.texture, n.viewDimension ?? "2d", n.multisampled ?? !1, a)), "storageTexture" in n && (this.bound[r] = new xu(n.storageTexture, n.viewDimension ?? "2d", n.access ?? "writeonly", a)), "externalTexture" in n && (this.bound[r] = new mu(a)), "sampler" in n && (n.sampler === "comparison" ? this.bound[r] = new pu(a) : this.bound[r] = new cu(a)), "texture" in n || "storageTexture" in n || "externalTexture" in n || "sampler" in n ? this.value[r] = this.bound[r] : Object.defineProperty(this.value, r, { get: () => this.bound[r].value }), t++;
+    }
+  }
+  [c] = !0;
+  _index;
+  resourceType = "bind-group-layout";
+  bound = {};
+  value = {};
+  $ = this.value;
+  [j]() {
+    return this.$;
+  }
+  toString() {
+    return `bindGroupLayout:${g(this) ?? "<unnamed>"}`;
+  }
+  get index() {
+    return this._index;
+  }
+  $name(e) {
+    return F(this, e), this;
+  }
+  $idx(e) {
+    return this._index = e, this;
+  }
+  unwrap(e) {
+    return e.device.createBindGroupLayout({ label: g(this) ?? "<unnamed>", entries: Object.values(this.entries).map((t, r) => {
+      if (t === null) return null;
+      let n = t.visibility, a = { binding: r, visibility: 0 };
+      if ("uniform" in t) n = n ?? Ne, a.buffer = { type: "uniform" };
+      else if ("storage" in t) n = n ?? (t.access === "mutable" ? rn : Ne), a.buffer = { type: t.access === "mutable" ? "storage" : "read-only-storage" };
+      else if ("sampler" in t) n = n ?? Ne, a.sampler = { type: t.sampler };
+      else if ("texture" in t) n = n ?? Ne, a.texture = { sampleType: t.texture, viewDimension: t.viewDimension ?? "2d", multisampled: t.multisampled ?? !1 };
+      else if ("storageTexture" in t) {
+        let s = t.access ?? "writeonly";
+        n = n ?? (s === "readonly" ? Ne : rn), a.storageTexture = { format: t.storageTexture, access: { mutable: "read-write", readonly: "read-only", writeonly: "write-only" }[s], viewDimension: t.viewDimension ?? "2d" };
+      } else "externalTexture" in t && (n = n ?? Ne, a.externalTexture = {});
+      return n?.includes("compute") && (a.visibility |= GPUShaderStage.COMPUTE), n?.includes("vertex") && (a.visibility |= GPUShaderStage.VERTEX), n?.includes("fragment") && (a.visibility |= GPUShaderStage.FRAGMENT), a;
+    }).filter((t) => t !== null) });
+  }
+}, da = class {
+  constructor(t, r) {
+    this.layout = t, this.entries = r;
+    for (let n of Object.keys(t.entries)) if (t.entries[n] !== null && !(n in r)) throw new Pu(g(t), n);
+  }
+  resourceType = "bind-group";
+  unwrap(t) {
+    return t.device.createBindGroup({ label: g(this.layout) ?? "<unnamed>", layout: t.unwrap(this.layout), entries: Object.entries(this.layout.entries).map(([r, n], a) => {
+      if (n === null) return null;
+      let s = this.entries[r];
+      if (s === void 0) throw new Error(`'${r}' is a resource required to populate bind group layout '${g(this.layout) ?? "<unnamed>"}'.`);
+      if ("uniform" in n) {
+        let i;
+        if (Qe(s)) {
+          if (!Hn(s)) throw new Xs(s);
+          i = { buffer: t.unwrap(s) };
+        } else i = { buffer: s };
+        return { binding: a, resource: i };
+      }
+      if ("storage" in n) {
+        let i;
+        if (Qe(s)) {
+          if (!Mt(s)) throw new Zr(s);
+          i = { buffer: t.unwrap(s) };
+        } else i = { buffer: s };
+        return { binding: a, resource: i };
+      }
+      if ("texture" in n) {
+        let i;
+        if (at(s)) {
+          if (!Eu(s)) throw new Uu(s);
+          i = t.unwrap(s.createView("sampled"));
+        } else aa(s) ? i = t.unwrap(s) : i = s;
+        return { binding: a, resource: i };
+      }
+      if ("storageTexture" in n) {
+        let i;
+        if (at(s)) {
+          if (!Mt(s)) throw new Zr(s);
+          n.access === "readonly" ? i = t.unwrap(s.createView("readonly")) : n.access === "mutable" ? i = t.unwrap(s.createView("mutable")) : i = t.unwrap(s.createView("writeonly"));
+        } else na(s) ? i = t.unwrap(s) : i = s;
+        return { binding: a, resource: i };
+      }
+      if ("sampler" in n) return ta(s) || ra(s) ? { binding: a, resource: t.unwrap(s) } : { binding: a, resource: s };
+      if ("externalTexture" in n) return { binding: a, resource: s };
+      throw new Error(`Malformed bind group entry: ${s} (${JSON.stringify(s)})`);
+    }).filter((r) => r !== null) });
+  }
+}, ca = "#CATCHALL#", Iu = class {
+  _stack = [];
+  _itemDepth = 0;
+  get itemDepth() {
+    return this._itemDepth;
+  }
+  get topItem() {
+    let e = this._stack[this._stack.length - 1];
+    if (!e || e.type !== "item") throw new Error("Internal error, expected item layer to be on top.");
+    return e;
+  }
+  get topFunctionReturnType() {
+    let e = this._stack.findLast((t) => t.type === "functionScope");
+    if (!e) throw new Error("Internal error, expected function scope to be present.");
+    return e.returnType;
+  }
+  pushItem() {
+    this._itemDepth++, this._stack.push({ type: "item", usedSlots: /* @__PURE__ */ new Set() });
+  }
+  popItem() {
+    this.pop("item");
+  }
+  pushSlotBindings(e) {
+    this._stack.push({ type: "slotBinding", bindingMap: new WeakMap(e) });
+  }
+  popSlotBindings() {
+    this.pop("slotBinding");
+  }
+  pushFunctionScope(e, t, r, n) {
+    this._stack.push({ type: "functionScope", args: e, argAliases: t, returnType: r, externalMap: n });
+  }
+  popFunctionScope() {
+    this.pop("functionScope");
+  }
+  pushBlockScope() {
+    this._stack.push({ type: "blockScope", declarations: /* @__PURE__ */ new Map() });
+  }
+  popBlockScope() {
+    this.pop("blockScope");
+  }
+  pop(e) {
+    let t = this._stack[this._stack.length - 1];
+    if (!t || e && t.type !== e) throw new Error(`Internal error, expected a ${e} layer to be on top.`);
+    this._stack.pop(), e === "item" && this._itemDepth--;
+  }
+  readSlot(e) {
+    for (let t = this._stack.length - 1; t >= 0; --t) {
+      let r = this._stack[t];
+      if (r?.type === "item") r.usedSlots.add(e);
+      else if (r?.type === "slotBinding") {
+        let n = r.bindingMap.get(e);
+        if (n !== void 0) return n;
+      } else if (!(r?.type === "functionScope" || r?.type === "blockScope")) throw new Error("Unknown layer type.");
+    }
+    return e.defaultValue;
+  }
+  getSnippetById(e) {
+    for (let t = this._stack.length - 1; t >= 0; --t) {
+      let r = this._stack[t];
+      if (r?.type === "functionScope") {
+        let n = r.args.find((s) => s.value === e);
+        if (n !== void 0) return n;
+        if (r.argAliases[e]) return r.argAliases[e];
+        let a = r.externalMap[e];
+        return a != null ? qs(a) : void 0;
+      }
+      if (r?.type === "blockScope") {
+        let n = r.declarations.get(e);
+        if (n !== void 0) return u(e, n);
+      }
+    }
+  }
+  defineBlockVariable(e, t) {
+    if (t.type === "unknown") throw Error(`Tried to define variable '${e}' of unknown type`);
+    for (let r = this._stack.length - 1; r >= 0; --r) {
+      let n = this._stack[r];
+      if (n?.type === "blockScope") return n.declarations.set(e, t), u(e, t);
+    }
+    throw new Error("No block scope found to define a variable in.");
+  }
+}, vt = ["", "  ", "    ", "      ", "        ", "          ", "            ", "              ", "                "], Zt = vt.length - 1, ku = class {
+  identLevel = 0;
+  get pre() {
+    return vt[this.identLevel] ?? vt[Zt].repeat(this.identLevel / Zt) + vt[this.identLevel % Zt];
+  }
+  indent() {
+    let e = this.pre;
+    return this.identLevel++, e;
+  }
+  dedent() {
+    return this.identLevel--, this.pre;
+  }
+  withResetLevel(e) {
+    let t = this.identLevel;
+    this.identLevel = 0;
+    try {
+      return e();
+    } finally {
+      this.identLevel = t;
+    }
+  }
+}, pa = class {
+  _memoizedResolves = /* @__PURE__ */ new WeakMap();
+  _memoizedDerived = /* @__PURE__ */ new WeakMap();
+  _indentController = new ku();
+  _itemStateStack = new Iu();
+  #e = [];
+  _declarations = [];
+  _varyingLocations;
+  get varyingLocations() {
+    return this._varyingLocations;
+  }
+  [c] = { itemStateStack: this._itemStateStack };
+  bindGroupLayoutsToPlaceholderMap = /* @__PURE__ */ new Map();
+  _nextFreeLayoutPlaceholderIdx = 0;
+  fixedBindings = [];
+  names;
+  expectedType;
+  constructor(t) {
+    this.names = t.names;
+  }
+  get pre() {
+    return this._indentController.pre;
+  }
+  get topFunctionReturnType() {
+    return this._itemStateStack.topFunctionReturnType;
+  }
+  indent() {
+    return this._indentController.indent();
+  }
+  dedent() {
+    return this._indentController.dedent();
+  }
+  withResetIndentLevel(t) {
+    return this._indentController.withResetLevel(t);
+  }
+  getById(t) {
+    let r = this._itemStateStack.getSnippetById(t);
+    return r === void 0 ? null : r;
+  }
+  defineVariable(t, r) {
+    return this._itemStateStack.defineBlockVariable(t, r);
+  }
+  pushBlockScope() {
+    this._itemStateStack.pushBlockScope();
+  }
+  popBlockScope() {
+    this._itemStateStack.popBlockScope();
+  }
+  fnToWgsl(t) {
+    this._itemStateStack.pushFunctionScope(t.args, t.argAliases, t.returnType, t.externalMap);
+    try {
+      return { head: Mu(this, t.args, t.returnType), body: Ba(this, t.body) };
+    } finally {
+      this._itemStateStack.popFunctionScope();
+    }
+  }
+  addDeclaration(t) {
+    this._declarations.push(t);
+  }
+  allocateLayoutEntry(t) {
+    let r = this.bindGroupLayoutsToPlaceholderMap, n = r.get(t);
+    return n || (n = `#BIND_GROUP_LAYOUT_${this._nextFreeLayoutPlaceholderIdx++}#`, r.set(t, n)), n;
+  }
+  allocateFixedEntry(t, r) {
+    let n = this.fixedBindings.length;
+    return this.fixedBindings.push({ layoutEntry: t, resource: r }), { group: ca, binding: n };
+  }
+  readSlot(t) {
+    let r = this._itemStateStack.readSlot(t);
+    if (r === void 0) throw new Cs(t);
+    return r;
+  }
+  withSlots(t, r) {
+    this._itemStateStack.pushSlotBindings(t);
+    try {
+      return r();
+    } finally {
+      this._itemStateStack.popSlotBindings();
+    }
+  }
+  withVaryingLocations(t, r) {
+    this._varyingLocations = t;
+    try {
+      return r();
+    } finally {
+      this._varyingLocations = void 0;
+    }
+  }
+  unwrap(t) {
+    if (Ar(t)) return this.withSlots(t[Me].pairs, () => this.unwrap(t[Me].inner));
+    let r = t;
+    for (; ; ) if (Or(r)) r = this.readSlot(r);
+    else if (Gr(r)) r = this._getOrCompute(r);
+    else break;
+    return r;
+  }
+  _getOrCompute(t) {
+    let r = this._memoizedDerived.get(t) ?? [];
+    this._itemStateStack.pushItem();
+    try {
+      for (let s of r) if ([...s.slotToValueMap.entries()].every(([i, l]) => i.areEqual(this._itemStateStack.readSlot(i), l))) return s.result;
+      this.pushMode(new Ns());
+      let n;
+      try {
+        n = t["~compute"]();
+      } finally {
+        this.popMode("normal");
+      }
+      let a = /* @__PURE__ */ new Map();
+      for (let s of this._itemStateStack.topItem.usedSlots) a.set(s, this._itemStateStack.readSlot(s));
+      return r.push({ slotToValueMap: a, result: n }), this._memoizedDerived.set(t, r), n;
+    } catch (n) {
+      throw n instanceof ht ? n.appendToTrace(t) : new ht(n, [t]);
+    } finally {
+      this._itemStateStack.popItem();
+    }
+  }
+  _getOrInstantiate(t) {
+    let r = this._memoizedResolves.get(t) ?? [];
+    this._itemStateStack.pushItem();
+    try {
+      for (let s of r) if ([...s.slotToValueMap.entries()].every(([i, l]) => i.areEqual(this._itemStateStack.readSlot(i), l))) return s.result;
+      let n;
+      if (Re(t)) n = Zn(this, t);
+      else if (Gr(t) || Or(t)) n = this.resolve(this.unwrap(t));
+      else if (Ls(t)) n = t["~resolve"](this);
+      else throw new TypeError(`Unresolvable internal value: ${t} (as json: ${JSON.stringify(t)})`);
+      let a = /* @__PURE__ */ new Map();
+      for (let s of this._itemStateStack.topItem.usedSlots) a.set(s, this._itemStateStack.readSlot(s));
+      return r.push({ slotToValueMap: a, result: n }), this._memoizedResolves.set(t, r), n;
+    } catch (n) {
+      throw n instanceof ht ? n.appendToTrace(t) : new ht(n, [t]);
+    } finally {
+      this._itemStateStack.popItem();
+    }
+  }
+  resolve(t, r) {
+    if (Ar(t)) return this.withSlots(t[Me].pairs, () => this.resolve(t[Me].inner, r));
+    if (Ds(t)) {
+      if (this._itemStateStack.itemDepth === 0) try {
+        this.pushMode(new Ws());
+        let n = Sn(this, () => this._getOrInstantiate(t));
+        return `${[...this._declarations].join(`
+
+`)}${n}`;
+      } finally {
+        this.popMode("codegen");
+      }
+      return this._getOrInstantiate(t);
+    }
+    if (typeof t == "number") {
+      if (r?.type === "abstractInt" || r?.type === "u32" || r?.type === "i32") return String(t);
+      let n = t.toExponential(), a = String(t);
+      return n.length < a.length ? n : a;
+    }
+    if (typeof t != "object" && typeof t != "function") return String(t);
+    if (r && lt(r)) {
+      if (!Array.isArray(t)) throw new Vt(`Cannot coerce ${t} into value of type '${r}'`);
+      if (r.elementCount !== t.length) throw new Vt(`Cannot create value of type '${r}' from an array of length: ${t.length}`);
+      return `array<${this.resolve(r.elementType)}, ${r.elementCount}>(${t.map((n) => this.resolve(n, r.elementType))})`;
+    }
+    if (Array.isArray(t)) return `array(${t.map((n) => this.resolve(n))})`;
+    if (r && be(r)) return `${this.resolve(r)}(${Object.entries(r.propTypes).map(([n, a]) => this.resolve(t[n], a))})`;
+    throw new Vt(`Value ${t} (as json: ${JSON.stringify(t)}) is not resolvable${r ? ` to type ${r}` : ""}`);
+  }
+  pushMode(t) {
+    this.#e.push(t);
+  }
+  popMode(t) {
+    let r = this.#e.pop();
+    t !== void 0 && Pt(r?.type === t, "Unexpected mode");
+  }
+  get mode() {
+    return this.#e[this.#e.length - 1] ?? zs;
+  }
+};
+function st(e, t, r) {
+  let n = new pa(t), a = r ? n.withSlots(r(new Xn([])).bindings, () => n.resolve(e)) : n.resolve(e), s = n.bindGroupLayoutsToPlaceholderMap, i = [], l = new Set([...s.keys()].map((b) => b.index).filter((b) => b !== void 0)), o = Qo(l), y = n.fixedBindings.map((b, v) => [String(v), b.layoutEntry]), h = () => {
+    let b = o.next().value, v = oa(Object.fromEntries(y));
+    return i[b] = v, a = a.replaceAll(ca, String(b)), [b, new da(v, Object.fromEntries(n.fixedBindings.map((x, P) => [String(P), x.resource])))];
+  }, w = y.length > 0 ? h() : void 0;
+  for (let [b, v] of s.entries()) {
+    let x = b.index ?? o.next().value;
+    i[x] = b, a = a.replaceAll(v, String(x));
+  }
+  return { code: a, usedBindGroupLayouts: i, catchall: w };
+}
+function Mu(e, t, r) {
+  let n = t.map((a) => `${a.value}: ${e.resolve(a.dataType)}`).join(", ");
+  return r.type !== "void" ? `(${n}) -> ${lr(r)}${e.resolve(r)} ` : `(${n}) `;
+}
+function ha(e) {
+  let { externals: t, template: r, names: n, config: a } = e, s = {};
+  Xe(s, t ?? {});
+  let i = { [c]: !0, "~resolve"(l) {
+    return Dt(l, s, r ?? "");
+  }, toString: () => "<root>" };
+  return st(i, { names: n === "strict" ? new Yt() : new $r() }, a);
+}
+function Au(e) {
+  return ha(e).code;
+}
+function Ou(e) {
+  let t = tt() ?? new pa({ names: new Yt() }), r = [1, 1, 1], n = [1, 1, 1], a = [r[0] * n[0], r[1] * n[1], r[2] * n[2]], s = /* @__PURE__ */ new Map(), i = Array.from({ length: r[0] }, () => Array.from({ length: r[1] }, () => Array.from({ length: r[2] }, () => /* @__PURE__ */ new Map()))), l = Array.from({ length: a[0] }, () => Array.from({ length: a[1] }, () => Array.from({ length: a[2] }, () => /* @__PURE__ */ new Map()))), o = Array.from({ length: a[0] }, (y, h) => Array.from({ length: a[1] }, (w, b) => Array.from({ length: a[2] }, (v, x) => {
+    let P = Math.floor(h / n[0]), $ = Math.floor(b / n[1]), k = Math.floor(x / n[2]);
+    return new Fs(s, { private: l[h][b][x], workgroup: i[P][$][k] });
+  })));
+  t.pushMode(o[0][0][0]);
+  try {
+    return { value: Sn(t, e), buffers: s, privateVars: l, workgroupVars: i };
+  } finally {
+    t.popMode("simulate");
+  }
+}
+function Gu(e, t, r, n) {
+  return new Bu(e, t, r, n);
+}
+function Ur(e) {
+  let t = e;
+  return t?.resourceType === "query-set" && !!t[c];
+}
+var Bu = class {
+  constructor(e, t, r, n) {
+    this._group = e, this.type = t, this.count = r, this.rawQuerySet = n, this._ownQuerySet = !n, this._querySet = n || null;
+  }
+  resourceType = "query-set";
+  _querySet = null;
+  _ownQuerySet;
+  _destroyed = !1;
+  _available = !0;
+  _readBuffer = null;
+  _resolveBuffer = null;
+  get querySet() {
+    if (this._destroyed) throw new Error("This QuerySet has been destroyed.");
+    return this.rawQuerySet ? this.rawQuerySet : this._querySet ? this._querySet : (this._querySet = this._group.device.createQuerySet({ type: this.type, count: this.count }), this._querySet);
+  }
+  get destroyed() {
+    return this._destroyed;
+  }
+  get available() {
+    return this._available;
+  }
+  get [c]() {
+    let e = this;
+    return { get readBuffer() {
+      return e._readBuffer || (e._readBuffer = e._group.device.createBuffer({ size: e.count * BigUint64Array.BYTES_PER_ELEMENT, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ })), e._readBuffer;
+    }, get resolveBuffer() {
+      return e._resolveBuffer || (e._resolveBuffer = e._group.device.createBuffer({ size: e.count * BigUint64Array.BYTES_PER_ELEMENT, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC })), e._resolveBuffer;
+    } };
+  }
+  $name(e) {
+    return F(this, e), this._querySet && (this._querySet.label = e), this;
+  }
+  resolve() {
+    if (this._destroyed) throw new Error("This QuerySet has been destroyed.");
+    if (!this._available) throw new Error("This QuerySet is busy resolving or reading.");
+    let e = this._group.device.createCommandEncoder();
+    e.resolveQuerySet(this.querySet, 0, this.count, this[c].resolveBuffer, 0), this._group.device.queue.submit([e.finish()]);
+  }
+  async read() {
+    if (this._group.flush(), !this._resolveBuffer) throw new Error("QuerySet must be resolved before reading.");
+    this._available = !1;
+    try {
+      let e = this._group.device.createCommandEncoder();
+      e.copyBufferToBuffer(this[c].resolveBuffer, 0, this[c].readBuffer, 0, this.count * BigUint64Array.BYTES_PER_ELEMENT), this._group.device.queue.submit([e.finish()]), await this._group.device.queue.onSubmittedWorkDone();
+      let t = this[c].readBuffer;
+      await t.mapAsync(GPUMapMode.READ);
+      let r = new BigUint64Array(t.getMappedRange().slice());
+      return t.unmap(), Array.from(r);
+    } finally {
+      this._available = !0;
+    }
+  }
+  destroy() {
+    this._destroyed || (this._destroyed = !0, this._querySet && this._ownQuerySet && this._querySet.destroy(), this._readBuffer?.destroy(), this._resolveBuffer?.destroy(), this._readBuffer = this._resolveBuffer = null);
+  }
+}, nn = class {
+  constructor(t) {
+    this._make = t;
+  }
+  _map = /* @__PURE__ */ new WeakMap();
+  getOrMake(t, ...r) {
+    if (this._map.has(t)) return this._map.get(t);
+    let n = this._make(t, ...r);
+    return this._map.set(t, n), n;
+  }
+};
+function fa(e, t, r) {
+  if (!r.enabledFeatures.has("timestamp-query")) throw new Error('Performance callback requires the "timestamp-query" feature to be enabled on GPU device.');
+  return e.timestampWrites ? { ...e, performanceCallback: t } : { ...e, performanceCallback: t, hasAutoQuerySet: !0, timestampWrites: { querySet: (globalThis.__TYPEGPU_AUTONAME__ ?? ((n) => n))(r.createQuerySet("timestamp", 2), "querySet"), beginningOfPassWriteIndex: 0, endOfPassWriteIndex: 1 } };
+}
+function ma(e, t, r) {
+  if (!r.enabledFeatures.has("timestamp-query")) throw new Error('Timestamp writes require the "timestamp-query" feature to be enabled on GPU device.');
+  e.hasAutoQuerySet && e.timestampWrites && e.timestampWrites.querySet.destroy();
+  let n = { querySet: t.querySet };
+  return t.beginningOfPassWriteIndex !== void 0 && (n.beginningOfPassWriteIndex = t.beginningOfPassWriteIndex), t.endOfPassWriteIndex !== void 0 && (n.endOfPassWriteIndex = t.endOfPassWriteIndex), { ...e, hasAutoQuerySet: !1, timestampWrites: n };
+}
+function ya(e, t) {
+  if (!e.timestampWrites) return {};
+  let { querySet: r, beginningOfPassWriteIndex: n, endOfPassWriteIndex: a } = e.timestampWrites, s = { querySet: Ur(r) ? t.unwrap(r) : r };
+  return n !== void 0 && (s.beginningOfPassWriteIndex = n), a !== void 0 && (s.endOfPassWriteIndex = a), { timestampWrites: s };
+}
+function rr({ root: e, priors: t }) {
+  let r = t.timestampWrites?.querySet, n = t.performanceCallback;
+  if (!r) throw new Error("Cannot dispatch workgroups with performance callback without a query set.");
+  if (!Ur(r)) throw new Error("Performance callback with raw GPUQuerySet is not supported. Use TgpuQuerySet instead.");
+  e.commandEncoder.resolveQuerySet(e.unwrap(r), 0, r.count, r[c].resolveBuffer, 0), e.flush(), e.device.queue.onSubmittedWorkDone().then(async () => {
+    if (!r.available) return;
+    let a = await r.read(), s = a[t.timestampWrites?.beginningOfPassWriteIndex ?? 0], i = a[t.timestampWrites?.endOfPassWriteIndex ?? 1];
+    if (s === void 0 || i === void 0) throw new Error("QuerySet did not return valid timestamps.");
+    await n(s, i);
+  });
+}
+function Fu(e, t, r) {
+  return new Nu(new Lu(e, t, r), {});
+}
+function Cu(e) {
+  let t = e;
+  return t?.resourceType === "compute-pipeline" && !!t[c];
+}
+var Nu = class _t {
+  constructor(t, r) {
+    this._core = t, this._priors = r, this[c] = { get rawPipeline() {
+      return t.unwrap().pipeline;
+    }, get priors() {
+      return r;
+    } }, this[Y] = t;
+  }
+  [c];
+  resourceType = "compute-pipeline";
+  [Y];
+  "~resolve"(t) {
+    return t.resolve(this._core);
+  }
+  toString() {
+    return `computePipeline:${g(this) ?? "<unnamed>"}`;
+  }
+  get rawPipeline() {
+    return this._core.unwrap().pipeline;
+  }
+  with(t, r) {
+    return new _t(this._core, { ...this._priors, bindGroupLayoutMap: new Map([...this._priors.bindGroupLayoutMap ?? [], [t, r]]) });
+  }
+  withPerformanceCallback(t) {
+    let r = fa(this._priors, t, this._core.branch);
+    return new _t(this._core, r);
+  }
+  withTimestampWrites(t) {
+    let r = ma(this._priors, t, this._core.branch);
+    return new _t(this._core, r);
+  }
+  dispatchWorkgroups(t, r, n) {
+    let a = this._core.unwrap(), { branch: s } = this._core, i = { label: g(this._core) ?? "<unnamed>", ...ya(this._priors, s) }, l = s.commandEncoder.beginComputePass(i);
+    l.setPipeline(a.pipeline);
+    let o = new Set(a.usedBindGroupLayouts);
+    if (a.usedBindGroupLayouts.forEach((y, h) => {
+      if (a.catchall && h === a.catchall[0]) l.setBindGroup(h, s.unwrap(a.catchall[1])), o.delete(y);
+      else {
+        let w = this._priors.bindGroupLayoutMap?.get(y);
+        w !== void 0 && (o.delete(y), l.setBindGroup(h, s.unwrap(w)));
+      }
+    }), o.size > 0) throw new fr(o);
+    l.dispatchWorkgroups(t, r, n), l.end(), this._priors.performanceCallback && rr({ root: s, priors: this._priors });
+  }
+  $name(t) {
+    return F(this._core, t), this;
+  }
+}, Lu = class {
+  constructor(e, t, r) {
+    this.branch = e, this._slotBindings = t, this._entryFn = r;
+  }
+  [c] = !0;
+  _memo;
+  "~resolve"(e) {
+    return e.withSlots(this._slotBindings, () => (e.resolve(this._entryFn), ""));
+  }
+  toString() {
+    return "computePipelineCore";
+  }
+  unwrap() {
+    if (this._memo === void 0) {
+      let e = this.branch.device, t, r;
+      if (De?.enabled) {
+        let l = performance.mark("typegpu:resolution:start");
+        t = st(this, { names: this.branch.nameRegistry }), r = performance.measure("typegpu:resolution", { start: l.name });
+      } else t = st(this, { names: this.branch.nameRegistry });
+      let { code: n, usedBindGroupLayouts: a, catchall: s } = t;
+      s !== void 0 && a[s[0]]?.$name(`${g(this) ?? "<unnamed>"} - Automatic Bind Group & Layout`);
+      let i = e.createShaderModule({ label: `${g(this) ?? "<unnamed>"} - Shader`, code: n });
+      this._memo = { pipeline: e.createComputePipeline({ label: g(this) ?? "<unnamed>", layout: e.createPipelineLayout({ label: `${g(this) ?? "<unnamed>"} - Pipeline Layout`, bindGroupLayouts: a.map((l) => this.branch.unwrap(l)) }), compute: { module: i } }), usedBindGroupLayouts: a, catchall: s }, De?.enabled && (async () => {
+        let l = performance.mark("typegpu:compile-start");
+        await e.queue.onSubmittedWorkDone();
+        let o = performance.measure("typegpu:compiled", { start: l.name });
+        De?.record("resolution", { resolveDuration: r?.duration, compileDuration: o.duration, wgslSize: n.length });
+      })();
+    }
+    return this._memo;
+  }
+};
+function an(e, t = "vertex") {
+  return new Du(e, t);
+}
+function wa(e) {
+  return e?.resourceType === "vertex-layout";
+}
+var nr = Symbol("defaultAttribEntry");
+function xt(e, t, r, n, a) {
+  if (dr(t) || wn(t)) {
+    let s = Pe(t);
+    return s !== void 0 && (n[a ?? nr] = s), xt(e, t.inner, $e(r, Oe(t)), n);
+  }
+  if (be(t)) {
+    let s = r, i = t.propTypes;
+    return Object.fromEntries(Object.entries(i).map(([l, o]) => {
+      s = $e(s, re(o));
+      let y = [l, xt(e, o, s, n, l)];
+      return s += D(o), y;
+    }));
+  }
+  if (ut(t)) {
+    let s = r, i = t.propTypes;
+    return Object.fromEntries(Object.entries(i).map(([l, o]) => {
+      s = $e(s, Oe(o));
+      let y = [l, xt(e, o, s, n, l)];
+      return s += D(o), y;
+    }));
+  }
+  if ("type" in t && typeof t.type == "string") {
+    if (Js.includes(t.type)) return { _layout: e, format: t.type, offset: r };
+    let s = Zs[t.type];
+    if (s) return { _layout: e, format: s, offset: r };
+  }
+  throw new Error(`Unsupported data used in vertex layout: ${String(t)}`);
+}
+var Du = class {
+  constructor(e, t) {
+    this.schemaForCount = e, this.stepMode = t;
+    let r = e(0);
+    this.stride = $e(D(r.elementType), re(r)), this.attrib = xt(this, r.elementType, 0, this._customLocationMap);
+  }
+  [c] = !0;
+  resourceType = "vertex-layout";
+  stride;
+  attrib;
+  _customLocationMap = {};
+  get vertexLayout() {
+    if (this._customLocationMap[nr] !== void 0) {
+      if (typeof this.attrib.format != "string" || typeof this.attrib.offset != "number") throw new Error("Single attribute vertex layouts must have a format and offset.");
+      return { arrayStride: this.stride, stepMode: this.stepMode, attributes: [{ format: this.attrib.format, offset: this.attrib.offset, shaderLocation: this._customLocationMap[nr] }] };
+    }
+    if (!Object.keys(this.attrib).every((e) => this._customLocationMap[e] !== void 0)) throw new Error("All attributes must have custom locations in order to unwrap a vertex layout.");
+    return { arrayStride: this.stride, stepMode: this.stepMode, attributes: [...Object.entries(this.attrib).map(([e, t]) => ({ format: t.format, offset: t.offset, shaderLocation: this._customLocationMap[e] }))] };
+  }
+  $name(e) {
+    return F(this, e), this;
+  }
+};
+function Wu(e) {
+  return typeof e?.loadOp == "string";
+}
+function zu(e, t) {
+  if (Re(e)) {
+    if (!Wu(t)) throw new Error("Expected a single color attachment, not a record.");
+    return [t];
+  }
+  let r = [];
+  for (let n of Object.keys(e)) {
+    let a = t[n];
+    if (!a) throw new Error(`A color attachment by the name of '${n}' was not provided to the shader.`);
+    r.push(a);
+  }
+  return r;
+}
+function Yu(e) {
+  return typeof e?.format == "string";
+}
+function Ru(e, t) {
+  if (Re(e)) {
+    if (In(e)) return [];
+    if (!Yu(t)) throw new Error("Expected a single color target configuration, not a record.");
+    return [t];
+  }
+  let r = [];
+  for (let n of Object.keys(e)) {
+    let a = t[n];
+    if (!a) throw new Error(`A color target by the name of '${n}' was not provided to the shader.`);
+    r.push(a);
+  }
+  return r;
+}
+function qu(e) {
+  return new Vu(new Ju(e), {});
+}
+function ju(e) {
+  let t = e;
+  return t?.resourceType === "render-pipeline" && !!t[c];
+}
+var Vu = class me {
+  [c];
+  resourceType = "render-pipeline";
+  [Y];
+  hasIndexBuffer = !1;
+  constructor(t, r) {
+    this[c] = { core: t, priors: r }, this[Y] = t;
+  }
+  "~resolve"(t) {
+    return t.resolve(this[c].core);
+  }
+  toString() {
+    return `renderPipeline:${g(this) ?? "<unnamed>"}`;
+  }
+  $name(t) {
+    return F(this[c].core, t), this;
+  }
+  with(t, r) {
+    let n = this[c];
+    if (ua(t)) return new me(n.core, { ...n.priors, bindGroupLayoutMap: new Map([...n.priors.bindGroupLayoutMap ?? [], [t, r]]) });
+    if (wa(t)) return new me(n.core, { ...n.priors, vertexLayoutMap: new Map([...n.priors.vertexLayoutMap ?? [], [t, r]]) });
+    throw new Error("Unsupported value passed into .with()");
+  }
+  withPerformanceCallback(t) {
+    let r = this[c], n = fa(r.priors, t, r.core.options.branch);
+    return new me(r.core, n);
+  }
+  withTimestampWrites(t) {
+    let r = this[c], n = ma(r.priors, t, r.core.options.branch);
+    return new me(r.core, n);
+  }
+  withColorAttachment(t) {
+    let r = this[c];
+    return new me(r.core, { ...r.priors, colorAttachment: t });
+  }
+  withDepthStencilAttachment(t) {
+    let r = this[c];
+    return new me(r.core, { ...r.priors, depthStencilAttachment: t });
+  }
+  withIndexBuffer(t, r, n, a) {
+    let s = this[c];
+    if (Kt(t)) {
+      if (typeof r != "string") throw new Error("If a GPUBuffer is passed, indexFormat must be provided.");
+      return new me(s.core, { ...s.priors, indexBuffer: { buffer: t, indexFormat: r, offsetBytes: n, sizeBytes: a } });
+    }
+    let i = { u32: "uint32", u16: "uint16" }, l = t.dataType.elementType;
+    return new me(s.core, { ...s.priors, indexBuffer: { buffer: t, indexFormat: i[l.type], offsetBytes: r !== void 0 ? r * Qt(l) : void 0, sizeBytes: a !== void 0 ? a * Qt(l) : void 0 } });
+  }
+  setupRenderPass() {
+    let t = this[c], r = t.core.unwrap(), { branch: n, fragmentFn: a } = t.core.options, s = zu(a.shell.out, t.priors.colorAttachment ?? {}).map((h) => at(h.view) ? { ...h, view: n.unwrap(h.view).createView() } : h), i = { label: g(t.core) ?? "<unnamed>", colorAttachments: s, ...ya(t.priors, n) };
+    if (t.priors.depthStencilAttachment !== void 0) {
+      let h = t.priors.depthStencilAttachment;
+      at(h.view) ? i.depthStencilAttachment = { ...h, view: n.unwrap(h.view).createView() } : i.depthStencilAttachment = h;
+    }
+    let l = n.commandEncoder.beginRenderPass(i);
+    l.setPipeline(r.pipeline);
+    let o = new Set(r.usedBindGroupLayouts);
+    r.usedBindGroupLayouts.forEach((h, w) => {
+      if (r.catchall && w === r.catchall[0]) l.setBindGroup(w, n.unwrap(r.catchall[1])), o.delete(h);
+      else {
+        let b = t.priors.bindGroupLayoutMap?.get(h);
+        b !== void 0 && (o.delete(h), l.setBindGroup(w, n.unwrap(b)));
+      }
+    });
+    let y = new Set(t.core.usedVertexLayouts);
+    if (t.core.usedVertexLayouts.forEach((h, w) => {
+      let b = t.priors.vertexLayoutMap?.get(h);
+      b && (y.delete(h), l.setVertexBuffer(w, n.unwrap(b)));
+    }), o.size > 0) throw new fr(o);
+    if (y.size > 0) throw new Mn(y);
+    return l;
+  }
+  draw(t, r, n, a) {
+    let s = this[c], i = this.setupRenderPass(), { branch: l } = s.core.options;
+    i.draw(t, r, n, a), i.end(), s.priors.performanceCallback ? rr({ root: l, priors: s.priors }) : l.flush();
+  }
+  drawIndexed(t, r, n, a, s) {
+    let i = this[c];
+    if (!i.priors.indexBuffer) throw new Error("No index buffer set for this render pipeline.");
+    let { buffer: l, indexFormat: o, offsetBytes: y, sizeBytes: h } = i.priors.indexBuffer, w = this.setupRenderPass(), { branch: b } = i.core.options;
+    Kt(l) ? w.setIndexBuffer(l, o, y, h) : w.setIndexBuffer(b.unwrap(l), o, y, h), w.drawIndexed(t, r, n, a, s), w.end(), i.priors.performanceCallback ? rr({ root: b, priors: i.priors }) : b.flush();
+  }
+}, Ju = class {
+  constructor(e) {
+    this.options = e;
+    let t = Ro(e.vertexFn.shell.in ?? {}, e.vertexAttribs);
+    this._vertexBufferLayouts = t.bufferDefinitions, this.usedVertexLayouts = t.usedVertexLayouts, this._targets = Ru(e.fragmentFn.shell.out, e.targets);
+  }
+  [c] = !0;
+  usedVertexLayouts;
+  _memo;
+  _vertexBufferLayouts;
+  _targets;
+  "~resolve"(e) {
+    let { vertexFn: t, fragmentFn: r, slotBindings: n } = this.options, a = Zu(t.shell.out, r.shell.in, g(t) ?? "<unnamed>", g(r) ?? "<unnamed>");
+    return e.withVaryingLocations(a, () => e.withSlots(n, () => (e.resolve(t), e.resolve(r), "")));
+  }
+  toString() {
+    return "renderPipelineCore";
+  }
+  unwrap() {
+    if (this._memo === void 0) {
+      let { branch: e, primitiveState: t, depthStencilState: r, multisampleState: n } = this.options, a = e.device, s, i;
+      if (De?.enabled) {
+        let v = performance.mark("typegpu:resolution:start");
+        s = st(this, { names: e.nameRegistry }), i = performance.measure("typegpu:resolution", { start: v.name });
+      } else s = st(this, { names: e.nameRegistry });
+      let { code: l, usedBindGroupLayouts: o, catchall: y } = s;
+      y !== void 0 && o[y[0]]?.$name(`${g(this) ?? "<unnamed>"} - Automatic Bind Group & Layout`);
+      let h = a.createShaderModule({ label: `${g(this) ?? "<unnamed>"} - Shader`, code: l }), w = { layout: a.createPipelineLayout({ label: `${g(this) ?? "<unnamed>"} - Pipeline Layout`, bindGroupLayouts: o.map((v) => e.unwrap(v)) }), vertex: { module: h, buffers: this._vertexBufferLayouts }, fragment: { module: h, targets: this._targets } }, b = g(this);
+      b !== void 0 && (w.label = b), t && (ie(t.stripIndexFormat) ? w.primitive = { ...t, stripIndexFormat: { u32: "uint32", u16: "uint16" }[t.stripIndexFormat.type] } : w.primitive = t), r && (w.depthStencil = r), n && (w.multisample = n), this._memo = { pipeline: a.createRenderPipeline(w), usedBindGroupLayouts: o, catchall: y }, De?.enabled && (async () => {
+        let v = performance.mark("typegpu:compile-start");
+        await a.queue.onSubmittedWorkDone();
+        let x = performance.measure("typegpu:compiled", { start: v.name });
+        De?.record("resolution", { resolveDuration: i?.duration, compileDuration: x.duration, wgslSize: l.length });
+      })();
+    }
+    return this._memo;
+  }
+};
+function Zu(e, t, r, n) {
+  let a = {}, s = /* @__PURE__ */ new Set();
+  function i(o, y) {
+    a[o] = y, s.add(y);
+  }
+  for (let [o, y] of Object.entries(e)) {
+    let h = Pe(y);
+    h !== void 0 && i(o, h);
+  }
+  for (let [o, y] of Object.entries(t ?? {})) {
+    let h = Pe(y);
+    h !== void 0 && (a[o] === void 0 ? i(o, h) : a[o] !== h && console.warn(`Mismatched location between vertexFn (${r}) output (${a[o]}) and fragmentFn (${n}) input (${h}) for the key "${o}", using the location set on vertex output.`));
+  }
+  let l = 0;
+  for (let o of Object.keys(e ?? {})) if (!(Ft(e[o]) || a[o] !== void 0)) {
+    for (; s.has(l); ) l++;
+    i(o, l);
+  }
+  return a;
+}
+function Xu(e) {
+  return e instanceof Tt;
+}
+var Tt = class {
+  constructor(e, t) {
+    this.resourceType = e, this.buffer = t, this[Y] = t, this.#e = this.buffer.as(this.resourceType);
+  }
+  [c] = !0;
+  [Y];
+  #e;
+  $name(e) {
+    return F(this[Y], e), this;
+  }
+  write(e) {
+    this.buffer.write(e);
+  }
+  writePartial(e) {
+    this.buffer.writePartial(e);
+  }
+  read() {
+    return this.buffer.read();
+  }
+  [j](e) {
+    return this.#e.$;
+  }
+  get $() {
+    return this.#e.$;
+  }
+  get value() {
+    return this.$;
+  }
+  "~resolve"(e) {
+    return e.resolve(this.#e);
+  }
+}, Qu = class ar {
+  constructor(t, r) {
+    this._getRoot = t, this._slotBindings = r;
+  }
+  with(t, r) {
+    return new ar(this._getRoot, [...this._slotBindings, [Nt(t) ? t.slot : t, r]]);
+  }
+  withCompute(t) {
+    return new Ku(this._getRoot(), this._slotBindings, t);
+  }
+  withVertex(t, r) {
+    return new Hu({ branch: this._getRoot(), primitiveState: void 0, depthStencilState: void 0, slotBindings: this._slotBindings, vertexFn: t, vertexAttribs: r, multisampleState: void 0 });
+  }
+  pipe(t) {
+    let r = t(new Xn([]));
+    return new ar(this._getRoot, [...this._slotBindings, ...r.bindings]);
+  }
+}, Ku = class {
+  constructor(e, t, r) {
+    this._root = e, this._slotBindings = t, this._entryFn = r;
+  }
+  createPipeline() {
+    return Fu(this._root, this._slotBindings, this._entryFn);
+  }
+}, Hu = class {
+  constructor(e) {
+    this._options = e;
+  }
+  withFragment(e, t, r) {
+    return Pt(typeof e != "string", "Just type mismatch validation"), Pt(typeof t != "string", "Just type mismatch validation"), new el({ ...this._options, fragmentFn: e, targets: t });
+  }
+}, el = class $t {
+  constructor(t) {
+    this._options = t;
+  }
+  withPrimitive(t) {
+    return new $t({ ...this._options, primitiveState: t });
+  }
+  withDepthStencil(t) {
+    return new $t({ ...this._options, depthStencilState: t });
+  }
+  withMultisample(t) {
+    return new $t({ ...this._options, multisampleState: t });
+  }
+  createPipeline() {
+    return qu(this._options);
+  }
+}, ga = class extends Qu {
+  constructor(t, r, n) {
+    super(() => this, []), this.device = t, this.nameRegistry = r, this._ownDevice = n, this["~unstable"] = this;
+  }
+  "~unstable";
+  _disposables = [];
+  _unwrappedBindGroupLayouts = new nn((t) => t.unwrap(this));
+  _unwrappedBindGroups = new nn((t) => t.unwrap(this));
+  _commandEncoder = null;
+  get commandEncoder() {
+    return this._commandEncoder || (this._commandEncoder = this.device.createCommandEncoder()), this._commandEncoder;
+  }
+  get enabledFeatures() {
+    return new Set(this.device.features);
+  }
+  createBuffer(t, r) {
+    let n = wt(this, t, r);
+    return this._disposables.push(n), n;
+  }
+  createUniform(t, r) {
+    let n = wt(this, t, r).$usage("uniform");
+    return this._disposables.push(n), new Tt("uniform", n);
+  }
+  createMutable(t, r) {
+    let n = wt(this, t, r).$usage("storage");
+    return this._disposables.push(n), new Tt("mutable", n);
+  }
+  createReadonly(t, r) {
+    let n = wt(this, t, r).$usage("storage");
+    return this._disposables.push(n), new Tt("readonly", n);
+  }
+  createQuerySet(t, r, n) {
+    return Gu(this, t, r, n);
+  }
+  createBindGroup(t, r) {
+    return new da(t, r);
+  }
+  destroy() {
+    for (let t of this._disposables) t.destroy();
+    this._ownDevice && this.device.destroy();
+  }
+  createTexture(t) {
+    let r = bu(t, this);
+    return this._disposables.push(r), r;
+  }
+  unwrap(t) {
+    if (Cu(t)) return t[c].rawPipeline;
+    if (ju(t)) return t[c].core.unwrap().pipeline;
+    if (ua(t)) return this._unwrappedBindGroupLayouts.getOrMake(t);
+    if (tn(t)) return this._unwrappedBindGroups.getOrMake(t);
+    if (Qe(t)) return t.buffer;
+    if (at(t)) return t[c].unwrap();
+    if (na(t)) {
+      if (t[c].unwrap) return t[c].unwrap();
+      throw new Error("Cannot unwrap laid-out texture view.");
+    }
+    if (aa(t)) {
+      if (t[c].unwrap) return t[c].unwrap();
+      throw new Error("Cannot unwrap laid-out texture view.");
+    }
+    if (wa(t)) return t.vertexLayout;
+    if (ta(t)) {
+      if (t[c].unwrap) return t[c].unwrap(this);
+      throw new Error("Cannot unwrap laid-out sampler.");
+    }
+    if (ra(t)) {
+      if (t[c].unwrap) return t[c].unwrap(this);
+      throw new Error("Cannot unwrap laid-out comparison sampler.");
+    }
+    if (Ur(t)) return t.querySet;
+    throw new Error(`Unknown resource type: ${t}`);
+  }
+  beginRenderPass(t, r) {
+    let n = this.commandEncoder.beginRenderPass(t), a = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), i, l = () => {
+      if (!i) throw new Error("Cannot draw without a call to pass.setPipeline");
+      let { core: o, priors: y } = i[c], h = o.unwrap();
+      n.setPipeline(h.pipeline);
+      let w = new Set(h.usedBindGroupLayouts);
+      h.usedBindGroupLayouts.forEach((v, x) => {
+        if (h.catchall && x === h.catchall[0]) n.setBindGroup(x, this.unwrap(h.catchall[1])), w.delete(v);
+        else {
+          let P = y.bindGroupLayoutMap?.get(v) ?? a.get(v);
+          P !== void 0 && (w.delete(v), tn(P) ? n.setBindGroup(x, this.unwrap(P)) : n.setBindGroup(x, P));
+        }
+      });
+      let b = /* @__PURE__ */ new Set();
+      if (o.usedVertexLayouts.forEach((v, x) => {
+        let P = y.vertexLayoutMap?.get(v), $ = P ? { buffer: P, offset: void 0, size: void 0 } : s.get(v);
+        !$ || !$.buffer ? b.add(v) : Qe($.buffer) ? n.setVertexBuffer(x, this.unwrap($.buffer), $.offset, $.size) : n.setVertexBuffer(x, $.buffer, $.offset, $.size);
+      }), w.size > 0) throw new fr(w);
+      if (b.size > 0) throw new Mn(b);
+    };
+    r({ setViewport(...o) {
+      n.setViewport(...o);
+    }, setScissorRect(...o) {
+      n.setScissorRect(...o);
+    }, setBlendConstant(...o) {
+      n.setBlendConstant(...o);
+    }, setStencilReference(...o) {
+      n.setStencilReference(...o);
+    }, beginOcclusionQuery(...o) {
+      n.beginOcclusionQuery(...o);
+    }, endOcclusionQuery(...o) {
+      n.endOcclusionQuery(...o);
+    }, executeBundles(...o) {
+      n.executeBundles(...o);
+    }, setPipeline(o) {
+      i = o;
+    }, setIndexBuffer: (o, y, h, w) => {
+      Qe(o) ? n.setIndexBuffer(this.unwrap(o), y, h, w) : n.setIndexBuffer(o, y, h, w);
+    }, setVertexBuffer(o, y, h, w) {
+      s.set(o, { buffer: y, offset: h, size: w });
+    }, setBindGroup(o, y) {
+      a.set(o, y);
+    }, draw(o, y, h, w) {
+      l(), n.draw(o, y, h, w);
+    }, drawIndexed(...o) {
+      l(), n.drawIndexed(...o);
+    }, drawIndirect(...o) {
+      l(), n.drawIndirect(...o);
+    }, drawIndexedIndirect(...o) {
+      l(), n.drawIndexedIndirect(...o);
+    } }), n.end();
+  }
+  flush() {
+    this._commandEncoder && (this.device.queue.submit([this._commandEncoder.finish()]), this._commandEncoder = null);
+  }
+};
+async function tl(e) {
+  let { adapter: t, device: r, unstable_names: n = "random" } = e ?? {};
+  if (!navigator.gpu) throw new Error("WebGPU is not supported by this browser.");
+  let a = await navigator.gpu.requestAdapter(t);
+  if (!a) throw new Error("Could not find a compatible GPU");
+  let s = [];
+  for (let i of r?.requiredFeatures ?? []) {
+    if (!a.features.has(i)) throw new Error(`Requested feature "${i}" is not supported by the adapter.`);
+    s.push(i);
+  }
+  for (let i of r?.optionalFeatures ?? []) a.features.has(i) ? s.push(i) : console.warn(`Optional feature "${i}" is not supported by the adapter.`);
+  return new ga(await a.requestDevice({ ...r, requiredFeatures: s }), n === "random" ? new $r() : new Yt(), !0);
+}
+function rl(e) {
+  let { device: t, unstable_names: r = "random" } = e ?? {};
+  return new ga(t, r === "random" ? new $r() : new Yt(), !1);
+}
+function sr(e) {
+  return new nl(e);
+}
+var nl = class {
+  constructor(e = void 0) {
+    this.defaultValue = e;
+  }
+  [c] = !0;
+  resourceType = "slot";
+  $name(e) {
+    return F(this, e), this;
+  }
+  areEqual(e, t) {
+    return Object.is(e, t);
+  }
+  toString() {
+    return `slot:${g(this) ?? "<unnamed>"}`;
+  }
+  [j](e) {
+    return Tr(e, e.unwrap(this));
+  }
+  get value() {
+    let e = tt();
+    if (!e) throw new Error("Cannot access tgpu.slot's value outside of resolution.");
+    return this[j](e);
+  }
+  get $() {
+    return this.value;
+  }
+};
+function al(e, t) {
+  return new sl(e, t);
+}
+var sl = class {
+  constructor(e, t = void 0) {
+    this.schema = e, this.defaultValue = t, this.slot = sr(t), this[Y] = this.slot;
+  }
+  [c] = !0;
+  resourceType = "accessor";
+  slot;
+  [Y];
+  $name(e) {
+    return this.slot.$name(e), this;
+  }
+  toString() {
+    return `accessor:${g(this) ?? "<unnamed>"}`;
+  }
+  [j]() {
+    return new Proxy({ [c]: !0, "~resolve": (e) => e.resolve(this), toString: () => `.value:${g(this) ?? "<unnamed>"}`, [C]: this.schema }, qe);
+  }
+  get value() {
+    if (hr()) return this[j]();
+    throw new Error("`tgpu.accessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call");
+  }
+  get $() {
+    return this.value;
+  }
+  "~resolve"(e) {
+    let t = e.unwrap(this.slot);
+    return Ys(t) || Xu(t) ? e.resolve(t) : Co(t) ? `${e.resolve(t)}()` : e.resolve(t, this.schema);
+  }
+};
+function il(e) {
+  return ul(e);
+}
+function ol([e, t]) {
+  return `${g(e) ?? "<unnamed>"}=${t}`;
+}
+function ul(e) {
+  if (tt()) throw new Error("Cannot create tgpu.derived objects at the resolution stage.");
+  return { [c]: !0, resourceType: "derived", "~compute": e, [j](t) {
+    return Tr(t, t.unwrap(this));
+  }, get value() {
+    let t = tt();
+    if (!t) throw new Error("Cannot access tgpu.derived's value outside of resolution.");
+    return this[j](t);
+  }, get $() {
+    return this.value;
+  }, with(t, r) {
+    return ba(this, [[t, r]]);
+  }, toString() {
+    return "derived";
+  } };
+}
+function ba(e, t) {
+  return { [c]: !0, resourceType: "derived", "~compute"() {
+    throw new Error("'~compute' should never be read on bound derived items.");
+  }, [Me]: { inner: e, pairs: t }, [j](r) {
+    return Tr(r, r.unwrap(this));
+  }, get value() {
+    let r = tt();
+    if (!r) throw new Error("Cannot access tgpu.derived's value outside of resolution.");
+    return this[j](r);
+  }, get $() {
+    return this.value;
+  }, with(r, n) {
+    return ba(e, [...t, [r, n]]);
+  }, toString() {
+    return `derived[${t.map(ol).join(", ")}]`;
+  } };
+}
+function ll(e, t) {
+  return new va("private", e, t);
+}
+function dl(e) {
+  return new va("workgroup", e);
+}
+var va = class {
+  [c] = {};
+  #e;
+  #t;
+  #r;
+  constructor(t, r, n) {
+    this.#e = t, this.#t = r, this.#r = n;
+  }
+  "~resolve"(t) {
+    let r = t.names.makeUnique(g(this));
+    return this.#r ? t.addDeclaration(`var<${this.#e}> ${r}: ${t.resolve(this.#t)} = ${t.resolve(this.#r, this.#t)};`) : t.addDeclaration(`var<${this.#e}> ${r}: ${t.resolve(this.#t)};`), r;
+  }
+  $name(t) {
+    return F(this, t), this;
+  }
+  toString() {
+    return `var:${g(this) ?? "<unnamed>"}`;
+  }
+  [j]() {
+    return new Proxy({ [c]: !0, "~resolve": (t) => t.resolve(this), toString: () => `.value:${g(this) ?? "<unnamed>"}`, [C]: this.#t }, qe);
+  }
+  get $() {
+    let t = St(), r = It();
+    if (t.type === "normal") throw new Br(r ? `Cannot access variable '${g(this) ?? "<unnamed>"}'. TypeGPU functions that depends on GPU resources need to be part of a compute dispatch, draw call or simulation` : "TypeGPU variables are inaccessible during normal JS execution. If you wanted to simulate GPU behavior, try `tgpu.simulate()`");
+    return t.type === "codegen" ? this[j]() : t.type === "simulate" ? (t.vars[this.#e].has(this) || t.vars[this.#e].set(this, this.#r), t.vars[this.#e].get(this)) : rt(t, "tgpuVariable.ts#TgpuVarImpl/$");
+  }
+  set $(t) {
+    let r = St(), n = It();
+    if (r.type === "normal") throw new Br(n ? `Cannot access ${String(this)}. TypeGPU functions that depends on GPU resources need to be part of a compute dispatch, draw call or simulation` : "TypeGPU variables are inaccessible during normal JS execution. If you wanted to simulate GPU behavior, try `tgpu.simulate()`");
+    if (r.type === "codegen") throw new Error("Unreachable tgpuVariable.ts#TgpuVarImpl/$");
+    if (r.type === "simulate") {
+      r.vars[this.#e].set(this, t);
+      return;
+    }
+    rt(r, "tgpuVariable.ts#TgpuVarImpl/$");
+  }
+  get value() {
+    return this.$;
+  }
+  set value(t) {
+    this.$ = t;
+  }
+}, cl = { fn: qr, bindGroupLayout: oa, vertexLayout: an, slot: sr, init: tl, initFromDevice: rl, resolve: Au, resolveWithContext: ha, "~unstable": { fn: qr, fragmentFn: Do, vertexFn: zo, computeFn: Bo, vertexLayout: an, derived: il, slot: sr, accessor: al, privateVar: ll, workgroupVar: dl, const: go, declare: xo, sampler: lu, comparisonSampler: du, simulate: Ou } }, T = cl, pl = d(() => {
+  throw new Error("`discard` relies on GPU resources and cannot be executed outside of a draw call");
+}, () => u("discard;", de), "discard"), hl = d((e) => typeof e == "number" ? Math.abs(e) : E.abs[e.kind](e), (e) => u(p`abs(${e})`, e.dataType), "abs"), fl = d((e) => typeof e == "number" ? Math.acos(e) : E.acos[e.kind](e), (e) => u(p`acos(${e})`, e.dataType), "acos"), ml = d((e) => typeof e == "number" ? Math.acosh(e) : E.acosh[e.kind](e), (e) => u(p`acosh(${e})`, e.dataType), "acosh"), yl = d((e) => typeof e == "number" ? Math.asin(e) : E.asin[e.kind](e), (e) => u(p`asin(${e})`, e.dataType), "asin"), wl = d((e) => typeof e == "number" ? Math.asinh(e) : E.asinh[e.kind](e), (e) => u(p`asinh(${e})`, e.dataType), "asinh"), gl = d((e) => typeof e == "number" ? Math.atan(e) : E.atan[e.kind](e), (e) => u(p`atan(${e})`, e.dataType), "atan"), bl = d((e) => typeof e == "number" ? Math.atanh(e) : E.atanh[e.kind](e), (e) => u(p`atanh(${e})`, e.dataType), "atanh"), vl = d((e, t) => typeof e == "number" && typeof t == "number" ? Math.atan2(e, t) : E.atan2[e.kind](e, t), (e, t) => u(p`atan2(${e}, ${t})`, e.dataType), "atan2", "unify"), _l = d((e) => typeof e == "number" ? Math.ceil(e) : E.ceil[e.kind](e), (e) => u(p`ceil(${e})`, e.dataType), "ceil"), xl = d((e, t, r) => typeof e == "number" ? Math.min(Math.max(t, e), r) : E.clamp[e.kind](e, t, r), (e, t, r) => u(p`clamp(${e}, ${t}, ${r})`, e.dataType), "clamp"), le = d((e) => typeof e == "number" ? Math.cos(e) : E.cos[e.kind](e), (e) => u(p`cos(${e})`, e.dataType), "cos"), Tl = d((e) => typeof e == "number" ? Math.cosh(e) : E.cosh[e.kind](e), (e) => u(p`cosh(${e})`, e.dataType), "cosh"), $l = d((e) => {
+  throw new Error("CPU implementation for countLeadingZeros not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`countLeadingZeros(${e})`, e.dataType), "countLeadingZeros"), El = d((e) => {
+  throw new Error("CPU implementation for countOneBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`countOneBits(${e})`, e.dataType), "countOneBits"), Ul = d((e) => {
+  throw new Error("CPU implementation for countTrailingZeros not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`countTrailingZeros(${e})`, e.dataType), "countTrailingZeros"), Pl = d((e, t) => E.cross[e.kind](e, t), (e, t) => u(p`cross(${e}, ${t})`, e.dataType), "cross"), Sl = d((e) => {
+  if (typeof e == "number") return e * 180 / Math.PI;
+  throw new Error("CPU implementation for degrees on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`degrees(${e})`, e.dataType), "degrees"), Il = d((e) => {
+  throw new Error("CPU implementation for determinant not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`determinant(${e})`, f), "determinant"), kl = d((e, t) => typeof e == "number" && typeof t == "number" ? Math.abs(e - t) : _a(M(e, t)), (e, t) => u(p`distance(${e}, ${t})`, e.dataType.type === "f16" || e.dataType.type.endsWith("h") ? We : f), "distance"), q = d((e, t) => E.dot[e.kind](e, t), (e, t) => u(p`dot(${e}, ${t})`, f), "dot"), Ml = d((e, t) => {
+  throw new Error("CPU implementation for dot4U8Packed not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e, t) => u(p`dot4U8Packed(${e}, ${t})`, m), "dot4U8Packed", [m, m]), Al = d((e, t) => {
+  throw new Error("CPU implementation for dot4I8Packed not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e, t) => u(p`dot4I8Packed(${e}, ${t})`, J), "dot4I8Packed", [J, J]), Ol = d((e) => typeof e == "number" ? Math.exp(e) : E.exp[e.kind](e), (e) => u(p`exp(${e})`, e.dataType), "exp"), Gl = d((e) => typeof e == "number" ? 2 ** e : E.exp2[e.kind](e), (e) => u(p`exp2(${e})`, e.dataType), "exp2"), Bl = d((e, t, r) => {
+  throw new Error("CPU implementation for extractBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e, t, r) => u(p`extractBits(${e}, ${t}, ${r})`, e.dataType), "extractBits", (e, t, r) => [e.dataType, m, m]), Fl = d((e, t, r) => {
+  throw new Error("CPU implementation for faceForward not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e, t, r) => u(p`faceForward(${e}, ${t}, ${r})`, e.dataType), "faceForward"), Cl = d((e) => {
+  throw new Error("CPU implementation for firstLeadingBit not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`firstLeadingBit(${e})`, e.dataType), "firstLeadingBit"), Nl = d((e) => {
+  throw new Error("CPU implementation for firstTrailingBit not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`firstTrailingBit(${e})`, e.dataType), "firstTrailingBit"), Ge = d((e) => typeof e == "number" ? Math.floor(e) : E.floor[e.kind](e), (e) => u(p`floor(${e})`, e.dataType), "floor"), Ll = d((e, t, r) => {
+  if (typeof e == "number") return e * t + r;
+  throw new Error("CPU implementation for fma on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e, t, r) => u(p`fma(${e}, ${t}, ${r})`, e.dataType), "fma"), we = d((e) => typeof e == "number" ? e - Math.floor(e) : E.fract[e.kind](e), (e) => u(p`fract(${e})`, e.dataType), "fract"), Dl = { f32: Z({ fract: f, exp: J }), f16: Z({ fract: We, exp: J }), abstractFloat: Z({ fract: kt, exp: mr }), vec2f: Z({ fract: _, exp: K }), vec3f: Z({ fract: S, exp: Ue }), vec4f: Z({ fract: O, exp: te }), vec2h: Z({ fract: Ke, exp: K }), vec3h: Z({ fract: He, exp: Ue }), vec4h: Z({ fract: et, exp: te }) }, Wl = d((e) => {
+  throw new Error("CPU implementation for frexp not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => {
+  let t = Dl[e.dataType.type];
+  if (!t) throw new Error(`Unsupported data type for frexp: ${e.dataType.type}. Supported types are f32, f16, abstractFloat, vec2f, vec3f, vec4f, vec2h, vec3h, vec4h.`);
+  return u(p`frexp(${e})`, t);
+}, "frexp"), zl = d((e, t, r, n) => {
+  throw new Error("CPU implementation for insertBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e, t, r, n) => u(p`insertBits(${e}, ${t}, ${r}, ${n})`, e.dataType), "insertBits"), Yl = d((e) => {
+  if (typeof e == "number") return 1 / Math.sqrt(e);
+  throw new Error("CPU implementation for inverseSqrt on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`inverseSqrt(${e})`, e.dataType), "inverseSqrt"), Rl = d((e, t) => {
+  throw new Error("CPU implementation for ldexp not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e, t) => u(p`ldexp(${e}, ${t})`, e.dataType), "ldexp", (e, t) => {
+  switch (e.dataType.type) {
+    case "abstractFloat":
+      return [kt, mr];
+    case "f32":
+    case "f16":
+      return [e.dataType, J];
+    case "vec2f":
+    case "vec2h":
+      return [e.dataType, K];
+    case "vec3f":
+    case "vec3h":
+      return [e.dataType, Ue];
+    case "vec4f":
+    case "vec4h":
+      return [e.dataType, te];
+    default:
+      throw new Error(`Unsupported data type for ldexp: ${e.dataType.type}. Supported types are abstractFloat, f32, f16, vec2f, vec2h, vec3f, vec3h, vec4f, vec4h.`);
+  }
+}), _a = d((e) => typeof e == "number" ? Math.abs(e) : E.length[e.kind](e), (e) => u(p`length(${e})`, f), "length"), ql = d((e) => typeof e == "number" ? Math.log(e) : E.log[e.kind](e), (e) => u(p`log(${e})`, e.dataType), "log"), jl = d((e) => typeof e == "number" ? Math.log2(e) : E.log2[e.kind](e), (e) => u(p`log2(${e})`, e.dataType), "log2"), Vl = d((e, t) => typeof e == "number" ? Math.max(e, t) : E.max[e.kind](e, t), (e, t) => u(p`max(${e}, ${t})`, e.dataType), "max", "unify"), Jl = d((e, t) => typeof e == "number" ? Math.min(e, t) : E.min[e.kind](e, t), (e, t) => u(p`min(${e}, ${t})`, e.dataType), "min", "unify"), ye = d((e, t, r) => {
+  if (typeof e == "number") {
+    if (typeof r != "number" || typeof t != "number") throw new Error("When e1 and e2 are numbers, the blend factor must be a number.");
+    return e * (1 - r) + t * r;
+  }
+  if (typeof e == "number" || typeof t == "number") throw new Error("e1 and e2 need to both be vectors of the same kind.");
+  return E.mix[e.kind](e, t, r);
+}, (e, t, r) => u(p`mix(${e}, ${t}, ${r})`, e.dataType), "mix"), Zl = { f32: Z({ fract: f, whole: f }), f16: Z({ fract: We, whole: We }), abstractFloat: Z({ fract: kt, whole: kt }), vec2f: Z({ fract: _, whole: _ }), vec3f: Z({ fract: S, whole: S }), vec4f: Z({ fract: O, whole: O }), vec2h: Z({ fract: Ke, whole: Ke }), vec3h: Z({ fract: He, whole: He }), vec4h: Z({ fract: et, whole: et }) }, Xl = d((e) => {
+  throw new Error("CPU implementation for modf not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => {
+  let t = Zl[e.dataType.type];
+  if (!t) throw new Error(`Unsupported data type for modf: ${e.dataType.type}. Supported types are f32, f16, abstractFloat, vec2f, vec3f, vec4f, vec2h, vec3h, vec4h.`);
+  return u(p`modf(${e})`, t);
+}, "modf"), Ql = d((e) => E.normalize[e.kind](e), (e) => u(p`normalize(${e})`, e.dataType), "normalize"), Kl = d((e, t) => {
+  if (typeof e == "number" && typeof t == "number") return e ** t;
+  if (typeof e == "object" && typeof t == "object" && "kind" in e && "kind" in t) return E.pow[e.kind](e, t);
+  throw new Error("Invalid arguments to pow()");
+}, (e, t) => u(p`pow(${e}, ${t})`, e.dataType), "pow"), Hl = d((e) => {
+  throw new Error("CPU implementation for quantizeToF16 not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`quantizeToF16(${e})`, e.dataType), "quantizeToF16"), ed = d((e) => {
+  if (typeof e == "number") return e * Math.PI / 180;
+  throw new Error("CPU implementation for radians on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`radians(${e})`, e.dataType), "radians"), td = d((e, t) => M(e, A(2 * q(t, e), t)), (e, t) => u(p`reflect(${e}, ${t})`, e.dataType), "reflect"), rd = d((e, t, r) => {
+  throw new Error("CPU implementation for refract not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e, t, r) => u(p`refract(${e}, ${t}, ${r})`, e.dataType), "refract", (e, t, r) => [e.dataType, t.dataType, e.dataType.type === "f16" || e.dataType.type.endsWith("h") ? We : f]), nd = d((e) => {
+  throw new Error("CPU implementation for reverseBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`reverseBits(${e})`, e.dataType), "reverseBits"), ad = d((e) => {
+  if (typeof e == "number") return Math.round(e);
+  throw new Error("CPU implementation for round on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`round(${e})`, e.dataType), "round"), sd = d((e) => {
+  if (typeof e == "number") return Math.max(0, Math.min(1, e));
+  throw new Error("CPU implementation for saturate on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`saturate(${e})`, e.dataType), "saturate"), ir = d((e) => typeof e == "number" ? Math.sign(e) : E.sign[e.kind](e), (e) => u(p`sign(${e})`, e.dataType), "sign"), Be = d((e) => typeof e == "number" ? Math.sin(e) : E.sin[e.kind](e), (e) => u(p`sin(${e})`, e.dataType), "sin"), id = d((e) => {
+  if (typeof e == "number") return Math.sinh(e);
+  throw new Error("CPU implementation for sinh on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`sinh(${e})`, e.dataType), "sinh"), od = d((e, t, r) => typeof r == "number" ? si(e, t, r) : E.smoothstep[r.kind](e, t, r), (e, t, r) => u(p`smoothstep(${e}, ${t}, ${r})`, r.dataType), "smoothstep"), it = d((e) => typeof e == "number" ? Math.sqrt(e) : E.sqrt[e.kind](e), (e) => u(p`sqrt(${e})`, e.dataType), "sqrt"), ud = d((e, t) => {
+  if (typeof e == "number") return e <= t ? 1 : 0;
+  throw new Error("CPU implementation for step on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e, t) => u(p`step(${e}, ${t})`, e.dataType), "step"), ld = d((e) => {
+  if (typeof e == "number") return Math.tan(e);
+  throw new Error("CPU implementation for tan on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`tan(${e})`, e.dataType), "tan"), dd = d((e) => typeof e == "number" ? Math.tanh(e) : E.tanh[e.kind](e), (e) => u(p`tanh(${e})`, e.dataType), "tanh"), cd = d((e) => {
+  throw new Error("CPU implementation for transpose not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`transpose(${e})`, e.dataType), "transpose"), pd = d((e) => {
+  throw new Error("CPU implementation for trunc not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}, (e) => u(p`trunc(${e})`, e.dataType), "trunc"), ct = A[c].jsImpl, hd = vr[c].jsImpl, fd = vr[c].gpuImpl, md = br[c].jsImpl, yd = br[c].gpuImpl, wd = yr[c].jsImpl, gd = yr[c].gpuImpl, bd = wr[c].jsImpl, vd = wr[c].gpuImpl, _d = gr[c].jsImpl, xd = gr[c].gpuImpl, Td = d((e, t) => ct(hd(t), e), (e, t) => u(p`(${fd(t)} * ${e})`, e.dataType), "translate4"), $d = d((e, t) => ct(md(t), e), (e, t) => u(p`(${yd(t)} * ${e})`, e.dataType), "scale4"), Ed = d((e, t) => ct(wd(t), e), (e, t) => u(p`(${gd(t)} * ${e})`, e.dataType), "rotateX4"), Ud = d((e, t) => ct(bd(t), e), (e, t) => u(p`(${vd(t)} * ${e})`, e.dataType), "rotateY4"), Pd = d((e, t) => ct(_d(t), e), (e, t) => u(p`(${xd(t)} * ${e})`, e.dataType), "rotateZ4");
+function je(e) {
+  return e.dataType.type.includes("2") ? En : e.dataType.type.includes("3") ? Un : Pn;
+}
+var Sd = d((e, t) => Sr(pt(e, t)), (e, t) => u(p`all(${e} == ${t})`, Ae), "allEq"), pt = d((e, t) => E.eq[e.kind](e, t), (e, t) => u(p`(${e} == ${t})`, je(e)), "eq"), Id = d((e, t) => ge(pt(e, t)), (e, t) => u(p`(${e} != ${t})`, je(e)), "ne"), jt = d((e, t) => E.lt[e.kind](e, t), (e, t) => u(p`(${e} < ${t})`, je(e)), "lt"), kd = d((e, t) => Pr(jt(e, t), pt(e, t)), (e, t) => u(p`(${e} <= ${t})`, je(e)), "le"), Md = d((e, t) => xa(ge(jt(e, t)), ge(pt(e, t))), (e, t) => u(p`(${e} > ${t})`, je(e)), "gt"), Ad = d((e, t) => ge(jt(e, t)), (e, t) => u(p`(${e} >= ${t})`, je(e)), "ge"), ge = d((e) => E.neg[e.kind](e), (e) => u(p`!(${e})`, e.dataType), "not"), Pr = d((e, t) => E.or[e.kind](e, t), (e, t) => u(p`(${e} | ${t})`, e.dataType), "or"), xa = d((e, t) => ge(Pr(ge(e), ge(t))), (e, t) => u(p`(${e} & ${t})`, e.dataType), "and"), Sr = d((e) => E.all[e.kind](e), (e) => u(p`all(${e})`, Ae), "all"), Od = d((e) => !Sr(ge(e)), (e) => u(p`any(${e})`, Ae), "any"), Gd = d((e, t, r = 0.01) => typeof e == "number" && typeof t == "number" ? Math.abs(e - t) < r : Dr(e) && Dr(t) ? E.isCloseToZero[e.kind](M(e, t), r) : !1, (e, t, r = u(0.01, f)) => ft(e) && ft(t) ? u(p`(abs(f32(${e}) - f32(${t})) <= ${r})`, Ae) : !ft(e) && !ft(t) ? u(p`all(abs(${e} - ${t}) <= (${e} - ${e}) + ${r})`, Ae) : u("false", Ae), "isCloseTo"), Ie = d((e, t, r) => typeof r == "boolean" ? r ? t : e : E.select[e.kind](e, t, r), (e, t, r) => u(p`select(${e}, ${t}, ${r})`, e.dataType), "select"), Bd = d(() => console.warn("workgroupBarrier is a no-op outside of CODEGEN mode."), () => u("workgroupBarrier()", de), "workgroupBarrier"), Fd = d(() => console.warn("storageBarrier is a no-op outside of CODEGEN mode."), () => u("storageBarrier()", de), "storageBarrier"), Cd = d(() => console.warn("textureBarrier is a no-op outside of CODEGEN mode."), () => u("textureBarrier()", de), "textureBarrier"), Nd = d((e) => {
+  throw new Error("Atomic operations are not supported outside of CODEGEN mode.");
+}, (e) => {
+  if (ie(e.dataType) && e.dataType.type === "atomic") return u(p`atomicLoad(&${e})`, e.dataType.inner);
+  throw new Error(`Invalid atomic type: ${JSON.stringify(e.dataType, null, 2)}`);
+}, "atomicLoad"), Ld = d((e, t) => {
+  throw new Error("Atomic operations are not supported outside of CODEGEN mode.");
+}, (e, t) => {
+  if (!ie(e.dataType) || e.dataType.type !== "atomic") throw new Error(`Invalid atomic type: ${JSON.stringify(e.dataType, null, 2)}`);
+  return u(p`atomicStore(&${e}, ${t})`, de);
+}, "atomicStore"), Fe = (e, t) => e.dataType.type === "atomic" && e.dataType.inner.type === "i32" ? [e.dataType, J] : [e.dataType, m], Dd = d((e, t) => {
+  throw new Error("Atomic operations are not supported outside of CODEGEN mode.");
+}, (e, t) => {
+  if (ie(e.dataType) && e.dataType.type === "atomic") return u(p`atomicAdd(&${e}, ${t})`, e.dataType.inner);
+  throw new Error(`Invalid atomic type: ${JSON.stringify(e.dataType, null, 2)}`);
+}, "atomicAdd", Fe), Wd = d((e, t) => {
+  throw new Error("Atomic operations are not supported outside of CODEGEN mode.");
+}, (e, t) => {
+  if (ie(e.dataType) && e.dataType.type === "atomic") return u(p`atomicSub(&${e}, ${t})`, e.dataType.inner);
+  throw new Error(`Invalid atomic type: ${JSON.stringify(e.dataType, null, 2)}`);
+}, "atomicSub", Fe), zd = d((e, t) => {
+  throw new Error("Atomic operations are not supported outside of CODEGEN mode.");
+}, (e, t) => {
+  if (ie(e.dataType) && e.dataType.type === "atomic") return u(p`atomicMax(&${e}, ${t})`, e.dataType.inner);
+  throw new Error(`Invalid atomic type: ${JSON.stringify(e.dataType, null, 2)}`);
+}, "atomicMax", Fe), Yd = d((e, t) => {
+  throw new Error("Atomic operations are not supported outside of CODEGEN mode.");
+}, (e, t) => {
+  if (ie(e.dataType) && e.dataType.type === "atomic") return u(p`atomicMin(&${e}, ${t})`, e.dataType.inner);
+  throw new Error(`Invalid atomic type: ${JSON.stringify(e.dataType, null, 2)}`);
+}, "atomicMin", Fe), Rd = d((e, t) => {
+  throw new Error("Atomic operations are not supported outside of CODEGEN mode.");
+}, (e, t) => {
+  if (ie(e.dataType) && e.dataType.type === "atomic") return u(p`atomicAnd(&${e}, ${t})`, e.dataType.inner);
+  throw new Error(`Invalid atomic type: ${JSON.stringify(e.dataType, null, 2)}`);
+}, "atomicAnd", Fe), qd = d((e, t) => {
+  throw new Error("Atomic operations are not supported outside of CODEGEN mode.");
+}, (e, t) => {
+  if (ie(e.dataType) && e.dataType.type === "atomic") return u(p`atomicOr(&${e}, ${t})`, e.dataType.inner);
+  throw new Error(`Invalid atomic type: ${JSON.stringify(e.dataType, null, 2)}`);
+}, "atomicOr", Fe), jd = d((e, t) => {
+  throw new Error("Atomic operations are not supported outside of CODEGEN mode.");
+}, (e, t) => {
+  if (ie(e.dataType) && e.dataType.type === "atomic") return u(p`atomicXor(&${e}, ${t})`, e.dataType.inner);
+  throw new Error(`Invalid atomic type: ${JSON.stringify(e.dataType, null, 2)}`);
+}, "atomicXor", Fe), Vd = d((e) => {
+  throw new Error("Derivative builtins are not allowed on the cpu");
+}, (e) => u(p`dpdx(${e})`, e.dataType), "dpdx"), Jd = d((e) => {
+  throw new Error("Derivative builtins are not allowed on the cpu");
+}, (e) => u(p`dpdxCoarse(${e})`, e.dataType), "dpdxCoarse"), Zd = d((e) => {
+  throw new Error("Derivative builtins are not allowed on the cpu");
+}, (e) => u(p`dpdxFine(${e})`, e.dataType), "dpdxFine"), Xd = d((e) => {
+  throw new Error("Derivative builtins are not allowed on the cpu");
+}, (e) => u(p`dpdy(${e})`, e.dataType), "dpdy"), Qd = d((e) => {
+  throw new Error("Derivative builtins are not allowed on the cpu");
+}, (e) => u(p`dpdyCoarse(${e})`, e.dataType), "dpdyCoarse"), Kd = d((e) => {
+  throw new Error("Derivative builtins are not allowed on the cpu");
+}, (e) => u(p`dpdyFine(${e})`, e.dataType), "dpdyFine"), Hd = d((e) => {
+  throw new Error("Derivative builtins are not allowed on the cpu");
+}, (e) => u(p`fwidth(${e})`, e.dataType), "fwidth"), ec = d((e) => {
+  throw new Error("Derivative builtins are not allowed on the cpu");
+}, (e) => u(p`fwidthCoarse(${e})`, e.dataType), "fwidthCoarse"), tc = d((e) => {
+  throw new Error("Derivative builtins are not allowed on the cpu");
+}, (e) => u(p`fwidthFine(${e})`, e.dataType), "fwidthFine"), rc = d((e) => e.length, (e) => bn(e.dataType) && lt(e.dataType.inner) && e.dataType.inner.elementCount > 0 ? u(String(e.dataType.inner.elementCount), mr) : u(p`arrayLength(${e})`, m), "arrayLength", (e) => [Tn(e.dataType)]), nc = d((e) => {
+  let t = new ArrayBuffer(4);
+  new Se(t).writeUint32(e);
+  let r = new Ee(t);
+  return _(r.readFloat16(), r.readFloat16());
+}, (e) => u(p`unpack2x16float(${e})`, _), "unpack2x16float"), ac = d((e) => {
+  let t = new ArrayBuffer(4), r = new Se(t);
+  r.writeFloat16(e.x), r.writeFloat16(e.y);
+  let n = new Ee(t);
+  return m(n.readUint32());
+}, (e) => u(p`pack2x16float(${e})`, m), "pack2x16float"), sc = d((e) => {
+  let t = new ArrayBuffer(4);
+  new Se(t).writeUint32(e);
+  let r = new Ee(t);
+  return O(r.readUint8() / 255, r.readUint8() / 255, r.readUint8() / 255, r.readUint8() / 255);
+}, (e) => u(p`unpack4x8unorm(${e})`, O), "unpack4x8unorm"), ic = d((e) => {
+  let t = new ArrayBuffer(4), r = new Se(t);
+  r.writeUint8(e.x * 255), r.writeUint8(e.y * 255), r.writeUint8(e.z * 255), r.writeUint8(e.w * 255);
+  let n = new Ee(t);
+  return m(n.readUint32());
+}, (e) => u(p`pack4x8unorm(${e})`, m), "pack4x8unorm"), oc = d((e, t, r, n, a) => {
+  throw new Error("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
+}, (...e) => u(p`textureSample(${e})`, O), "textureSample"), uc = d((e, t, r, n, a) => {
+  throw new Error("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
+}, (...e) => u(p`textureSampleLevel(${e})`, O), "textureSampleLevel"), lc = { u32: ue, i32: te, f32: O }, dc = d((e, t, r) => {
+  throw new Error("`textureLoad` relies on GPU resources and cannot be executed outside of a draw call");
+}, (...e) => {
+  let t = e[0].dataType;
+  return u(p`textureLoad(${e})`, "texelDataType" in t ? t.texelDataType : lc[t.channelDataType.type]);
+}, "textureLoad"), cc = d((e, t, r, n) => {
+  throw new Error("`textureStore` relies on GPU resources and cannot be executed outside of a draw call");
+}, (...e) => u(p`textureStore(${e})`, de), "textureStore"), pc = d((e, t) => {
+  throw new Error("`textureDimensions` relies on GPU resources and cannot be executed outside of a draw call");
+}, (...e) => {
+  let t = e[0].dataType.dimension;
+  return u(p`textureDimensions(${e})`, t === "1d" ? m : t === "3d" ? Ut : ne);
+}, "textureDimensions");
+const Ce = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  abs: hl,
+  acos: fl,
+  acosh: ml,
+  add: I,
+  all: Sr,
+  allEq: Sd,
+  and: xa,
+  any: Od,
+  arrayLength: rc,
+  asin: yl,
+  asinh: wl,
+  atan: gl,
+  atan2: vl,
+  atanh: bl,
+  atomicAdd: Dd,
+  atomicAnd: Rd,
+  atomicLoad: Nd,
+  atomicMax: zd,
+  atomicMin: Yd,
+  atomicOr: qd,
+  atomicStore: Ld,
+  atomicSub: Wd,
+  atomicXor: jd,
+  ceil: _l,
+  clamp: xl,
+  cos: le,
+  cosh: Tl,
+  countLeadingZeros: $l,
+  countOneBits: El,
+  countTrailingZeros: Ul,
+  cross: Pl,
+  degrees: Sl,
+  determinant: Il,
+  discard: pl,
+  distance: kl,
+  div: An,
+  dot: q,
+  dot4I8Packed: Al,
+  dot4U8Packed: Ml,
+  dpdx: Vd,
+  dpdxCoarse: Jd,
+  dpdxFine: Zd,
+  dpdy: Xd,
+  dpdyCoarse: Qd,
+  dpdyFine: Kd,
+  eq: pt,
+  exp: Ol,
+  exp2: Gl,
+  extractBits: Bl,
+  faceForward: Fl,
+  firstLeadingBit: Cl,
+  firstTrailingBit: Nl,
+  floor: Ge,
+  fma: Ll,
+  fract: we,
+  frexp: Wl,
+  fwidth: Hd,
+  fwidthCoarse: ec,
+  fwidthFine: tc,
+  ge: Ad,
+  gt: Md,
+  identity2: ii,
+  identity3: oi,
+  identity4: ui,
+  insertBits: zl,
+  inverseSqrt: Yl,
+  isCloseTo: Gd,
+  ldexp: Rl,
+  le: kd,
+  length: _a,
+  log: ql,
+  log2: jl,
+  lt: jt,
+  max: Vl,
+  min: Jl,
+  mix: ye,
+  mod: li,
+  modf: Xl,
+  mul: A,
+  ne: Id,
+  neg: di,
+  normalize: Ql,
+  not: ge,
+  or: Pr,
+  pack2x16float: ac,
+  pack4x8unorm: ic,
+  pow: Kl,
+  quantizeToF16: Hl,
+  radians: ed,
+  reflect: td,
+  refract: rd,
+  reverseBits: nd,
+  rotateX4: Ed,
+  rotateY4: Ud,
+  rotateZ4: Pd,
+  rotationX4: yr,
+  rotationY4: wr,
+  rotationZ4: gr,
+  round: ad,
+  saturate: sd,
+  scale4: $d,
+  scaling4: br,
+  select: Ie,
+  sign: ir,
+  sin: Be,
+  sinh: id,
+  smoothstep: od,
+  sqrt: it,
+  step: ud,
+  storageBarrier: Fd,
+  sub: M,
+  tan: ld,
+  tanh: dd,
+  textureBarrier: Cd,
+  textureDimensions: pc,
+  textureLoad: dc,
+  textureSample: oc,
+  textureSampleLevel: uc,
+  textureStore: cc,
+  translate4: Td,
+  translation4: vr,
+  transpose: cd,
+  trunc: pd,
+  unpack2x16float: nc,
+  unpack4x8unorm: sc,
+  workgroupBarrier: Bd
+}, Symbol.toStringTag, { value: "Module" })), hc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([], f), "randomGeneratorShell"), fc = (() => {
+  const e = (globalThis.__TYPEGPU_AUTONAME__ ?? ((t) => t))(T["~unstable"].privateVar(_), "seed");
+  return {
+    seed: (globalThis.__TYPEGPU_AUTONAME__ ?? ((t) => t))(T.fn([f])(((t) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(t.f = (r) => {
+      e.value = _(r, 0);
+    }, {
+      v: 1,
+      ast: { params: [{ type: "i", name: "value" }], body: [0, [[2, [7, "seed", "value"], "=", [6, [7, "d", "vec2f"], ["value", [5, "0"]]]]]], externalNames: ["seed", "d"] },
+      get externals() {
+        return { seed: e, d: W };
+      }
+    }) && t.f)({})), "seed"),
+    seed2: (globalThis.__TYPEGPU_AUTONAME__ ?? ((t) => t))(T.fn([_])(((t) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(t.f = (r) => {
+      e.value = r;
+    }, {
+      v: 1,
+      ast: { params: [{ type: "i", name: "value" }], body: [0, [[2, [7, "seed", "value"], "=", "value"]]], externalNames: ["seed"] },
+      get externals() {
+        return { seed: e };
+      }
+    }) && t.f)({})), "seed2"),
+    seed3: (globalThis.__TYPEGPU_AUTONAME__ ?? ((t) => t))(T.fn([S])(((t) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(t.f = (r) => {
+      e.value = I(r.xy, _(r.z));
+    }, {
+      v: 1,
+      ast: { params: [{ type: "i", name: "value" }], body: [0, [[2, [7, "seed", "value"], "=", [6, "add", [[7, "value", "xy"], [6, [7, "d", "vec2f"], [[7, "value", "z"]]]]]]]], externalNames: ["seed", "add", "d"] },
+      get externals() {
+        return { seed: e, add: I, d: W };
+      }
+    }) && t.f)({})), "seed3"),
+    seed4: (globalThis.__TYPEGPU_AUTONAME__ ?? ((t) => t))(T.fn([O])(((t) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(t.f = (r) => {
+      e.value = I(r.xy, r.zw);
+    }, {
+      v: 1,
+      ast: { params: [{ type: "i", name: "value" }], body: [0, [[2, [7, "seed", "value"], "=", [6, "add", [[7, "value", "xy"], [7, "value", "zw"]]]]]], externalNames: ["seed", "add"] },
+      get externals() {
+        return { seed: e, add: I };
+      }
+    }) && t.f)({})), "seed4"),
+    sample: hc(((t) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(t.f = ((r) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(r.f = () => {
+      "kernel";
+      const n = q(e.value, _(23.14077926, 232.61690225)), a = q(e.value, _(54.47856553, 345.84153136));
+      return e.value.x = we(le(n) * 136.8168), e.value.y = we(le(a) * 534.7645), e.value.y;
+    }, {
+      v: 1,
+      ast: { params: [], body: [0, [[13, "a", [6, "dot", [[7, "seed", "value"], [6, [7, "d", "vec2f"], [[5, "23.14077926"], [5, "232.61690225"]]]]]], [13, "b", [6, "dot", [[7, "seed", "value"], [6, [7, "d", "vec2f"], [[5, "54.47856553"], [5, "345.84153136"]]]]]], [2, [7, [7, "seed", "value"], "x"], "=", [6, "fract", [[1, [6, "cos", ["a"]], "*", [5, "136.8168"]]]]], [2, [7, [7, "seed", "value"], "y"], "=", [6, "fract", [[1, [6, "cos", ["b"]], "*", [5, "534.7645"]]]]], [10, [7, [7, "seed", "value"], "y"]]]], externalNames: ["dot", "seed", "d", "fract", "cos"] },
+      get externals() {
+        return { dot: q, seed: e, d: W, fract: we, cos: le };
+      }
+    }) && r.f)({}), {
+      v: 1,
+      ast: { params: [], body: [0, [[13, "a", [6, "dot", [[7, "seed", "value"], [6, [7, "d", "vec2f"], [[5, "23.14077926"], [5, "232.61690225"]]]]]], [13, "b", [6, "dot", [[7, "seed", "value"], [6, [7, "d", "vec2f"], [[5, "54.47856553"], [5, "345.84153136"]]]]]], [2, [7, [7, "seed", "value"], "x"], "=", [6, "fract", [[1, [6, "cos", ["a"]], "*", [5, "136.8168"]]]]], [2, [7, [7, "seed", "value"], "y"], "=", [6, "fract", [[1, [6, "cos", ["b"]], "*", [5, "534.7645"]]]]], [10, [7, [7, "seed", "value"], "y"]]]], externalNames: ["dot", "seed", "d", "fract", "cos"] },
+      get externals() {
+        return { dot: q, seed: e, d: W, fract: we, cos: le };
+      }
+    }) && t.f)({}))
+  };
+})(), mc = fc, z = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.slot(
+  mc
+), "randomGeneratorSlot"), Ye = Math.PI * 2, yc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([f])(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t) => {
+  z.value.seed(t);
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "seed" }], body: [0, [[6, [7, [7, "randomGeneratorSlot", "value"], "seed"], ["seed"]]]], externalNames: ["randomGeneratorSlot"] },
+  get externals() {
+    return { randomGeneratorSlot: z };
+  }
+}) && e.f)({})), "randSeed"), or = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([_])(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t) => {
+  z.value.seed2(t);
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "seed" }], body: [0, [[6, [7, [7, "randomGeneratorSlot", "value"], "seed2"], ["seed"]]]], externalNames: ["randomGeneratorSlot"] },
+  get externals() {
+    return { randomGeneratorSlot: z };
+  }
+}) && e.f)({})), "randSeed2"), ur = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([S])(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t) => {
+  z.value.seed3(t);
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "seed" }], body: [0, [[6, [7, [7, "randomGeneratorSlot", "value"], "seed3"], ["seed"]]]], externalNames: ["randomGeneratorSlot"] },
+  get externals() {
+    return { randomGeneratorSlot: z };
+  }
+}) && e.f)({})), "randSeed3"), wc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([O])(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t) => {
+  z.value.seed4(t);
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "seed" }], body: [0, [[6, [7, [7, "randomGeneratorSlot", "value"], "seed4"], ["seed"]]]], externalNames: ["randomGeneratorSlot"] },
+  get externals() {
+    return { randomGeneratorSlot: z };
+  }
+}) && e.f)({})), "randSeed4"), gc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([], f)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = () => z.value.sample(), {
+  v: 1,
+  ast: { params: [], body: [0, [[10, [6, [7, [7, "randomGeneratorSlot", "value"], "sample"], []]]]], externalNames: ["randomGeneratorSlot"] },
+  get externals() {
+    return { randomGeneratorSlot: z };
+  }
+}) && e.f)({})), "randFloat01"), bc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([], S)(
+  ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = () => S(
+    z.value.sample() * 2 - 1,
+    z.value.sample() * 2 - 1,
+    z.value.sample() * 2 - 1
+  ), {
+    v: 1,
+    ast: { params: [], body: [0, [[10, [6, [7, "d", "vec3f"], [[1, [1, [6, [7, [7, "randomGeneratorSlot", "value"], "sample"], []], "*", [5, "2"]], "-", [5, "1"]], [1, [1, [6, [7, [7, "randomGeneratorSlot", "value"], "sample"], []], "*", [5, "2"]], "-", [5, "1"]], [1, [1, [6, [7, [7, "randomGeneratorSlot", "value"], "sample"], []], "*", [5, "2"]], "-", [5, "1"]]]]]]], externalNames: ["d", "randomGeneratorSlot"] },
+    get externals() {
+      return { d: W, randomGeneratorSlot: z };
+    }
+  }) && e.f)({})
+), "randInUnitCube"), vc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([], _)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = () => {
+  const t = it(z.value.sample()), r = z.value.sample() * Ye;
+  return _(le(r) * t, Be(r) * t);
+}, {
+  v: 1,
+  ast: { params: [], body: [0, [[13, "radius", [6, "sqrt", [[6, [7, [7, "randomGeneratorSlot", "value"], "sample"], []]]]], [13, "angle", [1, [6, [7, [7, "randomGeneratorSlot", "value"], "sample"], []], "*", "TWO_PI"]], [10, [6, [7, "d", "vec2f"], [[1, [6, "cos", ["angle"]], "*", "radius"], [1, [6, "sin", ["angle"]], "*", "radius"]]]]]], externalNames: ["sqrt", "randomGeneratorSlot", "TWO_PI", "d", "cos", "sin"] },
+  get externals() {
+    return { sqrt: it, randomGeneratorSlot: z, TWO_PI: Ye, d: W, cos: le, sin: Be };
+  }
+}) && e.f)({})), "randInUnitCircle"), sn = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([], _)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = () => {
+  const t = z.value.sample() * Ye;
+  return _(le(t), Be(t));
+}, {
+  v: 1,
+  ast: { params: [], body: [0, [[13, "angle", [1, [6, [7, [7, "randomGeneratorSlot", "value"], "sample"], []], "*", "TWO_PI"]], [10, [6, [7, "d", "vec2f"], [[6, "cos", ["angle"]], [6, "sin", ["angle"]]]]]]], externalNames: ["randomGeneratorSlot", "TWO_PI", "d", "cos", "sin"] },
+  get externals() {
+    return { randomGeneratorSlot: z, TWO_PI: Ye, d: W, cos: le, sin: Be };
+  }
+}) && e.f)({})), "randOnUnitCircle"), ot = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([], S)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = () => {
+  const t = 2 * z.value.sample() - 1, r = it(1 - t * t), n = Ye * z.value.sample() - Math.PI, a = Be(n) * r, s = le(n) * r;
+  return S(a, s, t);
+}, {
+  v: 1,
+  ast: { params: [], body: [0, [[13, "z", [1, [1, [5, "2"], "*", [6, [7, [7, "randomGeneratorSlot", "value"], "sample"], []]], "-", [5, "1"]]], [13, "oneMinusZSq", [6, "sqrt", [[1, [5, "1"], "-", [1, "z", "*", "z"]]]]], [13, "theta", [1, [1, "TWO_PI", "*", [6, [7, [7, "randomGeneratorSlot", "value"], "sample"], []]], "-", [7, "Math", "PI"]]], [13, "x", [1, [6, "sin", ["theta"]], "*", "oneMinusZSq"]], [13, "y", [1, [6, "cos", ["theta"]], "*", "oneMinusZSq"]], [10, [6, [7, "d", "vec3f"], ["x", "y", "z"]]]]], externalNames: ["randomGeneratorSlot", "sqrt", "TWO_PI", "Math", "sin", "cos", "d"] },
+  get externals() {
+    return { randomGeneratorSlot: z, sqrt: it, TWO_PI: Ye, Math, sin: Be, cos: le, d: W };
+  }
+}) && e.f)({})), "randOnUnitSphere"), _c = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([S], S)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t) => {
+  const r = ot(), n = q(t, r);
+  return A(ir(n), r);
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "normal" }], body: [0, [[13, "value", [6, "randOnUnitSphere", []]], [13, "alignment", [6, "dot", ["normal", "value"]]], [10, [6, "mul", [[6, "sign", ["alignment"]], "value"]]]]], externalNames: ["randOnUnitSphere", "dot", "mul", "sign"] },
+  get externals() {
+    return { randOnUnitSphere: ot, dot: q, mul: A, sign: ir };
+  }
+}) && e.f)({})), "randOnUnitHemisphere"), Ta = ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = ((t) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(t.f = (r) => {
+  "kernel";
+  return A(A(r, A(r, r)), I(A(r, M(A(r, 6), 15)), 10));
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "t" }], body: [0, [[10, [6, "mul", [[6, "mul", ["t", [6, "mul", ["t", "t"]]]], [6, "add", [[6, "mul", ["t", [6, "sub", [[6, "mul", ["t", [5, "6"]]], [5, "15"]]]]], [5, "10"]]]]]]]], externalNames: ["mul", "add", "sub"] },
+  get externals() {
+    return { mul: A, add: I, sub: M };
+  }
+}) && t.f)({}), {
+  v: 1,
+  ast: { params: [{ type: "i", name: "t" }], body: [0, [[10, [6, "mul", [[6, "mul", ["t", [6, "mul", ["t", "t"]]]], [6, "add", [[6, "mul", ["t", [6, "sub", [[6, "mul", ["t", [5, "6"]]], [5, "15"]]]]], [5, "10"]]]]]]]], externalNames: ["mul", "add", "sub"] },
+  get externals() {
+    return { mul: A, add: I, sub: M };
+  }
+}) && e.f)({}), Ot = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([_], _)(Ta), "quinticInterpolation2"), on = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([S], S)(Ta), "quinticInterpolation3"), $a = ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = ((t) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(t.f = (r) => {
+  "kernel";
+  return A(A(A(30, r), r), I(A(r, M(r, 2)), 1));
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "t" }], body: [0, [[10, [6, "mul", [[6, "mul", [[6, "mul", [[5, "30"], "t"]], "t"]], [6, "add", [[6, "mul", ["t", [6, "sub", ["t", [5, "2"]]]]], [5, "1"]]]]]]]], externalNames: ["mul", "add", "sub"] },
+  get externals() {
+    return { mul: A, add: I, sub: M };
+  }
+}) && t.f)({}), {
+  v: 1,
+  ast: { params: [{ type: "i", name: "t" }], body: [0, [[10, [6, "mul", [[6, "mul", [[6, "mul", [[5, "30"], "t"]], "t"]], [6, "add", [[6, "mul", ["t", [6, "sub", ["t", [5, "2"]]]]], [5, "1"]]]]]]]], externalNames: ["mul", "add", "sub"] },
+  get externals() {
+    return { mul: A, add: I, sub: M };
+  }
+}) && e.f)({}), un = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([_], _)($a), "quinticDerivative2");
+(globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([S], S)($a), "quinticDerivative3");
+const xc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([K], _)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t) => (or(A(1e-3, _(t))), sn()), {
+  v: 1,
+  ast: { params: [{ type: "i", name: "pos" }], body: [0, [[6, "randSeed2", [[6, "mul", [[5, "1e-3"], [6, [7, "d", "vec2f"], ["pos"]]]]]], [10, [6, "randOnUnitCircle", []]]]], externalNames: ["randSeed2", "mul", "d", "randOnUnitCircle"] },
+  get externals() {
+    return { randSeed2: or, mul: A, d: W, randOnUnitCircle: sn };
+  }
+}) && e.f)({})), "computeJunctionGradient"), pe = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.slot(xc), "getJunctionGradientSlot");
+(globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([_], f)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t) => {
+  const r = K(Ge(t)), n = we(t), a = Ot(n), s = pe.$(r), i = pe.$(I(r, K(1, 0))), l = pe.$(I(r, K(0, 1))), o = pe.$(I(r, K(1, 1))), y = q(s, M(n, _(0, 0))), h = q(i, M(n, _(1, 0))), w = q(l, M(n, _(0, 1))), b = q(o, M(n, _(1, 1)));
+  return y + a.x * (h - y) + a.y * (w - y) + a.x * a.y * (y - h - w + b);
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "pos" }], body: [0, [[13, "i", [6, [7, "d", "vec2i"], [[6, "floor", ["pos"]]]]], [13, "f", [6, "fract", ["pos"]]], [13, "u", [6, "quinticInterpolation2", ["f"]]], [13, "ga", [6, [7, "getJunctionGradientSlot", "$"], ["i"]]], [13, "gb", [6, [7, "getJunctionGradientSlot", "$"], [[6, "add", ["i", [6, [7, "d", "vec2i"], [[5, "1"], [5, "0"]]]]]]]], [13, "gc", [6, [7, "getJunctionGradientSlot", "$"], [[6, "add", ["i", [6, [7, "d", "vec2i"], [[5, "0"], [5, "1"]]]]]]]], [13, "gd", [6, [7, "getJunctionGradientSlot", "$"], [[6, "add", ["i", [6, [7, "d", "vec2i"], [[5, "1"], [5, "1"]]]]]]]], [13, "va", [6, "dot", ["ga", [6, "sub", ["f", [6, [7, "d", "vec2f"], [[5, "0"], [5, "0"]]]]]]]], [13, "vb", [6, "dot", ["gb", [6, "sub", ["f", [6, [7, "d", "vec2f"], [[5, "1"], [5, "0"]]]]]]]], [13, "vc", [6, "dot", ["gc", [6, "sub", ["f", [6, [7, "d", "vec2f"], [[5, "0"], [5, "1"]]]]]]]], [13, "vd", [6, "dot", ["gd", [6, "sub", ["f", [6, [7, "d", "vec2f"], [[5, "1"], [5, "1"]]]]]]]], [13, "noise", [1, [1, [1, "va", "+", [1, [7, "u", "x"], "*", [1, "vb", "-", "va"]]], "+", [1, [7, "u", "y"], "*", [1, "vc", "-", "va"]]], "+", [1, [1, [7, "u", "x"], "*", [7, "u", "y"]], "*", [1, [1, [1, "va", "-", "vb"], "-", "vc"], "+", "vd"]]]], [10, "noise"]]], externalNames: ["d", "floor", "fract", "quinticInterpolation2", "getJunctionGradientSlot", "add", "dot", "sub"] },
+  get externals() {
+    return { d: W, floor: Ge, fract: we, quinticInterpolation2: Ot, getJunctionGradientSlot: pe, add: I, dot: q, sub: M };
+  }
+}) && e.f)({})), "sample");
+(globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([_], S)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t) => {
+  const r = K(Ge(t)), n = we(t), a = Ot(n), s = un(n), i = pe.$(r), l = pe.$(I(r, K(1, 0))), o = pe.$(I(r, K(0, 1))), y = pe.$(I(r, K(1, 1))), h = q(i, M(n, _(0, 0))), w = q(l, M(n, _(1, 0))), b = q(o, M(n, _(0, 1))), v = q(y, M(n, _(1, 1))), x = h + a.x * (w - h) + a.y * (b - h) + a.x * a.y * (h - w - b + v), P = I(
+    i,
+    I(
+      I(
+        I(A(a.x, M(l, i)), A(a.y, M(o, i))),
+        A(a.x, A(a.y, I(M(M(i, l), o), y)))
+      ),
+      A(s, M(I(A(a.yx, h - w - b + v), _(w, b)), h))
+    )
+  );
+  return S(x, P);
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "pos" }], body: [0, [[13, "i", [6, [7, "d", "vec2i"], [[6, "floor", ["pos"]]]]], [13, "f", [6, "fract", ["pos"]]], [13, "u", [6, "quinticInterpolation2", ["f"]]], [13, "du", [6, "quinticDerivative2", ["f"]]], [13, "ga", [6, [7, "getJunctionGradientSlot", "$"], ["i"]]], [13, "gb", [6, [7, "getJunctionGradientSlot", "$"], [[6, "add", ["i", [6, [7, "d", "vec2i"], [[5, "1"], [5, "0"]]]]]]]], [13, "gc", [6, [7, "getJunctionGradientSlot", "$"], [[6, "add", ["i", [6, [7, "d", "vec2i"], [[5, "0"], [5, "1"]]]]]]]], [13, "gd", [6, [7, "getJunctionGradientSlot", "$"], [[6, "add", ["i", [6, [7, "d", "vec2i"], [[5, "1"], [5, "1"]]]]]]]], [13, "va", [6, "dot", ["ga", [6, "sub", ["f", [6, [7, "d", "vec2f"], [[5, "0"], [5, "0"]]]]]]]], [13, "vb", [6, "dot", ["gb", [6, "sub", ["f", [6, [7, "d", "vec2f"], [[5, "1"], [5, "0"]]]]]]]], [13, "vc", [6, "dot", ["gc", [6, "sub", ["f", [6, [7, "d", "vec2f"], [[5, "0"], [5, "1"]]]]]]]], [13, "vd", [6, "dot", ["gd", [6, "sub", ["f", [6, [7, "d", "vec2f"], [[5, "1"], [5, "1"]]]]]]]], [13, "noise", [1, [1, [1, "va", "+", [1, [7, "u", "x"], "*", [1, "vb", "-", "va"]]], "+", [1, [7, "u", "y"], "*", [1, "vc", "-", "va"]]], "+", [1, [1, [7, "u", "x"], "*", [7, "u", "y"]], "*", [1, [1, [1, "va", "-", "vb"], "-", "vc"], "+", "vd"]]]], [13, "grad", [6, "add", ["ga", [6, "add", [[6, "add", [[6, "add", [[6, "mul", [[7, "u", "x"], [6, "sub", ["gb", "ga"]]]], [6, "mul", [[7, "u", "y"], [6, "sub", ["gc", "ga"]]]]]], [6, "mul", [[7, "u", "x"], [6, "mul", [[7, "u", "y"], [6, "add", [[6, "sub", [[6, "sub", ["ga", "gb"]], "gc"]], "gd"]]]]]]]], [6, "mul", ["du", [6, "sub", [[6, "add", [[6, "mul", [[7, "u", "yx"], [1, [1, [1, "va", "-", "vb"], "-", "vc"], "+", "vd"]]], [6, [7, "d", "vec2f"], ["vb", "vc"]]]], "va"]]]]]]]]], [10, [6, [7, "d", "vec3f"], ["noise", "grad"]]]]], externalNames: ["d", "floor", "fract", "quinticInterpolation2", "quinticDerivative2", "getJunctionGradientSlot", "add", "dot", "sub", "mul"] },
+  get externals() {
+    return { d: W, floor: Ge, fract: we, quinticInterpolation2: Ot, quinticDerivative2: un, getJunctionGradientSlot: pe, add: I, dot: q, sub: M, mul: A };
+  }
+}) && e.f)({})), "sampleWithGradient");
+Q(_);
+Q(_);
+const Tc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([Ue], S)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t) => (ur(A(1e-3, S(t))), ot()), {
+  v: 1,
+  ast: { params: [{ type: "i", name: "pos" }], body: [0, [[6, "randSeed3", [[6, "mul", [[5, "1e-3"], [6, [7, "d", "vec3f"], ["pos"]]]]]], [10, [6, "randOnUnitSphere", []]]]], externalNames: ["randSeed3", "mul", "d", "randOnUnitSphere"] },
+  get externals() {
+    return { randSeed3: ur, mul: A, d: W, randOnUnitSphere: ot };
+  }
+}) && e.f)({})), "computeJunctionGradient"), ln = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.slot(Tc), "getJunctionGradientSlot"), he = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([S, S], f)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t, r) => {
+  const n = M(t, r), a = ln.value(Ue(r));
+  return q(n, a);
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "pos" }, { type: "i", name: "junction" }], body: [0, [[13, "relative", [6, "sub", ["pos", "junction"]]], [13, "gridVector", [6, [7, "getJunctionGradientSlot", "value"], [[6, [7, "d", "vec3i"], ["junction"]]]]], [10, [6, "dot", ["relative", "gridVector"]]]]], externalNames: ["sub", "getJunctionGradientSlot", "d", "dot"] },
+  get externals() {
+    return { sub: M, getJunctionGradientSlot: ln, d: W, dot: q };
+  }
+}) && e.f)({})), "dotProdGrid");
+(globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn([S], f)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t) => {
+  const r = Ge(t), n = he(t, r), a = he(t, I(r, S(0, 0, 1))), s = he(t, I(r, S(0, 1, 0))), i = he(t, I(r, S(0, 1, 1))), l = he(t, I(r, S(1, 0, 0))), o = he(t, I(r, S(1, 0, 1))), y = he(t, I(r, S(1, 1, 0))), h = he(t, I(r, S(1, 1, 1))), w = M(t, r), b = on(w), v = ye(n, a, b.z), x = ye(s, i, b.z), P = ye(l, o, b.z), $ = ye(y, h, b.z), k = ye(v, x, b.y), L = ye(P, $, b.y);
+  return ye(k, L, b.x);
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "pos" }], body: [0, [[13, "minJunction", [6, "floor", ["pos"]]], [13, "xyz", [6, "dotProdGrid", ["pos", "minJunction"]]], [13, "xyZ", [6, "dotProdGrid", ["pos", [6, "add", ["minJunction", [6, [7, "d", "vec3f"], [[5, "0"], [5, "0"], [5, "1"]]]]]]]], [13, "xYz", [6, "dotProdGrid", ["pos", [6, "add", ["minJunction", [6, [7, "d", "vec3f"], [[5, "0"], [5, "1"], [5, "0"]]]]]]]], [13, "xYZ", [6, "dotProdGrid", ["pos", [6, "add", ["minJunction", [6, [7, "d", "vec3f"], [[5, "0"], [5, "1"], [5, "1"]]]]]]]], [13, "Xyz", [6, "dotProdGrid", ["pos", [6, "add", ["minJunction", [6, [7, "d", "vec3f"], [[5, "1"], [5, "0"], [5, "0"]]]]]]]], [13, "XyZ", [6, "dotProdGrid", ["pos", [6, "add", ["minJunction", [6, [7, "d", "vec3f"], [[5, "1"], [5, "0"], [5, "1"]]]]]]]], [13, "XYz", [6, "dotProdGrid", ["pos", [6, "add", ["minJunction", [6, [7, "d", "vec3f"], [[5, "1"], [5, "1"], [5, "0"]]]]]]]], [13, "XYZ", [6, "dotProdGrid", ["pos", [6, "add", ["minJunction", [6, [7, "d", "vec3f"], [[5, "1"], [5, "1"], [5, "1"]]]]]]]], [13, "partial", [6, "sub", ["pos", "minJunction"]]], [13, "smoothPartial", [6, "quinticInterpolation3", ["partial"]]], [13, "xy", [6, "mix", ["xyz", "xyZ", [7, "smoothPartial", "z"]]]], [13, "xY", [6, "mix", ["xYz", "xYZ", [7, "smoothPartial", "z"]]]], [13, "Xy", [6, "mix", ["Xyz", "XyZ", [7, "smoothPartial", "z"]]]], [13, "XY", [6, "mix", ["XYz", "XYZ", [7, "smoothPartial", "z"]]]], [13, "x", [6, "mix", ["xy", "xY", [7, "smoothPartial", "y"]]]], [13, "X", [6, "mix", ["Xy", "XY", [7, "smoothPartial", "y"]]]], [10, [6, "mix", ["x", "X", [7, "smoothPartial", "x"]]]]]], externalNames: ["floor", "dotProdGrid", "add", "d", "sub", "quinticInterpolation3", "mix"] },
+  get externals() {
+    return { floor: Ge, dotProdGrid: he, add: I, d: W, sub: M, quinticInterpolation3: on, mix: ye };
+  }
+}) && e.f)({})), "sample");
+Q(S);
+Q(S);
+const Xt = {
+  seed: yc,
+  seed2: or,
+  seed3: ur,
+  seed4: wc,
+  sample: gc,
+  inUnitCircle: vc,
+  inUnitCube: bc,
+  onHemisphere: _c,
+  onUnitSphere: ot
+}, Ea = await navigator.gpu.requestAdapter();
+if (!Ea)
+  throw new Error("No adapter");
+const Ua = await Ea.requestDevice();
+Ua.lost.then(() => {
+  throw Error("Device lost");
+});
+let gt = 0, Gt;
+const G = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.bindGroupLayout({
+  dimensions: { uniform: ne },
+  colors: { storage: Q(m), access: "mutable" },
+  newColors: { storage: Q(m), access: "mutable" },
+  ids: { storage: Q(m), access: "mutable" },
+  newIds: { storage: Q(m), access: "mutable" }
+}), "gridLayout"), xe = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.bindGroupLayout({
+  neighborhood: { uniform: m },
+  elements: {
+    storage: Q(hi),
+    access: "readonly"
+  },
+  rules: {
+    storage: Q(pi),
+    access: "readonly"
+  },
+  conditions: {
+    storage: Q(ci),
+    access: "readonly"
+  }
+}), "automatonLayout"), ae = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn(
+  [m, m],
+  m
+)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t, r) => r % G.bound.dimensions.$.y * G.bound.dimensions.$.x + t % G.bound.dimensions.$.x, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "x" }, { type: "i", name: "y" }], body: [0, [[10, [1, [1, [1, "y", "%", [7, [7, [7, [7, "gridLayout", "bound"], "dimensions"], "$"], "y"]], "*", [7, [7, [7, [7, "gridLayout", "bound"], "dimensions"], "$"], "x"]], "+", [1, "x", "%", [7, [7, [7, [7, "gridLayout", "bound"], "dimensions"], "$"], "x"]]]]]], externalNames: ["gridLayout"] },
+  get externals() {
+    return { gridLayout: G };
+  }
+}) && e.f)({})), "pointToIndex"), fe = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn(
+  [m, m, m],
+  m
+)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t, r, n) => Ie(
+  m(0),
+  m(1),
+  G.bound.ids.$[ae(r, n)] === t
+), {
+  v: 1,
+  ast: { params: [{ type: "i", name: "checkId" }, { type: "i", name: "x" }, { type: "i", name: "y" }], body: [0, [[10, [6, [7, "std", "select"], [[6, [7, "d", "u32"], [[5, "0"]]], [6, [7, "d", "u32"], [[5, "1"]]], [1, [8, [7, [7, [7, "gridLayout", "bound"], "ids"], "$"], [6, "pointToIndex", ["x", "y"]]], "==", "checkId"]]]]]], externalNames: ["std", "d", "gridLayout", "pointToIndex"] },
+  get externals() {
+    return { std: Ce, d: W, gridLayout: G, pointToIndex: ae };
+  }
+}) && e.f)({})), "testNeighbor"), oe = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn(
+  [m, m, m],
+  m
+)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t, r, n) => {
+  const a = G.bound.ids.$[ae(r, n)];
+  return Ie(
+    m(0),
+    m(1),
+    // Note: in unsigned space if idMask is > 31 it's gonna loop back to 0,
+    // so we cannot allow ids greater than 31 here. However no error is thrown,
+    // so to keep gpu logic simple we do the check during the compile step.
+    (t & m(1) << a) !== m(0)
+  );
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "packedIds" }, { type: "i", name: "x" }, { type: "i", name: "y" }], body: [0, [[13, "idMask", [8, [7, [7, [7, "gridLayout", "bound"], "ids"], "$"], [6, "pointToIndex", ["x", "y"]]]], [10, [6, [7, "std", "select"], [[6, [7, "d", "u32"], [[5, "0"]]], [6, [7, "d", "u32"], [[5, "1"]]], [1, [1, "packedIds", "&", [1, [6, [7, "d", "u32"], [[5, "1"]]], "<<", "idMask"]], "!=", [6, [7, "d", "u32"], [[5, "0"]]]]]]]]], externalNames: ["gridLayout", "pointToIndex", "std", "d"] },
+  get externals() {
+    return { gridLayout: G, pointToIndex: ae, std: Ce, d: W };
+  }
+}) && e.f)({})), "testIdInPack"), Bt = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn(
+  [m, m, m, m],
+  m
+)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t, r, n, a) => {
+  const s = fe(n, t - 1, r - 1) + fe(n, t, r - 1) + fe(n, t + 1, r - 1) + fe(n, t - 1, r) + fe(n, t + 1, r) + fe(n, t - 1, r + 1) + fe(n, t, r + 1) + fe(n, t + 1, r + 1);
+  return Ie(
+    m(0),
+    m(1),
+    (a & m(1) << s) !== m(0)
+  );
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "x" }, { type: "i", name: "y" }, { type: "i", name: "checkId" }, { type: "i", name: "packedCount" }], body: [0, [[13, "countMask", [1, [1, [1, [1, [1, [1, [1, [6, "testNeighbor", ["checkId", [1, "x", "-", [5, "1"]], [1, "y", "-", [5, "1"]]]], "+", [6, "testNeighbor", ["checkId", "x", [1, "y", "-", [5, "1"]]]]], "+", [6, "testNeighbor", ["checkId", [1, "x", "+", [5, "1"]], [1, "y", "-", [5, "1"]]]]], "+", [6, "testNeighbor", ["checkId", [1, "x", "-", [5, "1"]], "y"]]], "+", [6, "testNeighbor", ["checkId", [1, "x", "+", [5, "1"]], "y"]]], "+", [6, "testNeighbor", ["checkId", [1, "x", "-", [5, "1"]], [1, "y", "+", [5, "1"]]]]], "+", [6, "testNeighbor", ["checkId", "x", [1, "y", "+", [5, "1"]]]]], "+", [6, "testNeighbor", ["checkId", [1, "x", "+", [5, "1"]], [1, "y", "+", [5, "1"]]]]]], [10, [6, [7, "std", "select"], [[6, [7, "d", "u32"], [[5, "0"]]], [6, [7, "d", "u32"], [[5, "1"]]], [1, [1, "packedCount", "&", [1, [6, [7, "d", "u32"], [[5, "1"]]], "<<", "countMask"]], "!=", [6, [7, "d", "u32"], [[5, "0"]]]]]]]]], externalNames: ["testNeighbor", "std", "d"] },
+  get externals() {
+    return { testNeighbor: fe, std: Ce, d: W };
+  }
+}) && e.f)({})), "checkIdCount"), dn = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn(
+  [m, m, m, m],
+  m
+)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t, r, n, a) => {
+  const s = oe(n, t - 1, r - 1) + oe(n, t, r - 1) + oe(n, t + 1, r - 1) + oe(n, t - 1, r) + oe(n, t + 1, r) + oe(n, t - 1, r + 1) + oe(n, t, r + 1) + oe(n, t + 1, r + 1);
+  return Ie(
+    m(0),
+    m(1),
+    (a & m(1) << s) !== m(0)
+  );
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "x" }, { type: "i", name: "y" }, { type: "i", name: "packedIds" }, { type: "i", name: "packedCount" }], body: [0, [[13, "countMask", [1, [1, [1, [1, [1, [1, [1, [6, "testIdInPack", ["packedIds", [1, "x", "-", [5, "1"]], [1, "y", "-", [5, "1"]]]], "+", [6, "testIdInPack", ["packedIds", "x", [1, "y", "-", [5, "1"]]]]], "+", [6, "testIdInPack", ["packedIds", [1, "x", "+", [5, "1"]], [1, "y", "-", [5, "1"]]]]], "+", [6, "testIdInPack", ["packedIds", [1, "x", "-", [5, "1"]], "y"]]], "+", [6, "testIdInPack", ["packedIds", [1, "x", "+", [5, "1"]], "y"]]], "+", [6, "testIdInPack", ["packedIds", [1, "x", "-", [5, "1"]], [1, "y", "+", [5, "1"]]]]], "+", [6, "testIdInPack", ["packedIds", "x", [1, "y", "+", [5, "1"]]]]], "+", [6, "testIdInPack", ["packedIds", [1, "x", "+", [5, "1"]], [1, "y", "+", [5, "1"]]]]]], [10, [6, [7, "std", "select"], [[6, [7, "d", "u32"], [[5, "0"]]], [6, [7, "d", "u32"], [[5, "1"]]], [1, [1, "packedCount", "&", [1, [6, [7, "d", "u32"], [[5, "1"]]], "<<", "countMask"]], "!=", [6, [7, "d", "u32"], [[5, "0"]]]]]]]]], externalNames: ["testIdInPack", "std", "d"] },
+  get externals() {
+    return { testIdInPack: oe, std: Ce, d: W };
+  }
+}) && e.f)({})), "checkIdsCount"), cn = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn(
+  [m, m, ne, m],
+  m
+)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t, r, n, a) => {
+  const s = ae(
+    t + m(n.x),
+    r + m(n.y)
+  ), i = G.bound.ids.$[s];
+  return Bt(t, r, i, a);
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "x" }, { type: "i", name: "y" }, { type: "i", name: "checkPoint" }, { type: "i", name: "packedCount" }], body: [0, [[13, "pointIndex", [6, "pointToIndex", [[1, "x", "+", [6, [7, "d", "u32"], [[7, "checkPoint", "x"]]]], [1, "y", "+", [6, [7, "d", "u32"], [[7, "checkPoint", "y"]]]]]]], [13, "checkId", [8, [7, [7, [7, "gridLayout", "bound"], "ids"], "$"], "pointIndex"]], [10, [6, "checkIdCount", ["x", "y", "checkId", "packedCount"]]]]], externalNames: ["pointToIndex", "d", "gridLayout", "checkIdCount"] },
+  get externals() {
+    return { pointToIndex: ae, d: W, gridLayout: G, checkIdCount: Bt };
+  }
+}) && e.f)({})), "checkPointCount"), pn = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn(
+  [m, m, ne, m],
+  m
+)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t, r, n, a) => {
+  const s = ae(
+    t + n.x,
+    r + n.y
+  );
+  return Ie(
+    m(0),
+    m(1),
+    G.bound.ids.$[s] === a
+  );
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "x" }, { type: "i", name: "y" }, { type: "i", name: "comparePoint" }, { type: "i", name: "withId" }], body: [0, [[13, "comparePointIndex", [6, "pointToIndex", [[1, "x", "+", [7, "comparePoint", "x"]], [1, "y", "+", [7, "comparePoint", "y"]]]]], [10, [6, [7, "std", "select"], [[6, [7, "d", "u32"], [[5, "0"]]], [6, [7, "d", "u32"], [[5, "1"]]], [1, [8, [7, [7, [7, "gridLayout", "bound"], "ids"], "$"], "comparePointIndex"], "==", "withId"]]]]]], externalNames: ["pointToIndex", "std", "d", "gridLayout"] },
+  get externals() {
+    return { pointToIndex: ae, std: Ce, d: W, gridLayout: G };
+  }
+}) && e.f)({})), "comparePointWithId"), hn = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn(
+  [m, m, ne, m],
+  m
+)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t, r, n, a) => oe(a, t + n.x, r + n.y), {
+  v: 1,
+  ast: { params: [{ type: "i", name: "x" }, { type: "i", name: "y" }, { type: "i", name: "comparePoint" }, { type: "i", name: "packedIds" }], body: [0, [[10, [6, "testIdInPack", ["packedIds", [1, "x", "+", [7, "comparePoint", "x"]], [1, "y", "+", [7, "comparePoint", "y"]]]]]]], externalNames: ["testIdInPack"] },
+  get externals() {
+    return { testIdInPack: oe };
+  }
+}) && e.f)({})), "comparePointWithKindId"), fn = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T.fn(
+  [m, m, ne, ne],
+  m
+)(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (t, r, n, a) => {
+  const s = ae(
+    t + n.x,
+    r + n.y
+  ), i = ae(t + a.x, r + a.y);
+  return Ie(
+    m(0),
+    m(1),
+    G.bound.ids.$[s] === G.bound.ids.$[i]
+  );
+}, {
+  v: 1,
+  ast: { params: [{ type: "i", name: "x" }, { type: "i", name: "y" }, { type: "i", name: "comparePoint" }, { type: "i", name: "withPoint" }], body: [0, [[13, "comparePointIndex", [6, "pointToIndex", [[1, "x", "+", [7, "comparePoint", "x"]], [1, "y", "+", [7, "comparePoint", "y"]]]]], [13, "withPointIndex", [6, "pointToIndex", [[1, "x", "+", [7, "withPoint", "x"]], [1, "y", "+", [7, "withPoint", "y"]]]]], [10, [6, [7, "std", "select"], [[6, [7, "d", "u32"], [[5, "0"]]], [6, [7, "d", "u32"], [[5, "1"]]], [1, [8, [7, [7, [7, "gridLayout", "bound"], "ids"], "$"], "comparePointIndex"], "==", [8, [7, [7, [7, "gridLayout", "bound"], "ids"], "$"], "withPointIndex"]]]]]]], externalNames: ["pointToIndex", "std", "d", "gridLayout"] },
+  get externals() {
+    return { pointToIndex: ae, std: Ce, d: W, gridLayout: G };
+  }
+}) && e.f)({})), "comparePointWithPoint"), $c = (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(T["~unstable"].computeFn({
+  workgroupSize: Ht,
+  in: { pos: mn.globalInvocationId }
+})(((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = ({ pos: t }) => {
+  const r = t.x, n = t.y, a = ae(r, n), s = G.bound.colors.$[a], i = G.bound.ids.$[a], l = xe.bound.elements.$[i], o = l.ruleStart, y = l.ruleEnd;
+  for (let h = o; h < y; h++) {
+    const w = xe.bound.rules.$[h], b = w.accept;
+    let v = m(0);
+    const x = w.conditionsStart, P = w.conditionsEnd, $ = P - x;
+    for (let k = x; k < P; k++) {
+      const L = xe.bound.conditions.$[k], ee = L.opcode;
+      if (ee === _e.COUNT_ELEMENT) {
+        const H = L.checkId, se = L.countOrWithId;
+        v += Bt(r, n, H, se);
+      } else if (ee === _e.COUNT_POINT) {
+        const H = L.checkPointOrComparePoint, se = L.countOrWithId;
+        v += cn(r, n, H, se);
+      } else if (ee === _e.COUNT_KIND) {
+        const H = L.checkId, se = L.countOrWithId;
+        v += dn(r, n, H, se);
+      } else if (ee === _e.IS_ELEMENT) {
+        const H = L.checkPointOrComparePoint, se = L.countOrWithId;
+        v += pn(r, n, H, se);
+      } else if (ee === _e.IS_POINT) {
+        const H = L.checkPointOrComparePoint, se = L.withPoint;
+        v += fn(r, n, H, se);
+      } else if (ee === _e.IS_KIND) {
+        const H = L.checkPointOrComparePoint, se = L.countOrWithId;
+        v += hn(r, n, H, se);
+      } else if (ee === _e.CHANCE) {
+        const H = L.chance;
+        Xt.seed3(
+          S(
+            An(_(t.xy), _(G.bound.dimensions.$.xy)),
+            Gt.$
+          )
+        ), v += Ie(m(0), m(1), Xt.sample() < H);
+      }
+    }
+    if (b === Ve.ALL && v === $ || b === Ve.ANY && v >= m(1) || b === Ve.ONE && v === m(1) || b === Ve.NONE && v === m(0)) {
+      let k = w.toId;
+      if (w.toType === Wr.POINT) {
+        const ee = ae(
+          r + m(w.toNeighbor.x),
+          n + m(w.toNeighbor.y)
+        );
+        k = G.bound.ids.$[ee];
+      }
+      G.bound.newIds.$[a] = k, G.bound.newColors.$[a] = xe.bound.elements.$[k].color;
+      return;
+    }
+  }
+  G.bound.newIds.$[a] = i, G.bound.newColors.$[a] = s;
+}, {
+  v: 1,
+  ast: { params: [{ type: "d", props: [{ name: "pos", alias: "pos" }] }], body: [0, [[13, "x", [7, "pos", "x"]], [13, "y", [7, "pos", "y"]], [13, "index", [6, "pointToIndex", ["x", "y"]]], [13, "color", [8, [7, [7, [7, "gridLayout", "bound"], "colors"], "$"], "index"]], [13, "id", [8, [7, [7, [7, "gridLayout", "bound"], "ids"], "$"], "index"]], [13, "element", [8, [7, [7, [7, "automatonLayout", "bound"], "elements"], "$"], "id"]], [13, "ruleStart", [7, "element", "ruleStart"]], [13, "ruleEnd", [7, "element", "ruleEnd"]], [14, [12, "i", "ruleStart"], [1, "i", "<", "ruleEnd"], [102, "++", "i"], [0, [[13, "rule", [8, [7, [7, [7, "automatonLayout", "bound"], "rules"], "$"], "i"]], [13, "accept", [7, "rule", "accept"]], [12, "passing", [6, [7, "d", "u32"], [[5, "0"]]]], [13, "conditionsStart", [7, "rule", "conditionsStart"]], [13, "conditionsEnd", [7, "rule", "conditionsEnd"]], [13, "conditionsCount", [1, "conditionsEnd", "-", "conditionsStart"]], [14, [12, "j", "conditionsStart"], [1, "j", "<", "conditionsEnd"], [102, "++", "j"], [0, [[13, "condition", [8, [7, [7, [7, "automatonLayout", "bound"], "conditions"], "$"], "j"]], [13, "opcode", [7, "condition", "opcode"]], [11, [1, "opcode", "==", [7, "Opcode", "COUNT_ELEMENT"]], [0, [[13, "checkId", [7, "condition", "checkId"]], [13, "count", [7, "condition", "countOrWithId"]], [2, "passing", "+=", [6, "checkIdCount", ["x", "y", "checkId", "count"]]]]], [11, [1, "opcode", "==", [7, "Opcode", "COUNT_POINT"]], [0, [[13, "checkPoint", [7, "condition", "checkPointOrComparePoint"]], [13, "count", [7, "condition", "countOrWithId"]], [2, "passing", "+=", [6, "checkPointCount", ["x", "y", "checkPoint", "count"]]]]], [11, [1, "opcode", "==", [7, "Opcode", "COUNT_KIND"]], [0, [[13, "packedIds", [7, "condition", "checkId"]], [13, "count", [7, "condition", "countOrWithId"]], [2, "passing", "+=", [6, "checkIdsCount", ["x", "y", "packedIds", "count"]]]]], [11, [1, "opcode", "==", [7, "Opcode", "IS_ELEMENT"]], [0, [[13, "comparePoint", [7, "condition", "checkPointOrComparePoint"]], [13, "withId", [7, "condition", "countOrWithId"]], [2, "passing", "+=", [6, "comparePointWithId", ["x", "y", "comparePoint", "withId"]]]]], [11, [1, "opcode", "==", [7, "Opcode", "IS_POINT"]], [0, [[13, "comparePoint", [7, "condition", "checkPointOrComparePoint"]], [13, "withPoint", [7, "condition", "withPoint"]], [2, "passing", "+=", [6, "comparePointWithPoint", ["x", "y", "comparePoint", "withPoint"]]]]], [11, [1, "opcode", "==", [7, "Opcode", "IS_KIND"]], [0, [[13, "comparePoint", [7, "condition", "checkPointOrComparePoint"]], [13, "packedIds", [7, "condition", "countOrWithId"]], [2, "passing", "+=", [6, "comparePointWithKindId", ["x", "y", "comparePoint", "packedIds"]]]]], [11, [1, "opcode", "==", [7, "Opcode", "CHANCE"]], [0, [[13, "chance", [7, "condition", "chance"]], [6, [7, "randf", "seed3"], [[6, [7, "d", "vec3f"], [[6, [7, "std", "div"], [[6, [7, "d", "vec2f"], [[7, "pos", "xy"]]], [6, [7, "d", "vec2f"], [[7, [7, [7, [7, "gridLayout", "bound"], "dimensions"], "$"], "xy"]]]]], [7, "seed", "$"]]]]], [2, "passing", "+=", [6, [7, "std", "select"], [[6, [7, "d", "u32"], [[5, "0"]]], [6, [7, "d", "u32"], [[5, "1"]]], [1, [6, [7, "randf", "sample"], []], "<", "chance"]]]]]]]]]]]]]]]], [11, [3, [3, [3, [3, [1, "accept", "==", [7, "Accept", "ALL"]], "&&", [1, "passing", "==", "conditionsCount"]], "||", [3, [1, "accept", "==", [7, "Accept", "ANY"]], "&&", [1, "passing", ">=", [6, [7, "d", "u32"], [[5, "1"]]]]]], "||", [3, [1, "accept", "==", [7, "Accept", "ONE"]], "&&", [1, "passing", "==", [6, [7, "d", "u32"], [[5, "1"]]]]]], "||", [3, [1, "accept", "==", [7, "Accept", "NONE"]], "&&", [1, "passing", "==", [6, [7, "d", "u32"], [[5, "0"]]]]]], [0, [[12, "resolvedId", [7, "rule", "toId"]], [13, "toType", [7, "rule", "toType"]], [11, [1, "toType", "==", [7, "To", "POINT"]], [0, [[13, "pointIndex", [6, "pointToIndex", [[1, "x", "+", [6, [7, "d", "u32"], [[7, [7, "rule", "toNeighbor"], "x"]]]], [1, "y", "+", [6, [7, "d", "u32"], [[7, [7, "rule", "toNeighbor"], "y"]]]]]]], [2, "resolvedId", "=", [8, [7, [7, [7, "gridLayout", "bound"], "ids"], "$"], "pointIndex"]]]]], [2, [8, [7, [7, [7, "gridLayout", "bound"], "newIds"], "$"], "index"], "=", "resolvedId"], [2, [8, [7, [7, [7, "gridLayout", "bound"], "newColors"], "$"], "index"], "=", [7, [8, [7, [7, [7, "automatonLayout", "bound"], "elements"], "$"], "resolvedId"], "color"]], [10]]]]]]], [2, [8, [7, [7, [7, "gridLayout", "bound"], "newIds"], "$"], "index"], "=", "id"], [2, [8, [7, [7, [7, "gridLayout", "bound"], "newColors"], "$"], "index"], "=", "color"]]], externalNames: ["pointToIndex", "gridLayout", "automatonLayout", "d", "Opcode", "checkIdCount", "checkPointCount", "checkIdsCount", "comparePointWithId", "comparePointWithPoint", "comparePointWithKindId", "randf", "std", "seed", "Accept", "To"] },
+  get externals() {
+    return { pointToIndex: ae, gridLayout: G, automatonLayout: xe, d: W, Opcode: _e, checkIdCount: Bt, checkPointCount: cn, checkIdsCount: dn, comparePointWithId: pn, comparePointWithPoint: fn, comparePointWithKindId: hn, randf: Xt, std: Ce, seed: Gt, Accept: Ve, To: Wr };
+  }
+}) && e.f)({})), "mainCompute"), Kc = ({
+  canvas: e,
+  automaton: t
+}) => {
+  const r = T.initFromDevice({ device: Ua }), n = (globalThis.__TYPEGPU_AUTONAME__ ?? ((B) => B))(r["~unstable"].withCompute($c).createPipeline(), "pipeline");
+  gt = 0, Gt = (globalThis.__TYPEGPU_AUTONAME__ ?? ((B) => B))(r.createUniform(f), "seed");
+  const { width: a, height: s } = e, i = e.getContext("2d"), l = Math.ceil(a / Ht[0]), o = Math.ceil(s / Ht[1]), y = (globalThis.__TYPEGPU_AUTONAME__ ?? ((B) => B))(r.createBuffer(ne, ne(a, s)).$usage("uniform"), "dimensions"), h = (globalThis.__TYPEGPU_AUTONAME__ ?? ((B) => B))(r.createBuffer(Q(m, a * s)).$usage("storage"), "colors0"), w = (globalThis.__TYPEGPU_AUTONAME__ ?? ((B) => B))(r.createBuffer(Q(m, a * s)).$usage("storage"), "colors1"), b = (globalThis.__TYPEGPU_AUTONAME__ ?? ((B) => B))(r.createBuffer(Q(m, a * s)).$usage("storage"), "ids0"), v = (globalThis.__TYPEGPU_AUTONAME__ ?? ((B) => B))(r.createBuffer(Q(m, a * s)).$usage("storage"), "ids1"), x = new Uint32Array(a * s), P = new Uint32Array(a * s);
+  for (let B = 0; B < x.length; B++) {
+    const Ir = Math.random() > 0.5;
+    x[B] = Ir ? 4278190080 : 4294967295, P[B] = Ir ? 0 : 1;
+  }
+  h.write(Array.from(x)), b.write(Array.from(P));
+  const $ = (globalThis.__TYPEGPU_AUTONAME__ ?? ((B) => B))(r.createBuffer(Q(m, a * s)).$addFlags(GPUBufferUsage.MAP_READ), "colorsStagingBuffer"), k = r.createBindGroup(G, {
+    dimensions: y,
+    colors: h,
+    newColors: w,
+    ids: b,
+    newIds: v
+  }), L = r.createBindGroup(G, {
+    dimensions: y,
+    colors: w,
+    newColors: h,
+    ids: v,
+    newIds: b
+  });
+  let ee = r.createBindGroup(
+    xe,
+    Mr(r, t)
+  );
+  const H = i.createImageData(a, s), se = new Uint32Array(H.data.buffer);
+  return { evolve: async () => {
+    Gt.write(Math.random()), n.with(xe, ee).with(G, gt % 2 === 0 ? k : L).dispatchWorkgroups(l, o), $.copyFrom(gt % 2 === 0 ? h : w), r["~unstable"].flush();
+    const B = $.buffer;
+    await B.mapAsync(GPUMapMode.READ), se.set(new Uint32Array(B.getMappedRange())), i.putImageData(H, 0, 0), B.unmap(), gt++;
+  }, setAutomaton: ({ automaton: B }) => {
+    ee = r.createBindGroup(
+      xe,
+      Mr(r, B)
+    );
+  }, tgpuRoot: r };
+};
+export {
+  Kc as setup
+};