@wonderyard/vivarium 0.1.0

package/dist/compiler-CEYR17Vv.js

@@ -0,0 +1,527 @@
+import { V as x, p as M, T as j, m as we, a as q, i as d, J as ge, t as R, h as ke, y as D, f as ee, u as G, w as te, z as Ne, b as L, c as Ce, l as je, d as Pe, e as Ae, g as $e, K as xe, $ as C, o as y, j as be, k as Te, q as Ee, r as Ie, _ as J, s as re, v as ae, Y as V, x as oe, W as ie, B as Se, D as Me, E as Ue, L as se, F as Ge, P as ue, G as Le, H as _, I as ze, M as We, N as Fe, O as Be, Q as Re, R as F, U as De, X as Ke, Z as K, a0 as ne, a1 as le, a2 as ce, a3 as N, a4 as H, a5 as pe, a6 as k } from "./constants-Ry69vZz5.js";
+import { colorToABGR as Ye } from "./common/utils.js";
+var Je = { block: 0, binaryExpr: 1, assignmentExpr: 2, logicalExpr: 3, unaryExpr: 4, numericLiteral: 5, call: 6, memberAccess: 7, indexAccess: 8, return: 10, if: 11, let: 12, const: 13, for: 14, while: 15, continue: 16, break: 17, arrayExpr: 100, preUpdate: 101, postUpdate: 102, stringLiteral: 103, objectExpr: 104 }, Ve = { identifier: "i", destructuredObject: "d" }, He = 1;
+const Ze = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  FORMAT_VERSION: He,
+  FuncParameterType: Ve,
+  NodeTypeCatalog: Je
+}, Symbol.toStringTag, { value: "Module" }));
+var W = (e, t) => {
+  let a = t - 1, n = ~a;
+  return (e & a) === 0 ? e : (e & n) + t;
+}, Qe = { f32: 4, f16: 2, i32: 4, u32: 4, u16: 2, vec2f: 8, vec2h: 4, vec2i: 8, vec2u: 8, vec3f: 16, vec3h: 8, vec3i: 16, vec3u: 16, vec4f: 16, vec4h: 8, vec4i: 16, vec4u: 16, mat2x2f: 8, mat3x3f: 16, mat4x4f: 16, atomic: 4 };
+function Xe(e) {
+  let t = e?.type, a = Qe[t];
+  if (a !== void 0) return a;
+  if (D(e)) return Object.values(e.propTypes).map(b).reduce((n, o) => n > o ? n : o);
+  if (G(e)) return b(e.elementType);
+  if (ee(e)) {
+    let n = Object.values(e.propTypes)[0];
+    return n ? L(n) ?? 1 : 1;
+  }
+  if (te(e)) return L(e.elementType) ?? 1;
+  if (M(e) || j(e)) return L(e) ?? b(e.inner);
+  if (Ce.has(t)) return 1;
+  throw new Error(`Cannot determine alignment of data: ${JSON.stringify(e)}`);
+}
+function qe(e) {
+  if (ee(e)) {
+    let t = Object.values(e.propTypes)[0];
+    return t ? z(t) : 1;
+  }
+  return te(e) ? z(e.elementType) : j(e) ? L(e) ?? z(e.inner) : L(e) ?? 1;
+}
+var fe = /* @__PURE__ */ new WeakMap(), de = /* @__PURE__ */ new WeakMap();
+function b(e) {
+  let t = fe.get(e);
+  return t === void 0 && (t = Xe(e), fe.set(e, t)), t;
+}
+function z(e) {
+  let t = de.get(e);
+  return t === void 0 && (t = qe(e), de.set(e, t)), t;
+}
+function bt(e) {
+  return b(e);
+}
+var et = { f32: 4, f16: 2, i32: 4, u32: 4, u16: 2, vec2f: 8, vec2h: 4, vec2i: 8, vec2u: 8, vec3f: 12, vec3h: 6, vec3i: 12, vec3u: 12, vec4f: 16, vec4h: 8, vec4i: 16, vec4u: 16, mat2x2f: 16, mat3x3f: 48, mat4x4f: 64, uint8: 1, uint8x2: 2, uint8x4: 4, sint8: 1, sint8x2: 2, sint8x4: 4, unorm8: 1, unorm8x2: 2, unorm8x4: 4, snorm8: 1, snorm8x2: 2, snorm8x4: 4, uint16: 2, uint16x2: 4, uint16x4: 8, sint16: 2, sint16x2: 4, sint16x4: 8, unorm16: 2, unorm16x2: 4, unorm16x4: 8, snorm16: 2, snorm16x2: 4, snorm16x4: 8, float16: 2, float16x2: 4, float16x4: 8, float32: 4, float32x2: 8, float32x3: 12, float32x4: 16, uint32: 4, uint32x2: 8, uint32x3: 12, uint32x4: 16, sint32: 4, sint32x2: 8, sint32x3: 12, sint32x4: 16, "unorm10-10-10-2": 4, "unorm8x4-bgra": 4, atomic: 4 };
+function tt(e) {
+  let t = 0, a = e.propTypes;
+  for (let n of Object.values(a)) {
+    if (Number.isNaN(t)) throw new Error("Only the last property of a struct can be unbounded");
+    if (t = W(t, b(n)), t += T(n), Number.isNaN(t) && n.type !== "array") throw new Error("Cannot nest unbounded struct within another struct");
+  }
+  return W(t, b(e));
+}
+function nt(e) {
+  let t = 0, a = e.propTypes;
+  for (let n of Object.values(a)) {
+    let o = z(n);
+    t = W(t, o), t += T(n);
+  }
+  return t;
+}
+function rt(e) {
+  let t = et[e?.type];
+  if (t !== void 0) return t;
+  if (D(e)) return tt(e);
+  if (ee(e)) return nt(e);
+  if (G(e)) {
+    if (e.elementCount === 0) return Number.NaN;
+    let a = b(e.elementType);
+    return W(T(e.elementType), a) * e.elementCount;
+  }
+  if (te(e)) {
+    let a = z(e.elementType);
+    return W(T(e.elementType), a) * e.elementCount;
+  }
+  if (M(e) || j(e)) return Ne(e) ?? T(e.inner);
+  throw new Error(`Cannot determine size of data: ${e}`);
+}
+var me = /* @__PURE__ */ new WeakMap();
+function T(e) {
+  let t = me.get(e);
+  return t === void 0 && (t = rt(e), me.set(e, t)), t;
+}
+function Tt(e) {
+  return T(e);
+}
+function S(e, t) {
+  if (t === void 0) return (n) => S(e, n);
+  let a = (n) => {
+    if (n && n.length !== t) throw new Error(`Array schema of ${t} elements of type ${e.type} called with ${n.length} argument(s).`);
+    return Array.from({ length: t }, (o, r) => q(e, n?.[r]));
+  };
+  if (Object.setPrototypeOf(a, at), Number.isNaN(T(e))) throw new Error("Cannot nest runtime sized arrays.");
+  if (a.elementType = e, !Number.isInteger(t) || t < 0) throw new Error(`Cannot create array schema with invalid element count: ${t}.`);
+  return a.elementCount = t, a;
+}
+var at = { [d]: !0, type: "array", toString() {
+  return `arrayOf(${this.elementType}, ${this.elementCount})`;
+} }, { NodeTypeCatalog: p } = Ze, ot = ["==", "!=", "<", "<=", ">", ">=", "<<", ">>", "+", "-", "*", "/", "%", "|", "^", "&", "&&", "||"], it = ["&&", "||", "==", "!=", "<", "<=", ">", ">="], st = ["vec2f", "vec3f", "vec4f", "vec2h", "vec3h", "vec4h", "vec2i", "vec3i", "vec4i", "vec2u", "vec3u", "vec4u", "mat2x2f", "mat3x3f", "mat4x4f"], Z = { add: Ie, sub: Ee, mul: Te, div: be };
+function he(e, t, a) {
+  return a ? it.includes(t) ? C : t === "=" ? a : e : t === "!" || t === "~" ? C : e;
+}
+function ut(e) {
+  throw new Error(`'${JSON.stringify(e)}' was not handled by the WGSL generator.`);
+}
+function A(e, [t, a]) {
+  e.pushBlockScope();
+  try {
+    e.indent();
+    let n = a.map((o) => X(e, o)).join(`
+`);
+    return e.dedent(), `{
+${n}
+${e.pre}}`;
+  } finally {
+    e.popBlockScope();
+  }
+}
+function lt(e, t, a) {
+  return e.defineVariable(t, a);
+}
+function Q(e, t) {
+  let a = e.getById(t);
+  if (!a) throw new Error(`Identifier ${t} not found`);
+  return a;
+}
+function O(e, t, a) {
+  let n = e.expectedType;
+  e.expectedType = a;
+  try {
+    let o = g(e, t);
+    return xe(e, o, a);
+  } finally {
+    e.expectedType = n;
+  }
+}
+var ct = { "+": Ie[d].gpuImpl, "-": Ee[d].gpuImpl, "*": Te[d].gpuImpl, "/": be[d].gpuImpl };
+function g(e, t) {
+  if (typeof t == "string") return Q(e, t);
+  if (typeof t == "boolean") return y(t ? "true" : "false", C);
+  if (t[0] === p.logicalExpr || t[0] === p.binaryExpr || t[0] === p.assignmentExpr) {
+    let [a, n, o, r] = t, s = g(e, n), i = g(e, r), l = ct[o];
+    if (l) return l(s, i);
+    let f = t[0] === p.assignmentExpr ? s.dataType.type === "ptr" ? [s.dataType.inner] : [s.dataType] : void 0, m = J({ ctx: e, values: [s, i], restrictTo: f }), [h, E] = m || [s, i], u = e.resolve(h.value), c = e.resolve(E.value), $ = he(h.dataType, o, E.dataType);
+    return y(ot.includes(o) ? `(${u} ${o} ${c})` : `${u} ${o} ${c}`, $);
+  }
+  if (t[0] === p.postUpdate) {
+    let [a, n, o] = t, r = g(e, o), s = e.resolve(r.value);
+    return y(`${s}${n}`, r.dataType);
+  }
+  if (t[0] === p.unaryExpr) {
+    let [a, n, o] = t, r = g(e, o), s = e.resolve(r.value), i = he(r.dataType, n);
+    return y(`${n}${s}`, i);
+  }
+  if (t[0] === p.memberAccess) {
+    let [a, n, o] = t, r = g(e, n);
+    if (st.includes(r.dataType.type) && o in Z) return { value: new ae(o, r, Z[o][d].gpuImpl), dataType: re };
+    if (r.dataType.type === "unknown") {
+      let s = r.value[o];
+      return V(s);
+    }
+    return oe(r.dataType) ? y(`(*${e.resolve(r.value)}).${o}`, ie(r.dataType.inner, o)) : G(r.dataType) && o === "length" ? r.dataType.elementCount === 0 ? y(`arrayLength(&${e.resolve(r.value)})`, x) : y(String(r.dataType.elementCount), Re) : Se(r.dataType) && o === "columns" ? y(r.value, r.dataType) : Me(r.dataType) && Ue(r.value) ? V(r.value[o]) : y(`${e.resolve(r.value)}.${o}`, ie(r.dataType, o));
+  }
+  if (t[0] === p.indexAccess) {
+    let [a, n, o] = t, r = g(e, n), s = g(e, o), i = e.resolve(r.value), l = e.resolve(s.value);
+    if (r.dataType.type === "unknown") {
+      if (Array.isArray(o) && o[0] === p.numericLiteral) return V(r.value[o[1]]);
+      throw new Error(`Cannot index value ${i} of unknown type with index ${l}`);
+    }
+    return oe(r.dataType) ? y(`(*${i})[${l}]`, se(r.dataType.inner)) : y(`${i}[${l}]`, Ge(r.dataType) ? se(r.dataType) : re);
+  }
+  if (t[0] === p.numericLiteral) {
+    let a = typeof t[1] == "string" ? ue(Le(t[1])) : ue(t[1]);
+    if (!a) throw new Error(`Invalid numeric literal ${t[1]}`);
+    return a;
+  }
+  if (t[0] === p.call) {
+    let [a, n, o] = t, r = g(e, n);
+    if (D(r.value) || G(r.value)) {
+      if (o.length > 1) throw new _("Array and struct schemas should always be called with at most 1 argument");
+      if (!o[0]) return y(`${e.resolve(r.value)}()`, r.value);
+      let i = O(e, o[0], r.value);
+      return y(e.resolve(i.value, r.value), r.value);
+    }
+    if (r.value instanceof ae) {
+      if (!o[0]) throw new _(`An infix operator '${r.value.name}' was called without any arguments`);
+      let i = g(e, o[0]);
+      return r.value.operator(r.value.lhs, i);
+    }
+    if (!ze(r.value)) throw new Error(`Function ${String(r.value)} ${R(r.value)} has not been created using TypeGPU APIs. Did you mean to wrap the function with tgpu.fn(args, return)(...) ?`);
+    let s = r.value[d]?.argConversionHint ?? "keep";
+    try {
+      let i;
+      if (Array.isArray(s)) i = o.map((f, m) => {
+        let h = s[m];
+        if (!h) throw new _(`Function '${R(r.value)}' was called with too many arguments`);
+        return O(e, f, h);
+      });
+      else {
+        let f = o.map((m) => g(e, m));
+        s === "keep" ? i = f : s === "unify" ? i = J({ ctx: e, values: f }) ?? f : i = s(...f).map((m, h) => [m, f[h]]).map(([m, h]) => xe(e, h, m));
+      }
+      let l = r.value(...i);
+      if (!We(l)) throw new Error("Functions running in codegen mode must return snippets");
+      return l;
+    } catch (i) {
+      throw new Fe(i, [{ toString: () => R(r.value) }]);
+    }
+  }
+  if (t[0] === p.objectExpr) {
+    let a = t[1], n = e.expectedType;
+    if (!n || !D(n)) throw new _(`No target type could be inferred for object with keys [${Object.keys(a).join(", ")}], please wrap the object in the corresponding schema.`);
+    let o = Object.fromEntries(Object.entries(n.propTypes).map(([s, i]) => {
+      let l = a[s];
+      if (l === void 0) throw new _(`Missing property ${s} in object literal for struct ${n}`);
+      let f = O(e, l, i);
+      return [s, f];
+    })), r = Be(e, n, o);
+    return y(`${e.resolve(n)}(${r.map((s) => e.resolve(s.value)).join(", ")})`, n);
+  }
+  if (t[0] === p.arrayExpr) {
+    let [a, n] = t, o = e.expectedType, r, s;
+    if (G(o)) {
+      if (r = o.elementType, s = n.map((f) => O(e, f, r)), s.length !== o.elementCount) throw new _(`Cannot create value of type '${o}' from an array of length: ${s.length}`);
+    } else {
+      let f = n.map((h) => g(e, h));
+      if (f.length === 0) throw new _("Cannot infer the type of an empty array literal.");
+      let m = J({ ctx: e, values: f });
+      if (!m) throw new _("The given values cannot be automatically converted to a common type. Consider wrapping the array in an appropriate schema");
+      s = m, r = $e(s[0]?.dataType);
+    }
+    let i = `array<${e.resolve(r)}, ${s.length}>`, l = s.map((f) => e.resolve(f.value));
+    return y(`${i}(${l.join(", ")})`, S(r, s.length));
+  }
+  if (t[0] === p.stringLiteral) throw new Error("Cannot use string literals in TGSL.");
+  if (t[0] === p.preUpdate) throw new Error("Cannot use pre-updates in TGSL.");
+  ut(t);
+}
+function B(e) {
+  return typeof e != "object" || e[0] !== p.block ? [p.block, [e]] : e;
+}
+function X(e, t) {
+  if (typeof t == "string") return `${e.pre}${e.resolve(Q(e, t).value)};`;
+  if (typeof t == "boolean") return `${e.pre}${t ? "true" : "false"};`;
+  if (t[0] === p.return) {
+    let a = t[1], n = a !== void 0 ? e.resolve(O(e, a, e.topFunctionReturnType).value) : void 0;
+    return n ? `${e.pre}return ${n};` : `${e.pre}return;`;
+  }
+  if (t[0] === p.if) {
+    let [a, n, o, r] = t, s = e.resolve(O(e, n, C).value), i = A(e, B(o)), l = r ? A(e, B(r)) : void 0;
+    return l ? `${e.pre}if (${s}) ${i}
+${e.pre}else ${l}` : `${e.pre}if (${s}) ${i}`;
+  }
+  if (t[0] === p.let || t[0] === p.const) {
+    let [a, n, o] = t, r = o !== void 0 ? g(e, o) : void 0;
+    if (!r) throw new Error(`Cannot create variable '${n}' without an initial value.`);
+    if (ge(r.dataType)) throw new Error(`Cannot create variable '${n}' with loose data type.`);
+    lt(e, n, $e(r.dataType));
+    let s = e.resolve(Q(e, n).value);
+    return `${e.pre}var ${s} = ${e.resolve(r.value)};`;
+  }
+  if (t[0] === p.block) return A(e, t);
+  if (t[0] === p.for) {
+    let [a, n, o, r, s] = t, [i, l, f] = e.withResetIndentLevel(() => [n ? X(e, n) : void 0, o ? g(e, o) : void 0, r ? X(e, r) : void 0]), m = i ? i.slice(0, -1) : "", h = o ? O(e, o, C) : void 0, E = h ? e.resolve(h.value) : "", u = f ? f.slice(0, -1) : "", c = A(e, B(s));
+    return `${e.pre}for (${m}; ${E}; ${u}) ${c}`;
+  }
+  if (t[0] === p.while) {
+    let [a, n, o] = t, r = O(e, n, C), s = e.resolve(r.value), i = A(e, B(o));
+    return `${e.pre}while (${s}) ${i}`;
+  }
+  return t[0] === p.continue ? `${e.pre}continue;` : t[0] === p.break ? `${e.pre}break;` : `${e.pre}${e.resolve(g(e, t).value)};`;
+}
+function Et(e, t) {
+  return A(e, t);
+}
+function pt(e, t) {
+  if (t === void 0) return (n) => pt(e, n);
+  let a = (n) => {
+    if (n && n.length !== t) throw new Error(`Disarray schema of ${t} elements of type ${e.type} called with ${n.length} argument(s).`);
+    return Array.from({ length: t }, (o, r) => q(e, n?.[r]));
+  };
+  if (Object.setPrototypeOf(a, ft), a.elementType = e, !Number.isInteger(t) || t < 0) throw new Error(`Cannot create disarray schema with invalid element count: ${t}.`);
+  return a.elementCount = t, a;
+}
+var ft = { [d]: !0, type: "disarray", toString() {
+  return `disarrayOf(${this.elementType}, ${this.elementCount})`;
+} };
+function It(e) {
+  let t = (a) => Object.fromEntries(Object.entries(e).map(([n, o]) => [n, q(o, a?.[n])]));
+  return Object.setPrototypeOf(t, dt), t.propTypes = e, t;
+}
+var dt = { [d]: !0, type: "unstruct", $name(e) {
+  return ke(this, e), this;
+}, toString() {
+  return `unstruct:${R(this) ?? "<unnamed>"}`;
+} };
+function _t(e) {
+  return new mt(e);
+}
+var mt = class {
+  constructor(e) {
+    this.inner = e;
+  }
+  [d] = !0;
+  type = "atomic";
+};
+function U(e, t) {
+  return M(e) ? new ve(e.inner, [t, ...e.attribs]) : j(e) ? new ye(e.inner, [t, ...e.attribs]) : ge(e) ? new ye(e, [t]) : new ve(e, [t]);
+}
+function Ot(e, t) {
+  return U(t, { [d]: !0, type: "@align", params: [e] });
+}
+function kt(e, t) {
+  return U(t, { [d]: !0, type: "@size", params: [e] });
+}
+function Nt(e, t) {
+  return U(t, { [d]: !0, type: "@location", params: [e] });
+}
+function Ct(e, t) {
+  return U(t, { [d]: !0, type: "@interpolate", params: [e] });
+}
+function jt(e) {
+  if (!ht(e)) throw new Error("The @invariant attribute must only be applied to the position built-in value.");
+  let t = M(e) || j(e) ? e.attribs.find(we) : void 0;
+  if (!t || t.params[0] !== "position") throw new Error("The @invariant attribute must only be applied to the position built-in value.");
+  return U(e, { [d]: !0, type: "@invariant", params: [] });
+}
+function ht(e) {
+  return (M(e) || j(e)) && e.attribs.find(we) !== void 0;
+}
+function Pt(e) {
+  return !M(e) && !j(e) ? "" : e.attribs.map((t) => t.params.length === 0 ? `${t.type} ` : `${t.type}(${t.params.join(", ")}) `).join("");
+}
+var _e = class {
+  constructor(e, t) {
+    this.inner = e, this.attribs = t;
+    let a = t.find(je)?.params[0], n = t.find(Pe)?.params[0];
+    if (a !== void 0) {
+      if (a <= 0) throw new Error(`Custom data alignment must be a positive number, got: ${a}.`);
+      if (Math.log2(a) % 1 !== 0) throw new Error(`Alignment has to be a power of 2, got: ${a}.`);
+      if (Ae(this.inner) && a % b(this.inner) !== 0) throw new Error(`Custom alignment has to be a multiple of the standard data alignment. Got: ${a}, expected multiple of: ${b(this.inner)}.`);
+    }
+    if (n !== void 0) {
+      if (n < T(this.inner)) throw new Error(`Custom data size cannot be smaller then the standard data size. Got: ${n}, expected at least: ${T(this.inner)}.`);
+      if (n <= 0) throw new Error(`Custom data size must be a positive number. Got: ${n}.`);
+    }
+  }
+  [d] = !0;
+}, ve = class extends _e {
+  [d] = !0;
+  type = "decorated";
+}, ye = class extends _e {
+  [d] = !0;
+  type = "loose-decorated";
+};
+function w(e, t) {
+  return U(e, { [d]: !0, type: "@builtin", params: [t] });
+}
+var At = { vertexIndex: w(x, "vertex_index"), instanceIndex: w(x, "instance_index"), position: w(Ke, "position"), clipDistances: w(S(x, 8), "clip_distances"), frontFacing: w(C, "front_facing"), fragDepth: w(De, "frag_depth"), sampleIndex: w(x, "sample_index"), sampleMask: w(x, "sample_mask"), localInvocationId: w(F, "local_invocation_id"), localInvocationIndex: w(x, "local_invocation_index"), globalInvocationId: w(F, "global_invocation_id"), workgroupId: w(F, "workgroup_id"), numWorkgroups: w(F, "num_workgroups"), subgroupInvocationId: w(x, "subgroup_invocation_id"), subgroupSize: w(x, "subgroup_size") };
+function P(e, t) {
+  let a = e.prototype, n = Z[t][d].jsImpl;
+  a[t] = function(o) {
+    return n(this, o);
+  };
+}
+P(K, "add");
+P(K, "sub");
+P(K, "mul");
+P(K, "div");
+P(ne, "add");
+P(ne, "sub");
+P(ne, "mul");
+const Oe = (e) => {
+  if (e.some((t) => t > 31))
+    throw console.warn(
+      `Elements with an index greater than 31 and extending one or more kinds are not allowed when they are involved in conditions referencing kinds.
+To assign a lower index, move the elements with extensions higher in the definition list or reduce the overall number of elements and kinds.`
+    ), new Error(
+      "Element in condition involving kinds has an index greater than 31"
+    );
+}, vt = (e, t, a) => {
+  const { elements: n } = a, o = n.findIndex((r) => r.id === e);
+  if (o !== -1)
+    t.opcode = k.COUNT_ELEMENT, t.checkId = o;
+  else {
+    const r = n.map((i, l) => ({ ...i, index: l })).filter(
+      (i) => i.extensions.some((l) => l === e)
+    ).map((i) => i.index);
+    Oe(r);
+    const s = r.reduce((i, l) => (i |= 1 << l, i), 0);
+    t.checkId = s, t.opcode = k.COUNT_KIND;
+  }
+}, yt = (e, t) => {
+  t.opcode = k.COUNT_POINT, t.checkPointOrComparePoint = N(e.x, e.y);
+}, wt = (e, t, a) => {
+  const { check: n, count: o } = e;
+  if (typeof n > "u")
+    throw new Error("condition.check is undefined");
+  typeof n == "string" ? vt(n, t, a) : yt(n, t), t.countOrWithId = o.reduce(
+    // Packing numbers as positional bits.
+    // Example: [2, 3] -> 0b000001100
+    (r, s) => (r |= 1 << s, r),
+    0
+  );
+}, gt = (e, t, a) => {
+  const n = e.compare;
+  if (typeof n > "u")
+    throw new Error("condition.compare is undefined");
+  if (typeof e.with > "u")
+    throw new Error("condition.with is undefined");
+  if (t.checkPointOrComparePoint = N(
+    n.x,
+    n.y
+  ), typeof e.with == "string") {
+    const o = e.with;
+    if (a.elements.some((r) => r.id === o)) {
+      t.opcode = k.IS_ELEMENT;
+      const r = a.elements.findIndex(
+        (s) => s.id === o
+      );
+      t.countOrWithId = r;
+    } else {
+      const r = a.elements.map((i, l) => ({ ...i, index: l })).filter(
+        (i) => i.extensions.some((l) => l === o)
+      ).map((i) => i.index);
+      Oe(r);
+      const s = r.reduce((i, l) => (i |= 1 << l, i), 0);
+      t.countOrWithId = s, t.opcode = k.IS_KIND;
+    }
+  } else
+    t.opcode = k.IS_POINT, t.withPoint = N(e.with.x, e.with.y);
+}, St = (e, t) => {
+  const { elements: a, rules: n } = t, o = n.filter((u) => u.fromType === "element").reduce(
+    (u, c) => {
+      const $ = a.findIndex(
+        (v) => v.id === c.fromId
+      );
+      return u[$].push(c), u;
+    },
+    a.map(() => [])
+  ), r = n.filter((u) => u.fromType === "kind").reduce((u, c) => (a.forEach(($, v) => {
+    $.extensions.includes(c.fromId) && u[v].push(c);
+  }), u), o), s = [];
+  let i = [];
+  const l = /* @__PURE__ */ new Map();
+  r.forEach((u) => {
+    u.forEach((c, $) => {
+      let v, I;
+      const Y = `${c.fromId}:${$.toString()}`;
+      c.fromType === "kind" && l.has(Y) ? [v, I] = l.get(Y) : (v = i.length, Array.isArray(c.when) ? i = i.concat(c.when) : i = i.concat([c.when]), I = i.length, l.set(Y, [v, I])), s.push({
+        ...c,
+        conditionsStart: v,
+        conditionsEnd: I
+      });
+    });
+  });
+  const f = [], m = [], h = [];
+  let E = 0;
+  return a.forEach((u, c) => {
+    const $ = E, v = E + r[c].length;
+    E = v;
+    const I = le({
+      color: Ye(u.color),
+      ruleStart: $,
+      ruleEnd: v
+    });
+    f.push(I);
+  }), s.forEach((u) => {
+    const { conditionsStart: c, conditionsEnd: $ } = u, v = ce({
+      toType: H.ELEMENT_ID,
+      toId: 0,
+      toNeighbor: N(),
+      conditionsStart: c,
+      conditionsEnd: $,
+      accept: u.accept
+    });
+    if (m.push(v), typeof u.to > "u")
+      throw new Error("rule.to is undefined");
+    typeof u.to == "string" ? (v.toType = H.ELEMENT_ID, v.toId = a.findIndex((I) => I.id === u.to)) : (v.toType = H.POINT, v.toNeighbor = N(u.to.x, u.to.y));
+  }), i.forEach((u) => {
+    const c = pe({
+      opcode: k.NOOP,
+      checkId: 0,
+      countOrWithId: 0,
+      checkPointOrComparePoint: N(),
+      withPoint: N(),
+      chance: 0
+    });
+    h.push(c), u.type === "count" ? wt(u, c, t) : u.type === "is" ? gt(u, c, t) : (c.opcode = k.CHANCE, c.chance = u.ratio.part / u.ratio.whole);
+  }), {
+    neighborhood: (globalThis.__TYPEGPU_AUTONAME__ ?? ((u) => u))(e.createBuffer(x, t.neighborhood === "cross" ? 4 : 8).$usage("uniform"), "neighborhood"),
+    elements: (globalThis.__TYPEGPU_AUTONAME__ ?? ((u) => u))(e.createBuffer(
+      S(le, Math.max(a.length, 1)),
+      f
+    ).$usage("storage"), "elements"),
+    rules: (globalThis.__TYPEGPU_AUTONAME__ ?? ((u) => u))(e.createBuffer(S(ce, Math.max(s.length, 1)), m).$usage("storage"), "rules"),
+    conditions: (globalThis.__TYPEGPU_AUTONAME__ ?? ((u) => u))(e.createBuffer(
+      S(pe, Math.max(i.length, 1)),
+      h
+    ).$usage("storage"), "conditions")
+  };
+};
+export {
+  pt as C,
+  Tt as K,
+  S as U,
+  W as V,
+  Pt as Z,
+  Ot as a,
+  ht as b,
+  At as c,
+  Et as d,
+  b as e,
+  z as f,
+  St as g,
+  T as h,
+  bt as j,
+  Nt as l,
+  _t as o,
+  jt as p,
+  It as r,
+  kt as s,
+  Ve as t,
+  Ct as u
+};