@codexo/exojs-particles 0.15.3 → 0.16.0

package/dist/esm/modules/VelocityOverLifetime.js

@@ -1,63 +1,60 @@
-import { UpdateModule } from './UpdateModule.js';
+import { UpdateModule } from "./UpdateModule.js";
 
-/// <reference types="@webgpu/types" />
+//#region src/modules/VelocityOverLifetime.ts
 const lookupSize = 256;
 /**
- * Multiplies every live particle's velocity by a curve sampled at the
- * particle's current `elapsed / lifetime` ratio. The same scalar is applied
- * to both axes — the direction is preserved, only the magnitude scales.
- *
- * Common patterns:
- * - **Snappy spawn, slow drift:** `[0,1]→[1,0.1]` — fast initial motion
- *   that decays over lifetime.
- * - **Late acceleration:** `[0,0.2]→[1,1]` — particles ease in.
- * - **Pulse:** sine-shaped curve for breathing-style motion.
- *
- * Note: the curve **replaces** velocity each frame relative to the previous
- * frame's velocity, so the effect is multiplicative. Pair with `ApplyForce`
- * if you want a constant external acceleration on top.
- *
- * GPU-eligible: uploads the curve as a 256-tap 1D R32F texture; sampled
- * once per particle per frame.
- */
-class VelocityOverLifetime extends UpdateModule {
-    curve;
-    _prevSample = new Float32Array(0);
-    constructor(curve) {
-        super();
-        this.curve = curve;
-    }
-    apply(system, _dt) {
-        const { velX, velY, elapsed, lifetime, liveCount } = system;
-        const curve = this.curve;
-        // Resize per-particle previous-sample cache once.
-        if (this._prevSample.length < system.capacity) {
-            this._prevSample = new Float32Array(system.capacity);
-            this._prevSample.fill(1);
-        }
-        const prev = this._prevSample;
-        for (let i = 0; i < liveCount; i++) {
-            const t = (elapsed[i] ?? 0) / (lifetime[i] ?? 1);
-            const sample = curve.evaluate(t);
-            const prevSample = prev[i] ?? 1;
-            const last = prevSample === 0 ? 1 : prevSample;
-            const delta = sample / last;
-            velX[i] = (velX[i] ?? 0) * delta;
-            velY[i] = (velY[i] ?? 0) * delta;
-            prev[i] = sample === 0 ? 1e-6 : sample;
-        }
-    }
-    wgsl() {
-        // GPU path uses a different formulation: re-derive velocity from
-        // initial speed at t=0 by storing nothing — instead, scale relative
-        // to the previous sample stored in scales[idx] alpha? No — keep it
-        // simple and stateless: scale the integrated velocity by the
-        // *ratio* of (current sample) / (sample at previous frame's t).
-        // We approximate the previous t with `(elapsed - dt) / lifetime`.
-        return {
-            key: 'VelocityOverLifetime',
-            textures: [{ name: 'curve', format: 'r32float' }],
-            body: `
+* Multiplies every live particle's velocity by a curve sampled at the
+* particle's current `elapsed / lifetime` ratio. The same scalar is applied
+* to both axes - the direction is preserved, only the magnitude scales.
+*
+* Common patterns:
+* - **Snappy spawn, slow drift:** `[0,1]→[1,0.1]` - fast initial motion
+*   that decays over lifetime.
+* - **Late acceleration:** `[0,0.2]→[1,1]` - particles ease in.
+* - **Pulse:** sine-shaped curve for breathing-style motion.
+*
+* Note: the curve **replaces** velocity each frame relative to the previous
+* frame's velocity, so the effect is multiplicative. Pair with `ApplyForce`
+* if you want a constant external acceleration on top.
+*
+* GPU-eligible: uploads the curve as a 256-tap 1D R32F texture; sampled
+* once per particle per frame.
+*/
+var VelocityOverLifetime = class extends UpdateModule {
+	curve;
+	_prevSample = /* @__PURE__ */ new Float32Array(0);
+	constructor(curve) {
+		super();
+		this.curve = curve;
+	}
+	apply(particles, _dt) {
+		const { x: velX, y: velY } = particles.velocity;
+		const { elapsed, lifetime } = particles.timing;
+		const liveCount = particles.count;
+		const curve = this.curve;
+		if (this._prevSample.length < particles.capacity) {
+			this._prevSample = new Float32Array(particles.capacity);
+			this._prevSample.fill(1);
+		}
+		const prev = this._prevSample;
+		for (let i = 0; i < liveCount; i++) {
+			const t = (elapsed[i] ?? 0) / (lifetime[i] ?? 1);
+			const sample = curve.evaluate(t);
+			const prevSample = prev[i] ?? 1;
+			const delta = sample / (prevSample === 0 ? 1 : prevSample);
+			velX[i] = (velX[i] ?? 0) * delta;
+			velY[i] = (velY[i] ?? 0) * delta;
+			prev[i] = sample === 0 ? 1e-6 : sample;
+		}
+	}
+	wgsl() {
+		return {
+			key: "VelocityOverLifetime",
+			textures: [{
+				name: "curve",
+				format: "r32float"
+			}],
+			body: `
                 let velLifetime = max(timing[idx].y, 0.000001);
                 let velTNow = clamp(timing[idx].x / velLifetime, 0.0, 1.0);
                 let velTPrev = clamp((timing[idx].x - dt) / velLifetime, 0.0, 1.0);
@@ -65,21 +62,26 @@ class VelocityOverLifetime extends UpdateModule {
                 let velSamplePrev = textureSampleLevel(u_VelocityOverLifetime_curve, u_VelocityOverLifetime_curve_sampler, velTPrev, 0.0).r;
                 let velRatio = velSampleNow / max(velSamplePrev, 0.000001);
                 velocities[idx] = velocities[idx] * velRatio;
-            `,
-        };
-    }
-    uploadTextures(device, textures) {
-        const texture = textures.get('curve');
-        if (texture === undefined) {
-            return;
-        }
-        const data = new Float32Array(lookupSize);
-        for (let i = 0; i < lookupSize; i++) {
-            data[i] = this.curve.evaluate(i / (lookupSize - 1));
-        }
-        device.queue.writeTexture({ texture }, data.buffer, { offset: 0, bytesPerRow: lookupSize * 4, rowsPerImage: 1 }, { width: lookupSize, height: 1, depthOrArrayLayers: 1 });
-    }
-}
+            `
+		};
+	}
+	uploadTextures(device, textures) {
+		const texture = textures.get("curve");
+		if (texture === void 0) return;
+		const data = new Float32Array(lookupSize);
+		for (let i = 0; i < lookupSize; i++) data[i] = this.curve.evaluate(i / 255);
+		device.queue.writeTexture({ texture }, data.buffer, {
+			offset: 0,
+			bytesPerRow: lookupSize * 4,
+			rowsPerImage: 1
+		}, {
+			width: lookupSize,
+			height: 1,
+			depthOrArrayLayers: 1
+		});
+	}
+};
 
+//#endregion
 export { VelocityOverLifetime };
-//# sourceMappingURL=VelocityOverLifetime.js.map
+//# sourceMappingURL=VelocityOverLifetime.js.map

package/dist/esm/modules/VelocityOverLifetime.js.map

@@ -1 +1 @@
-{"version":3,"file":"VelocityOverLifetime.js","sources":["../../../../src/modules/VelocityOverLifetime.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"VelocityOverLifetime.js","names":[],"sources":["../../../src/modules/VelocityOverLifetime.ts"],"sourcesContent":["/// <reference types=\"@webgpu/types\" />\n\nimport type { Curve } from '#distributions/Curve';\nimport type { ParticleBatch } from '#ParticleStorage';\n\nimport { UpdateModule } from './UpdateModule';\nimport type { WgslContribution } from './WgslContribution';\n\nconst lookupSize = 256;\n\n/**\n * Multiplies every live particle's velocity by a curve sampled at the\n * particle's current `elapsed / lifetime` ratio. The same scalar is applied\n * to both axes - the direction is preserved, only the magnitude scales.\n *\n * Common patterns:\n * - **Snappy spawn, slow drift:** `[0,1]→[1,0.1]` - fast initial motion\n *   that decays over lifetime.\n * - **Late acceleration:** `[0,0.2]→[1,1]` - particles ease in.\n * - **Pulse:** sine-shaped curve for breathing-style motion.\n *\n * Note: the curve **replaces** velocity each frame relative to the previous\n * frame's velocity, so the effect is multiplicative. Pair with `ApplyForce`\n * if you want a constant external acceleration on top.\n *\n * GPU-eligible: uploads the curve as a 256-tap 1D R32F texture; sampled\n * once per particle per frame.\n */\nexport class VelocityOverLifetime extends UpdateModule {\n  public curve: Curve;\n\n  private _prevSample = new Float32Array(0);\n\n  public constructor(curve: Curve) {\n    super();\n    this.curve = curve;\n  }\n\n  public override apply(particles: ParticleBatch, _dt: number): void {\n    const { x: velX, y: velY } = particles.velocity;\n    const { elapsed, lifetime } = particles.timing;\n    const liveCount = particles.count;\n    const curve = this.curve;\n\n    // Resize per-particle previous-sample cache once.\n    if (this._prevSample.length < particles.capacity) {\n      this._prevSample = new Float32Array(particles.capacity);\n      this._prevSample.fill(1);\n    }\n\n    const prev = this._prevSample;\n\n    for (let i = 0; i < liveCount; i++) {\n      const t = (elapsed[i] ?? 0) / (lifetime[i] ?? 1);\n      const sample = curve.evaluate(t);\n      const prevSample = prev[i] ?? 1;\n      const last = prevSample === 0 ? 1 : prevSample;\n      const delta = sample / last;\n\n      velX[i] = (velX[i] ?? 0) * delta;\n      velY[i] = (velY[i] ?? 0) * delta;\n      prev[i] = sample === 0 ? 1e-6 : sample;\n    }\n  }\n\n  public override wgsl(): WgslContribution {\n    // GPU path uses a different formulation: re-derive velocity from\n    // initial speed at t=0 by storing nothing - instead, scale relative\n    // to the previous sample stored in scales[idx] alpha? No - keep it\n    // simple and stateless: scale the integrated velocity by the\n    // *ratio* of (current sample) / (sample at previous frame's t).\n    // We approximate the previous t with `(elapsed - dt) / lifetime`.\n    return {\n      key: 'VelocityOverLifetime',\n      textures: [{ name: 'curve', format: 'r32float' }],\n      body: `\n                let velLifetime = max(timing[idx].y, 0.000001);\n                let velTNow = clamp(timing[idx].x / velLifetime, 0.0, 1.0);\n                let velTPrev = clamp((timing[idx].x - dt) / velLifetime, 0.0, 1.0);\n                let velSampleNow = textureSampleLevel(u_VelocityOverLifetime_curve, u_VelocityOverLifetime_curve_sampler, velTNow, 0.0).r;\n                let velSamplePrev = textureSampleLevel(u_VelocityOverLifetime_curve, u_VelocityOverLifetime_curve_sampler, velTPrev, 0.0).r;\n                let velRatio = velSampleNow / max(velSamplePrev, 0.000001);\n                velocities[idx] = velocities[idx] * velRatio;\n            `,\n    };\n  }\n\n  public override uploadTextures(device: GPUDevice, textures: ReadonlyMap<string, GPUTexture>): void {\n    const texture = textures.get('curve');\n\n    if (texture === undefined) {\n      return;\n    }\n\n    const data = new Float32Array(lookupSize);\n\n    for (let i = 0; i < lookupSize; i++) {\n      data[i] = this.curve.evaluate(i / (lookupSize - 1));\n    }\n\n    device.queue.writeTexture(\n      { texture },\n      data.buffer,\n      { offset: 0, bytesPerRow: lookupSize * 4, rowsPerImage: 1 },\n      { width: lookupSize, height: 1, depthOrArrayLayers: 1 },\n    );\n  }\n}\n"],"mappings":";;;AAQA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;AAoBnB,IAAa,uBAAb,cAA0C,aAAa;CACrD,AAAO;CAEP,AAAQ,8BAAc,IAAI,aAAa,CAAC;CAExC,AAAO,YAAY,OAAc;EAC/B,MAAM;EACN,KAAK,QAAQ;CACf;CAEA,AAAgB,MAAM,WAA0B,KAAmB;EACjE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,UAAU;EACvC,MAAM,EAAE,SAAS,aAAa,UAAU;EACxC,MAAM,YAAY,UAAU;EAC5B,MAAM,QAAQ,KAAK;EAGnB,IAAI,KAAK,YAAY,SAAS,UAAU,UAAU;GAChD,KAAK,cAAc,IAAI,aAAa,UAAU,QAAQ;GACtD,KAAK,YAAY,KAAK,CAAC;EACzB;EAEA,MAAM,OAAO,KAAK;EAElB,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAAK;GAClC,MAAM,KAAK,QAAQ,MAAM,MAAM,SAAS,MAAM;GAC9C,MAAM,SAAS,MAAM,SAAS,CAAC;GAC/B,MAAM,aAAa,KAAK,MAAM;GAE9B,MAAM,QAAQ,UADD,eAAe,IAAI,IAAI;GAGpC,KAAK,MAAM,KAAK,MAAM,KAAK;GAC3B,KAAK,MAAM,KAAK,MAAM,KAAK;GAC3B,KAAK,KAAK,WAAW,IAAI,OAAO;EAClC;CACF;CAEA,AAAgB,OAAyB;EAOvC,OAAO;GACL,KAAK;GACL,UAAU,CAAC;IAAE,MAAM;IAAS,QAAQ;GAAW,CAAC;GAChD,MAAM;;;;;;;;;EASR;CACF;CAEA,AAAgB,eAAe,QAAmB,UAAiD;EACjG,MAAM,UAAU,SAAS,IAAI,OAAO;EAEpC,IAAI,YAAY,QACd;EAGF,MAAM,OAAO,IAAI,aAAa,UAAU;EAExC,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,KAC9B,KAAK,KAAK,KAAK,MAAM,SAAS,IAAK,GAAe;EAGpD,OAAO,MAAM,aACX,EAAE,QAAQ,GACV,KAAK,QACL;GAAE,QAAQ;GAAG,aAAa,aAAa;GAAG,cAAc;EAAE,GAC1D;GAAE,OAAO;GAAY,QAAQ;GAAG,oBAAoB;EAAE,CACxD;CACF;AACF"}

package/dist/esm/modules/WgslContribution.d.ts

@@ -12,14 +12,14 @@
  * more types here as new modules require them.
  */
 export type WgslPrimitive = 'f32' | 'i32' | 'u32' | 'vec2<f32>' | 'vec4<f32>';
-/** A named uniform field within a module's struct. Order matters — defines memory layout. */
+/** A named uniform field within a module's struct. Order matters - defines memory layout. */
 export interface WgslUniformField {
     name: string;
     type: WgslPrimitive;
 }
 /** A 1D texture binding (used by Curve / ColorGradient lookups). */
 export interface WgslTextureBinding {
-    /** Field name within the module — referenced in WGSL as `u_${moduleKey}_${name}`. */
+    /** Field name within the module - referenced in WGSL as `u_${moduleKey}_${name}`. */
     name: string;
     /** WGSL texture format. `r32float` for Curve, `rgba8unorm` for ColorGradient. */
     format: 'r32float' | 'rgba8unorm';
@@ -29,29 +29,29 @@ export interface WgslTextureBinding {
  * shader. `body` runs once per particle in the inner main function, with
  * these locals in scope:
  *
- * - `idx: u32` — the particle slot index (already gated on `< sim.liveCount`
+ * - `idx: u32` - the particle slot index (already gated on `< sim.liveCount`
  *   and skip-on-dead via `timing[idx].y < 0.0`).
- * - `dt: f32` — frame delta in seconds (mirrors `sim.dt`).
- * - **Packed SoA bindings** (see body of doc) — channels are packed into
+ * - `dt: f32` - frame delta in seconds (mirrors `sim.dt`).
+ * - **Packed SoA bindings** (see body of doc) - channels are packed into
  *   `vec2<f32>`-typed storage buffers to fit within WebGPU's default 8-buffer
  *   limit. Access x/y components for the per-axis values:
  *   - `positions[idx].x` / `.y` (was posX/posY)
  *   - `velocities[idx].x` / `.y` (was velX/velY)
  *   - `scales[idx].x` / `.y` (was scaleX/scaleY)
  *   - `rotInfo[idx].x` / `.y` (rotation, rotationSpeed)
- *   - `timing[idx].x` / `.y` (elapsed, lifetime — y is set to -1 when expired)
- *   - `color[idx]` — packed RGBA u32, single channel (no .x/.y)
- * - `sim: SimUniforms` — `{ dt: f32, liveCount: u32 }`.
- * - `modules.u_${key}: ${Key}Uniforms` — your module's uniform struct (if declared).
- * - `u_${key}_${textureName}` and `u_${key}_${textureName}_sampler` — texture bindings (if any).
+ *   - `timing[idx].x` / `.y` (elapsed, lifetime - y is set to -1 when expired)
+ *   - `color[idx]` - packed RGBA u32, single channel (no .x/.y)
+ * - `sim: SimUniforms` - `{ dt: f32, liveCount: u32 }`.
+ * - `modules.u_${key}: ${Key}Uniforms` - your module's uniform struct (if declared).
+ * - `u_${key}_${textureName}` and `u_${key}_${textureName}_sampler` - texture bindings (if any).
  *
  * The body should not declare new functions or top-level statements; it
  * runs inline in the main function. Use comments and parentheses generously
- * — composition concatenates several module bodies and any syntax mistake
+ * - composition concatenates several module bodies and any syntax mistake
  * surfaces only at pipeline-creation time.
  */
 export interface WgslContribution {
-    /** Unique key per module *class* (e.g. `'ApplyForce'`). Two ApplyForce instances on one system aren't supported — combine into one. */
+    /** Unique key per module *class* (e.g. `'ApplyForce'`). Two ApplyForce instances on one system aren't supported - combine into one. */
     key: string;
     uniforms?: readonly WgslUniformField[];
     textures?: readonly WgslTextureBinding[];
@@ -60,7 +60,7 @@ export interface WgslContribution {
      * scope before `main()`. Use this for noise/hash helpers or any
      * supporting function the {@link body} calls. Multiple modules can
      * declare preludes; they're concatenated in registration order. Naming
-     * collisions across modules are the author's problem — prefix helpers
+     * collisions across modules are the author's problem - prefix helpers
      * with the module key (e.g. `myModule_hash`) to avoid clashes.
      */
     prelude?: string;
@@ -73,9 +73,10 @@ export interface WgslContribution {
  *
  * Used by the codegen to size the system's combined uniform buffer.
  */
-export declare const wgslUniformByteSize: (fields: readonly WgslUniformField[]) => number;
+export declare const getWgslUniformByteSize: (fields: readonly WgslUniformField[]) => number;
 /** Per-WGSL-primitive size and alignment in bytes. */
-export declare const wgslFieldLayout: (type: WgslPrimitive) => {
+export declare const getWgslFieldLayout: (type: WgslPrimitive) => {
     size: number;
     align: number;
 };
+//# sourceMappingURL=WgslContribution.d.ts.map

package/dist/esm/modules/WgslContribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WgslContribution.d.ts","sourceRoot":"","sources":["../../../src/modules/WgslContribution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,WAAW,GAAG,WAAW,CAAC;AAE9E,6FAA6F;AAC7F,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB;AAED,oEAAoE;AACpE,MAAM,WAAW,kBAAkB;IACjC,qFAAqF;IACrF,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,MAAM,EAAE,UAAU,GAAG,YAAY,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,gBAAgB;IAC/B,uIAAuI;IACvI,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACvC,QAAQ,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACzC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,SAAS,gBAAgB,EAAE,KAAG,MAa5E,CAAC;AAEF,sDAAsD;AACtD,eAAO,MAAM,kBAAkB,GAAI,MAAM,aAAa,KAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAWrF,CAAC"}

package/dist/esm/modules/WgslContribution.js

@@ -1,34 +1,42 @@
+//#region src/modules/WgslContribution.ts
 /**
- * Compute the byte size of a uniform struct from its declared fields,
- * respecting WGSL std140-like alignment rules. Each field aligns to its
- * natural alignment; the struct itself rounds to its largest alignment.
- *
- * Used by the codegen to size the system's combined uniform buffer.
- */
-const wgslUniformByteSize = (fields) => {
-    let offset = 0;
-    let maxAlign = 4;
-    for (const field of fields) {
-        const { size, align } = wgslFieldLayout(field.type);
-        offset = Math.ceil(offset / align) * align;
-        offset += size;
-        maxAlign = Math.max(maxAlign, align);
-    }
-    return Math.ceil(offset / maxAlign) * maxAlign;
+* Compute the byte size of a uniform struct from its declared fields,
+* respecting WGSL std140-like alignment rules. Each field aligns to its
+* natural alignment; the struct itself rounds to its largest alignment.
+*
+* Used by the codegen to size the system's combined uniform buffer.
+*/
+const getWgslUniformByteSize = (fields) => {
+	let offset = 0;
+	let maxAlign = 4;
+	for (const field of fields) {
+		const { size, align } = getWgslFieldLayout(field.type);
+		offset = Math.ceil(offset / align) * align;
+		offset += size;
+		maxAlign = Math.max(maxAlign, align);
+	}
+	return Math.ceil(offset / maxAlign) * maxAlign;
 };
 /** Per-WGSL-primitive size and alignment in bytes. */
-const wgslFieldLayout = (type) => {
-    switch (type) {
-        case 'f32':
-        case 'i32':
-        case 'u32':
-            return { size: 4, align: 4 };
-        case 'vec2<f32>':
-            return { size: 8, align: 8 };
-        case 'vec4<f32>':
-            return { size: 16, align: 16 };
-    }
+const getWgslFieldLayout = (type) => {
+	switch (type) {
+		case "f32":
+		case "i32":
+		case "u32": return {
+			size: 4,
+			align: 4
+		};
+		case "vec2<f32>": return {
+			size: 8,
+			align: 8
+		};
+		case "vec4<f32>": return {
+			size: 16,
+			align: 16
+		};
+	}
 };
 
-export { wgslFieldLayout, wgslUniformByteSize };
-//# sourceMappingURL=WgslContribution.js.map
+//#endregion
+export { getWgslFieldLayout, getWgslUniformByteSize };
+//# sourceMappingURL=WgslContribution.js.map

package/dist/esm/modules/WgslContribution.js.map

@@ -1 +1 @@
-{"version":3,"file":"WgslContribution.js","sources":["../../../../src/modules/WgslContribution.ts"],"sourcesContent":[null],"names":[],"mappings":"AAwEA;;;;;;AAMG;AACI,MAAM,mBAAmB,GAAG,CAAC,MAAmC,KAAY;IACjF,IAAI,MAAM,GAAG,CAAC;IACd,IAAI,QAAQ,GAAG,CAAC;AAEhB,IAAA,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;AAC1B,QAAA,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC;QAEnD,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,GAAG,KAAK;QAC1C,MAAM,IAAI,IAAI;QACd,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;IACtC;IAEA,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,GAAG,QAAQ;AAChD;AAEA;AACO,MAAM,eAAe,GAAG,CAAC,IAAmB,KAAqC;IACtF,QAAQ,IAAI;AACV,QAAA,KAAK,KAAK;AACV,QAAA,KAAK,KAAK;AACV,QAAA,KAAK,KAAK;YACR,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE;AAC9B,QAAA,KAAK,WAAW;YACd,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE;AAC9B,QAAA,KAAK,WAAW;YACd,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;;AAEpC;;;;"}
+{"version":3,"file":"WgslContribution.js","names":[],"sources":["../../../src/modules/WgslContribution.ts"],"sourcesContent":["/**\n * WGSL primitive types accepted in {@link WgslUniformField} declarations.\n * The codegen emits matching WGSL field declarations; the writeUniforms\n * implementation must produce bytes in the layout WGSL expects (see\n * https://www.w3.org/TR/WGSL/#alignment-and-size).\n *\n * Common pitfalls:\n * - `vec2<f32>` aligns to 8 bytes; pad with `f32` or use `vec4<f32>`.\n * - `vec3<f32>` aligns to 16 bytes (so does `vec4<f32>`); avoid `vec3` for tight packing.\n *\n * For now the supported subset covers what the built-in modules need. Add\n * more types here as new modules require them.\n */\nexport type WgslPrimitive = 'f32' | 'i32' | 'u32' | 'vec2<f32>' | 'vec4<f32>';\n\n/** A named uniform field within a module's struct. Order matters - defines memory layout. */\nexport interface WgslUniformField {\n  name: string;\n  type: WgslPrimitive;\n}\n\n/** A 1D texture binding (used by Curve / ColorGradient lookups). */\nexport interface WgslTextureBinding {\n  /** Field name within the module - referenced in WGSL as `u_${moduleKey}_${name}`. */\n  name: string;\n  /** WGSL texture format. `r32float` for Curve, `rgba8unorm` for ColorGradient. */\n  format: 'r32float' | 'rgba8unorm';\n}\n\n/**\n * What an {@link UpdateModule} contributes to the system's composite compute\n * shader. `body` runs once per particle in the inner main function, with\n * these locals in scope:\n *\n * - `idx: u32` - the particle slot index (already gated on `< sim.liveCount`\n *   and skip-on-dead via `timing[idx].y < 0.0`).\n * - `dt: f32` - frame delta in seconds (mirrors `sim.dt`).\n * - **Packed SoA bindings** (see body of doc) - channels are packed into\n *   `vec2<f32>`-typed storage buffers to fit within WebGPU's default 8-buffer\n *   limit. Access x/y components for the per-axis values:\n *   - `positions[idx].x` / `.y` (was posX/posY)\n *   - `velocities[idx].x` / `.y` (was velX/velY)\n *   - `scales[idx].x` / `.y` (was scaleX/scaleY)\n *   - `rotInfo[idx].x` / `.y` (rotation, rotationSpeed)\n *   - `timing[idx].x` / `.y` (elapsed, lifetime - y is set to -1 when expired)\n *   - `color[idx]` - packed RGBA u32, single channel (no .x/.y)\n * - `sim: SimUniforms` - `{ dt: f32, liveCount: u32 }`.\n * - `modules.u_${key}: ${Key}Uniforms` - your module's uniform struct (if declared).\n * - `u_${key}_${textureName}` and `u_${key}_${textureName}_sampler` - texture bindings (if any).\n *\n * The body should not declare new functions or top-level statements; it\n * runs inline in the main function. Use comments and parentheses generously\n * - composition concatenates several module bodies and any syntax mistake\n * surfaces only at pipeline-creation time.\n */\nexport interface WgslContribution {\n  /** Unique key per module *class* (e.g. `'ApplyForce'`). Two ApplyForce instances on one system aren't supported - combine into one. */\n  key: string;\n  uniforms?: readonly WgslUniformField[];\n  textures?: readonly WgslTextureBinding[];\n  /**\n   * Optional WGSL declarations (functions, constants) emitted at module\n   * scope before `main()`. Use this for noise/hash helpers or any\n   * supporting function the {@link body} calls. Multiple modules can\n   * declare preludes; they're concatenated in registration order. Naming\n   * collisions across modules are the author's problem - prefix helpers\n   * with the module key (e.g. `myModule_hash`) to avoid clashes.\n   */\n  prelude?: string;\n  body: string;\n}\n\n/**\n * Compute the byte size of a uniform struct from its declared fields,\n * respecting WGSL std140-like alignment rules. Each field aligns to its\n * natural alignment; the struct itself rounds to its largest alignment.\n *\n * Used by the codegen to size the system's combined uniform buffer.\n */\nexport const getWgslUniformByteSize = (fields: readonly WgslUniformField[]): number => {\n  let offset = 0;\n  let maxAlign = 4;\n\n  for (const field of fields) {\n    const { size, align } = getWgslFieldLayout(field.type);\n\n    offset = Math.ceil(offset / align) * align;\n    offset += size;\n    maxAlign = Math.max(maxAlign, align);\n  }\n\n  return Math.ceil(offset / maxAlign) * maxAlign;\n};\n\n/** Per-WGSL-primitive size and alignment in bytes. */\nexport const getWgslFieldLayout = (type: WgslPrimitive): { size: number; align: number } => {\n  switch (type) {\n    case 'f32':\n    case 'i32':\n    case 'u32':\n      return { size: 4, align: 4 };\n    case 'vec2<f32>':\n      return { size: 8, align: 8 };\n    case 'vec4<f32>':\n      return { size: 16, align: 16 };\n  }\n};\n"],"mappings":";;;;;;;;AA+EA,MAAa,0BAA0B,WAAgD;CACrF,IAAI,SAAS;CACb,IAAI,WAAW;CAEf,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,EAAE,MAAM,UAAU,mBAAmB,MAAM,IAAI;EAErD,SAAS,KAAK,KAAK,SAAS,KAAK,IAAI;EACrC,UAAU;EACV,WAAW,KAAK,IAAI,UAAU,KAAK;CACrC;CAEA,OAAO,KAAK,KAAK,SAAS,QAAQ,IAAI;AACxC;;AAGA,MAAa,sBAAsB,SAAyD;CAC1F,QAAQ,MAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK,OACH,OAAO;GAAE,MAAM;GAAG,OAAO;EAAE;EAC7B,KAAK,aACH,OAAO;GAAE,MAAM;GAAG,OAAO;EAAE;EAC7B,KAAK,aACH,OAAO;GAAE,MAAM;GAAI,OAAO;EAAG;CACjC;AACF"}

package/dist/esm/modules/index.d.ts

@@ -13,10 +13,12 @@ export { RateSpawn } from './RateSpawn';
 export { RepelFromPoint } from './RepelFromPoint';
 export { RotateOverLifetime } from './RotateOverLifetime';
 export { ScaleOverLifetime } from './ScaleOverLifetime';
+export type { ParticleSpawnFields } from './spawnFields';
 export { SpawnModule } from './SpawnModule';
 export { SpawnOnDeath } from './SpawnOnDeath';
 export { Turbulence } from './Turbulence';
 export { UpdateModule } from './UpdateModule';
 export { VelocityOverLifetime } from './VelocityOverLifetime';
 export type { WgslContribution, WgslPrimitive, WgslTextureBinding, WgslUniformField } from './WgslContribution';
-export { wgslFieldLayout, wgslUniformByteSize } from './WgslContribution';
+export { getWgslFieldLayout, getWgslUniformByteSize } from './WgslContribution';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/modules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAChH,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/esm/modules/spawnFields.d.ts

@@ -0,0 +1,32 @@
+import type { Color, Vector } from '@codexo/exojs';
+import type { Distribution } from '#distributions/Distribution';
+import type { ParticleWriter } from '#ParticleStorage';
+/**
+ * Per-property spawn configuration shared by the built-in spawners.
+ *
+ * Every entry is a {@link Distribution} sampled once per emitted particle.
+ * Omitting an entry leaves that property at its spawn default: origin, no
+ * velocity, unit scale, no rotation, opaque white, frame 0, one second of life.
+ */
+export interface ParticleSpawnFields {
+    /** Total lifetime in seconds. Drives expiry. */
+    lifetime?: Distribution<number>;
+    position?: Distribution<Vector>;
+    velocity?: Distribution<Vector>;
+    scale?: Distribution<Vector>;
+    rotation?: Distribution<number>;
+    rotationSpeed?: Distribution<number>;
+    /** Initial tint. For a per-frame fade use a `ColorOverLifetime` update module. */
+    tint?: Distribution<Color>;
+    /** Atlas frame index. Ignored by a system that declares no frames. */
+    textureIndex?: Distribution<number>;
+}
+/**
+ * Samples every configured field of `fields` into one emitted particle.
+ *
+ * `vector` and `color` are scratch instances the caller owns, so a spawner
+ * allocates nothing per particle.
+ * @internal
+ */
+export declare const fillParticle: (particle: ParticleWriter, fields: ParticleSpawnFields, vector: Vector, color: Color) => void;
+//# sourceMappingURL=spawnFields.d.ts.map

package/dist/esm/modules/spawnFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawnFields.d.ts","sourceRoot":"","sources":["../../../src/modules/spawnFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,gDAAgD;IAChD,QAAQ,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAChC,QAAQ,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAChC,QAAQ,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAChC,KAAK,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAC7B,QAAQ,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAChC,aAAa,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IACrC,kFAAkF;IAClF,IAAI,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IAC3B,sEAAsE;IACtE,YAAY,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;CACrC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,UAAU,cAAc,EAAE,QAAQ,mBAAmB,EAAE,QAAQ,MAAM,EAAE,OAAO,KAAK,KAAG,IAmClH,CAAC"}

package/dist/esm/modules/spawnFields.js

@@ -0,0 +1,31 @@
+//#region src/modules/spawnFields.ts
+/**
+* Samples every configured field of `fields` into one emitted particle.
+*
+* `vector` and `color` are scratch instances the caller owns, so a spawner
+* allocates nothing per particle.
+* @internal
+*/
+const fillParticle = (particle, fields, vector, color) => {
+	if (fields.lifetime) particle.lifetime = fields.lifetime.sample();
+	if (fields.position) {
+		fields.position.sample(vector);
+		particle.position.set(vector.x, vector.y);
+	}
+	if (fields.velocity) {
+		fields.velocity.sample(vector);
+		particle.velocity.set(vector.x, vector.y);
+	}
+	if (fields.scale) {
+		fields.scale.sample(vector);
+		particle.scale.set(vector.x, vector.y);
+	}
+	if (fields.rotation) particle.rotation = fields.rotation.sample();
+	if (fields.rotationSpeed) particle.rotationSpeed = fields.rotationSpeed.sample();
+	if (fields.tint) particle.color = fields.tint.sample(color).toRgba8();
+	if (fields.textureIndex) particle.frame = fields.textureIndex.sample();
+};
+
+//#endregion
+export { fillParticle };
+//# sourceMappingURL=spawnFields.js.map

package/dist/esm/modules/spawnFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawnFields.js","names":[],"sources":["../../../src/modules/spawnFields.ts"],"sourcesContent":["import type { Color, Vector } from '@codexo/exojs';\n\nimport type { Distribution } from '#distributions/Distribution';\nimport type { ParticleWriter } from '#ParticleStorage';\n\n/**\n * Per-property spawn configuration shared by the built-in spawners.\n *\n * Every entry is a {@link Distribution} sampled once per emitted particle.\n * Omitting an entry leaves that property at its spawn default: origin, no\n * velocity, unit scale, no rotation, opaque white, frame 0, one second of life.\n */\nexport interface ParticleSpawnFields {\n  /** Total lifetime in seconds. Drives expiry. */\n  lifetime?: Distribution<number>;\n  position?: Distribution<Vector>;\n  velocity?: Distribution<Vector>;\n  scale?: Distribution<Vector>;\n  rotation?: Distribution<number>;\n  rotationSpeed?: Distribution<number>;\n  /** Initial tint. For a per-frame fade use a `ColorOverLifetime` update module. */\n  tint?: Distribution<Color>;\n  /** Atlas frame index. Ignored by a system that declares no frames. */\n  textureIndex?: Distribution<number>;\n}\n\n/**\n * Samples every configured field of `fields` into one emitted particle.\n *\n * `vector` and `color` are scratch instances the caller owns, so a spawner\n * allocates nothing per particle.\n * @internal\n */\nexport const fillParticle = (particle: ParticleWriter, fields: ParticleSpawnFields, vector: Vector, color: Color): void => {\n  if (fields.lifetime) {\n    particle.lifetime = fields.lifetime.sample();\n  }\n\n  if (fields.position) {\n    fields.position.sample(vector);\n    particle.position.set(vector.x, vector.y);\n  }\n\n  if (fields.velocity) {\n    fields.velocity.sample(vector);\n    particle.velocity.set(vector.x, vector.y);\n  }\n\n  if (fields.scale) {\n    fields.scale.sample(vector);\n    particle.scale.set(vector.x, vector.y);\n  }\n\n  if (fields.rotation) {\n    particle.rotation = fields.rotation.sample();\n  }\n\n  if (fields.rotationSpeed) {\n    particle.rotationSpeed = fields.rotationSpeed.sample();\n  }\n\n  if (fields.tint) {\n    particle.color = fields.tint.sample(color).toRgba8();\n  }\n\n  if (fields.textureIndex) {\n    particle.frame = fields.textureIndex.sample();\n  }\n};\n"],"mappings":";;;;;;;;AAiCA,MAAa,gBAAgB,UAA0B,QAA6B,QAAgB,UAAuB;CACzH,IAAI,OAAO,UACT,SAAS,WAAW,OAAO,SAAS,OAAO;CAG7C,IAAI,OAAO,UAAU;EACnB,OAAO,SAAS,OAAO,MAAM;EAC7B,SAAS,SAAS,IAAI,OAAO,GAAG,OAAO,CAAC;CAC1C;CAEA,IAAI,OAAO,UAAU;EACnB,OAAO,SAAS,OAAO,MAAM;EAC7B,SAAS,SAAS,IAAI,OAAO,GAAG,OAAO,CAAC;CAC1C;CAEA,IAAI,OAAO,OAAO;EAChB,OAAO,MAAM,OAAO,MAAM;EAC1B,SAAS,MAAM,IAAI,OAAO,GAAG,OAAO,CAAC;CACvC;CAEA,IAAI,OAAO,UACT,SAAS,WAAW,OAAO,SAAS,OAAO;CAG7C,IAAI,OAAO,eACT,SAAS,gBAAgB,OAAO,cAAc,OAAO;CAGvD,IAAI,OAAO,MACT,SAAS,QAAQ,OAAO,KAAK,OAAO,KAAK,CAAC,CAAC,QAAQ;CAGrD,IAAI,OAAO,cACT,SAAS,QAAQ,OAAO,aAAa,OAAO;AAEhD"}

package/dist/esm/particlesBuildInfo.d.ts

@@ -13,3 +13,4 @@ export interface ParticlesBuildInfo {
     readonly development: boolean;
 }
 export declare const particlesBuildInfo: ParticlesBuildInfo;
+//# sourceMappingURL=particlesBuildInfo.d.ts.map

package/dist/esm/particlesBuildInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particlesBuildInfo.d.ts","sourceRoot":"","sources":["../../src/particlesBuildInfo.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAED,eAAO,MAAM,kBAAkB,EAAE,kBAI/B,CAAC"}

package/dist/esm/particlesBuildInfo.js

@@ -1,8 +1,10 @@
+//#region src/particlesBuildInfo.ts
 const particlesBuildInfo = Object.freeze({
-    version: "0.15.3",
-    revision: "3af06d7",
-    development: false,
+	version: "0.16.0",
+	revision: "3a59179",
+	development: false
 });
 
+//#endregion
 export { particlesBuildInfo };
-//# sourceMappingURL=particlesBuildInfo.js.map
+//# sourceMappingURL=particlesBuildInfo.js.map

package/dist/esm/particlesBuildInfo.js.map

@@ -1 +1 @@
-{"version":3,"file":"particlesBuildInfo.js","sources":["../../../src/particlesBuildInfo.ts"],"sourcesContent":[null],"names":[],"mappings":"AAeO,MAAM,kBAAkB,GAAuB,MAAM,CAAC,MAAM,CAAC;AAClE,IAAA,OAAO,EAAE,QAAW;AACpB,IAAA,QAAQ,EAAE,SAAY;AACtB,IAAA,WAAW,EAAE,KAAO;AACrB,CAAA;;;;"}
+{"version":3,"file":"particlesBuildInfo.js","names":[],"sources":["../../src/particlesBuildInfo.ts"],"sourcesContent":["/**\n * Immutable compile-time build metadata for `@codexo/exojs-particles`.\n *\n * `development` mirrors the `__DEV__` compile-time constant and is statically\n * replaced before tree shaking. `version` is the exact `package.json` version\n * of the Particles package at build time. `revision` is the short\n * source-control revision (appended with `-dirty` when uncommitted changes are\n * present) or `\"unknown\"` when no revision information is available.\n */\nexport interface ParticlesBuildInfo {\n  readonly version: string;\n  readonly revision: string;\n  readonly development: boolean;\n}\n\nexport const particlesBuildInfo: ParticlesBuildInfo = Object.freeze({\n  version: __VERSION__,\n  revision: __REVISION__,\n  development: __DEV__,\n});\n"],"mappings":";AAeA,MAAa,qBAAyC,OAAO,OAAO;CAClE;CACA;CACA;AACF,CAAC"}

package/dist/esm/particlesExtension.d.ts

@@ -1,18 +1,25 @@
 import type { Extension } from '@codexo/exojs/extensions';
 /** Options for {@link createParticlesExtension}. */
 export interface ParticlesExtensionOptions {
-    /** WebGL2 particle renderer batch size. Default: 8192. */
+    /**
+     * Particles the WebGL2 renderer's instance buffer is pre-sized for.
+     * Defaults to 8192.
+     *
+     * This is a starting allocation, not a limit: a system with more live
+     * particles grows the buffer instead of dropping the surplus, so raise it
+     * only to avoid the initial growth steps for a known-large system.
+     */
     readonly batchSize?: number;
 }
 /**
  * Default immutable Particles extension descriptor.
- * Use with `ApplicationOptions.extensions` or call
- * `import '@codexo/exojs-particles/register'` for global auto-registration.
+ * Pass it to the application that should have it via
+ * `ApplicationOptions.extensions`.
  */
 export declare const particlesExtension: Extension;
 /**
  * Create a Particles extension with custom configuration.
- * Returns an application-local descriptor — safe to pass to one
+ * Returns an application-local descriptor - safe to pass to one
  * `Application` only. For shared use, prefer {@link particlesExtension}.
  *
  * @example
@@ -21,4 +28,5 @@ export declare const particlesExtension: Extension;
  * const app = new Application({ extensions: [ext] });
  * ```
  */
-export declare function createParticlesExtension(options?: ParticlesExtensionOptions): Extension;
+export declare const createParticlesExtension: (options?: ParticlesExtensionOptions) => Extension;
+//# sourceMappingURL=particlesExtension.d.ts.map

package/dist/esm/particlesExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particlesExtension.d.ts","sourceRoot":"","sources":["../../src/particlesExtension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,0BAA0B,CAAC;AAS3E,oDAAoD;AACpD,MAAM,WAAW,yBAAyB;IACxC;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAiBD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAG/B,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,GAAI,UAAS,yBAA8B,KAAG,SAOlF,CAAC"}