@wonderyard/vivarium 1.4.1 → 2.0.0

package/dist/constants-BT-9-x_4.js

@@ -0,0 +1,3289 @@
+var F = "0.10.0";
+const Ft = process.env.NODE_ENV === "development", ce = process.env.NODE_ENV === "test", i = /* @__PURE__ */ Symbol(`typegpu:${F}:$internal`), Fs = /* @__PURE__ */ Symbol(`typegpu:${F}:$gpuValueOf`), Jt = /* @__PURE__ */ Symbol(`typegpu:${F}:$getNameForward`), Yn = /* @__PURE__ */ Symbol(`typegpu:${F}:$providing`), De = /* @__PURE__ */ Symbol(`typegpu:${F}:$ownSnippet`), A = /* @__PURE__ */ Symbol(`typegpu:${F}:$resolve`), Ye = /* @__PURE__ */ Symbol(`typegpu:${F}:$cast`), ot = /* @__PURE__ */ Symbol(`typegpu:${F}:$gpuCallable`), qn = /* @__PURE__ */ Symbol(`typegpu:${F}:$repr`);
+function m(t) {
+  return !!t?.[i];
+}
+const K = globalThis;
+K.__TYPEGPU_VERSION__ !== void 0 && console.warn(`Found duplicate TypeGPU version. First was ${K.__TYPEGPU_VERSION__}, this one is ${F}. This may cause unexpected behavior.`);
+K.__TYPEGPU_VERSION__ = F;
+K.__TYPEGPU_AUTONAME__ = (t, e) => Hn(t) && m(t) && !ut(t) ? t.$name(e) : t;
+const Us = (Ft || ce) && {
+  get enabled() {
+    return !!K.__TYPEGPU_MEASURE_PERF__;
+  },
+  record(t, e) {
+    const n = K.__TYPEGPU_PERF_RECORDS__ ??= /* @__PURE__ */ new Map();
+    let r = n.get(t);
+    r || (r = [], n.set(t, r)), r.push(e);
+  }
+} || void 0;
+function qe(t) {
+  return !!t?.[Jt];
+}
+function ut(t) {
+  return qe(t) ? ut(t[Jt]) : He(t)?.name;
+}
+function yt(t, e) {
+  if (qe(t)) {
+    yt(t[Jt], e);
+    return;
+  }
+  Zn(t, { name: e });
+}
+function Hn(t) {
+  return !!t?.$name;
+}
+function Kn(t) {
+  return !!He(t)?.ast;
+}
+function He(t) {
+  return K.__TYPEGPU_META__.get(t);
+}
+function Zn(t, e) {
+  K.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap();
+  const n = K.__TYPEGPU_META__;
+  n.set(t, {
+    ...n.get(t),
+    ...e
+  });
+}
+const Xn = [
+  "uint8",
+  "uint8x2",
+  "uint8x4",
+  "sint8",
+  "sint8x2",
+  "sint8x4",
+  "unorm8",
+  "unorm8x2",
+  "unorm8x4",
+  "snorm8",
+  "snorm8x2",
+  "snorm8x4",
+  "uint16",
+  "uint16x2",
+  "uint16x4",
+  "sint16",
+  "sint16x2",
+  "sint16x4",
+  "unorm16",
+  "unorm16x2",
+  "unorm16x4",
+  "snorm16",
+  "snorm16x2",
+  "snorm16x4",
+  "float16",
+  "float16x2",
+  "float16x4",
+  "float32",
+  "float32x2",
+  "float32x3",
+  "float32x4",
+  "uint32",
+  "uint32x2",
+  "uint32x3",
+  "uint32x4",
+  "sint32",
+  "sint32x2",
+  "sint32x3",
+  "sint32x4",
+  "unorm10-10-10-2",
+  "unorm8x4-bgra"
+], js = {
+  f32: "float32",
+  vec2f: "float32x2",
+  vec3f: "float32x3",
+  vec4f: "float32x4",
+  f16: "float16",
+  vec2h: "float16x2",
+  vec4h: "float16x4",
+  u32: "uint32",
+  vec2u: "uint32x2",
+  vec3u: "uint32x3",
+  vec4u: "uint32x4",
+  i32: "sint32",
+  vec2i: "sint32x2",
+  vec3i: "sint32x3",
+  vec4i: "sint32x4"
+}, Bs = {
+  [i]: {},
+  type: "void",
+  toString() {
+    return "void";
+  }
+}, Jn = [
+  "bool",
+  "f32",
+  "f16",
+  "i32",
+  "u32",
+  "u16",
+  "vec2f",
+  "vec2h",
+  "vec2i",
+  "vec2u",
+  "vec2<bool>",
+  "vec3f",
+  "vec3h",
+  "vec3i",
+  "vec3u",
+  "vec3<bool>",
+  "vec4f",
+  "vec4h",
+  "vec4i",
+  "vec4u",
+  "vec4<bool>",
+  "mat2x2f",
+  "mat3x3f",
+  "mat4x4f",
+  "struct",
+  "array",
+  "ptr",
+  "atomic",
+  "decorated",
+  "abstractInt",
+  "abstractFloat",
+  "void",
+  "texture_1d",
+  "texture_storage_1d",
+  "texture_2d",
+  "texture_storage_2d",
+  "texture_multisampled_2d",
+  "texture_depth_2d",
+  "texture_depth_multisampled_2d",
+  "texture_2d_array",
+  "texture_storage_2d_array",
+  "texture_depth_2d_array",
+  "texture_cube",
+  "texture_depth_cube",
+  "texture_cube_array",
+  "texture_depth_cube_array",
+  "texture_3d",
+  "texture_storage_3d",
+  "texture_external",
+  "sampler",
+  "sampler_comparison"
+];
+function w(t) {
+  const e = t;
+  return m(e) && typeof e.kind == "string" && e.kind.startsWith("vec");
+}
+function Qn(t) {
+  const e = t;
+  return m(e) && typeof e.type == "string" && e.type.startsWith("vec2");
+}
+function tr(t) {
+  const e = t;
+  return m(e) && typeof e.type == "string" && e.type.startsWith("vec3");
+}
+function er(t) {
+  const e = t;
+  return m(e) && typeof e.type == "string" && e.type.startsWith("vec4");
+}
+function C(t) {
+  return Qn(t) || tr(t) || er(t);
+}
+function Ls(t) {
+  return C(t) && t.type.includes("b");
+}
+function L(t) {
+  const e = t;
+  return m(e) && typeof e.kind?.startsWith == "function" && e.kind.startsWith("mat");
+}
+function nr(t) {
+  return m(t) && t?.type === "mat2x2f";
+}
+function rr(t) {
+  return m(t) && t?.type === "mat3x3f";
+}
+function sr(t) {
+  return m(t) && t?.type === "mat4x4f";
+}
+function ct(t) {
+  return nr(t) || rr(t) || sr(t);
+}
+function Ae(t) {
+  return w(t) && [
+    "vec2f",
+    "vec3f",
+    "vec4f"
+  ].includes(t.kind);
+}
+function Ke(t) {
+  return m(t) && Jn.includes(t?.type);
+}
+function Rs(t) {
+  return m(t) && t?.type === "array";
+}
+function Ws(t) {
+  return m(t) && t?.type === "struct";
+}
+function at(t) {
+  return m(t) && t?.type === "ptr";
+}
+function Gs(t) {
+  return m(t) && t?.type === "atomic";
+}
+function cr(t) {
+  return m(t) && t?.type === "@align";
+}
+function or(t) {
+  return m(t) && t?.type === "@size";
+}
+function ar(t) {
+  return m(t) && t?.type === "@location";
+}
+function Ds(t) {
+  return m(t) && t?.type === "@interpolate";
+}
+function Ys(t) {
+  return m(t) && t?.type === "@builtin";
+}
+function ir(t) {
+  return m(t) && t?.type === "decorated";
+}
+function qs(t) {
+  return m(t) && t.type === "void";
+}
+function ur(t) {
+  const e = t?.type;
+  return m(t) && (e === "abstractInt" || e === "abstractFloat" || e === "f32" || e === "f16" || e === "i32" || e === "u32");
+}
+function Hs(t) {
+  const e = t?.type;
+  return m(t) && (e === "f16" || e === "vec2h" || e === "vec3h" || e === "vec4h");
+}
+const yr = [
+  "abstractInt",
+  "abstractFloat",
+  "f32",
+  "f16",
+  "i32",
+  "u32",
+  "bool"
+];
+function Ze(t) {
+  return !m(t) || yr.includes(t?.type);
+}
+function fr(t) {
+  return t.schema;
+}
+function St(t) {
+  return ir(t) || hr(t) ? t.inner : t;
+}
+function Ks(t) {
+  return at(t) ? t.inner : t;
+}
+const lr = [
+  "unstruct",
+  "disarray",
+  "loose-decorated",
+  ...Xn
+];
+function mr(t) {
+  return m(t) && lr.includes(t?.type);
+}
+function Zs(t) {
+  return m(t) && t?.type === "disarray";
+}
+function Xs(t) {
+  return m(t) && t?.type === "unstruct";
+}
+function hr(t) {
+  return m(t) && t?.type === "loose-decorated";
+}
+function Js(t) {
+  return t.attribs?.find(cr)?.params[0];
+}
+function Qs(t) {
+  return t.attribs?.find(or)?.params[0];
+}
+function tc(t) {
+  return t.attribs?.find(ar)?.params[0];
+}
+function ec(t) {
+  return Ke(t) || mr(t);
+}
+const it = /* @__PURE__ */ Symbol("UNKNOWN");
+var nc = class {
+  constructor(t, e, n) {
+    this.name = t, this.lhs = e, this.operator = n;
+  }
+}, rc = class {
+  constructor(t) {
+    this.matrix = t;
+  }
+}, sc = class {
+  [i] = !0;
+  constructor(t) {
+    this.op = t, yt(this, "consoleLog");
+  }
+};
+function pr(t) {
+  return t === "runtime" || t === "constant" || t === "argument";
+}
+function xr(t) {
+  return pr(t.origin);
+}
+const dr = {
+  uniform: {
+    space: "uniform",
+    access: "read"
+  },
+  readonly: {
+    space: "storage",
+    access: "read"
+  },
+  mutable: {
+    space: "storage",
+    access: "read-write"
+  },
+  workgroup: {
+    space: "workgroup",
+    access: "read-write"
+  },
+  private: {
+    space: "private",
+    access: "read-write"
+  },
+  function: {
+    space: "function",
+    access: "read-write"
+  },
+  "this-function": {
+    space: "function",
+    access: "read-write"
+  }
+};
+var Xe = class {
+  constructor(t, e, n) {
+    this.value = t, this.dataType = e, this.origin = n;
+  }
+};
+function oe(t) {
+  return t instanceof Xe;
+}
+function cc(t) {
+  return ur(t.dataType);
+}
+function l(t, e, n) {
+  if (Ft && oe(t)) throw new Error("Cannot nest snippets");
+  return new Xe(t, St(e), n);
+}
+const ee = "Invariant failed";
+function ae(t, e) {
+  if (t) return;
+  if (!Ft && !ce) throw new Error(ee);
+  const n = typeof e == "function" ? e() : e, r = n ? `${ee}: ${n}` : ee;
+  throw new Error(r);
+}
+var oc = class ne extends Error {
+  constructor(e, n) {
+    let r = n.map((s) => `- ${Kn(s) ? `fn*:${ut(s)}` : s}`);
+    r.length > 20 && (r = [
+      ...r.slice(0, 11),
+      "...",
+      ...r.slice(-10)
+    ]), super(`Resolution of the following tree failed:
+${r.join(`
+`)}: ${e && typeof e == "object" && "message" in e ? e.message : e}`), this.cause = e, this.trace = n, Object.setPrototypeOf(this, ne.prototype);
+  }
+  appendToTrace(e) {
+    const n = [e, ...this.trace];
+    return new ne(this.cause, n);
+  }
+}, ac = class re extends Error {
+  constructor(e, n) {
+    let r = n.map((s) => `- ${s}`);
+    r.length > 20 && (r = [
+      ...r.slice(0, 11),
+      "...",
+      ...r.slice(-10)
+    ]), super(`Execution of the following tree failed:
+${r.join(`
+`)}: ${e && typeof e == "object" && "message" in e ? e.message : e}`), this.cause = e, this.trace = n, Object.setPrototypeOf(this, re.prototype);
+  }
+  appendToTrace(e) {
+    const n = [e, ...this.trace];
+    return new re(this.cause, n);
+  }
+}, ic = class Je extends Error {
+  constructor(e) {
+    super(`Missing value for '${e}'`), this.slot = e, Object.setPrototypeOf(this, Je.prototype);
+  }
+}, uc = class Qe extends Error {
+  constructor(e) {
+    super(`Buffer '${ut(e) ?? "<unnamed>"}' is not bindable as a uniform. Use .$usage('uniform') to allow it.`), Object.setPrototypeOf(this, Qe.prototype);
+  }
+}, yc = class tn extends Error {
+  constructor(e, n) {
+    super(`The function '${e ?? "<unnamed>"}' is missing links to the following external values: ${n}.`), Object.setPrototypeOf(this, tn.prototype);
+  }
+}, fc = class en extends Error {
+  constructor(e) {
+    super(`Missing bind groups for layouts: '${[...e].map((n) => ut(n) ?? "<unnamed>").join(", ")}'. Please provide it using pipeline.with(bindGroup).(...)`), Object.setPrototypeOf(this, en.prototype);
+  }
+}, lc = class nn extends Error {
+  constructor(e) {
+    super(`Missing vertex buffers for layouts: '${[...e].map((n) => ut(n) ?? "<unnamed>").join(", ")}'. Please provide it using pipeline.with(layout, buffer).(...)`), Object.setPrototypeOf(this, nn.prototype);
+  }
+}, mc = class rn extends Error {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, rn.prototype);
+  }
+}, hc = class sn extends Error {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, sn.prototype);
+  }
+}, Qt = class cn extends Error {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, cn.prototype);
+  }
+}, gr = class on extends Error {
+  constructor(e, n) {
+    super(`Unsupported data types: ${e.map((r) => r.type).join(", ")}. Supported types are: ${n.map((r) => r.type).join(", ")}.`), Object.setPrototypeOf(this, on.prototype);
+  }
+};
+function vr(t) {
+  return t?.resourceType === "slot";
+}
+function br(t) {
+  return t?.resourceType === "lazy";
+}
+function zr(t) {
+  return t?.[Yn] !== void 0;
+}
+function pc(t) {
+  return t?.resourceType === "accessor";
+}
+function xc(t) {
+  return t?.resourceType === "mutable-accessor";
+}
+var ie = class {
+  type = "normal";
+}, dc = class {
+  type = "codegen";
+}, gc = class {
+  type = "simulate";
+  constructor(t, e) {
+    this.buffers = t, this.vars = e;
+  }
+};
+function wr(t) {
+  return !!t?.[A];
+}
+function an(t) {
+  return t?.[De];
+}
+function Mr(t) {
+  return !!t?.[ot];
+}
+function Tr(t) {
+  return !!t?.[Ye];
+}
+function Kt(t) {
+  return (typeof t.value != "string" || t.dataType === it) && an(t.value) === void 0;
+}
+function vc(t) {
+  return typeof t == "number" || typeof t == "boolean" || typeof t == "string" || wr(t) || Ke(t) || vr(t) || br(t) || zr(t);
+}
+function bc(t) {
+  return !!t && typeof t == "object" && "getMappedRange" in t && "mapAsync" in t;
+}
+let Ht = !1;
+function zc(t) {
+  if (Ht) return t();
+  try {
+    return Ht = !0, t();
+  } finally {
+    Ht = !1;
+  }
+}
+function wc() {
+  return Ht;
+}
+let et;
+function Mc(t, e) {
+  if (ae(et === void 0 || et === t, "Cannot nest context providers"), et === t) return e();
+  et = t;
+  try {
+    return e();
+  } finally {
+    et = void 0;
+  }
+}
+function _r() {
+  return et;
+}
+const Ir = new ie();
+function Tc() {
+  return et?.mode ?? Ir;
+}
+function _c() {
+  return et?.mode.type === "codegen";
+}
+function f(t, ...e) {
+  const n = _r();
+  function r(c) {
+    return oe(c) ? n.resolve(c.value, c.dataType).value : c;
+  }
+  let s = "";
+  for (let c = 0; c < t.length; ++c) {
+    s += t[c];
+    const a = e[c];
+    Array.isArray(a) ? s += a.filter((o) => o !== void 0).map(r).join(", ") : a && (s += r(a));
+  }
+  return s;
+}
+function Ic(t) {
+  return Q("function", t, "read-write");
+}
+function $c(t) {
+  return Q("private", t, "read-write");
+}
+function Ec(t) {
+  return Q("workgroup", t, "read-write");
+}
+function Sc(t, e = "read") {
+  return Q("storage", t, e);
+}
+function kc(t) {
+  return Q("uniform", t, "read");
+}
+function Vc(t) {
+  return Q("handle", t, "read");
+}
+function Q(t, e, n, r = !1) {
+  return {
+    [i]: {},
+    type: "ptr",
+    addressSpace: t,
+    inner: e,
+    access: n,
+    implicit: r,
+    toString: () => `ptr<${t}, ${e}, ${n}>`
+  };
+}
+function $r(t, e) {
+  const n = dr[t];
+  if (n) return Q(n.space, e, n.access);
+}
+function Oc(t) {
+  return Q(t.addressSpace, t.inner, t.access, !0);
+}
+function Er(t) {
+  return Q(t.addressSpace, t.inner, t.access, !1);
+}
+const Nc = (() => {
+  const t = ((e) => kr(e));
+  return yt(t, "ref"), t.toString = () => "ref", t[i] = !0, t[ot] = { call(e, [n]) {
+    if (n.origin === "argument") throw new Qt(f`d.ref(${n}) is illegal, cannot take a reference of an argument. Copy the value locally first, and take a reference of the copy.`);
+    if (at(n.dataType)) return l(n.value, Er(n.dataType), n.origin);
+    const r = $r(n.origin, n.dataType);
+    return l(new ue(n, r), r ?? it, "runtime");
+  } }, t;
+})();
+function Sr(t) {
+  return t?.[i]?.type === "ref";
+}
+function kr(t) {
+  const e = {
+    [i]: { type: "ref" },
+    get $() {
+      return t;
+    },
+    set $(n) {
+      if (n && typeof n == "object") for (const r of Object.keys(n)) t[r] = n[r];
+      else t = n;
+    }
+  };
+  if (t == null) throw new Error("Cannot create a ref from undefined or null");
+  return typeof t == "object" ? new Proxy(e, {
+    get(n, r) {
+      return r in n ? n[r] : t[r];
+    },
+    set(n, r, s) {
+      return r === i ? !1 : r === "$" ? (console.log("Setting ref value:", s), Reflect.set(e, r, s)) : Reflect.set(t, r, s);
+    }
+  }) : e;
+}
+var ue = class {
+  [i];
+  snippet;
+  #t;
+  constructor(t, e) {
+    this[i] = !0, this.snippet = t, this.#t = e;
+  }
+  get [De]() {
+    if (!this.#t) throw new Error(f`Cannot take a reference of ${this.snippet}`);
+    return l(this, this.#t, this.snippet.origin);
+  }
+  [A]() {
+    if (!this.#t) throw new Error(f`Cannot take a reference of ${this.snippet}`);
+    return l(f`(&${this.snippet})`, this.#t, this.snippet.origin);
+  }
+};
+function Vr(t) {
+  if (!at(t.dataType)) return t;
+  const e = t.dataType.inner, n = Ze(e) ? "runtime" : t.origin;
+  return t.value instanceof ue ? l(f`${t.value.snippet}`, e, n) : l(f`(*${t})`, e, n);
+}
+function Or(t, e) {
+  const n = t;
+  return Tr(n) ? n[Ye](e) : typeof n != "function" ? e : e === void 0 ? n() : n(e);
+}
+function Nr(t, e, n) {
+  if (!Mr(e)) return n;
+  const r = e;
+  return n === void 0 || n.value === void 0 ? r[ot].call(t, []) : r[ot].call(t, [n]);
+}
+function Pr(t) {
+  const e = String(t);
+  if (e !== "[object Object]") return e;
+  try {
+    return JSON.stringify(t);
+  } catch (n) {
+    return console.error("Error parsing JSON:", n), "<invalid json>";
+  }
+}
+function Fe(t) {
+  return w(t) || L(t) ? t.toString() : Array.isArray(t) ? `[${t.map(Fe).join(", ")}]` : t && typeof t == "object" ? `{ ${Object.entries(t).map(([e, n]) => `${e}: ${Fe(n)}`).join(", ")} }` : String(t);
+}
+function Cr(t, e) {
+  throw new Error(`Failed to handle ${t} at ${e}`);
+}
+const ye = {
+  rank: Number.POSITIVE_INFINITY,
+  action: "none"
+};
+function Zt(t, e) {
+  const n = St(t), r = St(e);
+  if (n.type === r.type) return {
+    rank: 0,
+    action: "none"
+  };
+  if (n.type === "abstractFloat") {
+    if (r.type === "f32") return {
+      rank: 1,
+      action: "none"
+    };
+    if (r.type === "f16") return {
+      rank: 2,
+      action: "none"
+    };
+  }
+  if (n.type === "abstractInt") {
+    if (r.type === "i32") return {
+      rank: 3,
+      action: "none"
+    };
+    if (r.type === "u32") return {
+      rank: 4,
+      action: "none"
+    };
+    if (r.type === "abstractFloat") return {
+      rank: 5,
+      action: "none"
+    };
+    if (r.type === "f32") return {
+      rank: 6,
+      action: "none"
+    };
+    if (r.type === "f16") return {
+      rank: 7,
+      action: "none"
+    };
+  }
+  return C(n) && C(r) && n.type[3] === r.type[3] ? Zt(n.primitive, r.primitive) : ct(n) && ct(r) && n.type[3] === r.type[3] ? {
+    rank: 0,
+    action: "none"
+  } : ye;
+}
+function Ar(t, e) {
+  const n = St(t), r = St(e);
+  if (at(n) && n.implicit && Zt(n.inner, r).rank < Number.POSITIVE_INFINITY) return {
+    rank: 0,
+    action: "deref"
+  };
+  if (at(r) && Zt(n, r.inner).rank < Number.POSITIVE_INFINITY) return {
+    rank: 1,
+    action: "ref"
+  };
+  const s = {
+    f32: 0,
+    f16: 1,
+    i32: 2,
+    u32: 3,
+    bool: 4
+  };
+  if (n.type in s && r.type in s) {
+    const c = n.type, a = r.type;
+    if (c !== a) {
+      const o = s[c];
+      return {
+        rank: s[a] < o ? 10 : 20,
+        action: "cast",
+        targetType: r
+      };
+    }
+  }
+  if (n.type === "abstractFloat") {
+    if (r.type === "u32") return {
+      rank: 2,
+      action: "cast",
+      targetType: r
+    };
+    if (r.type === "i32") return {
+      rank: 1,
+      action: "cast",
+      targetType: r
+    };
+  }
+  return ye;
+}
+function Fr(t, e, n) {
+  const r = Zt(t, e);
+  return r.rank < Number.POSITIVE_INFINITY ? r : n ? Ar(t, e) : ye;
+}
+function Ue(t, e, n) {
+  let r;
+  for (const c of e) {
+    const a = [];
+    let o = 0;
+    for (const b of t) {
+      const y = Fr(b, c, n);
+      if (o += y.rank, y.rank === Number.POSITIVE_INFINITY) break;
+      a.push(y);
+    }
+    o < (r?.sum ?? Number.POSITIVE_INFINITY) && (r = {
+      type: c,
+      details: a,
+      sum: o
+    });
+  }
+  if (!r) return;
+  const s = r.details.map((c, a) => ({
+    sourceIndex: a,
+    action: c.action,
+    ...c.action === "cast" && { targetType: c.targetType }
+  }));
+  return {
+    targetType: r.type,
+    actions: s,
+    hasImplicitConversions: s.some((c) => c.action === "cast")
+  };
+}
+function un(t, e) {
+  if (t.length === 0) return;
+  const n = [...new Set((e || t).map(St))], r = Ue(t, n, !1);
+  if (r) return r;
+  const s = Ue(t, n, !0);
+  if (s) return s;
+}
+function Ur(t, e, n, r) {
+  if (n.action === "none") return l(e.value, r, e.origin);
+  switch (n.action) {
+    case "ref":
+      return l(new ue(e, r), r, e.origin);
+    case "deref":
+      return Vr(e);
+    case "cast":
+      return Nr(t, r, e);
+    default:
+      Cr(n.action, "applyActionToSnippet");
+  }
+}
+function je(t, e) {
+  if (t.some((r) => r === it)) return;
+  const n = un(t, e);
+  if (n)
+    return t.map((r) => C(r) || ct(r) ? r : n.targetType);
+}
+function yn(t, e, n, r = !0) {
+  const s = e.map((a) => a.dataType);
+  if (s.some((a) => a === it)) return;
+  Ft && Array.isArray(n) && n.length === 0 && console.warn("convertToCommonType was called with an empty restrictTo array, which prevents any conversions from being made. If you intend to allow all conversions, pass undefined instead. If this was intended call the function conditionally since the result will always be undefined.");
+  const c = un(s, n);
+  if (c)
+    return (ce || Ft) && r && c.hasImplicitConversions && console.warn(`Implicit conversions from [
+${e.map((a) => `  ${a.value}: ${Pr(a.dataType)}`).join(`,
+`)}
+] to ${c.targetType.type} are supported, but not recommended.
+Consider using explicit conversions instead.`), e.map((a, o) => {
+      const b = c.actions[o];
+      return ae(b, "Action should not be undefined"), Ur(t, a, b, c.targetType);
+    });
+}
+function fn(t, e, n, r = !0) {
+  const s = Array.isArray(n) ? n : [n], { value: c, dataType: a, origin: o } = e;
+  if (s.length === 1) {
+    const y = s[0];
+    if (y === a) return l(c, y, o);
+    if (a === it) return l(f`${l(c, y, o)}`, y, o);
+  }
+  const b = yn(t, [e], s, r);
+  if (b) return b[0];
+  throw new Qt(`Cannot convert value of type '${String(a)}' to any of the target types: [${s.map((y) => y.type).join(", ")}]`);
+}
+function Pc(t, e, n) {
+  return Object.entries(e.propTypes).map(([r, s]) => {
+    const c = n[r];
+    if (!c) throw new Error(`Missing property ${r}`);
+    return yn(t, [c], [s])?.[0] ?? c;
+  });
+}
+function ft(t) {
+  const e = ((...n) => t.normalImpl(...n));
+  return yt(e, t.name), e.toString = () => t.name, e[ot] = {
+    get strictSignature() {
+    },
+    call(n, r) {
+      const { argTypes: s, returnType: c } = t.signature(...r.map((o) => at(o.dataType) && o.dataType.implicit ? o.dataType.inner : o.dataType)), a = r.map((o, b) => {
+        const y = s[b];
+        if (!y) throw new Error("Function called with invalid arguments");
+        return fn(n, o, y, !1);
+      });
+      if (a.every((o) => Kt(o))) {
+        n.pushMode(new ie());
+        try {
+          return l(t.normalImpl(...a.map((o) => o.value)), c, "constant");
+        } finally {
+          n.popMode("normal");
+        }
+      }
+      return l(t.codegenImpl(n, a), c, "runtime");
+    }
+  }, e;
+}
+const jr = {
+  [i]: {},
+  type: "abstractInt",
+  toString() {
+    return "abstractInt";
+  }
+}, se = {
+  [i]: {},
+  type: "abstractFloat",
+  toString() {
+    return "abstractFloat";
+  }
+}, Br = ft({
+  name: "bool",
+  signature: (t) => ({
+    argTypes: t ? [t] : [],
+    returnType: Z
+  }),
+  normalImpl(t) {
+    return t === void 0 ? !1 : typeof t == "boolean" ? t : !!t;
+  },
+  codegenImpl: (t, [e]) => e?.dataType === Z ? f`${e}` : f`bool(${e})`
+}), Z = Object.assign(Br, {
+  [i]: {},
+  type: "bool"
+}), Lr = ft({
+  name: "u32",
+  signature: (t) => ({
+    argTypes: t ? [t] : [],
+    returnType: z
+  }),
+  normalImpl(t) {
+    if (t === void 0) return 0;
+    if (typeof t == "boolean") return t ? 1 : 0;
+    if (!Number.isInteger(t)) {
+      const e = Math.trunc(t);
+      return e < 0 ? 0 : e > 4294967295 ? 4294967295 : e;
+    }
+    return (t & 4294967295) >>> 0;
+  },
+  codegenImpl: (t, [e]) => e?.dataType === z ? f`${e}` : f`u32(${e})`
+}), z = Object.assign(Lr, {
+  [i]: {},
+  type: "u32"
+}), Rr = ft({
+  name: "i32",
+  signature: (t) => ({
+    argTypes: t ? [t] : [],
+    returnType: X
+  }),
+  normalImpl(t) {
+    return t === void 0 ? 0 : typeof t == "boolean" ? t ? 1 : 0 : t | 0;
+  },
+  codegenImpl: (t, [e]) => e?.dataType === X ? f`${e}` : f`i32(${e})`
+}), Cc = {
+  [i]: {},
+  type: "u16"
+}, X = Object.assign(Rr, {
+  [i]: {},
+  type: "i32"
+}), Wr = ft({
+  name: "f32",
+  signature: (t) => ({
+    argTypes: t ? [t] : [],
+    returnType: T
+  }),
+  normalImpl(t) {
+    return t === void 0 ? 0 : typeof t == "boolean" ? t ? 1 : 0 : Math.fround(t);
+  },
+  codegenImpl: (t, [e]) => e?.dataType === T ? f`${e}` : f`f32(${e})`
+}), T = Object.assign(Wr, {
+  [i]: {},
+  type: "f32"
+}), ln = /* @__PURE__ */ new ArrayBuffer(4), Gr = new Float32Array(ln), Dr = new Uint32Array(ln);
+function Yr(t) {
+  Gr[0] = t;
+  const e = Dr[0], n = e >>> 31 & 1;
+  let r = e >>> 23 & 255, s = e & 8388607;
+  return r === 255 ? n << 15 | 31744 | (s ? 512 : 0) : (r = r - 127 + 15, r <= 0 ? r < -10 ? n << 15 : (s = (s | 8388608) >> 1 - r, s = s + 4096 >> 13, n << 15 | s) : r >= 31 || (s = s + 4096, s & 8388608 && (s = 0, ++r, r >= 31)) ? n << 15 | 31744 : n << 15 | r << 10 | s >> 13);
+}
+function qr(t) {
+  const e = t & 32768 ? -1 : 1, n = t >> 10 & 31, r = t & 1023;
+  return n === 0 ? r ? e * r * 2 ** -24 : e * 0 : n === 31 ? r ? NaN : e === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY : e * (1 + r / 1024) * 2 ** (n - 15);
+}
+function Hr(t) {
+  return qr(Yr(t));
+}
+const Kr = ft({
+  name: "f16",
+  signature: (t) => ({
+    argTypes: t ? [t] : [],
+    returnType: J
+  }),
+  normalImpl(t) {
+    return t === void 0 ? 0 : typeof t == "boolean" ? t ? 1 : 0 : Hr(t);
+  },
+  codegenImpl: (t, [e]) => e?.dataType === J ? f`${e}` : f`f16(${e})`
+}), J = Object.assign(Kr, {
+  [i]: {},
+  type: "f16"
+}), R = [
+  "x",
+  "y",
+  "z",
+  "w"
+], W = [
+  "r",
+  "g",
+  "b",
+  "a"
+];
+var P, fe = (P = class extends Array {
+  castElement() {
+    return this[i].elementSchema;
+  }
+  [A]() {
+    const e = this[i].elementSchema;
+    return this.every((n) => !n) ? l(`${this.kind}()`, e, "constant") : this.every((n) => this[0] === n) ? l(`${this.kind}(${this[0]})`, e, "runtime") : l(`${this.kind}(${this.join(", ")})`, e, "runtime");
+  }
+  toString() {
+    return this[A]().value;
+  }
+}, (() => {
+  for (let e = 0; e < 4; e++) for (let n = 0; n < 4; n++) for (let r = 0; r < 4; r++) for (let s = 0; s < 4; s++) {
+    const c = `${R[e]}${R[n]}${R[r]}${R[s]}`, a = `${W[e]}${W[n]}${W[r]}${W[s]}`;
+    Object.defineProperty(P.prototype, c, { get() {
+      return new this._Vec4(this[e], this[n], this[r], this[s]);
+    } }), Object.defineProperty(P.prototype, a, { get() {
+      return new this._Vec4(this[e], this[n], this[r], this[s]);
+    } });
+  }
+  for (let e = 0; e < 4; e++) for (let n = 0; n < 4; n++) for (let r = 0; r < 4; r++) {
+    const s = `${R[e]}${R[n]}${R[r]}`, c = `${W[e]}${W[n]}${W[r]}`;
+    Object.defineProperty(P.prototype, s, { get() {
+      return new this._Vec3(this[e], this[n], this[r]);
+    } }), Object.defineProperty(P.prototype, c, { get() {
+      return new this._Vec3(this[e], this[n], this[r]);
+    } });
+  }
+  for (let e = 0; e < 4; e++) for (let n = 0; n < 4; n++) {
+    const r = `${R[e]}${R[n]}`, s = `${W[e]}${W[n]}`;
+    Object.defineProperty(P.prototype, r, { get() {
+      return new this._Vec2(this[e], this[n]);
+    } }), Object.defineProperty(P.prototype, s, { get() {
+      return new this._Vec2(this[e], this[n]);
+    } });
+  }
+})(), P), jt = class extends fe {
+  e0;
+  e1;
+  constructor(t, e) {
+    super(2), this.e0 = this.castElement()(t), this.e1 = this.castElement()(e ?? t);
+  }
+  get 0() {
+    return this.e0;
+  }
+  get 1() {
+    return this.e1;
+  }
+  set 0(t) {
+    this.e0 = this.castElement()(t);
+  }
+  set 1(t) {
+    this.e1 = this.castElement()(t);
+  }
+  get x() {
+    return this[0];
+  }
+  get y() {
+    return this[1];
+  }
+  set x(t) {
+    this[0] = this.castElement()(t);
+  }
+  set y(t) {
+    this[1] = this.castElement()(t);
+  }
+  get r() {
+    return this[0];
+  }
+  get g() {
+    return this[1];
+  }
+  set r(t) {
+    this[0] = this.castElement()(t);
+  }
+  set g(t) {
+    this[1] = this.castElement()(t);
+  }
+}, Bt = class extends fe {
+  e0;
+  e1;
+  e2;
+  constructor(t, e, n) {
+    super(3), this.e0 = this.castElement()(t), this.e1 = this.castElement()(e ?? t), this.e2 = this.castElement()(n ?? t);
+  }
+  get 0() {
+    return this.e0;
+  }
+  get 1() {
+    return this.e1;
+  }
+  get 2() {
+    return this.e2;
+  }
+  set 0(t) {
+    this.e0 = this.castElement()(t);
+  }
+  set 1(t) {
+    this.e1 = this.castElement()(t);
+  }
+  set 2(t) {
+    this.e2 = this.castElement()(t);
+  }
+  get x() {
+    return this[0];
+  }
+  get y() {
+    return this[1];
+  }
+  get z() {
+    return this[2];
+  }
+  set x(t) {
+    this[0] = this.castElement()(t);
+  }
+  set y(t) {
+    this[1] = this.castElement()(t);
+  }
+  set z(t) {
+    this[2] = this.castElement()(t);
+  }
+  get r() {
+    return this[0];
+  }
+  get g() {
+    return this[1];
+  }
+  get b() {
+    return this[2];
+  }
+  set r(t) {
+    this[0] = this.castElement()(t);
+  }
+  set g(t) {
+    this[1] = this.castElement()(t);
+  }
+  set b(t) {
+    this[2] = this.castElement()(t);
+  }
+}, Lt = class extends fe {
+  e0;
+  e1;
+  e2;
+  e3;
+  constructor(t, e, n, r) {
+    super(4), this.e0 = this.castElement()(t), this.e1 = this.castElement()(e ?? t), this.e2 = this.castElement()(n ?? t), this.e3 = this.castElement()(r ?? t);
+  }
+  get 0() {
+    return this.e0;
+  }
+  get 1() {
+    return this.e1;
+  }
+  get 2() {
+    return this.e2;
+  }
+  get 3() {
+    return this.e3;
+  }
+  set 0(t) {
+    this.e0 = this.castElement()(t);
+  }
+  set 1(t) {
+    this.e1 = this.castElement()(t);
+  }
+  set 2(t) {
+    this.e2 = this.castElement()(t);
+  }
+  set 3(t) {
+    this.e3 = this.castElement()(t);
+  }
+  get x() {
+    return this[0];
+  }
+  get y() {
+    return this[1];
+  }
+  get r() {
+    return this[0];
+  }
+  get g() {
+    return this[1];
+  }
+  get b() {
+    return this[2];
+  }
+  get a() {
+    return this[3];
+  }
+  set r(t) {
+    this[0] = t;
+  }
+  set g(t) {
+    this[1] = t;
+  }
+  set b(t) {
+    this[2] = t;
+  }
+  set a(t) {
+    this[3] = t;
+  }
+  get z() {
+    return this[2];
+  }
+  get w() {
+    return this[3];
+  }
+  set x(t) {
+    this[0] = t;
+  }
+  set y(t) {
+    this[1] = t;
+  }
+  set z(t) {
+    this[2] = t;
+  }
+  set w(t) {
+    this[3] = t;
+  }
+}, le = class mn extends jt {
+  get [i]() {
+    return { elementSchema: T };
+  }
+  get kind() {
+    return "vec2f";
+  }
+  get _Vec2() {
+    return mn;
+  }
+  get _Vec3() {
+    return de;
+  }
+  get _Vec4() {
+    return we;
+  }
+}, me = class hn extends jt {
+  get [i]() {
+    return { elementSchema: J };
+  }
+  get kind() {
+    return "vec2h";
+  }
+  get _Vec2() {
+    return hn;
+  }
+  get _Vec3() {
+    return ge;
+  }
+  get _Vec4() {
+    return Me;
+  }
+}, he = class pn extends jt {
+  get [i]() {
+    return { elementSchema: X };
+  }
+  get kind() {
+    return "vec2i";
+  }
+  get _Vec2() {
+    return pn;
+  }
+  get _Vec3() {
+    return ve;
+  }
+  get _Vec4() {
+    return Te;
+  }
+}, pe = class xn extends jt {
+  get [i]() {
+    return { elementSchema: z };
+  }
+  get kind() {
+    return "vec2u";
+  }
+  get _Vec2() {
+    return xn;
+  }
+  get _Vec3() {
+    return be;
+  }
+  get _Vec4() {
+    return _e;
+  }
+}, xe = class dn extends jt {
+  get [i]() {
+    return { elementSchema: Z };
+  }
+  get kind() {
+    return "vec2<bool>";
+  }
+  get _Vec2() {
+    return dn;
+  }
+  get _Vec3() {
+    return ze;
+  }
+  get _Vec4() {
+    return Ie;
+  }
+}, de = class gn extends Bt {
+  get [i]() {
+    return { elementSchema: T };
+  }
+  get kind() {
+    return "vec3f";
+  }
+  get _Vec2() {
+    return le;
+  }
+  get _Vec3() {
+    return gn;
+  }
+  get _Vec4() {
+    return we;
+  }
+}, ge = class vn extends Bt {
+  get [i]() {
+    return { elementSchema: J };
+  }
+  get kind() {
+    return "vec3h";
+  }
+  get _Vec2() {
+    return me;
+  }
+  get _Vec3() {
+    return vn;
+  }
+  get _Vec4() {
+    return Me;
+  }
+}, ve = class bn extends Bt {
+  get [i]() {
+    return { elementSchema: X };
+  }
+  get kind() {
+    return "vec3i";
+  }
+  get _Vec2() {
+    return he;
+  }
+  get _Vec3() {
+    return bn;
+  }
+  get _Vec4() {
+    return Te;
+  }
+}, be = class zn extends Bt {
+  get [i]() {
+    return { elementSchema: z };
+  }
+  get kind() {
+    return "vec3u";
+  }
+  get _Vec2() {
+    return pe;
+  }
+  get _Vec3() {
+    return zn;
+  }
+  get _Vec4() {
+    return _e;
+  }
+}, ze = class wn extends Bt {
+  get [i]() {
+    return { elementSchema: Z };
+  }
+  get kind() {
+    return "vec3<bool>";
+  }
+  get _Vec2() {
+    return xe;
+  }
+  get _Vec3() {
+    return wn;
+  }
+  get _Vec4() {
+    return Ie;
+  }
+}, we = class Mn extends Lt {
+  get [i]() {
+    return { elementSchema: T };
+  }
+  get kind() {
+    return "vec4f";
+  }
+  get _Vec2() {
+    return le;
+  }
+  get _Vec3() {
+    return de;
+  }
+  get _Vec4() {
+    return Mn;
+  }
+}, Me = class Tn extends Lt {
+  get [i]() {
+    return { elementSchema: J };
+  }
+  get kind() {
+    return "vec4h";
+  }
+  get _Vec2() {
+    return me;
+  }
+  get _Vec3() {
+    return ge;
+  }
+  get _Vec4() {
+    return Tn;
+  }
+}, Te = class _n extends Lt {
+  get [i]() {
+    return { elementSchema: X };
+  }
+  get kind() {
+    return "vec4i";
+  }
+  get _Vec2() {
+    return he;
+  }
+  get _Vec3() {
+    return ve;
+  }
+  get _Vec4() {
+    return _n;
+  }
+}, _e = class In extends Lt {
+  get [i]() {
+    return { elementSchema: z };
+  }
+  get kind() {
+    return "vec4u";
+  }
+  get _Vec2() {
+    return pe;
+  }
+  get _Vec3() {
+    return be;
+  }
+  get _Vec4() {
+    return In;
+  }
+}, Ie = class $n extends Lt {
+  get [i]() {
+    return { elementSchema: Z };
+  }
+  get kind() {
+    return "vec4<bool>";
+  }
+  get _Vec2() {
+    return xe;
+  }
+  get _Vec3() {
+    return ze;
+  }
+  get _Vec4() {
+    return $n;
+  }
+};
+const $e = I(le, T), En = I(me, J), Sn = I(he, X), Ut = I(pe, z), kn = I(xe, Z), Rt = I(de, T), Vn = I(ge, J), On = I(ve, X), Nn = I(be, z), Pn = I(ze, Z), Ee = I(we, T), Cn = I(Me, J), An = I(Te, X), Fn = I(_e, z), Un = I(Ie, Z), Xt = {
+  vec2f: $e,
+  vec2h: En,
+  vec2i: Sn,
+  vec2u: Ut,
+  "vec2<bool>": kn,
+  vec3f: Rt,
+  vec3h: Vn,
+  vec3i: On,
+  vec3u: Nn,
+  "vec3<bool>": Pn,
+  vec4f: Ee,
+  vec4h: Cn,
+  vec4i: An,
+  vec4u: Fn,
+  "vec4<bool>": Un
+};
+function I(t, e) {
+  const { kind: n, length: r } = new t(), s = r, a = ft({
+    name: n,
+    signature: (...b) => ({
+      argTypes: b.map((y) => C(y) ? y : e),
+      returnType: o
+    }),
+    normalImpl: (...b) => {
+      const y = Array.from({ length: b.length });
+      let tt = 0;
+      for (const kt of b) if (typeof kt == "number" || typeof kt == "boolean") y[tt++] = kt;
+      else for (let te = 0; te < kt.length; ++te) y[tt++] = kt[te];
+      if (y.length <= 1 || y.length === s) return new t(...y);
+      throw new Error(`'${n}' constructor called with invalid number of arguments.`);
+    },
+    codegenImpl: (b, y) => y.length === 1 && y[0]?.dataType === o ? f`${y[0]}` : f`${n}(${y})`
+  }), o = Object.assign(a, {
+    [i]: {},
+    type: n,
+    primitive: e,
+    componentCount: s,
+    [qn]: void 0
+  });
+  return t.prototype.schema = o, o;
+}
+const Se = /* @__PURE__ */ new Set([
+  "alias",
+  "break",
+  "case",
+  "const",
+  "const_assert",
+  "continue",
+  "continuing",
+  "default",
+  "diagnostic",
+  "discard",
+  "else",
+  "enable",
+  "false",
+  "fn",
+  "for",
+  "if",
+  "let",
+  "loop",
+  "override",
+  "requires",
+  "return",
+  "struct",
+  "switch",
+  "true",
+  "var",
+  "while",
+  "NULL",
+  "Self",
+  "abstract",
+  "active",
+  "alignas",
+  "alignof",
+  "as",
+  "asm",
+  "asm_fragment",
+  "async",
+  "attribute",
+  "auto",
+  "await",
+  "become",
+  "cast",
+  "catch",
+  "class",
+  "co_await",
+  "co_return",
+  "co_yield",
+  "coherent",
+  "column_major",
+  "common",
+  "compile",
+  "compile_fragment",
+  "concept",
+  "const_cast",
+  "consteval",
+  "constexpr",
+  "constinit",
+  "crate",
+  "debugger",
+  "decltype",
+  "delete",
+  "demote",
+  "demote_to_helper",
+  "do",
+  "dynamic_cast",
+  "enum",
+  "explicit",
+  "export",
+  "extends",
+  "extern",
+  "external",
+  "fallthrough",
+  "filter",
+  "final",
+  "finally",
+  "friend",
+  "from",
+  "fxgroup",
+  "get",
+  "goto",
+  "groupshared",
+  "highp",
+  "impl",
+  "implements",
+  "import",
+  "inline",
+  "instanceof",
+  "interface",
+  "layout",
+  "lowp",
+  "macro",
+  "macro_rules",
+  "match",
+  "mediump",
+  "meta",
+  "mod",
+  "module",
+  "move",
+  "mut",
+  "mutable",
+  "namespace",
+  "new",
+  "nil",
+  "noexcept",
+  "noinline",
+  "nointerpolation",
+  "non_coherent",
+  "noncoherent",
+  "noperspective",
+  "null",
+  "nullptr",
+  "of",
+  "operator",
+  "package",
+  "packoffset",
+  "partition",
+  "pass",
+  "patch",
+  "pixelfragment",
+  "precise",
+  "precision",
+  "premerge",
+  "priv",
+  "protected",
+  "pub",
+  "public",
+  "readonly",
+  "ref",
+  "regardless",
+  "register",
+  "reinterpret_cast",
+  "require",
+  "resource",
+  "restrict",
+  "self",
+  "set",
+  "shared",
+  "sizeof",
+  "smooth",
+  "snorm",
+  "static",
+  "static_assert",
+  "static_cast",
+  "std",
+  "subroutine",
+  "super",
+  "target",
+  "template",
+  "this",
+  "thread_local",
+  "throw",
+  "trait",
+  "try",
+  "type",
+  "typedef",
+  "typeid",
+  "typename",
+  "typeof",
+  "union",
+  "unless",
+  "unorm",
+  "unsafe",
+  "unsized",
+  "use",
+  "using",
+  "varying",
+  "virtual",
+  "volatile",
+  "wgsl",
+  "where",
+  "with",
+  "writeonly",
+  "yield",
+  "sampler",
+  "uniform",
+  "storage"
+]), jn = /* @__PURE__ */ new Set([
+  "array",
+  "bool",
+  "f16",
+  "f32",
+  "i32",
+  "u32",
+  "mat2x2",
+  "mat2x3",
+  "mat2x4",
+  "mat3x2",
+  "mat3x3",
+  "mat3x4",
+  "mat4x2",
+  "mat4x3",
+  "mat4x4",
+  "vec2",
+  "vec3",
+  "vec4",
+  "bitcast",
+  "all",
+  "any",
+  "select",
+  "arrayLength",
+  "abs",
+  "acos",
+  "acosh",
+  "asin",
+  "asinh",
+  "atan",
+  "atanh",
+  "atan2",
+  "ceil",
+  "clamp",
+  "cos",
+  "cosh",
+  "countLeadingZeros",
+  "countOneBits",
+  "countTrailingZeros",
+  "cross",
+  "degrees",
+  "determinant",
+  "distance",
+  "dot",
+  "dot4U8Packed",
+  "dot4I8Packed",
+  "exp",
+  "exp2",
+  "extractBits",
+  "faceForward",
+  "firstLeadingBit",
+  "firstTrailingBit",
+  "floor",
+  "fma",
+  "fract",
+  "frexp",
+  "insertBits",
+  "inverseSqrt",
+  "ldexp",
+  "length",
+  "log",
+  "log2",
+  "max",
+  "min",
+  "mix",
+  "modf",
+  "normalize",
+  "pow",
+  "quantizeToF16",
+  "radians",
+  "reflect",
+  "refract",
+  "reverseBits",
+  "round",
+  "saturate",
+  "sign",
+  "sin",
+  "sinh",
+  "smoothstep",
+  "sqrt",
+  "step",
+  "tan",
+  "tanh",
+  "transpose",
+  "trunc",
+  "dpdx",
+  "dpdxCoarse",
+  "dpdxFine",
+  "dpdy",
+  "dpdyCoarse",
+  "dpdyFine",
+  "fwidth",
+  "fwidthCoarse",
+  "fwidthFine",
+  "textureDimensions",
+  "textureGather",
+  "textureGatherCompare",
+  "textureLoad",
+  "textureNumLayers",
+  "textureNumLevels",
+  "textureNumSamples",
+  "textureSample",
+  "textureSampleBias",
+  "textureSampleCompare",
+  "textureSampleCompareLevel",
+  "textureSampleGrad",
+  "textureSampleLevel",
+  "textureSampleBaseClampToEdge",
+  "textureStore",
+  "atomicLoad",
+  "atomicStore",
+  "atomicAdd",
+  "atomicSub",
+  "atomicMax",
+  "atomicMin",
+  "atomicAnd",
+  "atomicOr",
+  "atomicXor",
+  "atomicExchange",
+  "atomicCompareExchangeWeak",
+  "pack4x8snorm",
+  "pack4x8unorm",
+  "pack4xI8",
+  "pack4xU8",
+  "pack4xI8Clamp",
+  "pack4xU8Clamp",
+  "pack2x16snorm",
+  "pack2x16unorm",
+  "pack2x16float",
+  "unpack4x8snorm",
+  "unpack4x8unorm",
+  "unpack4xI8",
+  "unpack4xU8",
+  "unpack2x16snorm",
+  "unpack2x16unorm",
+  "unpack2x16float",
+  "storageBarrier",
+  "textureBarrier",
+  "workgroupBarrier",
+  "workgroupUniformLoad",
+  "subgroupAdd",
+  "subgroupExclusiveAdd",
+  "subgroupInclusiveAdd",
+  "subgroupAll",
+  "subgroupAnd",
+  "subgroupAny",
+  "subgroupBallot",
+  "subgroupBroadcast",
+  "subgroupBroadcastFirst",
+  "subgroupElect",
+  "subgroupMax",
+  "subgroupMin",
+  "subgroupMul",
+  "subgroupExclusiveMul",
+  "subgroupInclusiveMul",
+  "subgroupOr",
+  "subgroupShuffle",
+  "subgroupShuffleDown",
+  "subgroupShuffleUp",
+  "subgroupShuffleXor",
+  "subgroupXor",
+  "quadBroadcast",
+  "quadSwapDiagonal",
+  "quadSwapX",
+  "quadSwapY"
+]);
+function Zr(t) {
+  return t ? t.replaceAll(/\s/g, "_").replaceAll(/[^\w\d]/g, "") : "item";
+}
+function Xr(t) {
+  if (t === "_" || t.startsWith("__") || /\s/.test(t)) throw new Error(`Invalid identifier '${t}'. Choose an identifier without whitespaces or leading underscores.`);
+  const e = t.split("_")[0];
+  return !Se.has(e) && !jn.has(e);
+}
+function Jr(t) {
+  if (t === "_" || t.startsWith("__") || /\s/.test(t)) throw new Error(`Invalid identifier '${t}'. Choose an identifier without whitespaces or leading underscores.`);
+  const e = t.split("_")[0];
+  return !Se.has(e);
+}
+var Bn = class {
+  #t;
+  #e;
+  constructor() {
+    this.#t = /* @__PURE__ */ new Set([...Se, ...jn]), this.#e = [];
+  }
+  get #n() {
+    return this.#e[this.#e.length - 1]?.usedBlockScopeNames;
+  }
+  makeUnique(t, e) {
+    const n = Zr(t), r = this.getUniqueVariant(n);
+    return e ? this.#t.add(r) : this.#n?.add(r), r;
+  }
+  #r(t) {
+    const e = this.#e.findLastIndex((n) => n.type === "functionScope");
+    return this.#e.slice(e + 1).some((n) => n.usedBlockScopeNames.has(t));
+  }
+  makeValid(t) {
+    return Xr(t) && !this.#t.has(t) && !this.#r(t) ? (this.#n?.add(t), t) : this.makeUnique(t, !1);
+  }
+  isUsed(t) {
+    return this.#t.has(t) || this.#r(t);
+  }
+  pushFunctionScope() {
+    this.#e.push({ type: "functionScope" }), this.#e.push({
+      type: "blockScope",
+      usedBlockScopeNames: /* @__PURE__ */ new Set()
+    });
+  }
+  popFunctionScope() {
+    const t = this.#e.findLastIndex((e) => e.type === "functionScope");
+    if (t === -1) throw new Error("Tried to pop function scope when no scope was present.");
+    this.#e.splice(t);
+  }
+  pushBlockScope() {
+    this.#e.push({
+      type: "blockScope",
+      usedBlockScopeNames: /* @__PURE__ */ new Set()
+    });
+  }
+  popBlockScope() {
+    ae(this.#e[this.#e.length - 1]?.type === "blockScope", "Tried to pop block scope, but it is not present"), this.#e.pop();
+  }
+}, Ac = class extends Bn {
+  #t = 0;
+  getUniqueVariant(t) {
+    let e = `${t}_${this.#t++}`;
+    for (; this.isUsed(e); ) e = `${t}_${this.#t++}`;
+    return e;
+  }
+}, Fc = class extends Bn {
+  getUniqueVariant(t) {
+    let e = 0, n = t;
+    for (; this.isUsed(n); )
+      e++, n = `${t}_${e}`;
+    return n;
+  }
+};
+function ke(t) {
+  return Ln(t, !1);
+}
+function Uc(t) {
+  return Ln(t, !0);
+}
+function Ln(t, e) {
+  Object.keys(t).forEach((r) => {
+    if (!Jr(r)) throw new Error(`Property key '${r}' is a reserved WGSL word. Choose a different name.`);
+  });
+  const n = (r) => Object.fromEntries(Object.entries(t).map(([s, c]) => [s, Or(c, r?.[s])]));
+  return Object.setPrototypeOf(n, Qr), n.propTypes = t, Object.defineProperty(n, i, { value: { isAbstruct: e } }), n;
+}
+const Qr = {
+  type: "struct",
+  $name(t) {
+    return yt(this, t), this;
+  },
+  toString() {
+    return `struct:${ut(this) ?? "<unnamed>"}`;
+  }
+};
+function ts(t) {
+  return t >= 2 ** 63 || t < -9223372036854776e3 ? l(t, se, "constant") : Number.isInteger(t) ? (Number.isSafeInteger(t) || console.warn(`The integer ${t} exceeds the safe integer range and may have lost precision.`), l(t, jr, "constant")) : l(t, se, "constant");
+}
+function Ve(t) {
+  return t.type === "abstractFloat" ? T : t.type === "abstractInt" ? X : t;
+}
+function es(t) {
+  return l(t.value, Ve(t.dataType), t.origin);
+}
+function jc(t) {
+  return t.map(es);
+}
+function ns(t) {
+  if (oe(t)) return t;
+  if (Sr(t)) throw new Error("Cannot use refs (d.ref(...)) from the outer scope.");
+  const e = an(t);
+  return e || (w(t) || L(t) ? l(t, fr(t), "constant") : typeof t == "string" || typeof t == "function" || typeof t == "object" || typeof t == "symbol" || typeof t > "u" || t === null ? l(t, it, "constant") : typeof t == "number" ? ts(t) : typeof t == "boolean" ? l(t, Z, "constant") : l(t, it, "constant"));
+}
+var Bc = class {
+  [i] = !0;
+  constructor(t, e) {
+    this.type = t, this.elements = e;
+  }
+  toString() {
+    return "ArrayExpression";
+  }
+  [A](t) {
+    for (const e of this.elements) if (e.origin === "argument" && !Ze(e.dataType) || !xr(e)) {
+      const n = t.resolve(e.value, e.dataType).value, r = t.resolve(Ve(e.dataType)).value;
+      throw new Qt(`'${n}' reference cannot be used in an array constructor.
+-----
+Try '${r}(${n})' or 'arrayOf(${r}, count)([...])' to copy the value instead.
+-----`);
+    }
+    return l(f`${`array<${t.resolve(this.type.elementType).value}, ${this.elements.length}>`}(${this.elements})`, this.type, "runtime");
+  }
+}, Be = class extends Error {
+  constructor(t) {
+    super(t), this.name = this.constructor.name;
+  }
+};
+function U(t) {
+  const e = ((...n) => {
+    if (typeof t.normalImpl == "string") throw new Be(t.normalImpl);
+    return t.normalImpl(...n);
+  });
+  return yt(e, t.name), e.toString = () => t.name ?? "<unknown>", e[ot] = {
+    get strictSignature() {
+      return typeof t.signature != "function" ? t.signature : void 0;
+    },
+    call(n, r) {
+      const { argTypes: s, returnType: c } = typeof t.signature == "function" ? t.signature(...r.map((o) => at(o.dataType) && o.dataType.implicit ? o.dataType.inner : o.dataType)) : t.signature, a = r.map((o, b) => {
+        const y = s[b];
+        if (!y) throw new Error("Function called with invalid arguments");
+        return fn(n, o, y, !t.ignoreImplicitCastWarning);
+      });
+      if (!t.noComptime && a.every((o) => Kt(o)) && typeof t.normalImpl == "function") {
+        n.pushMode(new ie());
+        try {
+          return l(t.normalImpl(...a.map((o) => o.value)), c, "constant");
+        } catch (o) {
+          if (!(o instanceof Be)) throw o;
+        } finally {
+          n.popMode("normal");
+        }
+      }
+      return l(t.codegenImpl(n, a), Ve(c), "runtime");
+    }
+  }, e;
+}
+function Oe(t) {
+  const e = ((...n) => t(...n));
+  return e.toString = () => "comptime", e[Jt] = t, e[ot] = { call(n, r) {
+    if (!r.every((s) => Kt(s))) throw new Qt(`Called comptime function with runtime-known values: ${r.filter((s) => !Kt(s)).map((s) => `'${s.value}'`).join(", ")}`);
+    return ns(t(...r.map((s) => s.value)));
+  } }, e.$name = (n) => (yt(t, n), e), Object.defineProperty(e, i, { value: { isComptime: !0 } }), e;
+}
+var Ne = class {
+};
+function Pe(t) {
+  const e = ft({
+    name: t.type,
+    normalImpl: (...r) => {
+      const s = [];
+      for (const c of r) if (typeof c == "number") s.push(c);
+      else for (let a = 0; a < c.length; ++a) s.push(c[a]);
+      if (s.length !== 0 && s.length !== t.columns * t.rows) throw new Error(`'${t.type}' constructor called with invalid number of arguments.`);
+      for (let c = s.length; c < t.columns * t.rows; ++c) s.push(0);
+      return new t.MatImpl(...s);
+    },
+    signature: (...r) => ({
+      argTypes: r.map((s) => C(s) ? s : T),
+      returnType: n
+    }),
+    codegenImpl: (r, s) => f`${t.type}(${s})`
+  }), n = Object.assign(e, {
+    [i]: {},
+    type: t.type,
+    primitive: T,
+    identity: ls[t.columns],
+    translation: t.columns === 4 ? ms : void 0,
+    scaling: t.columns === 4 ? hs : void 0,
+    rotationX: t.columns === 4 ? ps : void 0,
+    rotationY: t.columns === 4 ? xs : void 0,
+    rotationZ: t.columns === 4 ? ds : void 0
+  });
+  return t.MatImpl.prototype.schema = n, n;
+}
+var rs = class extends Ne {
+  [i] = !0;
+  columns;
+  length = 4;
+  constructor(...t) {
+    super(), this.columns = [this.makeColumn(t[0], t[1]), this.makeColumn(t[2], t[3])];
+  }
+  get 0() {
+    return this.columns[0].x;
+  }
+  get 1() {
+    return this.columns[0].y;
+  }
+  get 2() {
+    return this.columns[1].x;
+  }
+  get 3() {
+    return this.columns[1].y;
+  }
+  set 0(t) {
+    this.columns[0].x = t;
+  }
+  set 1(t) {
+    this.columns[0].y = t;
+  }
+  set 2(t) {
+    this.columns[1].x = t;
+  }
+  set 3(t) {
+    this.columns[1].y = t;
+  }
+  *[Symbol.iterator]() {
+    yield this[0], yield this[1], yield this[2], yield this[3];
+  }
+  [A]() {
+    return l(`${this.kind}(${Array.from({ length: this.length }).map((t, e) => this[e]).join(", ")})`, Wt, "runtime");
+  }
+  toString() {
+    return this[A]().value;
+  }
+}, ss = class extends rs {
+  kind = "mat2x2f";
+  makeColumn(t, e) {
+    return $e(t, e);
+  }
+}, cs = class extends Ne {
+  [i] = !0;
+  columns;
+  length = 12;
+  constructor(...t) {
+    super(), this.columns = [
+      this.makeColumn(t[0], t[1], t[2]),
+      this.makeColumn(t[3], t[4], t[5]),
+      this.makeColumn(t[6], t[7], t[8])
+    ];
+  }
+  get 0() {
+    return this.columns[0].x;
+  }
+  get 1() {
+    return this.columns[0].y;
+  }
+  get 2() {
+    return this.columns[0].z;
+  }
+  get 3() {
+    return 0;
+  }
+  get 4() {
+    return this.columns[1].x;
+  }
+  get 5() {
+    return this.columns[1].y;
+  }
+  get 6() {
+    return this.columns[1].z;
+  }
+  get 7() {
+    return 0;
+  }
+  get 8() {
+    return this.columns[2].x;
+  }
+  get 9() {
+    return this.columns[2].y;
+  }
+  get 10() {
+    return this.columns[2].z;
+  }
+  get 11() {
+    return 0;
+  }
+  set 0(t) {
+    this.columns[0].x = t;
+  }
+  set 1(t) {
+    this.columns[0].y = t;
+  }
+  set 2(t) {
+    this.columns[0].z = t;
+  }
+  set 3(t) {
+  }
+  set 4(t) {
+    this.columns[1].x = t;
+  }
+  set 5(t) {
+    this.columns[1].y = t;
+  }
+  set 6(t) {
+    this.columns[1].z = t;
+  }
+  set 7(t) {
+  }
+  set 8(t) {
+    this.columns[2].x = t;
+  }
+  set 9(t) {
+    this.columns[2].y = t;
+  }
+  set 10(t) {
+    this.columns[2].z = t;
+  }
+  set 11(t) {
+  }
+  *[Symbol.iterator]() {
+    for (let t = 0; t < 12; t++) yield this[t];
+  }
+  [A]() {
+    return l(`${this.kind}(${this[0]}, ${this[1]}, ${this[2]}, ${this[4]}, ${this[5]}, ${this[6]}, ${this[8]}, ${this[9]}, ${this[10]})`, Gt, "runtime");
+  }
+  toString() {
+    return this[A]().value;
+  }
+}, os = class extends cs {
+  kind = "mat3x3f";
+  makeColumn(t, e, n) {
+    return Rt(t, e, n);
+  }
+}, as = class extends Ne {
+  [i] = !0;
+  columns;
+  constructor(...t) {
+    super(), this.columns = [
+      this.makeColumn(t[0], t[1], t[2], t[3]),
+      this.makeColumn(t[4], t[5], t[6], t[7]),
+      this.makeColumn(t[8], t[9], t[10], t[11]),
+      this.makeColumn(t[12], t[13], t[14], t[15])
+    ];
+  }
+  length = 16;
+  get 0() {
+    return this.columns[0].x;
+  }
+  get 1() {
+    return this.columns[0].y;
+  }
+  get 2() {
+    return this.columns[0].z;
+  }
+  get 3() {
+    return this.columns[0].w;
+  }
+  get 4() {
+    return this.columns[1].x;
+  }
+  get 5() {
+    return this.columns[1].y;
+  }
+  get 6() {
+    return this.columns[1].z;
+  }
+  get 7() {
+    return this.columns[1].w;
+  }
+  get 8() {
+    return this.columns[2].x;
+  }
+  get 9() {
+    return this.columns[2].y;
+  }
+  get 10() {
+    return this.columns[2].z;
+  }
+  get 11() {
+    return this.columns[2].w;
+  }
+  get 12() {
+    return this.columns[3].x;
+  }
+  get 13() {
+    return this.columns[3].y;
+  }
+  get 14() {
+    return this.columns[3].z;
+  }
+  get 15() {
+    return this.columns[3].w;
+  }
+  set 0(t) {
+    this.columns[0].x = t;
+  }
+  set 1(t) {
+    this.columns[0].y = t;
+  }
+  set 2(t) {
+    this.columns[0].z = t;
+  }
+  set 3(t) {
+    this.columns[0].w = t;
+  }
+  set 4(t) {
+    this.columns[1].x = t;
+  }
+  set 5(t) {
+    this.columns[1].y = t;
+  }
+  set 6(t) {
+    this.columns[1].z = t;
+  }
+  set 7(t) {
+    this.columns[1].w = t;
+  }
+  set 8(t) {
+    this.columns[2].x = t;
+  }
+  set 9(t) {
+    this.columns[2].y = t;
+  }
+  set 10(t) {
+    this.columns[2].z = t;
+  }
+  set 11(t) {
+    this.columns[2].w = t;
+  }
+  set 12(t) {
+    this.columns[3].x = t;
+  }
+  set 13(t) {
+    this.columns[3].y = t;
+  }
+  set 14(t) {
+    this.columns[3].z = t;
+  }
+  set 15(t) {
+    this.columns[3].w = t;
+  }
+  *[Symbol.iterator]() {
+    for (let t = 0; t < 16; t++) yield this[t];
+  }
+  [A]() {
+    return l(`${this.kind}(${Array.from({ length: this.length }).map((t, e) => this[e]).join(", ")})`, _, "runtime");
+  }
+  toString() {
+    return this[A]().value;
+  }
+}, is = class extends as {
+  kind = "mat4x4f";
+  makeColumn(t, e, n, r) {
+    return Ee(t, e, n, r);
+  }
+};
+const us = Oe(() => Wt(1, 0, 0, 1)).$name("identity2"), ys = Oe(() => Gt(1, 0, 0, 0, 1, 0, 0, 0, 1)).$name("identity3"), fs = Oe(() => _(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)).$name("identity4"), ls = {
+  2: us,
+  3: ys,
+  4: fs
+}, ms = U({
+  name: "translation4",
+  normalImpl: (t) => _(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, t.x, t.y, t.z, 1),
+  get signature() {
+    return {
+      argTypes: [Rt],
+      returnType: _
+    };
+  },
+  codegenImpl: (t, [e]) => f`mat4x4f(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, ${e}.x, ${e}.y, ${e}.z, 1)`
+}), hs = U({
+  name: "scaling4",
+  normalImpl: (t) => _(t.x, 0, 0, 0, 0, t.y, 0, 0, 0, 0, t.z, 0, 0, 0, 0, 1),
+  get signature() {
+    return {
+      argTypes: [Rt],
+      returnType: _
+    };
+  },
+  codegenImpl: (t, [e]) => f`mat4x4f(${e}.x, 0, 0, 0, 0, ${e}.y, 0, 0, 0, 0, ${e}.z, 0, 0, 0, 0, 1)`
+}), ps = U({
+  name: "rotationX4",
+  normalImpl: (t) => _(1, 0, 0, 0, 0, Math.cos(t), Math.sin(t), 0, 0, -Math.sin(t), Math.cos(t), 0, 0, 0, 0, 1),
+  get signature() {
+    return {
+      argTypes: [T],
+      returnType: _
+    };
+  },
+  codegenImpl: (t, [e]) => f`mat4x4f(1, 0, 0, 0, 0, cos(${e}), sin(${e}), 0, 0, -sin(${e}), cos(${e}), 0, 0, 0, 0, 1)`
+}), xs = U({
+  name: "rotationY4",
+  normalImpl: (t) => _(Math.cos(t), 0, -Math.sin(t), 0, 0, 1, 0, 0, Math.sin(t), 0, Math.cos(t), 0, 0, 0, 0, 1),
+  get signature() {
+    return {
+      argTypes: [T],
+      returnType: _
+    };
+  },
+  codegenImpl: (t, [e]) => f`mat4x4f(cos(${e}), 0, -sin(${e}), 0, 0, 1, 0, 0, sin(${e}), 0, cos(${e}), 0, 0, 0, 0, 1)`
+}), ds = U({
+  name: "rotationZ4",
+  normalImpl: (t) => _(Math.cos(t), Math.sin(t), 0, 0, -Math.sin(t), Math.cos(t), 0, 0, 0, 0, 1, 0, 0, 0, 0, 1),
+  get signature() {
+    return {
+      argTypes: [T],
+      returnType: _
+    };
+  },
+  codegenImpl: (t, [e]) => f`mat4x4f(cos(${e}), sin(${e}), 0, 0, -sin(${e}), cos(${e}), 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)`
+}), Wt = Pe({
+  type: "mat2x2f",
+  rows: 2,
+  columns: 2,
+  MatImpl: ss
+}), Gt = Pe({
+  type: "mat3x3f",
+  rows: 3,
+  columns: 3,
+  MatImpl: os
+}), _ = Pe({
+  type: "mat4x4f",
+  rows: 4,
+  columns: 4,
+  MatImpl: is
+});
+function Lc(t) {
+  return t.kind === "mat3x3f" ? [
+    t[0],
+    t[1],
+    t[2],
+    t[4],
+    t[5],
+    t[6],
+    t[8],
+    t[9],
+    t[10]
+  ] : Array.from({ length: t.length }).map((e, n) => t[n]);
+}
+const lt = (t, e, n) => {
+  if (t === e) return 0;
+  const r = u((n - t) / (e - t), 0, 1);
+  return r * r * (3 - 2 * r);
+}, u = (t, e, n) => Math.min(Math.max(e, t), n), mt = (t, e) => e === 0 ? t : Math.trunc(t / e);
+function G(t) {
+  const e = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4));
+  return e.setUint32(0, t, !0), e.getFloat32(0, !0);
+}
+function D(t) {
+  const e = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4));
+  return e.setUint32(0, t, !0), e.getInt32(0, !0);
+}
+const E = kn, V = $e, q = En, It = Sn, Pt = Ut, S = Pn, $ = Rt, j = Vn, $t = On, Ct = Nn, k = Un, O = Ee, H = Cn, Et = An, At = Fn, ht = (t) => Math.sqrt(t.x ** 2 + t.y ** 2), pt = (t) => Math.sqrt(t.x ** 2 + t.y ** 2 + t.z ** 2), xt = (t) => Math.sqrt(t.x ** 2 + t.y ** 2 + t.z ** 2 + t.w ** 2), Dt = (t, e) => t.x * e.x + t.y * e.y, Yt = (t, e) => t.x * e.x + t.y * e.y + t.z * e.z, qt = (t, e) => t.x * e.x + t.y * e.y + t.z * e.z + t.w * e.w, x = (t) => (e) => V(t(e.x), t(e.y)), d = (t) => (e) => q(t(e.x), t(e.y)), dt = (t) => (e) => It(t(e.x), t(e.y)), Vt = (t) => (e) => Pt(t(e.x), t(e.y)), p = (t) => (e) => $(t(e.x), t(e.y), t(e.z)), g = (t) => (e) => j(t(e.x), t(e.y), t(e.z)), gt = (t) => (e) => $t(t(e.x), t(e.y), t(e.z)), Ot = (t) => (e) => Ct(t(e.x), t(e.y), t(e.z)), h = (t) => (e) => O(t(e.x), t(e.y), t(e.z), t(e.w)), v = (t) => (e) => H(t(e.x), t(e.y), t(e.z), t(e.w)), vt = (t) => (e) => Et(t(e.x), t(e.y), t(e.z), t(e.w)), Nt = (t) => (e) => At(t(e.x), t(e.y), t(e.z), t(e.w)), Le = (t) => (e) => {
+  const n = e.columns;
+  return Wt(x(t)(n[0]), x(t)(n[1]));
+}, Re = (t) => (e) => {
+  const n = e.columns;
+  return Gt(p(t)(n[0]), p(t)(n[1]), p(t)(n[2]));
+}, We = (t) => (e) => {
+  const n = e.columns;
+  return _(h(t)(n[0]), h(t)(n[1]), h(t)(n[2]), h(t)(n[3]));
+}, Y = (t) => (e, n) => V(t(e.x, n.x), t(e.y, n.y)), nt = (t) => (e, n) => q(t(e.x, n.x), t(e.y, n.y)), bt = (t) => (e, n) => It(t(e.x, n.x), t(e.y, n.y)), zt = (t) => (e, n) => Pt(t(e.x, n.x), t(e.y, n.y)), B = (t) => (e, n) => $(t(e.x, n.x), t(e.y, n.y), t(e.z, n.z)), rt = (t) => (e, n) => j(t(e.x, n.x), t(e.y, n.y), t(e.z, n.z)), wt = (t) => (e, n) => $t(t(e.x, n.x), t(e.y, n.y), t(e.z, n.z)), Mt = (t) => (e, n) => Ct(t(e.x, n.x), t(e.y, n.y), t(e.z, n.z)), N = (t) => (e, n) => O(t(e.x, n.x), t(e.y, n.y), t(e.z, n.z), t(e.w, n.w)), st = (t) => (e, n) => H(t(e.x, n.x), t(e.y, n.y), t(e.z, n.z), t(e.w, n.w)), Tt = (t) => (e, n) => Et(t(e.x, n.x), t(e.y, n.y), t(e.z, n.z), t(e.w, n.w)), _t = (t) => (e, n) => At(t(e.x, n.x), t(e.y, n.y), t(e.z, n.z), t(e.w, n.w)), gs = (t) => (e, n) => {
+  const r = e.columns, s = n.columns;
+  return Wt(Y(t)(r[0], s[0]), Y(t)(r[1], s[1]));
+}, vs = (t) => (e, n) => {
+  const r = e.columns, s = n.columns;
+  return Gt(B(t)(r[0], s[0]), B(t)(r[1], s[1]), B(t)(r[2], s[2]));
+}, bs = (t) => (e, n) => {
+  const r = e.columns, s = n.columns;
+  return _(N(t)(r[0], s[0]), N(t)(r[1], s[1]), N(t)(r[2], s[2]), N(t)(r[3], s[3]));
+}, zs = (t) => (e, n, r) => V(t(e.x, n.x, r.x), t(e.y, n.y, r.y)), ws = (t) => (e, n, r) => q(t(e.x, n.x, r.x), t(e.y, n.y, r.y)), Ms = (t) => (e, n, r) => $(t(e.x, n.x, r.x), t(e.y, n.y, r.y), t(e.z, n.z, r.z)), Ts = (t) => (e, n, r) => j(t(e.x, n.x, r.x), t(e.y, n.y, r.y), t(e.z, n.z, r.z)), _s = (t) => (e, n, r) => O(t(e.x, n.x, r.x), t(e.y, n.y, r.y), t(e.z, n.z, r.z), t(e.w, n.w, r.w)), Is = (t) => (e, n, r) => H(t(e.x, n.x, r.x), t(e.y, n.y, r.y), t(e.z, n.z, r.z), t(e.w, n.w, r.w)), M = {
+  eq: {
+    vec2f: (t, e) => E(t.x === e.x, t.y === e.y),
+    vec2h: (t, e) => E(t.x === e.x, t.y === e.y),
+    vec2i: (t, e) => E(t.x === e.x, t.y === e.y),
+    vec2u: (t, e) => E(t.x === e.x, t.y === e.y),
+    "vec2<bool>": (t, e) => E(t.x === e.x, t.y === e.y),
+    vec3f: (t, e) => S(t.x === e.x, t.y === e.y, t.z === e.z),
+    vec3h: (t, e) => S(t.x === e.x, t.y === e.y, t.z === e.z),
+    vec3i: (t, e) => S(t.x === e.x, t.y === e.y, t.z === e.z),
+    vec3u: (t, e) => S(t.x === e.x, t.y === e.y, t.z === e.z),
+    "vec3<bool>": (t, e) => S(t.x === e.x, t.y === e.y, t.z === e.z),
+    vec4f: (t, e) => k(t.x === e.x, t.y === e.y, t.z === e.z, t.w === e.w),
+    vec4h: (t, e) => k(t.x === e.x, t.y === e.y, t.z === e.z, t.w === e.w),
+    vec4i: (t, e) => k(t.x === e.x, t.y === e.y, t.z === e.z, t.w === e.w),
+    vec4u: (t, e) => k(t.x === e.x, t.y === e.y, t.z === e.z, t.w === e.w),
+    "vec4<bool>": (t, e) => k(t.x === e.x, t.y === e.y, t.z === e.z, t.w === e.w)
+  },
+  lt: {
+    vec2f: (t, e) => E(t.x < e.x, t.y < e.y),
+    vec2h: (t, e) => E(t.x < e.x, t.y < e.y),
+    vec2i: (t, e) => E(t.x < e.x, t.y < e.y),
+    vec2u: (t, e) => E(t.x < e.x, t.y < e.y),
+    vec3f: (t, e) => S(t.x < e.x, t.y < e.y, t.z < e.z),
+    vec3h: (t, e) => S(t.x < e.x, t.y < e.y, t.z < e.z),
+    vec3i: (t, e) => S(t.x < e.x, t.y < e.y, t.z < e.z),
+    vec3u: (t, e) => S(t.x < e.x, t.y < e.y, t.z < e.z),
+    vec4f: (t, e) => k(t.x < e.x, t.y < e.y, t.z < e.z, t.w < e.w),
+    vec4h: (t, e) => k(t.x < e.x, t.y < e.y, t.z < e.z, t.w < e.w),
+    vec4i: (t, e) => k(t.x < e.x, t.y < e.y, t.z < e.z, t.w < e.w),
+    vec4u: (t, e) => k(t.x < e.x, t.y < e.y, t.z < e.z, t.w < e.w)
+  },
+  or: {
+    "vec2<bool>": (t, e) => E(t.x || e.x, t.y || e.y),
+    "vec3<bool>": (t, e) => S(t.x || e.x, t.y || e.y, t.z || e.z),
+    "vec4<bool>": (t, e) => k(t.x || e.x, t.y || e.y, t.z || e.z, t.w || e.w)
+  },
+  all: {
+    "vec2<bool>": (t) => t.x && t.y,
+    "vec3<bool>": (t) => t.x && t.y && t.z,
+    "vec4<bool>": (t) => t.x && t.y && t.z && t.w
+  },
+  abs: {
+    vec2f: x(Math.abs),
+    vec2h: d(Math.abs),
+    vec2i: dt(Math.abs),
+    vec2u: Vt(Math.abs),
+    vec3f: p(Math.abs),
+    vec3h: g(Math.abs),
+    vec3i: gt(Math.abs),
+    vec3u: Ot(Math.abs),
+    vec4f: h(Math.abs),
+    vec4h: v(Math.abs),
+    vec4i: vt(Math.abs),
+    vec4u: Nt(Math.abs)
+  },
+  atan2: {
+    vec2f: Y(Math.atan2),
+    vec2h: nt(Math.atan2),
+    vec3f: B(Math.atan2),
+    vec3h: rt(Math.atan2),
+    vec4f: N(Math.atan2),
+    vec4h: st(Math.atan2)
+  },
+  acos: {
+    vec2f: x(Math.acos),
+    vec2h: d(Math.acos),
+    vec2i: dt(Math.acos),
+    vec2u: Vt(Math.acos),
+    vec3f: p(Math.acos),
+    vec3h: g(Math.acos),
+    vec3i: gt(Math.acos),
+    vec3u: Ot(Math.acos),
+    vec4f: h(Math.acos),
+    vec4h: v(Math.acos),
+    vec4i: vt(Math.acos),
+    vec4u: Nt(Math.acos)
+  },
+  acosh: {
+    vec2f: x(Math.acosh),
+    vec2h: d(Math.acosh),
+    vec3f: p(Math.acosh),
+    vec3h: g(Math.acosh),
+    vec4f: h(Math.acosh),
+    vec4h: v(Math.acosh)
+  },
+  asin: {
+    vec2f: x(Math.asin),
+    vec2h: d(Math.asin),
+    vec3f: p(Math.asin),
+    vec3h: g(Math.asin),
+    vec4f: h(Math.asin),
+    vec4h: v(Math.asin)
+  },
+  asinh: {
+    vec2f: x(Math.asinh),
+    vec2h: d(Math.asinh),
+    vec3f: p(Math.asinh),
+    vec3h: g(Math.asinh),
+    vec4f: h(Math.asinh),
+    vec4h: v(Math.asinh)
+  },
+  atan: {
+    vec2f: x(Math.atan),
+    vec2h: d(Math.atan),
+    vec3f: p(Math.atan),
+    vec3h: g(Math.atan),
+    vec4f: h(Math.atan),
+    vec4h: v(Math.atan)
+  },
+  atanh: {
+    vec2f: x(Math.atanh),
+    vec2h: d(Math.atanh),
+    vec3f: p(Math.atanh),
+    vec3h: g(Math.atanh),
+    vec4f: h(Math.atanh),
+    vec4h: v(Math.atanh)
+  },
+  ceil: {
+    vec2f: x(Math.ceil),
+    vec2h: d(Math.ceil),
+    vec3f: p(Math.ceil),
+    vec3h: g(Math.ceil),
+    vec4f: h(Math.ceil),
+    vec4h: v(Math.ceil)
+  },
+  clamp: {
+    vec2f: (t, e, n) => V(u(t.x, e.x, n.x), u(t.y, e.y, n.y)),
+    vec2h: (t, e, n) => q(u(t.x, e.x, n.x), u(t.y, e.y, n.y)),
+    vec2i: (t, e, n) => It(u(t.x, e.x, n.x), u(t.y, e.y, n.y)),
+    vec2u: (t, e, n) => Pt(u(t.x, e.x, n.x), u(t.y, e.y, n.y)),
+    vec3f: (t, e, n) => $(u(t.x, e.x, n.x), u(t.y, e.y, n.y), u(t.z, e.z, n.z)),
+    vec3h: (t, e, n) => j(u(t.x, e.x, n.x), u(t.y, e.y, n.y), u(t.z, e.z, n.z)),
+    vec3i: (t, e, n) => $t(u(t.x, e.x, n.x), u(t.y, e.y, n.y), u(t.z, e.z, n.z)),
+    vec3u: (t, e, n) => Ct(u(t.x, e.x, n.x), u(t.y, e.y, n.y), u(t.z, e.z, n.z)),
+    vec4f: (t, e, n) => O(u(t.x, e.x, n.x), u(t.y, e.y, n.y), u(t.z, e.z, n.z), u(t.w, e.w, n.w)),
+    vec4h: (t, e, n) => H(u(t.x, e.x, n.x), u(t.y, e.y, n.y), u(t.z, e.z, n.z), u(t.w, e.w, n.w)),
+    vec4i: (t, e, n) => Et(u(t.x, e.x, n.x), u(t.y, e.y, n.y), u(t.z, e.z, n.z), u(t.w, e.w, n.w)),
+    vec4u: (t, e, n) => At(u(t.x, e.x, n.x), u(t.y, e.y, n.y), u(t.z, e.z, n.z), u(t.w, e.w, n.w))
+  },
+  length: {
+    vec2f: ht,
+    vec2h: ht,
+    vec3f: pt,
+    vec3h: pt,
+    vec4f: xt,
+    vec4h: xt
+  },
+  add: {
+    vec2f: Y((t, e) => t + e),
+    vec2h: nt((t, e) => t + e),
+    vec2i: bt((t, e) => t + e),
+    vec2u: zt((t, e) => t + e),
+    vec3f: B((t, e) => t + e),
+    vec3h: rt((t, e) => t + e),
+    vec3i: wt((t, e) => t + e),
+    vec3u: Mt((t, e) => t + e),
+    vec4f: N((t, e) => t + e),
+    vec4h: st((t, e) => t + e),
+    vec4i: Tt((t, e) => t + e),
+    vec4u: _t((t, e) => t + e),
+    mat2x2f: gs((t, e) => t + e),
+    mat3x3f: vs((t, e) => t + e),
+    mat4x4f: bs((t, e) => t + e)
+  },
+  smoothstep: {
+    vec2f: zs(lt),
+    vec2h: ws(lt),
+    vec3f: Ms(lt),
+    vec3h: Ts(lt),
+    vec4f: _s(lt),
+    vec4h: Is(lt)
+  },
+  addMixed: {
+    vec2f: (t, e) => x((n) => n + e)(t),
+    vec2h: (t, e) => d((n) => n + e)(t),
+    vec2i: (t, e) => dt((n) => n + e)(t),
+    vec2u: (t, e) => Vt((n) => n + e)(t),
+    vec3f: (t, e) => p((n) => n + e)(t),
+    vec3h: (t, e) => g((n) => n + e)(t),
+    vec3i: (t, e) => gt((n) => n + e)(t),
+    vec3u: (t, e) => Ot((n) => n + e)(t),
+    vec4f: (t, e) => h((n) => n + e)(t),
+    vec4h: (t, e) => v((n) => n + e)(t),
+    vec4i: (t, e) => vt((n) => n + e)(t),
+    vec4u: (t, e) => Nt((n) => n + e)(t),
+    mat2x2f: (t, e) => Le((n) => n + e)(t),
+    mat3x3f: (t, e) => Re((n) => n + e)(t),
+    mat4x4f: (t, e) => We((n) => n + e)(t)
+  },
+  mulSxV: {
+    vec2f: (t, e) => x((n) => t * n)(e),
+    vec2h: (t, e) => d((n) => t * n)(e),
+    vec2i: (t, e) => dt((n) => t * n)(e),
+    vec2u: (t, e) => Vt((n) => t * n)(e),
+    vec3f: (t, e) => p((n) => t * n)(e),
+    vec3h: (t, e) => g((n) => t * n)(e),
+    vec3i: (t, e) => gt((n) => t * n)(e),
+    vec3u: (t, e) => Ot((n) => t * n)(e),
+    vec4f: (t, e) => h((n) => t * n)(e),
+    vec4h: (t, e) => v((n) => t * n)(e),
+    vec4i: (t, e) => vt((n) => t * n)(e),
+    vec4u: (t, e) => Nt((n) => t * n)(e),
+    mat2x2f: (t, e) => Le((n) => t * n)(e),
+    mat3x3f: (t, e) => Re((n) => t * n)(e),
+    mat4x4f: (t, e) => We((n) => t * n)(e)
+  },
+  mulVxV: {
+    vec2f: Y((t, e) => t * e),
+    vec2h: nt((t, e) => t * e),
+    vec2i: bt((t, e) => t * e),
+    vec2u: zt((t, e) => t * e),
+    vec3f: B((t, e) => t * e),
+    vec3h: rt((t, e) => t * e),
+    vec3i: wt((t, e) => t * e),
+    vec3u: Mt((t, e) => t * e),
+    vec4f: N((t, e) => t * e),
+    vec4h: st((t, e) => t * e),
+    vec4i: Tt((t, e) => t * e),
+    vec4u: _t((t, e) => t * e),
+    mat2x2f: (t, e) => {
+      const n = t.columns, r = e.columns;
+      return Wt(n[0].x * r[0].x + n[1].x * r[0].y, n[0].y * r[0].x + n[1].y * r[0].y, n[0].x * r[1].x + n[1].x * r[1].y, n[0].y * r[1].x + n[1].y * r[1].y);
+    },
+    mat3x3f: (t, e) => {
+      const n = t.columns, r = e.columns;
+      return Gt(n[0].x * r[0].x + n[1].x * r[0].y + n[2].x * r[0].z, n[0].y * r[0].x + n[1].y * r[0].y + n[2].y * r[0].z, n[0].z * r[0].x + n[1].z * r[0].y + n[2].z * r[0].z, n[0].x * r[1].x + n[1].x * r[1].y + n[2].x * r[1].z, n[0].y * r[1].x + n[1].y * r[1].y + n[2].y * r[1].z, n[0].z * r[1].x + n[1].z * r[1].y + n[2].z * r[1].z, n[0].x * r[2].x + n[1].x * r[2].y + n[2].x * r[2].z, n[0].y * r[2].x + n[1].y * r[2].y + n[2].y * r[2].z, n[0].z * r[2].x + n[1].z * r[2].y + n[2].z * r[2].z);
+    },
+    mat4x4f: (t, e) => {
+      const n = t.columns, r = e.columns;
+      return _(n[0].x * r[0].x + n[1].x * r[0].y + n[2].x * r[0].z + n[3].x * r[0].w, n[0].y * r[0].x + n[1].y * r[0].y + n[2].y * r[0].z + n[3].y * r[0].w, n[0].z * r[0].x + n[1].z * r[0].y + n[2].z * r[0].z + n[3].z * r[0].w, n[0].w * r[0].x + n[1].w * r[0].y + n[2].w * r[0].z + n[3].w * r[0].w, n[0].x * r[1].x + n[1].x * r[1].y + n[2].x * r[1].z + n[3].x * r[1].w, n[0].y * r[1].x + n[1].y * r[1].y + n[2].y * r[1].z + n[3].y * r[1].w, n[0].z * r[1].x + n[1].z * r[1].y + n[2].z * r[1].z + n[3].z * r[1].w, n[0].w * r[1].x + n[1].w * r[1].y + n[2].w * r[1].z + n[3].w * r[1].w, n[0].x * r[2].x + n[1].x * r[2].y + n[2].x * r[2].z + n[3].x * r[2].w, n[0].y * r[2].x + n[1].y * r[2].y + n[2].y * r[2].z + n[3].y * r[2].w, n[0].z * r[2].x + n[1].z * r[2].y + n[2].z * r[2].z + n[3].z * r[2].w, n[0].w * r[2].x + n[1].w * r[2].y + n[2].w * r[2].z + n[3].w * r[2].w, n[0].x * r[3].x + n[1].x * r[3].y + n[2].x * r[3].z + n[3].x * r[3].w, n[0].y * r[3].x + n[1].y * r[3].y + n[2].y * r[3].z + n[3].y * r[3].w, n[0].z * r[3].x + n[1].z * r[3].y + n[2].z * r[3].z + n[3].z * r[3].w, n[0].w * r[3].x + n[1].w * r[3].y + n[2].w * r[3].z + n[3].w * r[3].w);
+    }
+  },
+  mulMxV: {
+    mat2x2f: (t, e) => {
+      const n = t.columns;
+      return V(n[0].x * e.x + n[1].x * e.y, n[0].y * e.x + n[1].y * e.y);
+    },
+    mat3x3f: (t, e) => {
+      const n = t.columns;
+      return $(n[0].x * e.x + n[1].x * e.y + n[2].x * e.z, n[0].y * e.x + n[1].y * e.y + n[2].y * e.z, n[0].z * e.x + n[1].z * e.y + n[2].z * e.z);
+    },
+    mat4x4f: (t, e) => {
+      const n = t.columns;
+      return O(n[0].x * e.x + n[1].x * e.y + n[2].x * e.z + n[3].x * e.w, n[0].y * e.x + n[1].y * e.y + n[2].y * e.z + n[3].y * e.w, n[0].z * e.x + n[1].z * e.y + n[2].z * e.z + n[3].z * e.w, n[0].w * e.x + n[1].w * e.y + n[2].w * e.z + n[3].w * e.w);
+    }
+  },
+  mulVxM: {
+    mat2x2f: (t, e) => {
+      const n = e.columns;
+      return V(t.x * n[0].x + t.y * n[0].y, t.x * n[1].x + t.y * n[1].y);
+    },
+    mat3x3f: (t, e) => {
+      const n = e.columns;
+      return $(t.x * n[0].x + t.y * n[0].y + t.z * n[0].z, t.x * n[1].x + t.y * n[1].y + t.z * n[1].z, t.x * n[2].x + t.y * n[2].y + t.z * n[2].z);
+    },
+    mat4x4f: (t, e) => {
+      const n = e.columns;
+      return O(t.x * n[0].x + t.y * n[0].y + t.z * n[0].z + t.w * n[0].w, t.x * n[1].x + t.y * n[1].y + t.z * n[1].z + t.w * n[1].w, t.x * n[2].x + t.y * n[2].y + t.z * n[2].z + t.w * n[2].w, t.x * n[3].x + t.y * n[3].y + t.z * n[3].z + t.w * n[3].w);
+    }
+  },
+  div: {
+    vec2f: Y((t, e) => t / e),
+    vec2h: nt((t, e) => t / e),
+    vec2i: bt(mt),
+    vec2u: zt(mt),
+    vec3f: B((t, e) => t / e),
+    vec3h: rt((t, e) => t / e),
+    vec3i: wt(mt),
+    vec3u: Mt(mt),
+    vec4f: N((t, e) => t / e),
+    vec4h: st((t, e) => t / e),
+    vec4i: Tt(mt),
+    vec4u: _t(mt)
+  },
+  dot: {
+    vec2f: Dt,
+    vec2h: Dt,
+    vec2i: Dt,
+    vec2u: Dt,
+    vec3f: Yt,
+    vec3h: Yt,
+    vec3i: Yt,
+    vec3u: Yt,
+    vec4f: qt,
+    vec4h: qt,
+    vec4i: qt,
+    vec4u: qt
+  },
+  normalize: {
+    vec2f: (t) => {
+      const e = ht(t);
+      return V(t.x / e, t.y / e);
+    },
+    vec2h: (t) => {
+      const e = ht(t);
+      return q(t.x / e, t.y / e);
+    },
+    vec2i: (t) => {
+      const e = ht(t);
+      return It(t.x / e, t.y / e);
+    },
+    vec2u: (t) => {
+      const e = ht(t);
+      return Pt(t.x / e, t.y / e);
+    },
+    vec3f: (t) => {
+      const e = pt(t);
+      return $(t.x / e, t.y / e, t.z / e);
+    },
+    vec3h: (t) => {
+      const e = pt(t);
+      return j(t.x / e, t.y / e, t.z / e);
+    },
+    vec3i: (t) => {
+      const e = pt(t);
+      return $t(t.x / e, t.y / e, t.z / e);
+    },
+    vec3u: (t) => {
+      const e = pt(t);
+      return Ct(t.x / e, t.y / e, t.z / e);
+    },
+    vec4f: (t) => {
+      const e = xt(t);
+      return O(t.x / e, t.y / e, t.z / e, t.w / e);
+    },
+    vec4h: (t) => {
+      const e = xt(t);
+      return H(t.x / e, t.y / e, t.z / e, t.w / e);
+    },
+    vec4i: (t) => {
+      const e = xt(t);
+      return Et(t.x / e, t.y / e, t.z / e, t.w / e);
+    },
+    vec4u: (t) => {
+      const e = xt(t);
+      return At(t.x / e, t.y / e, t.z / e, t.w / e);
+    }
+  },
+  cross: {
+    vec3f: (t, e) => $(t.y * e.z - t.z * e.y, t.z * e.x - t.x * e.z, t.x * e.y - t.y * e.x),
+    vec3h: (t, e) => j(t.y * e.z - t.z * e.y, t.z * e.x - t.x * e.z, t.x * e.y - t.y * e.x)
+  },
+  mod: {
+    vec2f: Y((t, e) => t % e),
+    vec2h: nt((t, e) => t % e),
+    vec2i: bt((t, e) => t % e),
+    vec2u: zt((t, e) => t % e),
+    vec3f: B((t, e) => t % e),
+    vec3h: rt((t, e) => t % e),
+    vec3i: wt((t, e) => t % e),
+    vec3u: Mt((t, e) => t % e),
+    vec4f: N((t, e) => t % e),
+    vec4h: st((t, e) => t % e),
+    vec4i: Tt((t, e) => t % e),
+    vec4u: _t((t, e) => t % e)
+  },
+  floor: {
+    vec2f: x(Math.floor),
+    vec2h: d(Math.floor),
+    vec3f: p(Math.floor),
+    vec3h: g(Math.floor),
+    vec4f: h(Math.floor),
+    vec4h: v(Math.floor)
+  },
+  max: {
+    vec2f: Y(Math.max),
+    vec2h: nt(Math.max),
+    vec2i: bt(Math.max),
+    vec2u: zt(Math.max),
+    vec3f: B(Math.max),
+    vec3h: rt(Math.max),
+    vec3i: wt(Math.max),
+    vec3u: Mt(Math.max),
+    vec4f: N(Math.max),
+    vec4h: st(Math.max),
+    vec4i: Tt(Math.max),
+    vec4u: _t(Math.max)
+  },
+  min: {
+    vec2f: Y(Math.min),
+    vec2h: nt(Math.min),
+    vec2i: bt(Math.min),
+    vec2u: zt(Math.min),
+    vec3f: B(Math.min),
+    vec3h: rt(Math.min),
+    vec3i: wt(Math.min),
+    vec3u: Mt(Math.min),
+    vec4f: N(Math.min),
+    vec4h: st(Math.min),
+    vec4i: Tt(Math.min),
+    vec4u: _t(Math.min)
+  },
+  pow: {
+    vec2f: (t, e) => V(t.x ** e.x, t.y ** e.y),
+    vec2h: (t, e) => q(t.x ** e.x, t.y ** e.y),
+    vec3f: (t, e) => $(t.x ** e.x, t.y ** e.y, t.z ** e.z),
+    vec3h: (t, e) => j(t.x ** e.x, t.y ** e.y, t.z ** e.z),
+    vec4f: (t, e) => O(t.x ** e.x, t.y ** e.y, t.z ** e.z, t.w ** e.w),
+    vec4h: (t, e) => H(t.x ** e.x, t.y ** e.y, t.z ** e.z, t.w ** e.w)
+  },
+  sign: {
+    vec2f: x(Math.sign),
+    vec2h: d(Math.sign),
+    vec2i: dt(Math.sign),
+    vec3f: p(Math.sign),
+    vec3h: g(Math.sign),
+    vec3i: gt(Math.sign),
+    vec4f: h(Math.sign),
+    vec4h: v(Math.sign),
+    vec4i: vt(Math.sign)
+  },
+  sqrt: {
+    vec2f: x(Math.sqrt),
+    vec2h: d(Math.sqrt),
+    vec3f: p(Math.sqrt),
+    vec3h: g(Math.sqrt),
+    vec4f: h(Math.sqrt),
+    vec4h: v(Math.sqrt)
+  },
+  mix: {
+    vec2f: (t, e, n) => typeof n == "number" ? V(t.x * (1 - n) + e.x * n, t.y * (1 - n) + e.y * n) : V(t.x * (1 - n.x) + e.x * n.x, t.y * (1 - n.y) + e.y * n.y),
+    vec2h: (t, e, n) => typeof n == "number" ? q(t.x * (1 - n) + e.x * n, t.y * (1 - n) + e.y * n) : q(t.x * (1 - n.x) + e.x * n.x, t.y * (1 - n.y) + e.y * n.y),
+    vec3f: (t, e, n) => typeof n == "number" ? $(t.x * (1 - n) + e.x * n, t.y * (1 - n) + e.y * n, t.z * (1 - n) + e.z * n) : $(t.x * (1 - n.x) + e.x * n.x, t.y * (1 - n.y) + e.y * n.y, t.z * (1 - n.z) + e.z * n.z),
+    vec3h: (t, e, n) => typeof n == "number" ? j(t.x * (1 - n) + e.x * n, t.y * (1 - n) + e.y * n, t.z * (1 - n) + e.z * n) : j(t.x * (1 - n.x) + e.x * n.x, t.y * (1 - n.y) + e.y * n.y, t.z * (1 - n.z) + e.z * n.z),
+    vec4f: (t, e, n) => typeof n == "number" ? O(t.x * (1 - n) + e.x * n, t.y * (1 - n) + e.y * n, t.z * (1 - n) + e.z * n, t.w * (1 - n) + e.w * n) : O(t.x * (1 - n.x) + e.x * n.x, t.y * (1 - n.y) + e.y * n.y, t.z * (1 - n.z) + e.z * n.z, t.w * (1 - n.w) + e.w * n.w),
+    vec4h: (t, e, n) => typeof n == "number" ? H(t.x * (1 - n) + e.x * n, t.y * (1 - n) + e.y * n, t.z * (1 - n) + e.z * n, t.w * (1 - n) + e.w * n) : H(t.x * (1 - n.x) + e.x * n.x, t.y * (1 - n.y) + e.y * n.y, t.z * (1 - n.z) + e.z * n.z, t.w * (1 - n.w) + e.w * n.w)
+  },
+  sin: {
+    vec2f: x(Math.sin),
+    vec2h: d(Math.sin),
+    vec3f: p(Math.sin),
+    vec3h: g(Math.sin),
+    vec4f: h(Math.sin),
+    vec4h: v(Math.sin)
+  },
+  cos: {
+    vec2f: x(Math.cos),
+    vec2h: d(Math.cos),
+    vec3f: p(Math.cos),
+    vec3h: g(Math.cos),
+    vec4f: h(Math.cos),
+    vec4h: v(Math.cos)
+  },
+  cosh: {
+    vec2f: x(Math.cosh),
+    vec2h: d(Math.cosh),
+    vec3f: p(Math.cosh),
+    vec3h: g(Math.cosh),
+    vec4f: h(Math.cosh),
+    vec4h: v(Math.cosh)
+  },
+  exp: {
+    vec2f: x(Math.exp),
+    vec2h: d(Math.exp),
+    vec3f: p(Math.exp),
+    vec3h: g(Math.exp),
+    vec4f: h(Math.exp),
+    vec4h: v(Math.exp)
+  },
+  exp2: {
+    vec2f: x((t) => 2 ** t),
+    vec2h: d((t) => 2 ** t),
+    vec3f: p((t) => 2 ** t),
+    vec3h: g((t) => 2 ** t),
+    vec4f: h((t) => 2 ** t),
+    vec4h: v((t) => 2 ** t)
+  },
+  log: {
+    vec2f: x(Math.log),
+    vec2h: d(Math.log),
+    vec3f: p(Math.log),
+    vec3h: g(Math.log),
+    vec4f: h(Math.log),
+    vec4h: v(Math.log)
+  },
+  log2: {
+    vec2f: x(Math.log2),
+    vec2h: d(Math.log2),
+    vec3f: p(Math.log2),
+    vec3h: g(Math.log2),
+    vec4f: h(Math.log2),
+    vec4h: v(Math.log2)
+  },
+  fract: {
+    vec2f: x((t) => t - Math.floor(t)),
+    vec2h: d((t) => t - Math.floor(t)),
+    vec3f: p((t) => t - Math.floor(t)),
+    vec3h: g((t) => t - Math.floor(t)),
+    vec4f: h((t) => t - Math.floor(t)),
+    vec4h: v((t) => t - Math.floor(t))
+  },
+  isCloseToZero: {
+    vec2f: (t, e) => Math.abs(t.x) <= e && Math.abs(t.y) <= e,
+    vec2h: (t, e) => Math.abs(t.x) <= e && Math.abs(t.y) <= e,
+    vec3f: (t, e) => Math.abs(t.x) <= e && Math.abs(t.y) <= e && Math.abs(t.z) <= e,
+    vec3h: (t, e) => Math.abs(t.x) <= e && Math.abs(t.y) <= e && Math.abs(t.z) <= e,
+    vec4f: (t, e) => Math.abs(t.x) <= e && Math.abs(t.y) <= e && Math.abs(t.z) <= e && Math.abs(t.w) <= e,
+    vec4h: (t, e) => Math.abs(t.x) <= e && Math.abs(t.y) <= e && Math.abs(t.z) <= e && Math.abs(t.w) <= e
+  },
+  neg: {
+    vec2f: x((t) => -t),
+    vec2h: d((t) => -t),
+    vec2i: dt((t) => -t),
+    vec2u: Vt((t) => -t),
+    "vec2<bool>": (t) => E(!t.x, !t.y),
+    vec3f: p((t) => -t),
+    vec3h: g((t) => -t),
+    vec3i: gt((t) => -t),
+    vec3u: Ot((t) => -t),
+    "vec3<bool>": (t) => S(!t.x, !t.y, !t.z),
+    vec4f: h((t) => -t),
+    vec4h: v((t) => -t),
+    vec4i: vt((t) => -t),
+    vec4u: Nt((t) => -t),
+    "vec4<bool>": (t) => k(!t.x, !t.y, !t.z, !t.w)
+  },
+  select: {
+    vec2f: (t, e, n) => V(n.x ? e.x : t.x, n.y ? e.y : t.y),
+    vec2h: (t, e, n) => q(n.x ? e.x : t.x, n.y ? e.y : t.y),
+    vec2i: (t, e, n) => It(n.x ? e.x : t.x, n.y ? e.y : t.y),
+    vec2u: (t, e, n) => Pt(n.x ? e.x : t.x, n.y ? e.y : t.y),
+    "vec2<bool>": (t, e, n) => E(n.x ? e.x : t.x, n.y ? e.y : t.y),
+    vec3f: (t, e, n) => $(n.x ? e.x : t.x, n.y ? e.y : t.y, n.z ? e.z : t.z),
+    vec3h: (t, e, n) => j(n.x ? e.x : t.x, n.y ? e.y : t.y, n.z ? e.z : t.z),
+    vec3i: (t, e, n) => $t(n.x ? e.x : t.x, n.y ? e.y : t.y, n.z ? e.z : t.z),
+    vec3u: (t, e, n) => Ct(n.x ? e.x : t.x, n.y ? e.y : t.y, n.z ? e.z : t.z),
+    "vec3<bool>": (t, e, n) => S(n.x ? e.x : t.x, n.y ? e.y : t.y, n.z ? e.z : t.z),
+    vec4f: (t, e, n) => O(n.x ? e.x : t.x, n.y ? e.y : t.y, n.z ? e.z : t.z, n.w ? e.w : t.w),
+    vec4h: (t, e, n) => H(n.x ? e.x : t.x, n.y ? e.y : t.y, n.z ? e.z : t.z, n.w ? e.w : t.w),
+    vec4i: (t, e, n) => Et(n.x ? e.x : t.x, n.y ? e.y : t.y, n.z ? e.z : t.z, n.w ? e.w : t.w),
+    vec4u: (t, e, n) => At(n.x ? e.x : t.x, n.y ? e.y : t.y, n.z ? e.z : t.z, n.w ? e.w : t.w),
+    "vec4<bool>": (t, e, n) => k(n.x ? e.x : t.x, n.y ? e.y : t.y, n.z ? e.z : t.z, n.w ? e.w : t.w)
+  },
+  tanh: {
+    vec2f: x(Math.tanh),
+    vec2h: d(Math.tanh),
+    vec3f: p(Math.tanh),
+    vec3h: g(Math.tanh),
+    vec4f: h(Math.tanh),
+    vec4h: v(Math.tanh)
+  },
+  bitcastU32toF32: {
+    vec2u: (t) => V(G(t.x), G(t.y)),
+    vec3u: (t) => $(G(t.x), G(t.y), G(t.z)),
+    vec4u: (t) => O(G(t.x), G(t.y), G(t.z), G(t.w))
+  },
+  bitcastU32toI32: {
+    vec2u: (t) => It(D(t.x), D(t.y)),
+    vec3u: (t) => $t(D(t.x), D(t.y), D(t.z)),
+    vec4u: (t) => Et(D(t.x), D(t.y), D(t.z), D(t.w))
+  }
+}, Ge = (t) => "primitive" in t ? t.primitive : t, Ce = (t) => (e, n) => {
+  const { restrict: r } = t ?? {}, s = (tt) => {
+    throw r ? new gr([e, n], r) : new Error(`Cannot apply operator to ${e.type} and ${n.type}: ${tt}`);
+  };
+  if (t?.noMat && (ct(e) || ct(n))) return s("matrices not supported");
+  const c = C(e) || ct(e), a = C(n) || ct(n);
+  if (!c && !a) {
+    const tt = je([e, n], r);
+    return tt ? {
+      argTypes: tt,
+      returnType: tt[0]
+    } : s("incompatible scalar types");
+  }
+  if (c && a)
+    return t?.matVecProduct && C(e) !== C(n) ? {
+      argTypes: [e, n],
+      returnType: C(e) ? e : n
+    } : e.type !== n.type ? s("operands must have the same type") : {
+      argTypes: [e, n],
+      returnType: e
+    };
+  const [o, b] = c ? [n, e] : [e, n], y = je([o], [Ge(b)]);
+  return y ? {
+    argTypes: c ? [e, y[0]] : [y[0], n],
+    returnType: b
+  } : s(`scalar not convertible to ${Ge(b).type}`);
+}, Rn = Ce(), $s = Ce({ matVecProduct: !0 }), Wn = Ce({
+  noMat: !0,
+  restrict: [
+    T,
+    J,
+    se
+  ]
+});
+function Gn(t, e) {
+  if (typeof t == "number" && typeof e == "number") return t + e;
+  if (typeof t == "number" && w(e)) return M.addMixed[e.kind](e, t);
+  if (w(t) && typeof e == "number") return M.addMixed[t.kind](t, e);
+  if (w(t) && w(e) || L(t) && L(e)) return M.add[t.kind](t, e);
+  throw new Error("Add/Sub called with invalid arguments.");
+}
+const Rc = U({
+  name: "add",
+  signature: Rn,
+  normalImpl: Gn,
+  codegenImpl: (t, [e, n]) => f`(${e} + ${n})`
+});
+function Es(t, e) {
+  return Gn(t, Dn(-1, e));
+}
+const Wc = U({
+  name: "sub",
+  signature: Rn,
+  normalImpl: Es,
+  codegenImpl: (t, [e, n]) => f`(${e} - ${n})`
+});
+function Dn(t, e) {
+  if (typeof t == "number" && typeof e == "number") return t * e;
+  if (typeof t == "number" && (w(e) || L(e))) return M.mulSxV[e.kind](t, e);
+  if ((w(t) || L(t)) && typeof e == "number") return M.mulSxV[t.kind](e, t);
+  if (w(t) && w(e)) return M.mulVxV[t.kind](t, e);
+  if (Ae(t) && L(e)) return M.mulVxM[e.kind](t, e);
+  if (L(t) && Ae(e)) return M.mulMxV[t.kind](t, e);
+  if (L(t) && L(e)) return M.mulVxV[t.kind](t, e);
+  throw new Error("Mul called with invalid arguments.");
+}
+const Gc = U({
+  name: "mul",
+  signature: $s,
+  normalImpl: Dn,
+  codegenImpl: (t, [e, n]) => f`(${e} * ${n})`
+});
+function Ss(t, e) {
+  if (typeof t == "number" && typeof e == "number") return t / e;
+  if (typeof t == "number" && w(e)) {
+    const n = Xt[e.kind];
+    return M.div[e.kind](n(t), e);
+  }
+  if (w(t) && typeof e == "number") {
+    const n = Xt[t.kind];
+    return M.div[t.kind](t, n(e));
+  }
+  if (w(t) && w(e)) return M.div[t.kind](t, e);
+  throw new Error("Div called with invalid arguments.");
+}
+const Dc = U({
+  name: "div",
+  signature: Wn,
+  normalImpl: Ss,
+  codegenImpl: (t, [e, n]) => f`(${e} / ${n})`,
+  ignoreImplicitCastWarning: !0
+}), Yc = U({
+  name: "mod",
+  signature: Wn,
+  normalImpl: ((t, e) => {
+    if (typeof t == "number" && typeof e == "number") return t % e;
+    if (typeof t == "number" && w(e)) {
+      const n = Xt[e.kind];
+      return M.mod[e.kind](n(t), e);
+    }
+    if (w(t) && typeof e == "number") {
+      const n = Xt[t.kind];
+      return M.mod[t.kind](t, n(e));
+    }
+    if (w(t) && w(e)) return M.mod[t.kind](t, e);
+    throw new Error("Mod called with invalid arguments, expected types: number or vector.");
+  }),
+  codegenImpl: (t, [e, n]) => f`(${e} % ${n})`
+});
+function ks(t) {
+  return typeof t == "number" ? -t : M.neg[t.kind](t);
+}
+const qc = U({
+  name: "neg",
+  signature: (t) => ({
+    argTypes: [t],
+    returnType: t
+  }),
+  normalImpl: ks,
+  codegenImpl: (t, [e]) => f`-(${e})`
+});
+var Vs = /* @__PURE__ */ ((t) => (t.TOP_LEFT = "TOP_LEFT", t.TOP = "TOP", t.TOP_RIGHT = "TOP_RIGHT", t.LEFT = "LEFT", t.SELF = "SELF", t.RIGHT = "RIGHT", t.BOTTOM_LEFT = "BOTTOM_LEFT", t.BOTTOM = "BOTTOM", t.BOTTOM_RIGHT = "BOTTOM_RIGHT", t))(Vs || {}), Os = /* @__PURE__ */ ((t) => (t.TOP = "TOP", t.LEFT = "LEFT", t.SELF = "SELF", t.RIGHT = "RIGHT", t.BOTTOM = "BOTTOM", t))(Os || {});
+const Hc = {
+  TOP_LEFT: { x: -1, y: -1 },
+  TOP: { x: 0, y: -1 },
+  TOP_RIGHT: { x: 1, y: -1 },
+  LEFT: { x: -1, y: 0 },
+  SELF: { x: 0, y: 0 },
+  RIGHT: { x: 1, y: 0 },
+  BOTTOM_LEFT: { x: -1, y: 1 },
+  BOTTOM: { x: 0, y: 1 },
+  BOTTOM_RIGHT: { x: 1, y: 1 }
+};
+var Ns = /* @__PURE__ */ ((t) => (t[t.ELEMENT_ID = 0] = "ELEMENT_ID", t[t.POINT = 1] = "POINT", t))(Ns || {}), Ps = /* @__PURE__ */ ((t) => (t[t.NOOP = 0] = "NOOP", t[t.COUNT_ELEMENT = 1] = "COUNT_ELEMENT", t[t.COUNT_POINT = 2] = "COUNT_POINT", t[t.COUNT_KIND = 3] = "COUNT_KIND", t[t.IS_ELEMENT = 4] = "IS_ELEMENT", t[t.IS_POINT = 5] = "IS_POINT", t[t.IS_KIND = 6] = "IS_KIND", t[t.CHANCE = 7] = "CHANCE", t))(Ps || {}), Cs = /* @__PURE__ */ ((t) => (t[t.ALL = 0] = "ALL", t[t.ANY = 1] = "ANY", t[t.ONE = 2] = "ONE", t[t.NONE = 3] = "NONE", t))(Cs || {});
+const Kc = {
+  all: 0,
+  any: 1,
+  one: 2,
+  none: 3
+  /* NONE */
+}, Zc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((t) => t))(ke({
+  color: z,
+  ruleStart: z,
+  ruleEnd: z
+}), "GpuElement"), Xc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((t) => t))(ke({
+  toType: z,
+  toId: z,
+  toNeighbor: Ut,
+  accept: z,
+  conditionsStart: z,
+  conditionsEnd: z
+}), "GpuRule"), Jc = (globalThis.__TYPEGPU_AUTONAME__ ?? ((t) => t))(ke({
+  opcode: z,
+  checkId: z,
+  countOrWithId: z,
+  checkPointOrComparePoint: Ut,
+  withPoint: Ut,
+  chance: T
+}), "GpuCondition"), As = [8, 8], Qc = As[0];
+export {
+  i as $,
+  Cs as A,
+  Ws as B,
+  Os as C,
+  Rs as D,
+  Xs as E,
+  Js as F,
+  Zc as G,
+  Zs as H,
+  Pr as I,
+  cr as J,
+  or as K,
+  Ke as L,
+  Qs as M,
+  St as N,
+  Ps as O,
+  Z as P,
+  Yc as Q,
+  Dc as R,
+  Vs as S,
+  Ns as T,
+  Gc as U,
+  Wc as V,
+  Rc as W,
+  ec as X,
+  qs as Y,
+  tc as Z,
+  Ln as _,
+  Xc as a,
+  G as a$,
+  l as a0,
+  it as a1,
+  nc as a2,
+  f as a3,
+  jr as a4,
+  ct as a5,
+  rc as a6,
+  xr as a7,
+  Ze as a8,
+  at as a9,
+  Lc as aA,
+  _ as aB,
+  Gt as aC,
+  Wt as aD,
+  ar as aE,
+  Ds as aF,
+  Bs as aG,
+  fe as aH,
+  Ne as aI,
+  Fs as aJ,
+  an as aK,
+  De as aL,
+  Hn as aM,
+  Jt as aN,
+  vc as aO,
+  Kn as aP,
+  He as aQ,
+  yc as aR,
+  _r as aS,
+  U as aT,
+  M as aU,
+  gr as aV,
+  je as aW,
+  se as aX,
+  Hs as aY,
+  Uc as aZ,
+  Sr as a_,
+  Vr as aa,
+  C as ab,
+  Un as ac,
+  Pn as ad,
+  kn as ae,
+  Cn as af,
+  Vn as ag,
+  En as ah,
+  J as ai,
+  Kt as aj,
+  ns as ak,
+  Jr as al,
+  ut as am,
+  yt as an,
+  A as ao,
+  qn as ap,
+  Gs as aq,
+  Cc as ar,
+  ke as as,
+  Nc as at,
+  Ec as au,
+  kc as av,
+  Sc as aw,
+  $c as ax,
+  Vc as ay,
+  Ic as az,
+  Jc as b,
+  rr as b$,
+  D as b0,
+  cc as b1,
+  w as b2,
+  ms as b3,
+  hs as b4,
+  ps as b5,
+  xs as b6,
+  ds as b7,
+  Be as b8,
+  lt as b9,
+  ts as bA,
+  Qt as bB,
+  Ir as bC,
+  ue as bD,
+  fn as bE,
+  yn as bF,
+  sc as bG,
+  Bc as bH,
+  Mr as bI,
+  Pc as bJ,
+  Ks as bK,
+  $r as bL,
+  Oc as bM,
+  _c as bN,
+  Xn as bO,
+  js as bP,
+  oe as bQ,
+  fc as bR,
+  lc as bS,
+  uc as bT,
+  ac as bU,
+  jc as bV,
+  pr as bW,
+  bc as bX,
+  Us as bY,
+  Ls as bZ,
+  nr as b_,
+  qc as ba,
+  fs as bb,
+  ys as bc,
+  us as bd,
+  mc as be,
+  Cr as bf,
+  Yn as bg,
+  gc as bh,
+  Mc as bi,
+  Fc as bj,
+  Ac as bk,
+  pc as bl,
+  xc as bm,
+  Tc as bn,
+  zc as bo,
+  ae as bp,
+  un as bq,
+  Ve as br,
+  ic as bs,
+  zr as bt,
+  vr as bu,
+  br as bv,
+  ie as bw,
+  oc as bx,
+  wr as by,
+  dc as bz,
+  Kc as c,
+  hc as c0,
+  Fe as c1,
+  wc as c2,
+  As as c3,
+  Qc as c4,
+  Ee as d,
+  An as e,
+  On as f,
+  Sn as g,
+  Fn as h,
+  X as i,
+  Nn as j,
+  Rt as k,
+  $e as l,
+  T as m,
+  Hc as n,
+  Oe as o,
+  ot as p,
+  Ye as q,
+  Or as r,
+  Nr as s,
+  ir as t,
+  z as u,
+  Ut as v,
+  hr as w,
+  Ys as x,
+  m as y,
+  mr as z
+};