@adatechnology/game-fluids-three 0.0.0-stage → 0.1.1

package/dist/index.global.js

@@ -0,0 +1,1117 @@
+"use strict";
+var GameFluidsThree = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    createFluidRenderer: () => createFluidRenderer,
+    smoothOutline: () => smoothOutline
+  });
+
+  // src/clip.ts
+  var sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+  var cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  var norm = (a) => {
+    const l = Math.hypot(a[0], a[1], a[2]) || 1;
+    return [a[0] / l, a[1] / l, a[2] / l];
+  };
+  var orient = (p, n, outward) => {
+    if (dot(cross(sub(p[1], p[0]), sub(p[2], p[0])), outward) < 0) return { p: [...p].reverse(), n: [...n].reverse() };
+    return { p, n };
+  };
+  var finish = (faces) => {
+    let maxVertices = 0;
+    for (const f of faces) maxVertices += (f.p.length * 2 + 2) * 3;
+    maxVertices += faces.length * 3 * 2 + 64;
+    return { faces, maxVertices };
+  };
+  var cylinderSolid = (radius, height, segments) => {
+    const faces = [];
+    const ring = (y, i) => {
+      const a = i / segments * Math.PI * 2;
+      return [Math.cos(a) * radius, y, Math.sin(a) * radius];
+    };
+    const radial = (i) => {
+      const a = i / segments * Math.PI * 2;
+      return [Math.cos(a), 0, Math.sin(a)];
+    };
+    for (let i = 0; i < segments; i++) {
+      const j = (i + 1) % segments;
+      const mid = norm([radial(i)[0] + radial(j)[0], 0, radial(i)[2] + radial(j)[2]]);
+      faces.push(orient([ring(0, i), ring(0, j), ring(height, j), ring(height, i)], [radial(i), radial(j), radial(j), radial(i)], mid));
+    }
+    const bottom = [];
+    const top = [];
+    for (let i = 0; i < segments; i++) {
+      bottom.push(ring(0, i));
+      top.push(ring(height, i));
+    }
+    faces.push(orient(bottom, bottom.map(() => [0, -1, 0]), [0, -1, 0]));
+    faces.push(orient(top, top.map(() => [0, 1, 0]), [0, 1, 0]));
+    return finish(faces);
+  };
+  var boxSolid = (size) => {
+    const hx = size[0] / 2;
+    const hz = size[2] / 2;
+    const hy = size[1];
+    const c = (x, y, z) => [x * hx, y * hy, z * hz];
+    const quad = (a, b, cc, d, n) => orient([a, b, cc, d], [n, n, n, n], n);
+    return finish([
+      quad(c(1, 0, -1), c(1, 1, -1), c(1, 1, 1), c(1, 0, 1), [1, 0, 0]),
+      quad(c(-1, 0, -1), c(-1, 1, -1), c(-1, 1, 1), c(-1, 0, 1), [-1, 0, 0]),
+      quad(c(-1, 1, -1), c(1, 1, -1), c(1, 1, 1), c(-1, 1, 1), [0, 1, 0]),
+      quad(c(-1, 0, -1), c(1, 0, -1), c(1, 0, 1), c(-1, 0, 1), [0, -1, 0]),
+      quad(c(-1, 0, 1), c(1, 0, 1), c(1, 1, 1), c(-1, 1, 1), [0, 0, 1]),
+      quad(c(-1, 0, -1), c(1, 0, -1), c(1, 1, -1), c(-1, 1, -1), [0, 0, -1])
+    ]);
+  };
+  var polyP = [];
+  var polyN = [];
+  var cut = [];
+  var clipSolid = (solid, u, d, pos, nor) => {
+    let count = 0;
+    const capacity = Math.floor(pos.length / 3);
+    cut.length = 0;
+    const put = (px, py, pz, nx, ny, nz) => {
+      if (count >= capacity) return;
+      pos[count * 3] = px;
+      pos[count * 3 + 1] = py;
+      pos[count * 3 + 2] = pz;
+      nor[count * 3] = nx;
+      nor[count * 3 + 1] = ny;
+      nor[count * 3 + 2] = nz;
+      count++;
+    };
+    for (const face of solid.faces) {
+      const m = face.p.length;
+      polyP.length = 0;
+      polyN.length = 0;
+      for (let i = 0; i < m; i++) {
+        const a = face.p[i];
+        const b = face.p[(i + 1) % m];
+        const na = face.n[i];
+        const nb = face.n[(i + 1) % m];
+        const da = u[0] * a[0] + u[1] * a[1] + u[2] * a[2] - d;
+        const db = u[0] * b[0] + u[1] * b[1] + u[2] * b[2] - d;
+        const ina = da <= 0;
+        const inb = db <= 0;
+        if (ina) {
+          polyP.push(a[0], a[1], a[2]);
+          polyN.push(na[0], na[1], na[2]);
+          if (da > -1e-7) cut.push(a[0], a[1], a[2]);
+        }
+        if (ina !== inb) {
+          const t = da / (da - db);
+          const x = a[0] + (b[0] - a[0]) * t;
+          const y = a[1] + (b[1] - a[1]) * t;
+          const z = a[2] + (b[2] - a[2]) * t;
+          polyP.push(x, y, z);
+          polyN.push(na[0] + (nb[0] - na[0]) * t, na[1] + (nb[1] - na[1]) * t, na[2] + (nb[2] - na[2]) * t);
+          cut.push(x, y, z);
+        }
+      }
+      const n = polyP.length / 3;
+      for (let i = 1; i < n - 1; i++) {
+        for (const k of [0, i, i + 1]) put(polyP[k * 3], polyP[k * 3 + 1], polyP[k * 3 + 2], polyN[k * 3], polyN[k * 3 + 1], polyN[k * 3 + 2]);
+      }
+    }
+    const pts = [];
+    for (let i = 0; i < cut.length; i += 3) {
+      let dup = false;
+      for (const q of pts) {
+        if (Math.abs(q[0] - cut[i]) + Math.abs(q[1] - cut[i + 1]) + Math.abs(q[2] - cut[i + 2]) < 1e-6) {
+          dup = true;
+          break;
+        }
+      }
+      if (!dup) pts.push([cut[i], cut[i + 1], cut[i + 2]]);
+    }
+    if (pts.length >= 3) {
+      const c = [0, 0, 0];
+      for (const q of pts) {
+        c[0] += q[0] / pts.length;
+        c[1] += q[1] / pts.length;
+        c[2] += q[2] / pts.length;
+      }
+      const e1 = norm(cross(u, Math.abs(u[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0]));
+      const e2 = cross(u, e1);
+      const keyed = pts.map((q) => ({ q, a: Math.atan2(dot(sub(q, c), e2), dot(sub(q, c), e1)) })).sort((p, r) => p.a - r.a);
+      for (let i = 0; i < keyed.length; i++) {
+        for (const q of [c, keyed[i].q, keyed[(i + 1) % keyed.length].q]) put(q[0], q[1], q[2], u[0], u[1], u[2]);
+      }
+    }
+    return count;
+  };
+
+  // src/liquid-body.ts
+  var INSET = 0.985;
+  var LiquidBody = class {
+    constructor(THREE, containerId, object, offset) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "containerId", containerId);
+      __publicField(this, "object", object);
+      __publicField(this, "group");
+      __publicField(this, "mesh", null);
+      __publicField(this, "geometry", null);
+      __publicField(this, "pos", new Float32Array(0));
+      __publicField(this, "nor", new Float32Array(0));
+      __publicField(this, "solid", null);
+      __publicField(this, "shapeKey", "");
+      __publicField(this, "steamAcc", 0);
+      __publicField(this, "inverse");
+      __publicField(this, "tmpN");
+      __publicField(this, "tmpP");
+      __publicField(this, "vertices", 0);
+      this.group = new THREE.Group();
+      this.group.name = "fluid_liquid_body";
+      this.group.position.set(offset[0], offset[1], offset[2]);
+      this.inverse = new THREE.Matrix4();
+      this.tmpN = new THREE.Vector3();
+      this.tmpP = new THREE.Vector3();
+      object.add(this.group);
+    }
+    get visible() {
+      return !!this.mesh && this.mesh.visible;
+    }
+    build(state, quality) {
+      const shape = state.shape;
+      if (!shape) return;
+      const key = JSON.stringify(shape) + quality.bodySegments;
+      if (key === this.shapeKey) return;
+      this.shapeKey = key;
+      this.solid = shape.kind === "cylinder" ? cylinderSolid(shape.radius * INSET, shape.height * INSET, quality.bodySegments) : boxSolid([shape.size[0] * INSET, shape.size[1] * INSET, shape.size[2] * INSET]);
+      const T = this.THREE;
+      this.geometry?.dispose();
+      this.pos = new Float32Array(this.solid.maxVertices * 3);
+      this.nor = new Float32Array(this.solid.maxVertices * 3);
+      this.geometry = new T.BufferGeometry();
+      const p = new T.BufferAttribute(this.pos, 3);
+      const n = new T.BufferAttribute(this.nor, 3);
+      p.setUsage(T.DynamicDrawUsage);
+      n.setUsage(T.DynamicDrawUsage);
+      this.geometry.setAttribute("position", p);
+      this.geometry.setAttribute("normal", n);
+      if (!this.mesh) {
+        this.mesh = new T.Mesh(this.geometry);
+        this.mesh.name = "fluid_liquid";
+        this.mesh.frustumCulled = false;
+        this.mesh.renderOrder = 3;
+        this.group.add(this.mesh);
+      } else this.mesh.geometry = this.geometry;
+    }
+    update(dt, world, materials, quality, particles) {
+      const state = world.container(this.containerId);
+      const def = state?.liquid ? world.liquids.get(state.liquid) : void 0;
+      if (!state || !state.shape || !def || state.liters <= 1e-6) {
+        if (this.mesh) this.mesh.visible = false;
+        this.vertices = 0;
+        return;
+      }
+      this.build(state, quality);
+      if (!this.mesh || !this.solid) return;
+      this.mesh.material = materials.liquidBody(def);
+      this.object.updateWorldMatrix(true, false);
+      this.group.updateWorldMatrix(true, false);
+      this.inverse.copy(this.group.matrixWorld).invert();
+      this.tmpN.set(state.surfaceNormal[0], state.surfaceNormal[1], state.surfaceNormal[2]).transformDirection(this.inverse);
+      this.tmpP.set(state.surfacePoint[0], state.surfacePoint[1], state.surfacePoint[2]).applyMatrix4(this.inverse);
+      const u = [this.tmpN.x, this.tmpN.y, this.tmpN.z];
+      const d = u[0] * this.tmpP.x + u[1] * this.tmpP.y + u[2] * this.tmpP.z;
+      this.vertices = clipSolid(this.solid, u, d, this.pos, this.nor);
+      const geometry = this.geometry;
+      geometry.setDrawRange(0, this.vertices);
+      geometry.getAttribute("position").needsUpdate = true;
+      geometry.getAttribute("normal").needsUpdate = true;
+      this.mesh.visible = this.vertices > 0;
+      if (state.steaming && this.vertices > 0) {
+        this.steamAcc += dt * quality.steamRate;
+        while (this.steamAcc >= 1) {
+          this.steamAcc -= 1;
+          const o = this.tmpP.set(state.surfacePoint[0], state.surfacePoint[1], state.surfacePoint[2]);
+          particles.steam([o.x, o.y + 0.01, o.z]);
+        }
+      } else this.steamAcc = 0;
+    }
+    get triangles() {
+      return this.visible ? Math.floor(this.vertices / 3) : 0;
+    }
+    dispose() {
+      this.object.remove(this.group);
+      this.geometry?.dispose();
+      this.geometry = null;
+      this.mesh = null;
+    }
+  };
+
+  // src/util.ts
+  var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+  var Rng = class {
+    constructor(seed) {
+      __publicField(this, "state");
+      this.state = seed >>> 0 || 1;
+    }
+    next() {
+      this.state = this.state + 1831565813 >>> 0;
+      let t = this.state;
+      t = Math.imul(t ^ t >>> 15, t | 1);
+      t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    }
+  };
+  var hashPoint = (x, y, z) => {
+    let h = 2166136261;
+    for (const v of [x, y, z]) h = Math.imul(h ^ Math.round(v * 1e3), 16777619);
+    return h >>> 0;
+  };
+
+  // src/materials.ts
+  var stainColorOf = (def) => {
+    if (def.stainColor !== void 0) return def.stainColor;
+    const r = (def.color >> 16 & 255) * 0.65;
+    const g = (def.color >> 8 & 255) * 0.65;
+    const b = (def.color & 255) * 0.65;
+    return Math.round(r) << 16 | Math.round(g) << 8 | Math.round(b);
+  };
+  var MaterialCache = class {
+    constructor(THREE, envMap) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "envMap", envMap);
+      __publicField(this, "body", /* @__PURE__ */ new Map());
+      __publicField(this, "stream", /* @__PURE__ */ new Map());
+      __publicField(this, "film", /* @__PURE__ */ new Map());
+      __publicField(this, "wet", /* @__PURE__ */ new Map());
+    }
+    make(params) {
+      const m = new this.THREE.MeshStandardMaterial({ metalness: 0, ...params });
+      if (this.envMap) m.envMap = this.envMap;
+      return m;
+    }
+    /** The volume of liquid inside a container. */
+    liquidBody(def) {
+      let m = this.body.get(def.id);
+      if (!m) {
+        m = this.make({
+          color: def.color,
+          opacity: def.opacity,
+          transparent: def.opacity < 0.999,
+          roughness: clamp(1 - def.gloss * 0.9, 0.04, 1),
+          envMapIntensity: 0.5 + def.gloss * 0.9,
+          depthWrite: def.opacity >= 0.999
+        });
+        this.body.set(def.id, m);
+      }
+      return m;
+    }
+    /** A jet or a drop in the air. */
+    liquidStream(def) {
+      let m = this.stream.get(def.id);
+      if (!m) {
+        m = this.make({
+          color: def.color,
+          opacity: clamp(def.opacity + 0.1, 0.35, 1),
+          transparent: true,
+          roughness: clamp(1 - def.gloss * 0.95, 0.03, 1),
+          envMapIntensity: 0.8 + def.gloss,
+          side: this.THREE.DoubleSide,
+          depthWrite: false
+        });
+        this.stream.set(def.id, m);
+      }
+      return m;
+    }
+    /** The thin outer film of a stain (and the permanent mark): tinted by vertex colour, soft rim by vertex alpha, mostly matte. */
+    stainFilm(def) {
+      let m = this.film.get(def.id);
+      if (!m) {
+        m = this.make({
+          color: 16777215,
+          vertexColors: true,
+          transparent: true,
+          roughness: clamp(0.95 - def.gloss * 0.45, 0.3, 1),
+          envMapIntensity: 0.4 + def.gloss * 0.4,
+          depthWrite: false,
+          polygonOffset: true,
+          polygonOffsetFactor: -2,
+          polygonOffsetUnits: -2
+        });
+        this.film.set(def.id, m);
+      }
+      return m;
+    }
+    /** The glossy wet part of a stain, which shrinks while it dries. */
+    stainWet(def) {
+      let m = this.wet.get(def.id);
+      if (!m) {
+        m = this.make({
+          color: 16777215,
+          vertexColors: true,
+          transparent: true,
+          roughness: clamp(1 - def.gloss, 0.02, 0.7),
+          envMapIntensity: 0.9 + def.gloss * 1.4,
+          depthWrite: false,
+          polygonOffset: true,
+          polygonOffsetFactor: -3,
+          polygonOffsetUnits: -3
+        });
+        this.wet.set(def.id, m);
+      }
+      return m;
+    }
+    dispose() {
+      for (const map of [this.body, this.stream, this.film, this.wet]) {
+        for (const m of map.values()) m.dispose();
+        map.clear();
+      }
+    }
+  };
+
+  // src/particles.ts
+  var VERTEX = (
+    /* glsl */
+    `
+attribute float aSize;
+attribute vec4 aColor;
+attribute float aSoft;
+uniform float uScale;
+varying vec4 vColor;
+varying float vSoft;
+void main() {
+  vColor = aColor;
+  vSoft = aSoft;
+  vec4 mv = modelViewMatrix * vec4(position, 1.0);
+  gl_PointSize = aSize * uScale / max(0.1, -mv.z);
+  gl_Position = projectionMatrix * mv;
+}
+`
+  );
+  var FRAGMENT = (
+    /* glsl */
+    `
+varying vec4 vColor;
+varying float vSoft;
+void main() {
+  float d = length(gl_PointCoord - vec2(0.5)) * 2.0;
+  if (d > 1.0 || vColor.a <= 0.001) discard;
+  float edge = mix(smoothstep(1.0, 0.8, d), 1.0 - d, vSoft);
+  gl_FragColor = vec4(vColor.rgb, vColor.a * edge);
+}
+`
+  );
+  var ParticlePool = class {
+    constructor(THREE, capacity, pointScale) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "points");
+      __publicField(this, "geometry");
+      __publicField(this, "material");
+      __publicField(this, "capacity");
+      __publicField(this, "next", 0);
+      __publicField(this, "pos");
+      __publicField(this, "size");
+      __publicField(this, "color");
+      __publicField(this, "soft");
+      __publicField(this, "vel");
+      __publicField(this, "life");
+      __publicField(this, "maxLife");
+      __publicField(this, "size0");
+      __publicField(this, "size1");
+      __publicField(this, "alpha");
+      __publicField(this, "floorY");
+      __publicField(this, "kind");
+      __publicField(this, "rgb");
+      __publicField(this, "rng", new Rng(1234567));
+      __publicField(this, "alive", 0);
+      this.capacity = capacity;
+      this.pos = new Float32Array(capacity * 3);
+      this.size = new Float32Array(capacity);
+      this.color = new Float32Array(capacity * 4);
+      this.soft = new Float32Array(capacity);
+      this.vel = new Float32Array(capacity * 3);
+      this.life = new Float32Array(capacity);
+      this.maxLife = new Float32Array(capacity);
+      this.size0 = new Float32Array(capacity);
+      this.size1 = new Float32Array(capacity);
+      this.alpha = new Float32Array(capacity);
+      this.floorY = new Float32Array(capacity);
+      this.kind = new Uint8Array(capacity);
+      this.rgb = new Float32Array(capacity * 3);
+      this.life.fill(0);
+      const T = THREE;
+      this.geometry = new T.BufferGeometry();
+      const attr = (array, n) => {
+        const a = new T.BufferAttribute(array, n);
+        a.setUsage(T.DynamicDrawUsage);
+        return a;
+      };
+      this.geometry.setAttribute("position", attr(this.pos, 3));
+      this.geometry.setAttribute("aSize", attr(this.size, 1));
+      this.geometry.setAttribute("aColor", attr(this.color, 4));
+      this.geometry.setAttribute("aSoft", attr(this.soft, 1));
+      this.material = new T.ShaderMaterial({
+        vertexShader: VERTEX,
+        fragmentShader: FRAGMENT,
+        uniforms: { uScale: { value: pointScale } },
+        transparent: true,
+        depthWrite: false
+      });
+      this.points = new T.Points(this.geometry, this.material);
+      this.points.frustumCulled = false;
+      this.points.renderOrder = 4;
+      this.points.name = "fluid_particles";
+    }
+    get count() {
+      return this.alive;
+    }
+    slot() {
+      const i = this.next;
+      this.next = (this.next + 1) % this.capacity;
+      return i;
+    }
+    setColor(i, hex) {
+      this.rgb[i * 3] = (hex >> 16 & 255) / 255;
+      this.rgb[i * 3 + 1] = (hex >> 8 & 255) / 255;
+      this.rgb[i * 3 + 2] = (hex & 255) / 255;
+    }
+    /** Droplets thrown up by an impact; `floorY` is the height they stop at. */
+    splash(point, intensity, hex, opacity, count) {
+      const rng = new Rng(hashPoint(point[0], point[1], point[2]) ^ this.next);
+      const n = Math.max(2, Math.round(count * (0.35 + 0.65 * clamp(intensity, 0, 1))));
+      for (let k = 0; k < n; k++) {
+        const i = this.slot();
+        const a = rng.next() * Math.PI * 2;
+        const h = (0.25 + rng.next() * 0.9) * (0.4 + intensity);
+        const up = (0.7 + rng.next() * 1.5) * (0.5 + intensity);
+        this.pos.set([point[0], point[1] + 0.01, point[2]], i * 3);
+        this.vel.set([Math.cos(a) * h, up, Math.sin(a) * h], i * 3);
+        this.life[i] = this.maxLife[i] = 0.45 + rng.next() * 0.45;
+        this.size0[i] = 0.012 + rng.next() * 0.014;
+        this.size1[i] = this.size0[i] * 0.7;
+        this.alpha[i] = clamp(opacity + 0.2, 0.35, 1);
+        this.soft[i] = 0;
+        this.kind[i] = 0;
+        this.floorY[i] = point[1];
+        this.setColor(i, hex);
+      }
+    }
+    /** One puff of steam rising from `point`. */
+    steam(point) {
+      const i = this.slot();
+      const r = this.rng;
+      this.pos.set([point[0] + (r.next() - 0.5) * 0.04, point[1], point[2] + (r.next() - 0.5) * 0.04], i * 3);
+      this.vel.set([(r.next() - 0.5) * 0.06, 0.22 + r.next() * 0.12, (r.next() - 0.5) * 0.06], i * 3);
+      this.life[i] = this.maxLife[i] = 1.2 + r.next() * 0.6;
+      this.size0[i] = 0.03;
+      this.size1[i] = 0.1;
+      this.alpha[i] = 0.24;
+      this.soft[i] = 1;
+      this.kind[i] = 1;
+      this.floorY[i] = -1e9;
+      this.setColor(i, 16054527);
+    }
+    update(dt, gravity) {
+      let alive = 0;
+      for (let i = 0; i < this.capacity; i++) {
+        if (this.life[i] <= 0) {
+          this.size[i] = 0;
+          this.color[i * 4 + 3] = 0;
+          continue;
+        }
+        this.life[i] -= dt;
+        const k = 1 - this.life[i] / this.maxLife[i];
+        if (this.life[i] <= 0) {
+          this.size[i] = 0;
+          this.color[i * 4 + 3] = 0;
+          continue;
+        }
+        alive++;
+        if (this.kind[i] === 0) {
+          this.vel[i * 3 + 1] -= gravity * dt;
+        } else {
+          this.vel[i * 3] += Math.sin((k + i) * 7) * 0.02 * dt;
+        }
+        this.pos[i * 3] += this.vel[i * 3] * dt;
+        this.pos[i * 3 + 1] += this.vel[i * 3 + 1] * dt;
+        this.pos[i * 3 + 2] += this.vel[i * 3 + 2] * dt;
+        if (this.kind[i] === 0 && this.pos[i * 3 + 1] < this.floorY[i]) {
+          this.life[i] = 0;
+          alive--;
+          this.size[i] = 0;
+          this.color[i * 4 + 3] = 0;
+          continue;
+        }
+        this.size[i] = this.size0[i] + (this.size1[i] - this.size0[i]) * k;
+        const fade = this.kind[i] === 1 ? Math.min(1, k * 4) * (1 - k) : 1 - k * k;
+        this.color[i * 4] = this.rgb[i * 3];
+        this.color[i * 4 + 1] = this.rgb[i * 3 + 1];
+        this.color[i * 4 + 2] = this.rgb[i * 3 + 2];
+        this.color[i * 4 + 3] = this.alpha[i] * fade;
+      }
+      this.alive = alive;
+      for (const name of ["position", "aSize", "aColor", "aSoft"]) this.geometry.getAttribute(name).needsUpdate = true;
+    }
+    clear() {
+      this.life.fill(0);
+      this.alive = 0;
+      this.update(0, 0);
+    }
+    dispose() {
+      this.geometry.dispose();
+      this.material.dispose();
+    }
+  };
+
+  // src/quality.ts
+  var PROFILES = {
+    low: { bodySegments: 10, streamSamples: 8, streamSides: 4, thinDrops: 4, stainSubdiv: 1, maxStains: 24, maxStreams: 12, maxParticles: 96, steamRate: 4, splashDroplets: 5 },
+    medium: { bodySegments: 14, streamSamples: 12, streamSides: 5, thinDrops: 6, stainSubdiv: 2, maxStains: 48, maxStreams: 24, maxParticles: 256, steamRate: 8, splashDroplets: 9 },
+    high: { bodySegments: 20, streamSamples: 20, streamSides: 8, thinDrops: 8, stainSubdiv: 4, maxStains: 96, maxStreams: 48, maxParticles: 512, steamRate: 14, splashDroplets: 14 }
+  };
+  var profileOf = (q) => PROFILES[q ?? "medium"] ?? PROFILES.medium;
+
+  // ../game-fluids/dist/index.js
+  var ballistic = (origin, velocity, gravity, t) => [
+    origin[0] + velocity[0] * t,
+    origin[1] + velocity[1] * t - 0.5 * gravity * t * t,
+    origin[2] + velocity[2] * t
+  ];
+  var sampleStream = (stream, gravity, t) => ballistic(stream.origin, stream.velocity, gravity, t);
+  var SAMPLES = 16;
+  var COS = [];
+  var SIN = [];
+  for (let i = 0; i < SAMPLES; i++) {
+    COS.push(Math.cos(i / SAMPLES * Math.PI * 2));
+    SIN.push(Math.sin(i / SAMPLES * Math.PI * 2));
+  }
+
+  // src/stains.ts
+  var smoothOutline = (front, subdiv, out) => {
+    const n = front.length;
+    const res = out ?? [];
+    res.length = n * subdiv;
+    for (let i = 0; i < n; i++) {
+      const p0 = front[(i + n - 1) % n];
+      const p1 = front[i];
+      const p2 = front[(i + 1) % n];
+      const p3 = front[(i + 2) % n];
+      for (let j = 0; j < subdiv; j++) {
+        const t = j / subdiv;
+        const r = 0.5 * (2 * p1 + (-p0 + p2) * t + (2 * p0 - 5 * p1 + 4 * p2 - p3) * t * t + (-p0 + 3 * p1 - 3 * p2 + p3) * t * t * t);
+        res[i * subdiv + j] = Math.max(4e-3, r);
+      }
+    }
+    return res;
+  };
+  var StainVisual = class {
+    constructor(THREE, profile, slot) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "slot", slot);
+      __publicField(this, "group");
+      __publicField(this, "outer");
+      __publicField(this, "inner");
+      __publicField(this, "ring");
+      __publicField(this, "radii", []);
+      __publicField(this, "tint");
+      __publicField(this, "stainId", "");
+      __publicField(this, "signature", Number.NaN);
+      __publicField(this, "triangles", 0);
+      this.ring = SAMPLES * profile.stainSubdiv;
+      this.group = new THREE.Group();
+      this.group.name = "fluid_stain";
+      this.tint = new THREE.Color();
+      this.outer = this.makeFan("fluid_stain_film", 1);
+      this.inner = this.makeFan("fluid_stain_wet", 2);
+      this.group.add(this.outer.mesh, this.inner.mesh);
+      this.group.visible = false;
+    }
+    makeFan(name, order) {
+      const T = this.THREE;
+      const count = 1 + this.ring;
+      const position = new Float32Array(count * 3);
+      const color = new Float32Array(count * 4);
+      const normal = new Float32Array(count * 3);
+      const geometry = new T.BufferGeometry();
+      const p = new T.BufferAttribute(position, 3);
+      const c = new T.BufferAttribute(color, 4);
+      p.setUsage(T.DynamicDrawUsage);
+      c.setUsage(T.DynamicDrawUsage);
+      geometry.setAttribute("position", p);
+      geometry.setAttribute("normal", new T.BufferAttribute(normal, 3));
+      geometry.setAttribute("color", c);
+      const index = [];
+      for (let i = 0; i < this.ring; i++) index.push(0, 1 + i, 1 + (i + 1) % this.ring);
+      geometry.setIndex(index);
+      const mesh = new T.Mesh(geometry);
+      mesh.name = name;
+      mesh.frustumCulled = false;
+      mesh.renderOrder = order;
+      return { mesh, position, color };
+    }
+    assign(def, materials) {
+      this.outer.mesh.material = materials.stainFilm(def);
+      this.inner.mesh.material = materials.stainWet(def);
+    }
+    hide() {
+      this.group.visible = false;
+      this.stainId = "";
+      this.signature = Number.NaN;
+      this.triangles = 0;
+    }
+    /** Rebuild the vertices from the stain state (skipped when nothing changed). */
+    update(stain, def, profile) {
+      const sig = stain.center[0] * 3 + stain.center[1] * 5 + stain.center[2] * 7 + stain.front.reduce((s, v, i) => s + v * (i + 1), 0) * 11 + stain.wetness * 13 + stain.wetRadius * 17 + stain.soaked / (stain.soaked + stain.liters + 1e-6) * 19;
+      if (sig === this.signature && this.group.visible) return;
+      this.signature = sig;
+      const n = stain.normal ?? [0, 1, 0];
+      const t1 = stain.tangent ?? [1, 0, 0];
+      const t2 = [n[1] * t1[2] - n[2] * t1[1], n[2] * t1[0] - n[0] * t1[2], n[0] * t1[1] - n[1] * t1[0]];
+      smoothOutline(stain.front, profile.stainSubdiv, this.radii);
+      const ring = this.ring;
+      const lift = 15e-4 + 4e-4 * (this.slot % 6);
+      const mean = stain.front.reduce((s, v) => s + v, 0) / stain.front.length;
+      const wet = clamp(stain.wetness, 0, 1);
+      const soakRatio = stain.soaked / (stain.soaked + stain.liters + 1e-6);
+      this.tint.setHex(stainColorOf(def));
+      const dark = 1 - 0.3 * wet - 0.2 * soakRatio;
+      const markAlpha = def.leavesMark ? 0.34 : 0.1;
+      const aMid = (markAlpha + (0.62 - markAlpha) * wet) * (0.75 + 0.25 * Math.min(1, stain.liters * 20 + soakRatio));
+      this.writeFan(this.outer, stain.center, n, t1, t2, lift, 1, this.tint.r * dark, this.tint.g * dark, this.tint.b * dark, aMid, aMid * 0.45);
+      this.outer.mesh.visible = true;
+      const wr = clamp(stain.wetRadius, 0, 1);
+      const showInner = wr > 0.05 && wet > 0.03;
+      this.inner.mesh.visible = showInner;
+      if (showInner) {
+        this.tint.setHex(def.color);
+        const shift = stain.flow ? -mean * 0.1 * (1 - wr) : 0;
+        const centre = stain.flow ? [stain.center[0] + stain.flow[0] * shift, stain.center[1] + stain.flow[1] * shift, stain.center[2] + stain.flow[2] * shift] : stain.center;
+        const a = clamp(def.opacity, 0.2, 0.85) * wet * 0.8;
+        this.writeFan(this.inner, centre, n, t1, t2, lift + 7e-4, 0.9 * wr, this.tint.r, this.tint.g, this.tint.b, a, a * 0.5);
+      }
+      this.triangles = ring * (showInner ? 2 : 1);
+      this.group.visible = true;
+    }
+    writeFan(fan, center, n, t1, t2, lift, scale, r, g, b, aCentre, aRim) {
+      const ring = this.ring;
+      const px = center[0] + n[0] * lift;
+      const py = center[1] + n[1] * lift;
+      const pz = center[2] + n[2] * lift;
+      fan.position[0] = px;
+      fan.position[1] = py;
+      fan.position[2] = pz;
+      fan.color[0] = r * 0.85;
+      fan.color[1] = g * 0.85;
+      fan.color[2] = b * 0.85;
+      fan.color[3] = aCentre;
+      const normalAttr = fan.mesh.geometry.getAttribute("normal");
+      for (let i = 0; i <= ring; i++) {
+        normalAttr.setXYZ(i, n[0], n[1], n[2]);
+      }
+      normalAttr.needsUpdate = true;
+      for (let i = 0; i < ring; i++) {
+        const a = i / ring * Math.PI * 2;
+        const c = Math.cos(a) * this.radii[i] * scale;
+        const s = Math.sin(a) * this.radii[i] * scale;
+        const o = (1 + i) * 3;
+        fan.position[o] = px + t1[0] * c + t2[0] * s;
+        fan.position[o + 1] = py + t1[1] * c + t2[1] * s;
+        fan.position[o + 2] = pz + t1[2] * c + t2[2] * s;
+        const k = (1 + i) * 4;
+        fan.color[k] = r;
+        fan.color[k + 1] = g;
+        fan.color[k + 2] = b;
+        fan.color[k + 3] = aRim;
+      }
+      const geometry = fan.mesh.geometry;
+      geometry.getAttribute("position").needsUpdate = true;
+      geometry.getAttribute("color").needsUpdate = true;
+    }
+    dispose() {
+      for (const fan of [this.outer, this.inner]) fan.mesh.geometry.dispose();
+    }
+  };
+
+  // src/streams.ts
+  var GHOST_TIME = 0.4;
+  var StreamVisual = class {
+    constructor(THREE, profile, dropGeometry) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "tube");
+      __publicField(this, "drops");
+      __publicField(this, "positions");
+      __publicField(this, "normals");
+      __publicField(this, "samples");
+      __publicField(this, "sides");
+      __publicField(this, "matrix");
+      __publicField(this, "maxDrops");
+      __publicField(this, "id", "");
+      __publicField(this, "age", 0);
+      __publicField(this, "ghostAge", -1);
+      /** Last known state, kept while the stream breaks into drops. */
+      __publicField(this, "state", null);
+      __publicField(this, "triangles", 0);
+      const T = THREE;
+      this.samples = profile.streamSamples;
+      this.sides = profile.streamSides;
+      this.maxDrops = Math.max(profile.thinDrops, 2) + 2;
+      this.positions = new Float32Array(this.samples * this.sides * 3);
+      this.normals = new Float32Array(this.samples * this.sides * 3);
+      const geometry = new T.BufferGeometry();
+      const p = new T.BufferAttribute(this.positions, 3);
+      const n = new T.BufferAttribute(this.normals, 3);
+      p.setUsage(T.DynamicDrawUsage);
+      n.setUsage(T.DynamicDrawUsage);
+      geometry.setAttribute("position", p);
+      geometry.setAttribute("normal", n);
+      const index = [];
+      for (let i = 0; i < this.samples - 1; i++) {
+        for (let j = 0; j < this.sides; j++) {
+          const a = i * this.sides + j;
+          const b = i * this.sides + (j + 1) % this.sides;
+          const c = (i + 1) * this.sides + j;
+          const d = (i + 1) * this.sides + (j + 1) % this.sides;
+          index.push(a, c, b, b, c, d);
+        }
+      }
+      geometry.setIndex(index);
+      this.tube = new T.Mesh(geometry);
+      this.tube.name = "fluid_stream";
+      this.tube.frustumCulled = false;
+      this.tube.renderOrder = 2;
+      this.drops = new T.InstancedMesh(dropGeometry, void 0, this.maxDrops);
+      this.drops.name = "fluid_stream_drops";
+      this.drops.frustumCulled = false;
+      this.drops.renderOrder = 2;
+      this.drops.instanceMatrix.setUsage(T.DynamicDrawUsage);
+      this.drops.count = 0;
+      this.matrix = new T.Matrix4();
+    }
+    setMaterial(material) {
+      this.tube.material = material;
+      this.drops.material = material;
+    }
+    hide() {
+      this.tube.visible = false;
+      this.drops.visible = false;
+      this.drops.count = 0;
+      this.triangles = 0;
+    }
+    dropAt(slot, x, y, z, radius) {
+      this.matrix.makeScale(radius, radius, radius).setPosition(x, y, z);
+      this.drops.setMatrixAt(slot, this.matrix);
+    }
+    /**
+     * Draw the stream. `state` is the world's stream while it lives, or the last known one while ghost (`ghostAge >= 0`).
+     */
+    update(state, gravity, dt, profile, time) {
+      this.state = state;
+      this.age += dt;
+      if (this.ghostAge >= 0) this.ghostAge += dt;
+      const flight = Math.max(0.02, state.flightTime ?? 1);
+      const [vx, vy, vz] = state.velocity;
+      const speed0 = Math.max(0.3, Math.hypot(vx, vy, vz));
+      const q = Math.max(state.rate, 0) / 1e3;
+      const r0 = clamp(Math.sqrt(q / (Math.PI * speed0)), 15e-4, 0.03);
+      const tB = Math.min(flight, this.age);
+      const tA = this.ghostAge >= 0 ? Math.min(flight, this.ghostAge) : 0;
+      let drops = 0;
+      const thin = state.thin && this.ghostAge < 0;
+      if (thin) {
+        this.tube.visible = false;
+        this.triangles = 0;
+        const n = profile.thinDrops;
+        const phase = time * 1.3;
+        for (let k = 0; k < n && drops < this.maxDrops; k++) {
+          const tau = (phase + k / n) % 1 * flight;
+          if (tau > tB) continue;
+          const p = sampleStream(state, gravity, tau);
+          const grow = Math.min(1, tau / (0.12 * flight + 0.02));
+          this.dropAt(drops++, p[0], p[1], p[2], Math.max(2e-3, r0 * 1.8) * (0.4 + 0.6 * grow));
+        }
+      } else if (tB - tA > 0.015) {
+        this.writeTube(state, gravity, tA, tB, r0, speed0);
+        this.tube.visible = true;
+        this.triangles = (this.samples - 1) * this.sides * 2;
+        if (tB < flight) {
+          const p = sampleStream(state, gravity, tB);
+          const w = this.radiusAt(state, gravity, tB, r0, speed0);
+          this.dropAt(drops++, p[0], p[1], p[2], w * 1.35);
+        }
+        if (this.ghostAge >= 0) {
+          const p = sampleStream(state, gravity, tA);
+          const w = this.radiusAt(state, gravity, tA, r0, speed0);
+          this.dropAt(drops++, p[0], p[1], p[2], w * 1.4 * (1 - this.ghostAge / GHOST_TIME * 0.4));
+        }
+      } else {
+        this.tube.visible = false;
+        this.triangles = 0;
+        if (tA < flight) {
+          const p = sampleStream(state, gravity, this.ghostAge >= 0 ? tA : tB);
+          this.dropAt(drops++, p[0], p[1], p[2], Math.max(3e-3, r0 * 1.3));
+        }
+      }
+      this.drops.count = drops;
+      this.drops.visible = drops > 0;
+      this.drops.instanceMatrix.needsUpdate = true;
+      this.triangles += drops * 24;
+    }
+    /** The ghost is over once its tail reached the landing. */
+    get finished() {
+      return this.ghostAge >= 0 && (this.ghostAge >= GHOST_TIME || this.ghostAge >= (this.state?.flightTime ?? 0));
+    }
+    radiusAt(state, gravity, t, r0, speed0) {
+      const vy = state.velocity[1] - gravity * t;
+      const speed = Math.max(0.3, Math.hypot(state.velocity[0], vy, state.velocity[2]));
+      const fade = this.ghostAge >= 0 ? clamp(1 - this.ghostAge / GHOST_TIME, 0.15, 1) : 1;
+      return r0 * Math.sqrt(speed0 / speed) * fade;
+    }
+    writeTube(state, gravity, tA, tB, r0, speed0) {
+      const n = this.samples;
+      const sides = this.sides;
+      for (let i = 0; i < n; i++) {
+        const k = i / (n - 1);
+        const t = tA + (tB - tA) * k;
+        const p = sampleStream(state, gravity, t);
+        const vx = state.velocity[0];
+        const vy = state.velocity[1] - gravity * t;
+        const vz = state.velocity[2];
+        const l = Math.hypot(vx, vy, vz) || 1;
+        const tx = vx / l;
+        const ty = vy / l;
+        const tz = vz / l;
+        const ax = Math.abs(tz) < 0.9 ? 0 : 1;
+        const az = Math.abs(tz) < 0.9 ? 1 : 0;
+        let b1x = ty * az - tz * 0;
+        let b1y = tz * ax - tx * az;
+        let b1z = tx * 0 - ty * ax;
+        const bl = Math.hypot(b1x, b1y, b1z) || 1;
+        b1x /= bl;
+        b1y /= bl;
+        b1z /= bl;
+        const b2x = ty * b1z - tz * b1y;
+        const b2y = tz * b1x - tx * b1z;
+        const b2z = tx * b1y - ty * b1x;
+        const end = Math.min(1, 0.35 + Math.min(k, 1 - k) * 8);
+        const r = this.radiusAt(state, gravity, t, r0, speed0) * end;
+        for (let j = 0; j < sides; j++) {
+          const a = j / sides * Math.PI * 2;
+          const c = Math.cos(a);
+          const s = Math.sin(a);
+          const nx = b1x * c + b2x * s;
+          const ny = b1y * c + b2y * s;
+          const nz = b1z * c + b2z * s;
+          const o = (i * sides + j) * 3;
+          this.positions[o] = p[0] + nx * r;
+          this.positions[o + 1] = p[1] + ny * r;
+          this.positions[o + 2] = p[2] + nz * r;
+          this.normals[o] = nx;
+          this.normals[o + 1] = ny;
+          this.normals[o + 2] = nz;
+        }
+      }
+      const g = this.tube.geometry;
+      g.getAttribute("position").needsUpdate = true;
+      g.getAttribute("normal").needsUpdate = true;
+    }
+    start(id) {
+      this.id = id;
+      this.age = 0;
+      this.ghostAge = -1;
+      this.state = null;
+    }
+    dispose() {
+      this.tube.geometry.dispose();
+      this.drops.dispose();
+    }
+  };
+
+  // src/renderer.ts
+  function createFluidRenderer(THREE, options) {
+    const { scene, fluids } = options;
+    const quality = options.quality ?? "medium";
+    const profile = profileOf(quality);
+    const materials = new MaterialCache(THREE, options.envMap ?? null);
+    const root = new THREE.Group();
+    root.name = "fluid_renderer";
+    scene.add(root);
+    const particles = new ParticlePool(THREE, profile.maxParticles, options.pointScale ?? 600);
+    root.add(particles.points);
+    const dropGeometry = new THREE.SphereGeometry(1, 8, 6);
+    const bodies = /* @__PURE__ */ new Map();
+    const streamsActive = /* @__PURE__ */ new Map();
+    const streamsFree = [];
+    let streamsCreated = 0;
+    const stainsActive = /* @__PURE__ */ new Map();
+    const stainsFree = [];
+    let stainsCreated = 0;
+    let time = 0;
+    let disposed = false;
+    const offSplash = fluids.on("splash", (e) => {
+      if (e.type !== "splash" || disposed) return;
+      const def = fluids.liquids.get(e.liquid);
+      if (!def) return;
+      particles.splash(e.point, e.intensity, def.color, def.opacity, profile.splashDroplets);
+    });
+    const acquireStream = (id) => {
+      let v = streamsFree.pop() ?? null;
+      if (!v) {
+        if (streamsCreated >= profile.maxStreams) return null;
+        streamsCreated++;
+        v = new StreamVisual(THREE, profile, dropGeometry);
+        root.add(v.tube, v.drops);
+      }
+      v.start(id);
+      return v;
+    };
+    const releaseStream = (v) => {
+      v.hide();
+      streamsActive.delete(v.id);
+      streamsFree.push(v);
+    };
+    const syncStreams = (dt) => {
+      const live = fluids.streams();
+      const seen = /* @__PURE__ */ new Set();
+      live.sort((a, b) => b.rate - a.rate);
+      for (const s of live) {
+        seen.add(s.id);
+        let v = streamsActive.get(s.id);
+        if (!v) {
+          const fresh = acquireStream(s.id);
+          if (!fresh) continue;
+          v = fresh;
+          streamsActive.set(s.id, v);
+        }
+        const def = fluids.liquids.get(s.liquid);
+        if (!def) continue;
+        v.ghostAge = -1;
+        v.setMaterial(materials.liquidStream(def));
+        v.update(s, fluids.gravity, dt, profile, time);
+      }
+      for (const v of [...streamsActive.values()]) {
+        if (seen.has(v.id)) continue;
+        if (v.ghostAge < 0) v.ghostAge = 0;
+        if (!v.state || v.finished) {
+          releaseStream(v);
+          continue;
+        }
+        v.update(v.state, fluids.gravity, dt, profile, time);
+        if (v.finished) releaseStream(v);
+      }
+    };
+    const syncStains = () => {
+      const all = fluids.stains();
+      const wanted = all.length > profile.maxStains ? [...all].sort((a, b) => (a.age ?? 0) - (b.age ?? 0)).slice(0, profile.maxStains) : all;
+      const ids = new Set(wanted.map((s) => s.id));
+      for (const [id, v] of [...stainsActive]) {
+        if (ids.has(id)) continue;
+        v.hide();
+        stainsActive.delete(id);
+        stainsFree.push(v);
+      }
+      for (const s of wanted) {
+        const def = fluids.liquids.get(s.liquid);
+        if (!def) continue;
+        let v = stainsActive.get(s.id);
+        if (!v) {
+          v = stainsFree.pop();
+          if (!v) {
+            if (stainsCreated >= profile.maxStains) continue;
+            v = new StainVisual(THREE, profile, stainsCreated++);
+            root.add(v.group);
+          }
+          v.stainId = s.id;
+          v.signature = Number.NaN;
+          v.assign(def, materials);
+          stainsActive.set(s.id, v);
+        }
+        v.update(s, def, profile);
+      }
+    };
+    const renderer = {
+      bindContainer(containerId, object, opts = {}) {
+        renderer.unbindContainer(containerId);
+        bodies.set(containerId, new LiquidBody(THREE, containerId, object, opts.innerOffset ?? [0, 0, 0]));
+      },
+      unbindContainer(containerId) {
+        const body = bodies.get(containerId);
+        if (!body) return;
+        body.dispose();
+        bodies.delete(containerId);
+      },
+      update(dt) {
+        if (disposed) return;
+        time += dt;
+        for (const body of bodies.values()) body.update(dt, fluids, materials, profile, particles);
+        syncStreams(dt);
+        syncStains();
+        particles.update(dt, fluids.gravity);
+      },
+      clear() {
+        for (const v of [...streamsActive.values()]) releaseStream(v);
+        for (const [id, v] of [...stainsActive]) {
+          v.hide();
+          stainsActive.delete(id);
+          stainsFree.push(v);
+        }
+        particles.clear();
+      },
+      dispose() {
+        if (disposed) return;
+        disposed = true;
+        offSplash();
+        for (const body of bodies.values()) body.dispose();
+        bodies.clear();
+        for (const v of [...streamsActive.values(), ...streamsFree]) v.dispose();
+        for (const v of [...stainsActive.values(), ...stainsFree]) v.dispose();
+        streamsActive.clear();
+        stainsActive.clear();
+        streamsFree.length = 0;
+        stainsFree.length = 0;
+        particles.dispose();
+        dropGeometry.dispose();
+        materials.dispose();
+        scene.remove(root);
+        root.clear();
+      },
+      stats() {
+        let triangles = 0;
+        let containers = 0;
+        for (const body of bodies.values()) {
+          triangles += body.triangles;
+          if (body.visible) containers++;
+        }
+        for (const v of streamsActive.values()) triangles += v.triangles;
+        for (const v of stainsActive.values()) triangles += v.triangles;
+        return {
+          quality,
+          containers,
+          streams: streamsActive.size,
+          stains: stainsActive.size,
+          particles: particles.count,
+          triangles,
+          budget: { stains: profile.maxStains, streams: profile.maxStreams, particles: profile.maxParticles }
+        };
+      }
+    };
+    return renderer;
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map