@codexo/exojs-particles 0.15.3 → 0.16.0

package/dist/esm/distributions/ConeDirection.js

@@ -1,44 +1,46 @@
-import { Vector } from '@codexo/exojs';
+import { Vector } from "@codexo/exojs";
 
+//#region src/distributions/ConeDirection.ts
 const tau = Math.PI * 2;
 /**
- * Random unit vector inside a cone, scaled by a speed magnitude.
- *
- * The cone is centred on `directionAngle` (in radians, 0 = +X, π/2 = +Y for
- * screen-down coordinates) and spans `±halfAngle` radians around it. Speed
- * is sampled uniformly in `[minSpeed, maxSpeed]`.
- *
- * Use for emission cones, explosions, fountain spread — anywhere the
- * direction has a preferred axis with bounded variance.
- *
- * @example
- * // Upward fountain with ±15° spread, 200-300 px/s:
- * const up = new ConeDirection(-Math.PI / 2, Math.PI / 12, 200, 300);
- * up.sample(particle.velocity);
- */
-class ConeDirection {
-    directionAngle;
-    halfAngle;
-    minSpeed;
-    maxSpeed;
-    _scratch = new Vector();
-    constructor(directionAngle, halfAngle, minSpeed, maxSpeed) {
-        this.directionAngle = directionAngle;
-        this.halfAngle = halfAngle;
-        this.minSpeed = minSpeed;
-        this.maxSpeed = maxSpeed;
-    }
-    sample(out = this._scratch) {
-        const angle = this.directionAngle + (Math.random() * 2 - 1) * this.halfAngle;
-        const speed = this.minSpeed + Math.random() * (this.maxSpeed - this.minSpeed);
-        out.set(Math.cos(angle) * speed, Math.sin(angle) * speed);
-        return out;
-    }
-    /** Convenience: omnidirectional emission (full circle, 0..2π). */
-    static omni(minSpeed, maxSpeed) {
-        return new ConeDirection(0, tau / 2, minSpeed, maxSpeed);
-    }
-}
+* Random unit vector inside a cone, scaled by a speed magnitude.
+*
+* The cone is centred on `directionAngle` (in radians, 0 = +X, π/2 = +Y for
+* screen-down coordinates) and spans `±halfAngle` radians around it. Speed
+* is sampled uniformly in `[minSpeed, maxSpeed]`.
+*
+* Use for emission cones, explosions, fountain spread - anywhere the
+* direction has a preferred axis with bounded variance.
+*
+* @example
+* // Upward fountain with ±15° spread, 200-300 px/s:
+* const up = new ConeDirection(-Math.PI / 2, Math.PI / 12, 200, 300);
+* up.sample(particle.velocity);
+*/
+var ConeDirection = class ConeDirection {
+	directionAngle;
+	halfAngle;
+	minSpeed;
+	maxSpeed;
+	_scratch = new Vector();
+	constructor(directionAngle, halfAngle, minSpeed, maxSpeed) {
+		this.directionAngle = directionAngle;
+		this.halfAngle = halfAngle;
+		this.minSpeed = minSpeed;
+		this.maxSpeed = maxSpeed;
+	}
+	sample(out = this._scratch) {
+		const angle = this.directionAngle + (Math.random() * 2 - 1) * this.halfAngle;
+		const speed = this.minSpeed + Math.random() * (this.maxSpeed - this.minSpeed);
+		out.set(Math.cos(angle) * speed, Math.sin(angle) * speed);
+		return out;
+	}
+	/** Convenience: omnidirectional emission (full circle, 0..2π). */
+	static omni(minSpeed, maxSpeed) {
+		return new ConeDirection(0, tau / 2, minSpeed, maxSpeed);
+	}
+};
 
+//#endregion
 export { ConeDirection };
-//# sourceMappingURL=ConeDirection.js.map
+//# sourceMappingURL=ConeDirection.js.map

package/dist/esm/distributions/ConeDirection.js.map

