@tixyel/streamelements 7.0.5 → 7.2.0

package/dist/index.d.ts

@@ -2414,15 +2414,28 @@ declare class ElementHelper {
      * Adds 'container' class and data-index to all parent elements, and wraps each character in a span with class 'char' and data-index.
      * @param htmlString - The input HTML string containing formatted text elements (span, strong, em, etc).
      * @param startIndex - The starting index for the data-index attribute (default is 0).
+     * @param preserveInterElementWhitespace - Whether to preserve whitespace between elements (default is false).
+     * @param options - Optional settings for splitting text, including skipWhitespaceIndex to control index incrementing for whitespace characters.
      * @returns - A new HTML string with containers and character-level indexing.
      * @example
      * ```javascript
      * const result = splitTextToChars('<span>TesTe</span> <strong>bold</strong>', 0);
      * console.log(result);
      * // Output: '<span class="container" data-index="0"><span class="char" data-index="0">T</span><span class="char" data-index="1">e</span>...'
+     *
+     * // Example with skipWhitespaceIndex
+     * const resultSkipWhitespace = splitTextToChars('<span>Hello World</span>', 0, false, { skipWhitespaceIndex: true });
+     * // The space character will have data-index but won't increment index for subsequent characters
      * ```
      */
-    splitTextToChars(htmlString: string, startIndex?: number, preserveInterElementWhitespace?: boolean): string;
+    splitTextToChars(htmlString: string, startIndex?: number, preserveInterElementWhitespace?: boolean, options?: {
+        /**
+         * If true, skips incrementing the index for whitespace characters (space, newline, tab).
+         * These characters will still have a data-index, but it won't be incremented for subsequent characters.
+         * Default is true.
+         */
+        skipWhitespaceIndex?: boolean;
+    }): string;
 }
 
 declare class ObjectHelper {
@@ -3093,7 +3106,217 @@ type IdentifyYouTubeResult = {
     top: TopType;
 };
 
+type Point = {
+    x: number;
+    y: number;
+};
+type AnimOptions = {
+    /** Duration in seconds. Default: `1` */
+    duration?: number;
+    fps?: number;
+    easing?: (t: number) => number;
+};
+type AnimResult = {
+    x: number[];
+    y: number[];
+};
+type QuadraticParams = AnimOptions & {
+    from: Point;
+    to: Point;
+    control: Point;
+};
+type CubicParams = AnimOptions & {
+    from: Point & {
+        control: Point;
+    };
+    to: Point & {
+        control: Point;
+    };
+};
+type MultiCubicPoint = Point & {
+    control?: Point;
+    controlIn?: Point;
+    controlOut?: Point;
+};
+type MultiCubicParams = AnimOptions & {
+    points: [MultiCubicPoint, MultiCubicPoint, MultiCubicPoint, ...MultiCubicPoint[]];
+};
+type CircleParams = AnimOptions & {
+    center: Point;
+    radius: number;
+    from?: number;
+    to?: number;
+};
+type SpiralParams = AnimOptions & {
+    center: Point;
+    radius: {
+        from: number;
+        to: number;
+    };
+    turns?: number;
+};
+declare class AnimateHelper {
+    /**
+     * Interpolate a number from start to end
+     * @example
+     * ```ts
+     * const value = animate.lerp(0, 100, 0.5);
+     * console.log(value); // 50
+     * // Clamped between 0 and 1
+     * const clamped = animate.lerp(0, 100, 1.5);
+     * console.log(clamped); // 100
+     * const clamped2 = animate.lerp(0, 100, -0.5);
+     * console.log(clamped2); // 0
+     * const easeIn = animate.lerp(0, 100, (t) => t * t);
+     * console.log(easeIn); // 25 at t=0.5
+     * const linear = animate.lerp(0, 100, 0.5);
+     * console.log(linear); // 50 at t=0.5
+     * // Ease-in should be less than linear at t=0.5
+     * console.log(easeIn < linear); // true
+     * ```
+     */
+    lerp(start: number, end: number, t: number): number;
+    /**
+     * Create a quadratic Bezier path between two positions using a control point.
+     * Returns sampled x/y coordinates for the animation timeline.
+     * @example
+     * ```ts
+     * const { x, y } = animate.quadratic({
+     *   from: { x: 0, y: 0 },
+     *   to: { x: 100, y: 0 },
+     *   control: { x: 50, y: 50 },
+     *   duration: 1,
+     *   fps: 60,
+     *   easing: Motion.easeInOut,
+     * });
+     *
+     * // Use with Motion.animate
+     * Motion.animate(element, { x, y }, { duration: 1 });
+     * ```
+     */
+    quadratic({ from, to, control, duration, fps, easing, }: QuadraticParams): AnimResult;
+    /**
+     * Create a cubic Bezier path between two positions using two control points.
+     * Returns sampled x/y coordinates for the animation timeline.
+     * @example
+     * ```ts
+     * const { x, y } = animate.cubic({
+     *   from: { x: 0, y: 0, control: { x: 50, y: 100 } },
+     *   to: { x: 200, y: 0, control: { x: 150, y: 100 } },
+     *   duration: 2,
+     *   fps: 60,
+     *   easing: Motion.easeInOut,
+     * });
+     * ```
+     */
+    cubic({ from, to, duration, fps, easing }: CubicParams): AnimResult;
+    private getMultiCubicOutgoingControl;
+    private getMultiCubicIncomingControl;
+    /**
+     * Create a chained cubic Bezier path using 3 or more points.
+     * First and last points use a single control handle.
+     * Middle points can use separate incoming and outgoing handles.
+     *
+     * Every consecutive pair creates one cubic segment:
+     * `P0 = points[i]`, `P1 = points[i].controlOut`, `P2 = points[i + 1].controlIn`, `P3 = points[i + 1]`.
+     *
+     * For compatibility, `control` is treated as a shared handle when `controlIn` or `controlOut`
+     * are not provided.
+     * @example
+     * ```ts
+     * const { x, y } = animate.multiCubic({
+     *   points: [
+     *     { x: 0, y: 0, control: { x: 20, y: 40 } },
+     *     {
+     *       x: 100,
+     *       y: 0,
+     *       controlIn: { x: 80, y: 60 },
+     *       controlOut: { x: 120, y: -20 },
+     *     },
+     *     { x: 200, y: 50, control: { x: 160, y: 120 } },
+     *   ],
+     *   duration: 2,
+     *   fps: 60,
+     *   easing: Motion.easeInOut,
+     * });
+     * ```
+     */
+    multiCubic({ points, duration, fps, easing }: MultiCubicParams): AnimResult;
+    /**
+     * Create a circular path around a center point.
+     * Angles in degrees. Default: `from: 0`, `to: 360`.
+     * @example
+     * ```ts
+     * const { x, y } = animate.circle({
+     *   center: { x: 100, y: 100 },
+     *   radius: 50,
+     *   from: 0,
+     *   to: 360,
+     *   duration: 3,
+     *   fps: 60,
+     * });
+     * ```
+     */
+    circle({ center, radius, from, to, duration, fps, easing, }: CircleParams): AnimResult;
+    /**
+     * Create a spiral path around a center point.
+     * @example
+     * ```ts
+     * const { x, y } = animate.spiral({
+     *   center: { x: 0, y: 0 },
+     *   radius: { from: 10, to: 100 },
+     *   turns: 3,
+     *   duration: 2,
+     *   fps: 60,
+     *   easing: (t) => 1 - (1 - t) * (1 - t),
+     * });
+     *
+     * // This will create a spiral that starts at radius 10 and expands to radius 100 over 3 turns.
+     * ```
+     */
+    spiral({ center, radius, turns, duration, fps, easing, }: SpiralParams): AnimResult;
+    /**
+     * Chain multiple animation paths together sequentially.
+     * @example
+     * ```ts
+     * const path1 = animate.quadratic({
+     *   from: { x: 0, y: 0 },
+     *   to: { x: 100, y: 0 },
+     *   control: { x: 50, y: 50 },
+     *   duration: 1,
+     *   fps: 60,
+     * });
+     *
+     * const path2 = animate.circle({
+     *   center: { x: 100, y: 0 },
+     *   radius: 30,
+     *   from: 0,
+     *   to: 180,
+     *   duration: 1,
+     *   fps: 60,
+     * });
+     *
+     * const combined = animate.chain(path1, path2);
+     * ```
+     */
+    chain(...animations: AnimResult[]): AnimResult;
+    /**
+     * Execute multiple animations in sequence with optional delays between them.
+     * Each animation will be sampled and delays will add repeating the last coordinate.
+     * @example
+     * ```ts
+     * const path1 = animate.quadratic({ from: { x: 0, y: 0 }, to: { x: 50, y: 0 }, control: { x: 25, y: 25 }, duration: 0.5, fps: 30 });
+     * const path2 = animate.quadratic({ from: { x: 50, y: 0 }, to: { x: 100, y: 0 }, control: { x: 75, y: 25 }, duration: 0.5, fps: 30 });
+     *
+     * // 30 frames delay between animations
+     * const sequenced = animate.sequence([path1, path2], 30);
+     * ```
+     */
+    sequence(animations: AnimResult[], delayFrames?: number | number[]): AnimResult;
+}
+
 declare namespace Helper {
+    const animate: AnimateHelper;
     const number: NumberHelper;
     const element: ElementHelper;
     const object: ObjectHelper;

package/dist/index.es.js

@@ -262,8 +262,8 @@ var e = class {
 		if (l === 0 || u === 0) throw Error("Element has zero width or height, cannot scale");
 		let d = c.width * n / l, f = c.height * n / u, p = o === "width" ? d : o === "height" ? f : Math.min(d, f);
 		if (t > 0) {
-			let e = c.width * t / l, n = c.height * t / u, r = Math.max(e, n);
-			p = Math.max(r, p);
+			let e = c.width * t / l, n = c.height * t / u;
+			p = Math.max(Math.max(e, n), p);
 		}
 		let m = {
 			width: l * p,
@@ -275,10 +275,10 @@ var e = class {
 	scalev2(e, t = {}) {
 		let { parent: n = e.parentElement, prefer: r = "auto", min: i = 0, max: a = 1, apply: o = () => {} } = t;
 		if (!n) throw Error("No parent element found for scaling");
-		let s = n.getBoundingClientRect(), c = e.getBoundingClientRect(), l = s.width, u = s.height, d = c.width, f = c.height, p = l * i / d, m = u * i / f, h = l * a / d, g = u * a / f, _ = Math.min(h, g), v = Math.max(p, m);
-		_ = Math.max(_, v);
-		let y = d * _, b = f * _;
-		return r === "width" ? _ = Math.max(p, Math.min(h, l / d)) : r === "height" ? _ = Math.max(m, Math.min(g, u / f)) : y > l ? _ = Math.max(p, Math.min(h, l / d)) : b > u && (_ = Math.max(m, Math.min(g, u / f))), o.apply(e, [_, e]), _;
+		let s = n.getBoundingClientRect(), c = e.getBoundingClientRect(), l = s.width, u = s.height, d = c.width, f = c.height, p = l * i / d, m = u * i / f, h = l * a / d, g = u * a / f, _ = Math.min(h, g);
+		_ = Math.max(_, Math.max(p, m));
+		let v = d * _, y = f * _;
+		return r === "width" ? _ = Math.max(p, Math.min(h, l / d)) : r === "height" ? _ = Math.max(m, Math.min(g, u / f)) : v > l ? _ = Math.max(p, Math.min(h, l / d)) : y > u && (_ = Math.max(m, Math.min(g, u / f))), o.apply(e, [_, e]), _;
 	}
 	fitText(e, t = 1, n = {}) {
 		let r = parseFloat(getComputedStyle(e).getPropertyValue("font-size")), a = {
@@ -289,33 +289,35 @@ var e = class {
 		let s = r * (o.clientWidth * t / e.offsetWidth), c = new i().balance(s, a.minFontSize, a.maxFontSize);
 		return e.style.fontSize = c + "px", e;
 	}
-	splitTextToChars(e, t = 0, n = !1) {
-		let r = new DOMParser(), i = document.createElement("div"), a = t;
-		function o(e) {
+	splitTextToChars(e, t = 0, n = !1, r = {}) {
+		let { skipWhitespaceIndex: i = !0 } = r, a = new DOMParser(), o = document.createElement("div"), s = t;
+		function c(e) {
 			if (e.nodeType === Node.TEXT_NODE) {
-				let t = (e.textContent || "").split("").map((e, t) => {
-					let n = document.createElement("span");
-					return n.classList.add("char"), n.dataset.index = String(a), n.dataset.exclusivityIndex = String(t), n.style.setProperty("--char-index", String(a)), n.style.setProperty("--exclusivity-index", String(t)), e === " " || e === "\n" || e === "	" ? n.style.whiteSpace = "pre-wrap" : a++, n.textContent = e, n;
-				}), n = document.createDocumentFragment();
-				return t.forEach((e) => n.appendChild(e)), n;
+				let t = e.textContent || "", n = 0, r = t.split("").map((e) => {
+					let t = document.createElement("span");
+					t.classList.add("char"), t.dataset.index = String(s), t.dataset.exclusivityIndex = String(n), t.dataset.type = "char", t.style.setProperty("--char-index", String(s)), t.style.setProperty("--exclusivity-index", String(n));
+					let r = e === " " || e === "\n" || e === "	";
+					return r && (t.style.whiteSpace = "pre-wrap", t.classList.remove("char"), t.classList.add("whitespace"), t.dataset.type = "whitespace"), (!r || !i) && (s++, n++), t.textContent = e, t;
+				}), a = document.createDocumentFragment();
+				return r.forEach((e) => a.appendChild(e)), a;
 			} else if (e.nodeType === Node.ELEMENT_NODE) {
 				let t = e.cloneNode(!1);
-				return t.classList.add("container"), t.dataset.index = String(a), t.style.setProperty("--char-index", String(a)), t.style.setProperty("--exclusivity-index", String(a)), a++, e.childNodes.forEach((e) => {
-					let n = o(e);
+				return t.classList.add("container"), t.dataset.index = String(s), t.dataset.type = "container", t.style.setProperty("--char-index", String(s)), t.style.setProperty("--exclusivity-index", String(s)), s++, e.childNodes.forEach((e) => {
+					let n = c(e);
 					t.appendChild(n);
 				}), t;
 			}
 			return e.cloneNode(!0);
 		}
-		r.parseFromString(e, "text/html").body.childNodes.forEach((e) => {
+		a.parseFromString(e, "text/html").body.childNodes.forEach((e) => {
 			if (!n && e.nodeType === Node.TEXT_NODE && !e.textContent?.trim()) return;
-			let t = o(e);
-			i.appendChild(t);
+			let t = c(e);
+			o.appendChild(t);
 		});
-		let s = "";
-		return Array.from(i.childNodes).forEach((e) => {
-			e.nodeType === Node.TEXT_NODE ? s += e.textContent : s += e.outerHTML;
-		}), s;
+		let l = "";
+		return Array.from(o.childNodes).forEach((e) => {
+			e.nodeType === Node.TEXT_NODE ? l += e.textContent : l += e.outerHTML;
+		}), l;
 	}
 }, o = class {
 	flatten(e, t = !0, n = "") {
@@ -9702,8 +9704,8 @@ var M = class {
 		function m(e, t) {
 			let n = e?.trim?.() ?? "";
 			if (!n.length) return null;
-			let r = t[n], i = r === void 0 ? n : r, a = parseFloat(String(i).replace(/\s/g, ""));
-			return isNaN(a) ? null : a;
+			let r = t[n], i = parseFloat(String(r === void 0 ? n : r).replace(/\s/g, ""));
+			return isNaN(i) ? null : i;
 		}
 		function h(e, t, n) {
 			let r = isNaN(Number(t)) ? 0 : Math.max(0, parseInt(String(t))), i = m(e, n);
@@ -9718,8 +9720,8 @@ var M = class {
 			}
 		}
 		function g(e, t = /* @__PURE__ */ new Date()) {
-			let n = t.getTime() - e.getTime(), r = n >= 0, i = Math.abs(n), a = Math.floor(i / 1e3), o = Math.floor(a / 60), s = Math.floor(o / 60), c = Math.floor(s / 24), l = Math.floor(c / 30), u = Math.floor(c / 365), d = r ? "ago" : "from now";
-			return u > 0 ? `${u}y ${d}` : l > 0 ? `${l}mo ${d}` : c > 0 ? `${c}d ${d}` : s > 0 ? `${s}h ${d}` : o > 0 ? `${o}m ${d}` : `${Math.max(a, 0)}s ${d}`;
+			let n = t.getTime() - e.getTime(), r = n >= 0, i = Math.floor(Math.abs(n) / 1e3), a = Math.floor(i / 60), o = Math.floor(a / 60), s = Math.floor(o / 24), c = Math.floor(s / 30), l = Math.floor(s / 365), u = r ? "ago" : "from now";
+			return l > 0 ? `${l}y ${u}` : c > 0 ? `${c}mo ${u}` : s > 0 ? `${s}d ${u}` : o > 0 ? `${o}h ${u}` : a > 0 ? `${a}m ${u}` : `${Math.max(i, 0)}s ${u}`;
 		}
 		function _(e, t, n) {
 			let r = e?.trim?.() ?? "";
@@ -10309,7 +10311,7 @@ var M = class {
 			message: new T().array(e)[0]
 		};
 	}
-}, z = class {
+}, z = class e {
 	delay(e, t) {
 		return new Promise((n) => setTimeout(() => {
 			n(t ? t() ?? null : null);
@@ -10356,9 +10358,9 @@ var M = class {
 			isSameMoment: i === 0
 		};
 	}
-	probability(e) {
-		let t = Object.values(e).reduce((e, t) => e + t, 0), n = this.typedEntries(e).sort((e, t) => t[1] - e[1]), r = Math.random() * t, i = 0;
-		for (let [e, t] of n) if (i += t, r < i) return e;
+	probability(t) {
+		let n = Object.values(t).reduce((e, t) => e + t, 0), r = new e().typedEntries(t).sort((e, t) => t[1] - e[1]), i = Math.random() * n, a = 0;
+		for (let [e, t] of r) if (a += t, i < a) return e;
 	}
 	async findSubscriptionTier({ userId: e, name: t, broadcasterId: n }, r, i = !1) {
 		let a = (e) => e === "prime" || e === "1000" || e === 1e3 || e === 1 || e === "1" ? 1 : e === "2000" || e === 2e3 || e === 2 || e === "2" ? 2 : e === "3000" || e === 3e3 || e === 3 || e === "3" ? 3 : 1;
@@ -10472,9 +10474,105 @@ var M = class {
 			}
 		}
 	}
+}, ne = class {
+	lerp(e, t, n) {
+		let r = Math.max(0, Math.min(1, n));
+		return e + (t - e) * r;
+	}
+	quadratic({ from: e, to: t, control: n, duration: r = 1, fps: i = 60, easing: a = (e) => e }) {
+		let o = Math.max(2, Math.round(r * i)), s = [], c = [];
+		for (let r = 0; r <= o; r++) {
+			let i = a(r / o);
+			s.push((1 - i) * (1 - i) * e.x + 2 * (1 - i) * i * n.x + i * i * t.x), c.push((1 - i) * (1 - i) * e.y + 2 * (1 - i) * i * n.y + i * i * t.y);
+		}
+		return {
+			x: s,
+			y: c
+		};
+	}
+	cubic({ from: e, to: t, duration: n = 1, fps: r = 60, easing: i = (e) => e }) {
+		let a = Math.max(2, Math.round(n * r)), o = [], s = [];
+		for (let n = 0; n <= a; n++) {
+			let r = i(n / a), c = 1 - r;
+			o.push(c * c * c * e.x + 3 * c * c * r * e.control.x + 3 * c * r * r * t.control.x + r * r * r * t.x), s.push(c * c * c * e.y + 3 * c * c * r * e.control.y + 3 * c * r * r * t.control.y + r * r * r * t.y);
+		}
+		return {
+			x: o,
+			y: s
+		};
+	}
+	getMultiCubicOutgoingControl(e, t) {
+		let n = e.controlOut ?? e.control;
+		if (n) return n;
+		throw Error(t === 0 ? "The first multiCubic point requires `control` or `controlOut`." : `The multiCubic point at index ${t} requires \`controlOut\` or a shared \`control\`.`);
+	}
+	getMultiCubicIncomingControl(e, t, n) {
+		let r = e.controlIn ?? e.control;
+		if (r) return r;
+		throw Error(t === n ? "The last multiCubic point requires `control` or `controlIn`." : `The multiCubic point at index ${t} requires \`controlIn\` or a shared \`control\`.`);
+	}
+	multiCubic({ points: e, duration: t = 1, fps: n = 60, easing: r = (e) => e }) {
+		if (e.length < 3) throw Error("multiCubic requires at least 3 points.");
+		let i = e.length - 1, a = e.length - 1, o = Math.max(2, Math.round(t * n)), s = Math.max(1, Math.floor(o / i)), c = o % i, l = [], u = [];
+		for (let t = 0; t < i; t++) {
+			let n = e[t], i = e[t + 1], o = this.getMultiCubicOutgoingControl(n, t), d = this.getMultiCubicIncomingControl(i, t + 1, a), f = s + (c > 0 ? 1 : 0);
+			c > 0 && c--;
+			let p = t === 0 ? 0 : 1;
+			for (let e = p; e <= f; e++) {
+				let t = r(e / f), a = 1 - t;
+				l.push(a * a * a * n.x + 3 * a * a * t * o.x + 3 * a * t * t * d.x + t * t * t * i.x), u.push(a * a * a * n.y + 3 * a * a * t * o.y + 3 * a * t * t * d.y + t * t * t * i.y);
+			}
+		}
+		return {
+			x: l,
+			y: u
+		};
+	}
+	circle({ center: e, radius: t, from: n = 0, to: r = 360, duration: i = 1, fps: a = 60, easing: o = (e) => e }) {
+		let s = Math.max(2, Math.round(i * a)), c = [], l = [];
+		for (let i = 0; i <= s; i++) {
+			let a = o(i / s), u = (n + (r - n) * a) * Math.PI / 180;
+			c.push(e.x + t * Math.cos(u)), l.push(e.y + t * Math.sin(u));
+		}
+		return {
+			x: c,
+			y: l
+		};
+	}
+	spiral({ center: e, radius: t, turns: n = 1, duration: r = 1, fps: i = 60, easing: a = (e) => e }) {
+		let o = Math.max(2, Math.round(r * i)), s = [], c = [];
+		for (let r = 0; r <= o; r++) {
+			let i = a(r / o), l = this.lerp(t.from, t.to, i), u = i * n * 360 * Math.PI / 180;
+			s.push(e.x + l * Math.cos(u)), c.push(e.y + l * Math.sin(u));
+		}
+		return {
+			x: s,
+			y: c
+		};
+	}
+	chain(...e) {
+		let t = [], n = [];
+		for (let r of e) t.push(...r.x), n.push(...r.y);
+		return {
+			x: t,
+			y: n
+		};
+	}
+	sequence(e, t = 0) {
+		let n = [], r = [], i = Array.isArray(t) ? t : e.map(() => t);
+		for (let t = 0; t < e.length; t++) {
+			let a = e[t], o = i[t] ?? 0;
+			for (let e = 0; e < o; e++) n.push(a.x[0]), r.push(a.y[0]);
+			n.push(...a.x), r.push(...a.y);
+		}
+		return {
+			x: n,
+			y: r
+		};
+	}
 }, B;
 (function(e) {
-	e.number = new i(), e.element = new a(), e.object = new o(), e.message = new E(), e.event = new D(), e.string = new N(), e.sound = new P(), e.color = new M(), e.random = new T(), e.fn = new F(), e.utils = new z();
+	e.animate = new ne(), e.number = new i(), e.element = new a(), e.object = new o(), e.message = new E(), e.event = new D(), e.string = new N(), e.sound = new P(), e.color = new M(), e.random = new T(), e.fn = new F(), e.utils = new z();
 })(B ||= {});
 //#endregion
 //#region src/actions/button.ts
@@ -10595,7 +10693,7 @@ var V = [], H = class e {
 			return !1;
 		}
 	}
-}, G = [], ne = class extends e {
+}, G = [], re = class extends e {
 	constructor(e = {}) {
 		super(), this.SE_API = null, this.id = "widget communications", this.loaded = !1, this.history = [], this.detected = /* @__PURE__ */ new Set(), this.id = e.id || this.id, G.push(this), Z?.then(async (e) => {
 			this.loaded = !0, this.SE_API = e, Promise.all([async () => {
@@ -12664,7 +12762,7 @@ var J = class {
 	timeEnd(e) {
 		!this.enabled || !console.timeEnd || console.timeEnd(e);
 	}
-}, re = class extends e {
+}, ie = class extends e {
 	constructor(e, t) {
 		super(), this.isDebug = !1, this.init = !1, this.emulate = !1, this.username = e.username, this.password = e.password, this.channels = e.channels, this.isDebug = !!e.isDebug, this.init = !!e.init, this.emulate = t, this.load().then((e) => {
 			this.instance = e, this.emit("load", e), this.connect();
@@ -12836,7 +12934,7 @@ var J = class {
 		list: {}
 	}
 };
-async function ie() {
+async function ae() {
 	let e = localStorage.getItem("SE_API-STORE") ?? "", t = e ? JSON.parse(e) : {};
 	return Y.store.list = t, Y;
 }
@@ -12891,7 +12989,7 @@ var X;
 })(X ||= {});
 //#endregion
 //#region src/main.ts
-var Z = typeof SE_API < "u" ? Promise.resolve(SE_API) : Promise.resolve(ie()), Q = new J(), $ = {
+var Z = typeof SE_API < "u" ? Promise.resolve(SE_API) : Promise.resolve(ae()), Q = new J(), $ = {
 	SeAPI: Z,
 	Client: r,
 	Helper: B,
@@ -12903,14 +13001,14 @@ var Z = typeof SE_API < "u" ? Promise.resolve(SE_API) : Promise.resolve(ie()), Q
 		useStorage: n,
 		useQueue: K,
 		useLogger: J,
-		useComms: ne,
+		useComms: re,
 		FakeUserPool: te
 	},
 	actions: {
 		Button: H,
 		Command: W
 	},
-	multistream: { useComfyJs: re },
+	multistream: { useComfyJs: ie },
 	internal: {
 		usedStorages: t,
 		usedComms: G,
@@ -12923,8 +13021,8 @@ var Z = typeof SE_API < "u" ? Promise.resolve(SE_API) : Promise.resolve(ie()), Q
 typeof window < "u" ? window.Tixyel = $ : globalThis.Tixyel = $;
 //#endregion
 //#region src/index.ts
-var ae = $;
+var oe = $;
 //#endregion
-export { ae as default };
+export { oe as default };
 
 //# sourceMappingURL=index.es.js.map