@@ -1 +1 @@
-{"version":3,"file":"ConeDirection.js","sources":["../../../../src/distributions/ConeDirection.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA,MAAM,GAAG,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;AAEvB;;;;;;;;;;;;;;AAcG;MACU,aAAa,CAAA;AAIf,IAAA,cAAA;AACA,IAAA,SAAA;AACA,IAAA,QAAA;AACA,IAAA,QAAA;AANQ,IAAA,QAAQ,GAAG,IAAI,MAAM,EAAE;AAExC,IAAA,WAAA,CACS,cAAsB,EACtB,SAAiB,EACjB,QAAgB,EAChB,QAAgB,EAAA;QAHhB,IAAA,CAAA,cAAc,GAAd,cAAc;QACd,IAAA,CAAA,SAAS,GAAT,SAAS;QACT,IAAA,CAAA,QAAQ,GAAR,QAAQ;QACR,IAAA,CAAA,QAAQ,GAAR,QAAQ;IACd;AAEI,IAAA,MAAM,CAAC,GAAA,GAAc,IAAI,CAAC,QAAQ,EAAA;QACvC,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,SAAS;QAC5E,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAE7E,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;AAEzD,QAAA,OAAO,GAAG;IACZ;;AAGO,IAAA,OAAO,IAAI,CAAC,QAAgB,EAAE,QAAgB,EAAA;AACnD,QAAA,OAAO,IAAI,aAAa,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC;IAC1D;AACD;;;;"}
+{"version":3,"file":"ConeDirection.js","names":[],"sources":["../../../src/distributions/ConeDirection.ts"],"sourcesContent":["import { Vector } from '@codexo/exojs';\n\nimport type { Distribution } from './Distribution';\n\nconst tau = Math.PI * 2;\n\n/**\n * Random unit vector inside a cone, scaled by a speed magnitude.\n *\n * The cone is centred on `directionAngle` (in radians, 0 = +X, π/2 = +Y for\n * screen-down coordinates) and spans `±halfAngle` radians around it. Speed\n * is sampled uniformly in `[minSpeed, maxSpeed]`.\n *\n * Use for emission cones, explosions, fountain spread - anywhere the\n * direction has a preferred axis with bounded variance.\n *\n * @example\n * // Upward fountain with ±15° spread, 200-300 px/s:\n * const up = new ConeDirection(-Math.PI / 2, Math.PI / 12, 200, 300);\n * up.sample(particle.velocity);\n */\nexport class ConeDirection implements Distribution<Vector> {\n  private readonly _scratch = new Vector();\n\n  public constructor(\n    public directionAngle: number,\n    public halfAngle: number,\n    public minSpeed: number,\n    public maxSpeed: number,\n  ) {}\n\n  public sample(out: Vector = this._scratch): Vector {\n    const angle = this.directionAngle + (Math.random() * 2 - 1) * this.halfAngle;\n    const speed = this.minSpeed + Math.random() * (this.maxSpeed - this.minSpeed);\n\n    out.set(Math.cos(angle) * speed, Math.sin(angle) * speed);\n\n    return out;\n  }\n\n  /** Convenience: omnidirectional emission (full circle, 0..2π). */\n  public static omni(minSpeed: number, maxSpeed: number): ConeDirection {\n    return new ConeDirection(0, tau / 2, minSpeed, maxSpeed);\n  }\n}\n"],"mappings":";;;AAIA,MAAM,MAAM,KAAK,KAAK;;;;;;;;;;;;;;;;AAiBtB,IAAa,gBAAb,MAAa,cAA8C;CAIhD;CACA;CACA;CACA;CANT,AAAiB,WAAW,IAAI,OAAO;CAEvC,AAAO,YACL,AAAO,gBACP,AAAO,WACP,AAAO,UACP,AAAO,UACP;EAJO;EACA;EACA;EACA;CACN;CAEH,AAAO,OAAO,MAAc,KAAK,UAAkB;EACjD,MAAM,QAAQ,KAAK,kBAAkB,KAAK,OAAO,IAAI,IAAI,KAAK,KAAK;EACnE,MAAM,QAAQ,KAAK,WAAW,KAAK,OAAO,KAAK,KAAK,WAAW,KAAK;EAEpE,IAAI,IAAI,KAAK,IAAI,KAAK,IAAI,OAAO,KAAK,IAAI,KAAK,IAAI,KAAK;EAExD,OAAO;CACT;;CAGA,OAAc,KAAK,UAAkB,UAAiC;EACpE,OAAO,IAAI,cAAc,GAAG,MAAM,GAAG,UAAU,QAAQ;CACzD;AACF"}

package/dist/esm/distributions/Constant.d.ts

@@ -15,3 +15,4 @@ export declare class Constant<T> implements Distribution<T>, LifetimeFunction<T>
     evaluate(_t: number, out?: T): T;
     private _copyOrReturn;
 }
+//# sourceMappingURL=Constant.d.ts.map

package/dist/esm/distributions/Constant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Constant.d.ts","sourceRoot":"","sources":["../../../src/distributions/Constant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAErE;;;;;;;;GAQG;AACH,qBAAa,QAAQ,CAAC,CAAC,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAC5C,KAAK,EAAE,CAAC;gBAAR,KAAK,EAAE,CAAC;IAE3B,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC;IAIlB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC;IAIvC,OAAO,CAAC,aAAa;CAetB"}

package/dist/esm/distributions/Constant.js

@@ -1,35 +1,35 @@
+//#region src/distributions/Constant.ts
 /**
- * Distribution that always returns the same value. Implements both
- * {@link Distribution} and {@link LifetimeFunction} so it can stand in
- * wherever a randomized or time-parameterised value is expected.
- *
- * For mutable types (Vector, Color, ...) the constant value is copied into
- * `out` if provided, otherwise the constructor's value is returned directly.
- * Mutating that returned reference mutates the distribution's source.
- */
-class Constant {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-    sample(out) {
-        return this._copyOrReturn(out);
-    }
-    evaluate(_t, out) {
-        return this._copyOrReturn(out);
-    }
-    _copyOrReturn(out) {
-        if (out === undefined || out === null) {
-            return this.value;
-        }
-        const target = out;
-        if (typeof target.copy === 'function') {
-            target.copy(this.value);
-            return out;
-        }
-        return this.value;
-    }
-}
+* Distribution that always returns the same value. Implements both
+* {@link Distribution} and {@link LifetimeFunction} so it can stand in
+* wherever a randomized or time-parameterised value is expected.
+*
+* For mutable types (Vector, Color, ...) the constant value is copied into
+* `out` if provided, otherwise the constructor's value is returned directly.
+* Mutating that returned reference mutates the distribution's source.
+*/
+var Constant = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+	sample(out) {
+		return this._copyOrReturn(out);
+	}
+	evaluate(_t, out) {
+		return this._copyOrReturn(out);
+	}
+	_copyOrReturn(out) {
+		if (out === void 0 || out === null) return this.value;
+		const target = out;
+		if (typeof target.copy === "function") {
+			target.copy(this.value);
+			return out;
+		}
+		return this.value;
+	}
+};
 
+//#endregion
 export { Constant };
-//# sourceMappingURL=Constant.js.map
+//# sourceMappingURL=Constant.js.map

package/dist/esm/distributions/Constant.js.map

@@ -1 +1 @@
-{"version":3,"file":"Constant.js","sources":["../../../../src/distributions/Constant.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;AAQG;MACU,QAAQ,CAAA;AACO,IAAA,KAAA;AAA1B,IAAA,WAAA,CAA0B,KAAQ,EAAA;QAAR,IAAA,CAAA,KAAK,GAAL,KAAK;IAAM;AAE9B,IAAA,MAAM,CAAC,GAAO,EAAA;AACnB,QAAA,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC;IAChC;IAEO,QAAQ,CAAC,EAAU,EAAE,GAAO,EAAA;AACjC,QAAA,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC;IAChC;AAEQ,IAAA,aAAa,CAAC,GAAO,EAAA;QAC3B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;YACrC,OAAO,IAAI,CAAC,KAAK;QACnB;QAEA,MAAM,MAAM,GAAG,GAAqC;AAEpD,QAAA,IAAI,OAAO,MAAM,CAAC,IAAI,KAAK,UAAU,EAAE;AACrC,YAAA,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;AAEvB,YAAA,OAAO,GAAG;QACZ;QAEA,OAAO,IAAI,CAAC,KAAK;IACnB;AACD;;;;"}
+{"version":3,"file":"Constant.js","names":[],"sources":["../../../src/distributions/Constant.ts"],"sourcesContent":["import type { Distribution, LifetimeFunction } from './Distribution';\n\n/**\n * Distribution that always returns the same value. Implements both\n * {@link Distribution} and {@link LifetimeFunction} so it can stand in\n * wherever a randomized or time-parameterised value is expected.\n *\n * For mutable types (Vector, Color, ...) the constant value is copied into\n * `out` if provided, otherwise the constructor's value is returned directly.\n * Mutating that returned reference mutates the distribution's source.\n */\nexport class Constant<T> implements Distribution<T>, LifetimeFunction<T> {\n  public constructor(public value: T) {}\n\n  public sample(out?: T): T {\n    return this._copyOrReturn(out);\n  }\n\n  public evaluate(_t: number, out?: T): T {\n    return this._copyOrReturn(out);\n  }\n\n  private _copyOrReturn(out?: T): T {\n    if (out === undefined || out === null) {\n      return this.value;\n    }\n\n    const target = out as { copy?: (src: T) => unknown };\n\n    if (typeof target.copy === 'function') {\n      target.copy(this.value);\n\n      return out;\n    }\n\n    return this.value;\n  }\n}\n"],"mappings":";;;;;;;;;;AAWA,IAAa,WAAb,MAAyE;CAC7C;CAA1B,AAAO,YAAY,AAAO,OAAU;EAAV;CAAW;CAErC,AAAO,OAAO,KAAY;EACxB,OAAO,KAAK,cAAc,GAAG;CAC/B;CAEA,AAAO,SAAS,IAAY,KAAY;EACtC,OAAO,KAAK,cAAc,GAAG;CAC/B;CAEA,AAAQ,cAAc,KAAY;EAChC,IAAI,QAAQ,UAAa,QAAQ,MAC/B,OAAO,KAAK;EAGd,MAAM,SAAS;EAEf,IAAI,OAAO,OAAO,SAAS,YAAY;GACrC,OAAO,KAAK,KAAK,KAAK;GAEtB,OAAO;EACT;EAEA,OAAO,KAAK;CACd;AACF"}

package/dist/esm/distributions/Curve.d.ts

@@ -7,7 +7,7 @@ export interface CurveKey {
 /**
  * Piecewise-linear keyframe curve sampled by lifetime ratio `t` in `[0, 1]`.
  *
- * Keyframes are stored sorted by `t` and clamped at the endpoints — sampling
+ * Keyframes are stored sorted by `t` and clamped at the endpoints - sampling
  * outside the keyframe range returns the nearest endpoint value. The
  * implementation tracks the last accessed segment so monotonically advancing
  * `t` (the typical case for per-particle lifetime sampling) costs O(1)
@@ -28,3 +28,4 @@ export declare class Curve implements LifetimeFunction<number> {
     constructor(keys: readonly CurveKey[]);
     evaluate(t: number): number;
 }
+//# sourceMappingURL=Curve.d.ts.map

package/dist/esm/distributions/Curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Curve.d.ts","sourceRoot":"","sources":["../../../src/distributions/Curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,kFAAkF;AAClF,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,KAAM,YAAW,gBAAgB,CAAC,MAAM,CAAC;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,YAAY,CAAK;gBAEN,IAAI,EAAE,SAAS,QAAQ,EAAE;IAQrC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;CAiCnC"}

package/dist/esm/distributions/Curve.js

@@ -1,59 +1,50 @@
+//#region src/distributions/Curve.ts
 const compareT = (a, b) => a.t - b.t;
 /**
- * Piecewise-linear keyframe curve sampled by lifetime ratio `t` in `[0, 1]`.
- *
- * Keyframes are stored sorted by `t` and clamped at the endpoints — sampling
- * outside the keyframe range returns the nearest endpoint value. The
- * implementation tracks the last accessed segment so monotonically advancing
- * `t` (the typical case for per-particle lifetime sampling) costs O(1)
- * amortized per call instead of O(log n).
- *
- * @example
- * // Scale pulses up then down over lifetime:
- * const sizeCurve = new Curve([
- *     { t: 0,    v: 0.2 },
- *     { t: 0.4,  v: 1.5 },
- *     { t: 1,    v: 0.0 },
- * ]);
- * scale.x = scale.y = sizeCurve.evaluate(particle.elapsedRatio);
- */
-class Curve {
-    _keys;
-    _lastSegment = 0;
-    constructor(keys) {
-        if (keys.length === 0) {
-            throw new Error('Curve requires at least one keyframe.');
-        }
-        this._keys = [...keys].sort(compareT);
-    }
-    evaluate(t) {
-        const keys = this._keys;
-        const last = keys.length - 1;
-        const first = keys[0];
-        const lastKey = keys[last];
-        if (first === undefined || lastKey === undefined)
-            return 0;
-        if (t <= first.t)
-            return first.v;
-        if (t >= lastKey.t)
-            return lastKey.v;
-        // Cache-friendly forward search: most callers sweep t monotonically.
-        let segment = this._lastSegment;
-        if (t < (keys[segment]?.t ?? 0)) {
-            segment = 0;
-        }
-        while (segment < last && t > (keys[segment + 1]?.t ?? Infinity)) {
-            segment++;
-        }
-        this._lastSegment = segment;
-        const a = keys[segment];
-        const b = keys[segment + 1];
-        if (a === undefined || b === undefined)
-            return lastKey.v;
-        const ratio = (t - a.t) / (b.t - a.t);
-        return a.v + (b.v - a.v) * ratio;
-    }
-}
+* Piecewise-linear keyframe curve sampled by lifetime ratio `t` in `[0, 1]`.
+*
+* Keyframes are stored sorted by `t` and clamped at the endpoints - sampling
+* outside the keyframe range returns the nearest endpoint value. The
+* implementation tracks the last accessed segment so monotonically advancing
+* `t` (the typical case for per-particle lifetime sampling) costs O(1)
+* amortized per call instead of O(log n).
+*
+* @example
+* // Scale pulses up then down over lifetime:
+* const sizeCurve = new Curve([
+*     { t: 0,    v: 0.2 },
+*     { t: 0.4,  v: 1.5 },
+*     { t: 1,    v: 0.0 },
+* ]);
+* scale.x = scale.y = sizeCurve.evaluate(particle.elapsedRatio);
+*/
+var Curve = class {
+	_keys;
+	_lastSegment = 0;
+	constructor(keys) {
+		if (keys.length === 0) throw new Error("Curve requires at least one keyframe.");
+		this._keys = [...keys].sort(compareT);
+	}
+	evaluate(t) {
+		const keys = this._keys;
+		const last = keys.length - 1;
+		const first = keys[0];
+		const lastKey = keys[last];
+		if (first === void 0 || lastKey === void 0) return 0;
+		if (t <= first.t) return first.v;
+		if (t >= lastKey.t) return lastKey.v;
+		let segment = this._lastSegment;
+		if (t < (keys[segment]?.t ?? 0)) segment = 0;
+		while (segment < last && t > (keys[segment + 1]?.t ?? Infinity)) segment++;
+		this._lastSegment = segment;
+		const a = keys[segment];
+		const b = keys[segment + 1];
+		if (a === void 0 || b === void 0) return lastKey.v;
+		const ratio = (t - a.t) / (b.t - a.t);
+		return a.v + (b.v - a.v) * ratio;
+	}
+};
 
+//#endregion
 export { Curve };
-//# sourceMappingURL=Curve.js.map
+//# sourceMappingURL=Curve.js.map

package/dist/esm/distributions/Curve.js.map

@@ -1 +1 @@
-{"version":3,"file":"Curve.js","sources":["../../../../src/distributions/Curve.ts"],"sourcesContent":[null],"names":[],"mappings":"AAQA,MAAM,QAAQ,GAAG,CAAC,CAAW,EAAE,CAAW,KAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAEhE;;;;;;;;;;;;;;;;;AAiBG;MACU,KAAK,CAAA;AACC,IAAA,KAAK;IACd,YAAY,GAAG,CAAC;AAExB,IAAA,WAAA,CAAmB,IAAyB,EAAA;AAC1C,QAAA,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;AACrB,YAAA,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC;QAC1D;AAEA,QAAA,IAAI,CAAC,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;IACvC;AAEO,IAAA,QAAQ,CAAC,CAAS,EAAA;AACvB,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK;AACvB,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC;AAC5B,QAAA,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC;AACrB,QAAA,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC;AAE1B,QAAA,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,SAAS;AAAE,YAAA,OAAO,CAAC;AAE1D,QAAA,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC,CAAC;AAChC,QAAA,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC;YAAE,OAAO,OAAO,CAAC,CAAC;;AAGpC,QAAA,IAAI,OAAO,GAAG,IAAI,CAAC,YAAY;AAE/B,QAAA,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE;YAC/B,OAAO,GAAG,CAAC;QACb;AAEA,QAAA,OAAO,OAAO,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE;AAC/D,YAAA,OAAO,EAAE;QACX;AAEA,QAAA,IAAI,CAAC,YAAY,GAAG,OAAO;AAE3B,QAAA,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;QACvB,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;AAE3B,QAAA,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,SAAS;YAAE,OAAO,OAAO,CAAC,CAAC;AAExD,QAAA,MAAM,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAErC,QAAA,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK;IAClC;AACD;;;;"}
+{"version":3,"file":"Curve.js","names":[],"sources":["../../../src/distributions/Curve.ts"],"sourcesContent":["import type { LifetimeFunction } from './Distribution';\n\n/** A keyframe in a {@link Curve}: value `v` at lifetime ratio `t` in `[0, 1]`. */\nexport interface CurveKey {\n  t: number;\n  v: number;\n}\n\nconst compareT = (a: CurveKey, b: CurveKey): number => a.t - b.t;\n\n/**\n * Piecewise-linear keyframe curve sampled by lifetime ratio `t` in `[0, 1]`.\n *\n * Keyframes are stored sorted by `t` and clamped at the endpoints - sampling\n * outside the keyframe range returns the nearest endpoint value. The\n * implementation tracks the last accessed segment so monotonically advancing\n * `t` (the typical case for per-particle lifetime sampling) costs O(1)\n * amortized per call instead of O(log n).\n *\n * @example\n * // Scale pulses up then down over lifetime:\n * const sizeCurve = new Curve([\n *     { t: 0,    v: 0.2 },\n *     { t: 0.4,  v: 1.5 },\n *     { t: 1,    v: 0.0 },\n * ]);\n * scale.x = scale.y = sizeCurve.evaluate(particle.elapsedRatio);\n */\nexport class Curve implements LifetimeFunction<number> {\n  private readonly _keys: CurveKey[];\n  private _lastSegment = 0;\n\n  public constructor(keys: readonly CurveKey[]) {\n    if (keys.length === 0) {\n      throw new Error('Curve requires at least one keyframe.');\n    }\n\n    this._keys = [...keys].sort(compareT);\n  }\n\n  public evaluate(t: number): number {\n    const keys = this._keys;\n    const last = keys.length - 1;\n    const first = keys[0];\n    const lastKey = keys[last];\n\n    if (first === undefined || lastKey === undefined) return 0;\n\n    if (t <= first.t) return first.v;\n    if (t >= lastKey.t) return lastKey.v;\n\n    // Cache-friendly forward search: most callers sweep t monotonically.\n    let segment = this._lastSegment;\n\n    if (t < (keys[segment]?.t ?? 0)) {\n      segment = 0;\n    }\n\n    while (segment < last && t > (keys[segment + 1]?.t ?? Infinity)) {\n      segment++;\n    }\n\n    this._lastSegment = segment;\n\n    const a = keys[segment];\n    const b = keys[segment + 1];\n\n    if (a === undefined || b === undefined) return lastKey.v;\n\n    const ratio = (t - a.t) / (b.t - a.t);\n\n    return a.v + (b.v - a.v) * ratio;\n  }\n}\n"],"mappings":";AAQA,MAAM,YAAY,GAAa,MAAwB,EAAE,IAAI,EAAE;;;;;;;;;;;;;;;;;;;AAoB/D,IAAa,QAAb,MAAuD;CACrD,AAAiB;CACjB,AAAQ,eAAe;CAEvB,AAAO,YAAY,MAA2B;EAC5C,IAAI,KAAK,WAAW,GAClB,MAAM,IAAI,MAAM,uCAAuC;EAGzD,KAAK,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC,KAAK,QAAQ;CACtC;CAEA,AAAO,SAAS,GAAmB;EACjC,MAAM,OAAO,KAAK;EAClB,MAAM,OAAO,KAAK,SAAS;EAC3B,MAAM,QAAQ,KAAK;EACnB,MAAM,UAAU,KAAK;EAErB,IAAI,UAAU,UAAa,YAAY,QAAW,OAAO;EAEzD,IAAI,KAAK,MAAM,GAAG,OAAO,MAAM;EAC/B,IAAI,KAAK,QAAQ,GAAG,OAAO,QAAQ;EAGnC,IAAI,UAAU,KAAK;EAEnB,IAAI,KAAK,KAAK,QAAQ,EAAE,KAAK,IAC3B,UAAU;EAGZ,OAAO,UAAU,QAAQ,KAAK,KAAK,UAAU,EAAE,EAAE,KAAK,WACpD;EAGF,KAAK,eAAe;EAEpB,MAAM,IAAI,KAAK;EACf,MAAM,IAAI,KAAK,UAAU;EAEzB,IAAI,MAAM,UAAa,MAAM,QAAW,OAAO,QAAQ;EAEvD,MAAM,SAAS,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;EAEnC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK;CAC7B;AACF"}

package/dist/esm/distributions/Distribution.d.ts

@@ -1,6 +1,6 @@
 /**
  * Value distribution sampled at particle spawn time. Each `sample()` call
- * may return a different value — used to randomize spawn properties
+ * may return a different value - used to randomize spawn properties
  * (lifetime, position, velocity, scale, tint, ...) without per-particle
  * subclassing.
  *
@@ -34,12 +34,13 @@ export interface Distribution<T> {
 /**
  * Lifetime-parameterised function that produces a deterministic `T` for a
  * given lifetime ratio `t` in `[0, 1]`. Used by per-frame update modules
- * that interpolate over particle lifetime — `ColorOverLifetime` (ColorGradient),
+ * that interpolate over particle lifetime - `ColorOverLifetime` (ColorGradient),
  * `ScaleOverLifetime` (Curve), etc.
  *
- * Mutable-target rule: same as {@link Distribution} — pass your own scratch
+ * Mutable-target rule: same as {@link Distribution} - pass your own scratch
  * via `out` for hot loops, omit for one-off calls.
  */
 export interface LifetimeFunction<T> {
     evaluate(t: number, out?: T): T;
 }
+//# sourceMappingURL=Distribution.d.ts.map

package/dist/esm/distributions/Distribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Distribution.d.ts","sourceRoot":"","sources":["../../../src/distributions/Distribution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;CACjC"}

package/dist/esm/distributions/LineSegment.d.ts

@@ -13,3 +13,4 @@ export declare class LineSegment implements Distribution<Vector> {
     constructor(x0: number, y0: number, x1: number, y1: number);
     sample(out?: Vector): Vector;
 }
+//# sourceMappingURL=LineSegment.d.ts.map

package/dist/esm/distributions/LineSegment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LineSegment.d.ts","sourceRoot":"","sources":["../../../src/distributions/LineSegment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;GAGG;AACH,qBAAa,WAAY,YAAW,YAAY,CAAC,MAAM,CAAC;IAI7C,EAAE,EAAE,MAAM;IACV,EAAE,EAAE,MAAM;IACV,EAAE,EAAE,MAAM;IACV,EAAE,EAAE,MAAM;IANnB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;gBAGhC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM;IAGZ,MAAM,CAAC,GAAG,GAAE,MAAsB,GAAG,MAAM;CAOnD"}

package/dist/esm/distributions/LineSegment.js

@@ -1,27 +1,29 @@
-import { Vector } from '@codexo/exojs';
+import { Vector } from "@codexo/exojs";
 
+//#region src/distributions/LineSegment.ts
 /**
- * Random point on a line segment between `(x0, y0)` and `(x1, y1)`. Uniform
- * parameter distribution: `t = Math.random()` then `lerp(start, end, t)`.
- */
-class LineSegment {
-    x0;
-    y0;
-    x1;
-    y1;
-    _scratch = new Vector();
-    constructor(x0, y0, x1, y1) {
-        this.x0 = x0;
-        this.y0 = y0;
-        this.x1 = x1;
-        this.y1 = y1;
-    }
-    sample(out = this._scratch) {
-        const t = Math.random();
-        out.set(this.x0 + (this.x1 - this.x0) * t, this.y0 + (this.y1 - this.y0) * t);
-        return out;
-    }
-}
+* Random point on a line segment between `(x0, y0)` and `(x1, y1)`. Uniform
+* parameter distribution: `t = Math.random()` then `lerp(start, end, t)`.
+*/
+var LineSegment = class {
+	x0;
+	y0;
+	x1;
+	y1;
+	_scratch = new Vector();
+	constructor(x0, y0, x1, y1) {
+		this.x0 = x0;
+		this.y0 = y0;
+		this.x1 = x1;
+		this.y1 = y1;
+	}
+	sample(out = this._scratch) {
+		const t = Math.random();
+		out.set(this.x0 + (this.x1 - this.x0) * t, this.y0 + (this.y1 - this.y0) * t);
+		return out;
+	}
+};
 
+//#endregion
 export { LineSegment };
-//# sourceMappingURL=LineSegment.js.map
+//# sourceMappingURL=LineSegment.js.map

package/dist/esm/distributions/LineSegment.js.map

@@ -1 +1 @@
-{"version":3,"file":"LineSegment.js","sources":["../../../../src/distributions/LineSegment.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;AAGG;MACU,WAAW,CAAA;AAIb,IAAA,EAAA;AACA,IAAA,EAAA;AACA,IAAA,EAAA;AACA,IAAA,EAAA;AANQ,IAAA,QAAQ,GAAG,IAAI,MAAM,EAAE;AAExC,IAAA,WAAA,CACS,EAAU,EACV,EAAU,EACV,EAAU,EACV,EAAU,EAAA;QAHV,IAAA,CAAA,EAAE,GAAF,EAAE;QACF,IAAA,CAAA,EAAE,GAAF,EAAE;QACF,IAAA,CAAA,EAAE,GAAF,EAAE;QACF,IAAA,CAAA,EAAE,GAAF,EAAE;IACR;AAEI,IAAA,MAAM,CAAC,GAAA,GAAc,IAAI,CAAC,QAAQ,EAAA;AACvC,QAAA,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE;AAEvB,QAAA,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;AAE7E,QAAA,OAAO,GAAG;IACZ;AACD;;;;"}
+{"version":3,"file":"LineSegment.js","names":[],"sources":["../../../src/distributions/LineSegment.ts"],"sourcesContent":["import { Vector } from '@codexo/exojs';\n\nimport type { Distribution } from './Distribution';\n\n/**\n * Random point on a line segment between `(x0, y0)` and `(x1, y1)`. Uniform\n * parameter distribution: `t = Math.random()` then `lerp(start, end, t)`.\n */\nexport class LineSegment implements Distribution<Vector> {\n  private readonly _scratch = new Vector();\n\n  public constructor(\n    public x0: number,\n    public y0: number,\n    public x1: number,\n    public y1: number,\n  ) {}\n\n  public sample(out: Vector = this._scratch): Vector {\n    const t = Math.random();\n\n    out.set(this.x0 + (this.x1 - this.x0) * t, this.y0 + (this.y1 - this.y0) * t);\n\n    return out;\n  }\n}\n"],"mappings":";;;;;;;AAQA,IAAa,cAAb,MAAyD;CAI9C;CACA;CACA;CACA;CANT,AAAiB,WAAW,IAAI,OAAO;CAEvC,AAAO,YACL,AAAO,IACP,AAAO,IACP,AAAO,IACP,AAAO,IACP;EAJO;EACA;EACA;EACA;CACN;CAEH,AAAO,OAAO,MAAc,KAAK,UAAkB;EACjD,MAAM,IAAI,KAAK,OAAO;EAEtB,IAAI,IAAI,KAAK,MAAM,KAAK,KAAK,KAAK,MAAM,GAAG,KAAK,MAAM,KAAK,KAAK,KAAK,MAAM,CAAC;EAE5E,OAAO;CACT;AACF"}

package/dist/esm/distributions/Range.d.ts

@@ -10,3 +10,4 @@ export declare class Range implements Distribution<number> {
     constructor(min: number, max: number);
     sample(): number;
 }
+//# sourceMappingURL=Range.d.ts.map

package/dist/esm/distributions/Range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Range.d.ts","sourceRoot":"","sources":["../../../src/distributions/Range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;GAIG;AACH,qBAAa,KAAM,YAAW,YAAY,CAAC,MAAM,CAAC;IAEvC,GAAG,EAAE,MAAM;IACX,GAAG,EAAE,MAAM;gBADX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM;IAGb,MAAM,IAAI,MAAM;CAGxB"}

package/dist/esm/distributions/Range.js

@@ -1,19 +1,21 @@
+//#region src/distributions/Range.ts
 /**
- * Uniform random number in `[min, max]`. Each `sample()` returns a fresh
- * roll; the bounds are inclusive on both ends (modulo the rounding bias
- * inherent to `Math.random()`).
- */
-class Range {
-    min;
-    max;
-    constructor(min, max) {
-        this.min = min;
-        this.max = max;
-    }
-    sample() {
-        return this.min + Math.random() * (this.max - this.min);
-    }
-}
+* Uniform random number in `[min, max]`. Each `sample()` returns a fresh
+* roll; the bounds are inclusive on both ends (modulo the rounding bias
+* inherent to `Math.random()`).
+*/
+var Range = class {
+	min;
+	max;
+	constructor(min, max) {
+		this.min = min;
+		this.max = max;
+	}
+	sample() {
+		return this.min + Math.random() * (this.max - this.min);
+	}
+};
 
+//#endregion
 export { Range };
-//# sourceMappingURL=Range.js.map
+//# sourceMappingURL=Range.js.map

package/dist/esm/distributions/Range.js.map

@@ -1 +1 @@
-{"version":3,"file":"Range.js","sources":["../../../../src/distributions/Range.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;AAIG;MACU,KAAK,CAAA;AAEP,IAAA,GAAA;AACA,IAAA,GAAA;IAFT,WAAA,CACS,GAAW,EACX,GAAW,EAAA;QADX,IAAA,CAAA,GAAG,GAAH,GAAG;QACH,IAAA,CAAA,GAAG,GAAH,GAAG;IACT;IAEI,MAAM,GAAA;AACX,QAAA,OAAO,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;IACzD;AACD;;;;"}
+{"version":3,"file":"Range.js","names":[],"sources":["../../../src/distributions/Range.ts"],"sourcesContent":["import type { Distribution } from './Distribution';\n\n/**\n * Uniform random number in `[min, max]`. Each `sample()` returns a fresh\n * roll; the bounds are inclusive on both ends (modulo the rounding bias\n * inherent to `Math.random()`).\n */\nexport class Range implements Distribution<number> {\n  public constructor(\n    public min: number,\n    public max: number,\n  ) {}\n\n  public sample(): number {\n    return this.min + Math.random() * (this.max - this.min);\n  }\n}\n"],"mappings":";;;;;;AAOA,IAAa,QAAb,MAAmD;CAExC;CACA;CAFT,AAAO,YACL,AAAO,KACP,AAAO,KACP;EAFO;EACA;CACN;CAEH,AAAO,SAAiB;EACtB,OAAO,KAAK,MAAM,KAAK,OAAO,KAAK,KAAK,MAAM,KAAK;CACrD;AACF"}

package/dist/esm/distributions/VectorRange.d.ts

@@ -18,3 +18,4 @@ export declare class VectorRange implements Distribution<Vector> {
     constructor(minX: number, maxX: number, minY: number, maxY: number);
     sample(out?: Vector): Vector;
 }
+//# sourceMappingURL=VectorRange.d.ts.map

package/dist/esm/distributions/VectorRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VectorRange.d.ts","sourceRoot":"","sources":["../../../src/distributions/VectorRange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;;;;;GAQG;AACH,qBAAa,WAAY,YAAW,YAAY,CAAC,MAAM,CAAC;IAI7C,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IANrB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;gBAGhC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM;IAGd,MAAM,CAAC,GAAG,GAAE,MAAsB,GAAG,MAAM;CAKnD"}

package/dist/esm/distributions/VectorRange.js

@@ -1,31 +1,33 @@
-import { Vector } from '@codexo/exojs';
+import { Vector } from "@codexo/exojs";
 
+//#region src/distributions/VectorRange.ts
 /**
- * Uniform random vector with each axis sampled independently in its own
- * `[min, max]` range. Each `sample()` writes into the provided `out` Vector
- * (or an internal scratch instance when `out` is omitted).
- *
- * @example
- * const knockback = new VectorRange(-300, 300, -800, -200);  // any X, upward Y
- * knockback.sample(particle.velocity);  // writes into existing instance, no alloc
- */
-class VectorRange {
-    minX;
-    maxX;
-    minY;
-    maxY;
-    _scratch = new Vector();
-    constructor(minX, maxX, minY, maxY) {
-        this.minX = minX;
-        this.maxX = maxX;
-        this.minY = minY;
-        this.maxY = maxY;
-    }
-    sample(out = this._scratch) {
-        out.set(this.minX + Math.random() * (this.maxX - this.minX), this.minY + Math.random() * (this.maxY - this.minY));
-        return out;
-    }
-}
+* Uniform random vector with each axis sampled independently in its own
+* `[min, max]` range. Each `sample()` writes into the provided `out` Vector
+* (or an internal scratch instance when `out` is omitted).
+*
+* @example
+* const knockback = new VectorRange(-300, 300, -800, -200);  // any X, upward Y
+* knockback.sample(particle.velocity);  // writes into existing instance, no alloc
+*/
+var VectorRange = class {
+	minX;
+	maxX;
+	minY;
+	maxY;
+	_scratch = new Vector();
+	constructor(minX, maxX, minY, maxY) {
+		this.minX = minX;
+		this.maxX = maxX;
+		this.minY = minY;
+		this.maxY = maxY;
+	}
+	sample(out = this._scratch) {
+		out.set(this.minX + Math.random() * (this.maxX - this.minX), this.minY + Math.random() * (this.maxY - this.minY));
+		return out;
+	}
+};
 
+//#endregion
 export { VectorRange };
-//# sourceMappingURL=VectorRange.js.map
+//# sourceMappingURL=VectorRange.js.map

package/dist/esm/distributions/VectorRange.js.map

@@ -1 +1 @@
-{"version":3,"file":"VectorRange.js","sources":["../../../../src/distributions/VectorRange.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;AAQG;MACU,WAAW,CAAA;AAIb,IAAA,IAAA;AACA,IAAA,IAAA;AACA,IAAA,IAAA;AACA,IAAA,IAAA;AANQ,IAAA,QAAQ,GAAG,IAAI,MAAM,EAAE;AAExC,IAAA,WAAA,CACS,IAAY,EACZ,IAAY,EACZ,IAAY,EACZ,IAAY,EAAA;QAHZ,IAAA,CAAA,IAAI,GAAJ,IAAI;QACJ,IAAA,CAAA,IAAI,GAAJ,IAAI;QACJ,IAAA,CAAA,IAAI,GAAJ,IAAI;QACJ,IAAA,CAAA,IAAI,GAAJ,IAAI;IACV;AAEI,IAAA,MAAM,CAAC,GAAA,GAAc,IAAI,CAAC,QAAQ,EAAA;AACvC,QAAA,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;AAEjH,QAAA,OAAO,GAAG;IACZ;AACD;;;;"}
+{"version":3,"file":"VectorRange.js","names":[],"sources":["../../../src/distributions/VectorRange.ts"],"sourcesContent":["import { Vector } from '@codexo/exojs';\n\nimport type { Distribution } from './Distribution';\n\n/**\n * Uniform random vector with each axis sampled independently in its own\n * `[min, max]` range. Each `sample()` writes into the provided `out` Vector\n * (or an internal scratch instance when `out` is omitted).\n *\n * @example\n * const knockback = new VectorRange(-300, 300, -800, -200);  // any X, upward Y\n * knockback.sample(particle.velocity);  // writes into existing instance, no alloc\n */\nexport class VectorRange implements Distribution<Vector> {\n  private readonly _scratch = new Vector();\n\n  public constructor(\n    public minX: number,\n    public maxX: number,\n    public minY: number,\n    public maxY: number,\n  ) {}\n\n  public sample(out: Vector = this._scratch): Vector {\n    out.set(this.minX + Math.random() * (this.maxX - this.minX), this.minY + Math.random() * (this.maxY - this.minY));\n\n    return out;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAaA,IAAa,cAAb,MAAyD;CAI9C;CACA;CACA;CACA;CANT,AAAiB,WAAW,IAAI,OAAO;CAEvC,AAAO,YACL,AAAO,MACP,AAAO,MACP,AAAO,MACP,AAAO,MACP;EAJO;EACA;EACA;EACA;CACN;CAEH,AAAO,OAAO,MAAc,KAAK,UAAkB;EACjD,IAAI,IAAI,KAAK,OAAO,KAAK,OAAO,KAAK,KAAK,OAAO,KAAK,OAAO,KAAK,OAAO,KAAK,OAAO,KAAK,KAAK,OAAO,KAAK,KAAK;EAEhH,OAAO;CACT;AACF"}

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

@@ -10,3 +10,4 @@ export type { Distribution, LifetimeFunction } from './Distribution';
 export { LineSegment } from './LineSegment';
 export { Range } from './Range';
 export { VectorRange } from './VectorRange';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/distributions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}