upwwwards 0.1.9-beta.1 → 0.1.10-beta.1

package/dist/{index-Di5rQVjZ.d.ts → index-ymMzfIlh.d.ts}

@@ -783,11 +783,48 @@ declare abstract class Scroll extends Lazy {
     static to(target: HTMLElement | number | string, options?: ScrollToOptions): void;
 }
 
+declare namespace Split {
+    /**
+        * Options for {@link Split.add}: GSAP `SplitText.Vars`, plus an optional `reconstruct` flag.
+        * By default, each target keeps one cached {@link Split.SPLIT}: a later `add` that only needs a
+        * **subset** of already split types (and a compatible `mask`) returns that same object; if new types
+        * or a new `mask` are required, types are **merged** and the existing `SplitText` is re-split in place.
+        * Set `reconstruct: true` to **replace** the cached types / mask with this call’s values and re-split
+        * (no merge). `reconstruct` is upwwwards-only and is not passed to GSAP.
+    */
+    type VARS = SplitText.Vars & {
+        reconstruct?: boolean;
+    };
+    /**
+        * A split kind accepted in `vars.type` (`'chars'`, `'lines'`, or `'words'`).
+    */
+    type TYPE = 'chars' | 'lines' | 'words';
+    /**
+        * Result of {@link Split.add}: one stable object per `target` on this helper.
+        * `chars` / `lines` / `words` / `masks` are the same array references across calls; their contents are
+        * updated in place when the underlying `SplitText` is re-split. `types` / `mask` reflect the current
+        * split definition; `splitText` is the single GSAP instance for that target.
+    */
+    type SPLIT = {
+        types: TYPE[];
+        mask: TYPE | undefined;
+        chars: Element[];
+        lines: Element[];
+        words: Element[];
+        masks: Element[];
+        splitText: SplitText;
+    };
+}
 /**
-    * Collection of GSAP `SplitText` instances owned by a private GSAP context, reverted together by `destroy`
-    * (which restores the original markup).
+    * Helper that owns one GSAP `SplitText` per target in a private GSAP context, reverted together by {@link Split.destroy}
+    * (restoring the original markup).
+    * On the **same target**, {@link Split.add} returns the same {@link Split.SPLIT}: subset requests reuse it as-is;
+    * wider requests (or a new `mask`) merge into the cached types and call `splitText.split(…)`. Pass
+    * `reconstruct: true` to replace the definition instead of merging. Element arrays on the `SPLIT` are kept by
+    * reference and refreshed in place after a re-split — prefer that object over holding individual node refs across
+    * a reconstruct / expand (tweens already targeting old nodes stay stale).
     * When constructed inside an `Up.Anime.sub` callback, the instance pushes its `destroy` on the workspace's cleaning stack
-    * (the list of destructors run by `Up.Anime.unsub`), so it is cleaned up automatically.
+    * (run by `Up.Anime.unsub`), so it is cleaned up automatically.
     * @note Requires `'SplitText'` in the Anime config (`plugins: ['SplitText']`).
     * @note Get the class from the Anime bucket (`bucket.Split`): it is only usable once Anime has loaded GSAP.
     * @example
@@ -816,15 +853,28 @@ declare class Split {
     */
     constructor();
     /**
-        * Splits `target` with `SplitText.create` inside the managed context, so `destroy` reverts it.
-        * @param target Element(s) to split.
-        * @param vars `SplitText` options.
-        * @returns The created `SplitText` instance.
+        * Splits `target` according to `vars.type` (and optional `mask`). Work is recorded in the managed GSAP context
+        * so {@link Split.destroy} can revert it.
+        * **Same target, default:** if the cached split already covers the requested types and `mask`, returns that
+        * {@link Split.SPLIT} unchanged; otherwise merges the new types (and updates `mask` when provided), re-splits
+        * via `splitText.split(…)`, and refreshes `chars` / `lines` / `words` / `masks` in place.
+        * **`reconstruct: true`:** replaces the cached types / mask with this call’s values, re-splits, then refreshes
+        * the arrays (still the same `SPLIT` object / `splitText` instance). Unknown tokens in `type` are ignored.
+        * @param target Element(s) to split (Map key for the per-target cache).
+        * @param vars GSAP `SplitText` options; `type` is required. Optional `reconstruct` is upwwwards-only and is not passed to GSAP.
+        * @returns The cached {@link Split.SPLIT} for `target` (created on first `add`).
+        * @example
+        * ```ts
+        * const lines = split.add('.title', { type: 'lines' })
+        * const both  = split.add('.title', { type: 'lines,words' }) // same object; union + re-split
+        * const words = split.add('.title', { type: 'words' }) // same object; subset → no re-split
+        * const only  = split.add('.title', { type: 'words', reconstruct: true }) // same object; replace + re-split
+        * ```
     */
-    add(target: gsap.DOMTarget, vars?: SplitText.Vars): SplitText;
+    add(target: gsap.DOMTarget, { reconstruct, ...vars }: Split.VARS): Split.SPLIT;
     /**
-        * Reverts every `SplitText` instance created through this helper, then starts over with an empty context.
-        * The instance stays usable afterwards.
+        * Clears the per-target cache, reverts every `SplitText` owned by this helper, and starts over with an empty context.
+        * The instance stays usable afterwards (new `add` calls behave like on a fresh `Split`).
     */
     destroy(): void;
 }

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { W as Wait } from './Wait-C8AD49l9.js';
 import { T as Thread, a as App } from './Thread-5NGNyOJb.js';
 export { b as AppCache } from './Thread-5NGNyOJb.js';
 import { A as Adapter, a as AdapterConfig } from './index-BlwaDpQl.js';
-import { P as Plugin } from './index-Di5rQVjZ.js';
+import { P as Plugin } from './index-ymMzfIlh.js';
 import 'lenis';
 import 'gsap/SplitText';
 import 'gsap/ScrollTrigger';

package/dist/initializers/vite.d.ts

@@ -1,6 +1,6 @@
 import { Plugin as Plugin$1 } from 'vite';
 import { Up } from '../index.js';
-import { P as Plugin } from '../index-Di5rQVjZ.js';
+import { P as Plugin } from '../index-ymMzfIlh.js';
 import { C as Classter } from '../Classter-BvYgmPAa.js';
 import '../symbols/index.js';
 import '../Wait-C8AD49l9.js';

package/dist/plugins/@anime/Split.js

@@ -4,12 +4,17 @@ import Logs from "../../scripts/Logs.js";
 class Split {
   // #PROPS
   // ##STATICS
+  static #RGX_TYPE = /\s*,\s*/;
+  static #TYPES = ["chars", "lines", "words"];
+  static #PROPS = [...Split.#TYPES, "masks"];
+  static #PROPS_LENGTH = Split.#PROPS.length;
   /**
       * Anime bucket shared by the Anime plugin once GSAP is loaded; includes `SplitText` when it is in the Anime config.
       * @internal
   */
   static [BUCKET];
   // ##PRIVATES
+  #CACHE = /* @__PURE__ */ new Map();
   #ctx = Split[BUCKET].gsap.context(Up.App.void);
   // ##PUBLICS
   // #MANAGERS
@@ -29,23 +34,75 @@ class Split {
   // ##GET
   // ##ADD
   /**
-      * Splits `target` with `SplitText.create` inside the managed context, so `destroy` reverts it.
-      * @param target Element(s) to split.
-      * @param vars `SplitText` options.
-      * @returns The created `SplitText` instance.
+      * Splits `target` according to `vars.type` (and optional `mask`). Work is recorded in the managed GSAP context
+      * so {@link Split.destroy} can revert it.
+      * **Same target, default:** if the cached split already covers the requested types and `mask`, returns that
+      * {@link Split.SPLIT} unchanged; otherwise merges the new types (and updates `mask` when provided), re-splits
+      * via `splitText.split(…)`, and refreshes `chars` / `lines` / `words` / `masks` in place.
+      * **`reconstruct: true`:** replaces the cached types / mask with this call’s values, re-splits, then refreshes
+      * the arrays (still the same `SPLIT` object / `splitText` instance). Unknown tokens in `type` are ignored.
+      * @param target Element(s) to split (Map key for the per-target cache).
+      * @param vars GSAP `SplitText` options; `type` is required. Optional `reconstruct` is upwwwards-only and is not passed to GSAP.
+      * @returns The cached {@link Split.SPLIT} for `target` (created on first `add`).
+      * @example
+      * ```ts
+      * const lines = split.add('.title', { type: 'lines' })
+      * const both  = split.add('.title', { type: 'lines,words' }) // same object; union + re-split
+      * const words = split.add('.title', { type: 'words' }) // same object; subset → no re-split
+      * const only  = split.add('.title', { type: 'words', reconstruct: true }) // same object; replace + re-split
+      * ```
   */
-  add(target, vars) {
-    return this.#ctx.add(() => Split[BUCKET].SplitText.create(target, vars));
+  add(target, { reconstruct, ...vars }) {
+    return this.#ctx.add(() => {
+      const TYPES = vars.type.trim().split(Split.#RGX_TYPE);
+      for (let i = TYPES.length - 1; i > -1; i--) if (!Split.#TYPES.includes(TYPES[i])) TYPES.splice(i, 1);
+      let split = this.#CACHE.get(target);
+      if (split) {
+        if (reconstruct) {
+          split.types = TYPES;
+          split.mask = vars.mask;
+          vars.type = TYPES.join(",");
+        } else {
+          if (Split.#isIncluded(split.types, TYPES) && (!vars.mask || split.mask === vars.mask)) return split;
+          for (let i = 0, max = TYPES.length; i < max; i++) if (!split.types.includes(TYPES[i])) split.types.push(TYPES[i]);
+          vars.type = split.types.join(",");
+          if (vars.mask) split.mask = vars.mask;
+        }
+        split.splitText.split(vars);
+      } else this.#CACHE.set(target, split = {
+        types: TYPES,
+        mask: vars.mask,
+        chars: [],
+        lines: [],
+        words: [],
+        masks: [],
+        splitText: Split[BUCKET].SplitText.create(target, vars)
+      });
+      for (let i = 0; i < Split.#PROPS_LENGTH; i++) {
+        const TARGET = split[Split.#PROPS[i]], SOURCE = split.splitText[Split.#PROPS[i]], LENGTH = SOURCE.length;
+        TARGET.length = LENGTH;
+        for (let j = 0; j < LENGTH; j++) TARGET[j] = SOURCE[j];
+      }
+      return split;
+    });
   }
   // ##DESTROY
   /**
-      * Reverts every `SplitText` instance created through this helper, then starts over with an empty context.
-      * The instance stays usable afterwards.
+      * Clears the per-target cache, reverts every `SplitText` owned by this helper, and starts over with an empty context.
+      * The instance stays usable afterwards (new `add` calls behave like on a fresh `Split`).
   */
   destroy() {
+    if (this.#CACHE.size) this.#CACHE.clear();
     this.#ctx.revert();
     this.#ctx = Split[BUCKET].gsap.context(Up.App.void);
   }
+  // ##IS
+  static #isIncluded(target, source) {
+    const LENGTH = source.length;
+    if (LENGTH > target.length) return false;
+    for (let i = 0; i < LENGTH; i++) if (!target.includes(source[i])) return false;
+    return true;
+  }
 }
 var Split_default = Split;
 export {

package/dist/plugins/@anime/Split.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/plugins/@anime/Split.ts"],"sourcesContent":["/* [Split] */\r\n\r\n// #IMPORTS\r\n\r\n    // ##SYMBOLS\r\nimport { BUCKET } from '../../symbols/index.js'\r\n\r\n    // ##CORE\r\nimport Up from '../../core/Up.js'\r\n\r\n    // ##SCRIPTS\r\nimport Logs from '../../scripts/Logs.js'\r\n\r\n    // ##TYPES\r\nimport type SplitText from 'gsap/SplitText'\r\n\r\nimport type { AnimeBucket } from '../Anime.js'\r\n\r\n// #CLASS\r\n\r\n    // ##THIS\r\n/**\r\n    * Collection of GSAP `SplitText` instances owned by a private GSAP context, reverted together by `destroy`\r\n    * (which restores the original markup).\r\n    * When constructed inside an `Up.Anime.sub` callback, the instance pushes its `destroy` on the workspace's cleaning stack\r\n    * (the list of destructors run by `Up.Anime.unsub`), so it is cleaned up automatically.\r\n    * @note Requires `'SplitText'` in the Anime config (`plugins: ['SplitText']`).\r\n    * @note Get the class from the Anime bucket (`bucket.Split`): it is only usable once Anime has loaded GSAP.\r\n    * @example\r\n    * ```ts\r\n    * Up.Anime.sub(KEY, (bucket: AnimeBucket): void =>\r\n    * {\r\n    *     const SPLIT = new bucket.Split()\r\n    *     const TEXT  = SPLIT.add('.hero__title', { type: 'lines,words' })\r\n    *\r\n    *     bucket.gsap.from(TEXT.words, { yPercent: 100, stagger: 0.05 })\r\n    * })\r\n    * ```\r\n*/\r\nclass Split\r\n{\r\n\r\n// #PROPS\r\n\r\n    // ##STATICS\r\n    /**\r\n        * Anime bucket shared by the Anime plugin once GSAP is loaded; includes `SplitText` when it is in the Anime config.\r\n        * @internal\r\n    */\r\n    static [BUCKET]: AnimeBucket & { SplitText?: typeof SplitText }\r\n\r\n    // ##PRIVATES\r\n    #ctx: gsap.Context = Split[BUCKET].gsap.context(Up.App.void)\r\n\r\n    // ##PUBLICS\r\n\r\n// #MANAGERS\r\n\r\n    // ##CONSTRUCTOR\r\n    /**\r\n        * Creates an empty collection and, inside a `sub` callback, registers `destroy` on the workspace's cleaning stack.\r\n        * @throws If `'SplitText'` is not in the Anime config.\r\n    */\r\n    constructor ()\r\n    {\r\n        if (!Split[BUCKET].SplitText) Logs.throw('SPLIT', '\"SplitText\" (GSAP PLUGIN) IS REQUIRED TO USE THIS CLASS (ADD \"SplitText\" TO THE \"Anime\" CONFIGURATION).')\r\n\r\n        Split[BUCKET].workspace.cleaningStack?.push(this.destroy.bind(this))\r\n    }\r\n\r\n    // ##SETTER\r\n\r\n    // ##GETTER\r\n\r\n// #METHODS\r\n\r\n    // ##SET\r\n\r\n    // ##GET\r\n\r\n    // ##ADD\r\n    /**\r\n        * Splits `target` with `SplitText.create` inside the managed context, so `destroy` reverts it.\r\n        * @param target Element(s) to split.\r\n        * @param vars `SplitText` options.\r\n        * @returns The created `SplitText` instance.\r\n    */\r\n    add(target: gsap.DOMTarget, vars?: SplitText.Vars): SplitText { return this.#ctx.add((): SplitText => Split[BUCKET].SplitText!.create(target, vars)) }\r\n\r\n    // ##DESTROY\r\n    /**\r\n        * Reverts every `SplitText` instance created through this helper, then starts over with an empty context.\r\n        * The instance stays usable afterwards.\r\n    */\r\n    destroy(): void\r\n    {\r\n        this.#ctx.revert()\r\n\r\n        this.#ctx = Split[BUCKET].gsap.context(Up.App.void)\r\n    }\r\n\r\n}\r\n\r\n// #EXPORTS\r\n\r\n    // ##THIS\r\nexport default Split"],"mappings":"AAKA,SAAS,cAAc;AAGvB,OAAO,QAAQ;AAGf,OAAO,UAAU;AA4BjB,MAAM,MACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASI,QAAQ,MAAM;AAAA;AAAA,EAGd,OAAqB,MAAM,MAAM,EAAE,KAAK,QAAQ,GAAG,IAAI,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAW3D,cACA;AACI,QAAI,CAAC,MAAM,MAAM,EAAE,UAAW,MAAK,MAAM,SAAS,yGAAyG;AAE3J,UAAM,MAAM,EAAE,UAAU,eAAe,KAAK,KAAK,QAAQ,KAAK,IAAI,CAAC;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,IAAI,QAAwB,MAAkC;AAAE,WAAO,KAAK,KAAK,IAAI,MAAiB,MAAM,MAAM,EAAE,UAAW,OAAO,QAAQ,IAAI,CAAC;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOrJ,UACA;AACI,SAAK,KAAK,OAAO;AAEjB,SAAK,OAAO,MAAM,MAAM,EAAE,KAAK,QAAQ,GAAG,IAAI,IAAI;AAAA,EACtD;AAEJ;AAKA,IAAO,gBAAQ;","names":[]}
+{"version":3,"sources":["../../../src/plugins/@anime/Split.ts"],"sourcesContent":["/* [Split] */\r\n\r\n// #IMPORTS\r\n\r\n    // ##SYMBOLS\r\nimport { BUCKET } from '../../symbols/index.js'\r\n\r\n    // ##CORE\r\nimport Up from '../../core/Up.js'\r\n\r\n    // ##SCRIPTS\r\nimport Logs from '../../scripts/Logs.js'\r\n\r\n    // ##TYPES\r\nimport type SplitText from 'gsap/SplitText'\r\n\r\nimport type { AnimeBucket } from '../Anime.js'\r\n\r\n// #TYPES\r\n\r\n    // ##THIS\r\nnamespace Split\r\n{\r\n    /**\r\n        * Options for {@link Split.add}: GSAP `SplitText.Vars`, plus an optional `reconstruct` flag.\r\n        * By default, each target keeps one cached {@link Split.SPLIT}: a later `add` that only needs a\r\n        * **subset** of already split types (and a compatible `mask`) returns that same object; if new types\r\n        * or a new `mask` are required, types are **merged** and the existing `SplitText` is re-split in place.\r\n        * Set `reconstruct: true` to **replace** the cached types / mask with this call’s values and re-split\r\n        * (no merge). `reconstruct` is upwwwards-only and is not passed to GSAP.\r\n    */\r\n    export type VARS = SplitText.Vars & { reconstruct?: boolean }\r\n\r\n    /**\r\n        * A split kind accepted in `vars.type` (`'chars'`, `'lines'`, or `'words'`).\r\n    */\r\n    export type TYPE = 'chars' | 'lines' | 'words'\r\n\r\n    /**\r\n        * Result of {@link Split.add}: one stable object per `target` on this helper.\r\n        * `chars` / `lines` / `words` / `masks` are the same array references across calls; their contents are\r\n        * updated in place when the underlying `SplitText` is re-split. `types` / `mask` reflect the current\r\n        * split definition; `splitText` is the single GSAP instance for that target.\r\n    */\r\n    export type SPLIT =\r\n    {\r\n        types    : TYPE[],\r\n        mask     : TYPE | undefined,\r\n        chars    : Element[],\r\n        lines    : Element[],\r\n        words    : Element[],\r\n        masks    : Element[],\r\n        splitText: SplitText\r\n    }\r\n}\r\n\r\n// #CLASS\r\n\r\n    // ##THIS\r\n/**\r\n    * Helper that owns one GSAP `SplitText` per target in a private GSAP context, reverted together by {@link Split.destroy}\r\n    * (restoring the original markup).\r\n    * On the **same target**, {@link Split.add} returns the same {@link Split.SPLIT}: subset requests reuse it as-is;\r\n    * wider requests (or a new `mask`) merge into the cached types and call `splitText.split(…)`. Pass\r\n    * `reconstruct: true` to replace the definition instead of merging. Element arrays on the `SPLIT` are kept by\r\n    * reference and refreshed in place after a re-split — prefer that object over holding individual node refs across\r\n    * a reconstruct / expand (tweens already targeting old nodes stay stale).\r\n    * When constructed inside an `Up.Anime.sub` callback, the instance pushes its `destroy` on the workspace's cleaning stack\r\n    * (run by `Up.Anime.unsub`), so it is cleaned up automatically.\r\n    * @note Requires `'SplitText'` in the Anime config (`plugins: ['SplitText']`).\r\n    * @note Get the class from the Anime bucket (`bucket.Split`): it is only usable once Anime has loaded GSAP.\r\n    * @example\r\n    * ```ts\r\n    * Up.Anime.sub(KEY, (bucket: AnimeBucket): void =>\r\n    * {\r\n    *     const SPLIT = new bucket.Split()\r\n    *     const TEXT  = SPLIT.add('.hero__title', { type: 'lines,words' })\r\n    *\r\n    *     bucket.gsap.from(TEXT.words, { yPercent: 100, stagger: 0.05 })\r\n    * })\r\n    * ```\r\n*/\r\nclass Split\r\n{\r\n\r\n// #PROPS\r\n\r\n    // ##STATICS\r\n    static #RGX_TYPE = /\\s*,\\s*/\r\n\r\n    static #TYPES: Split.TYPE[] = ['chars', 'lines', 'words']\r\n    static #PROPS               = [...Split.#TYPES, 'masks'] satisfies (keyof Split.SPLIT)[]\r\n\r\n    static #PROPS_LENGTH = Split.#PROPS.length\r\n\r\n    /**\r\n        * Anime bucket shared by the Anime plugin once GSAP is loaded; includes `SplitText` when it is in the Anime config.\r\n        * @internal\r\n    */\r\n    static [BUCKET]: AnimeBucket & { SplitText?: typeof SplitText }\r\n\r\n    // ##PRIVATES\r\n    #CACHE = new Map<gsap.DOMTarget, Split.SPLIT>()\r\n\r\n    #ctx: gsap.Context = Split[BUCKET].gsap.context(Up.App.void)\r\n\r\n    // ##PUBLICS\r\n\r\n// #MANAGERS\r\n\r\n    // ##CONSTRUCTOR\r\n    /**\r\n        * Creates an empty collection and, inside a `sub` callback, registers `destroy` on the workspace's cleaning stack.\r\n        * @throws If `'SplitText'` is not in the Anime config.\r\n    */\r\n    constructor ()\r\n    {\r\n        if (!Split[BUCKET].SplitText) Logs.throw('SPLIT', '\"SplitText\" (GSAP PLUGIN) IS REQUIRED TO USE THIS CLASS (ADD \"SplitText\" TO THE \"Anime\" CONFIGURATION).')\r\n\r\n        Split[BUCKET].workspace.cleaningStack?.push(this.destroy.bind(this))\r\n    }\r\n\r\n    // ##SETTER\r\n\r\n    // ##GETTER\r\n\r\n// #METHODS\r\n\r\n    // ##SET\r\n\r\n    // ##GET\r\n\r\n    // ##ADD\r\n    /**\r\n        * Splits `target` according to `vars.type` (and optional `mask`). Work is recorded in the managed GSAP context\r\n        * so {@link Split.destroy} can revert it.\r\n        * **Same target, default:** if the cached split already covers the requested types and `mask`, returns that\r\n        * {@link Split.SPLIT} unchanged; otherwise merges the new types (and updates `mask` when provided), re-splits\r\n        * via `splitText.split(…)`, and refreshes `chars` / `lines` / `words` / `masks` in place.\r\n        * **`reconstruct: true`:** replaces the cached types / mask with this call’s values, re-splits, then refreshes\r\n        * the arrays (still the same `SPLIT` object / `splitText` instance). Unknown tokens in `type` are ignored.\r\n        * @param target Element(s) to split (Map key for the per-target cache).\r\n        * @param vars GSAP `SplitText` options; `type` is required. Optional `reconstruct` is upwwwards-only and is not passed to GSAP.\r\n        * @returns The cached {@link Split.SPLIT} for `target` (created on first `add`).\r\n        * @example\r\n        * ```ts\r\n        * const lines = split.add('.title', { type: 'lines' })\r\n        * const both  = split.add('.title', { type: 'lines,words' }) // same object; union + re-split\r\n        * const words = split.add('.title', { type: 'words' }) // same object; subset → no re-split\r\n        * const only  = split.add('.title', { type: 'words', reconstruct: true }) // same object; replace + re-split\r\n        * ```\r\n    */\r\n    add(target: gsap.DOMTarget, {reconstruct, ...vars}: Split.VARS): Split.SPLIT\r\n    {\r\n        return this.#ctx.add((): Split.SPLIT =>\r\n        {\r\n            const TYPES = vars.type.trim().split(Split.#RGX_TYPE) as Split.TYPE[]\r\n\r\n            for (let i = TYPES.length - 1; i > -1; i--) if (!Split.#TYPES.includes(TYPES[i])) TYPES.splice(i, 1)\r\n\r\n            let split = this.#CACHE.get(target)\r\n\r\n            if (split)\r\n            {\r\n                if (reconstruct)\r\n                {\r\n                    split.types = TYPES\r\n                    split.mask  = vars.mask\r\n                    vars.type   = TYPES.join(',')\r\n                }\r\n                else\r\n                {\r\n                    if (Split.#isIncluded(split.types, TYPES) && (!vars.mask || split.mask === vars.mask)) return split\r\n\r\n                    for (let i = 0, max = TYPES.length; i < max; i++) if (!split.types.includes(TYPES[i])) split.types.push(TYPES[i])\r\n\r\n                    vars.type = split.types.join(',')\r\n\r\n                    if (vars.mask) split.mask = vars.mask\r\n                }\r\n\r\n                split.splitText.split(vars)\r\n            }\r\n            else this.#CACHE.set(target, split =\r\n            {\r\n                types    : TYPES,\r\n                mask     : vars.mask,\r\n                chars    : [],\r\n                lines    : [],\r\n                words    : [],\r\n                masks    : [],\r\n                splitText: Split[BUCKET].SplitText!.create(target, vars)\r\n            })\r\n    \r\n            for (let i = 0; i < Split.#PROPS_LENGTH; i++)\r\n            {\r\n                const\r\n                TARGET = split[Split.#PROPS[i]],\r\n                SOURCE = split.splitText[Split.#PROPS[i]],\r\n                LENGTH = SOURCE.length\r\n\r\n                TARGET.length = LENGTH\r\n\r\n                for (let j = 0; j < LENGTH; j++) TARGET[j] = SOURCE[j]\r\n            }\r\n\r\n            return split\r\n        })\r\n    }\r\n\r\n    // ##DESTROY\r\n    /**\r\n        * Clears the per-target cache, reverts every `SplitText` owned by this helper, and starts over with an empty context.\r\n        * The instance stays usable afterwards (new `add` calls behave like on a fresh `Split`).\r\n    */\r\n    destroy(): void\r\n    {\r\n        if (this.#CACHE.size) this.#CACHE.clear()\r\n\r\n        this.#ctx.revert()\r\n\r\n        this.#ctx = Split[BUCKET].gsap.context(Up.App.void)\r\n    }\r\n\r\n    // ##IS\r\n    static #isIncluded(target: Split.TYPE[], source: Split.TYPE[]): boolean\r\n    {\r\n        const LENGTH = source.length\r\n\r\n        if (LENGTH > target.length) return false\r\n    \r\n        for (let i = 0; i < LENGTH; i++) if (!target.includes(source[i])) return false\r\n\r\n        return true\r\n    }\r\n\r\n}\r\n\r\n// #EXPORTS\r\n\r\n    // ##THIS\r\nexport default Split\r\n\r\nexport type { Split }"],"mappings":"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","names":[]}

package/dist/plugins/Anime.d.ts

@@ -1,5 +1,5 @@
 import '../symbols/index.js';
-export { A as Anime, c as AnimeBucket, d as Split, e as Timeline, f as Tweens, A as default } from '../index-Di5rQVjZ.js';
+export { A as Anime, c as AnimeBucket, d as Split, e as Timeline, f as Tweens, A as default } from '../index-ymMzfIlh.js';
 import 'gsap/all';
 import '../index-BlwaDpQl.js';
 import '../Thread-5NGNyOJb.js';

package/dist/plugins/Puppeteer.d.ts

@@ -1,4 +1,4 @@
-export { M as Matrix4, g as Puppeteer, g as default } from '../index-Di5rQVjZ.js';
+export { M as Matrix4, g as Puppeteer, g as default } from '../index-ymMzfIlh.js';
 import '../index-BlwaDpQl.js';
 import '../symbols/index.js';
 import '../Thread-5NGNyOJb.js';

package/dist/plugins/Scroll.d.ts

@@ -1,5 +1,5 @@
 import '../symbols/index.js';
-export { S as Scroll, b as ScrollBucket, S as default } from '../index-Di5rQVjZ.js';
+export { S as Scroll, b as ScrollBucket, S as default } from '../index-ymMzfIlh.js';
 import 'lenis';
 import '../Thread-5NGNyOJb.js';
 import '../index-BlwaDpQl.js';

package/dist/plugins/Synthra.d.ts

@@ -1,5 +1,5 @@
 import '../symbols/index.js';
-export { B as Basic, h as Package, i as Plugin, j as Spider, k as Synthra, l as SynthraBucket, m as SynthraPlugins, n as SynthraThree, X as X3D, k as default } from '../index-Di5rQVjZ.js';
+export { B as Basic, h as Package, i as Plugin, j as Spider, k as Synthra, l as SynthraBucket, m as SynthraPlugins, n as SynthraThree, X as X3D, k as default } from '../index-ymMzfIlh.js';
 import 'three';
 import '../Thread-5NGNyOJb.js';
 import '../index-BlwaDpQl.js';

package/dist/plugins/Transmitter.d.ts

@@ -1,5 +1,5 @@
 import '../symbols/index.js';
-export { T as Transmitter, a as TransmitterChannels, T as default } from '../index-Di5rQVjZ.js';
+export { T as Transmitter, a as TransmitterChannels, T as default } from '../index-ymMzfIlh.js';
 import '../index-BlwaDpQl.js';
 import '../Thread-5NGNyOJb.js';
 import 'lenis';

package/dist/plugins/index.d.ts

@@ -1,4 +1,4 @@
-export { A as Anime, L as Lazy, O as Observer, P as Plugin, g as Puppeteer, o as Screen, S as Scroll, k as Synthra, T as Transmitter } from '../index-Di5rQVjZ.js';
+export { A as Anime, L as Lazy, O as Observer, P as Plugin, g as Puppeteer, o as Screen, S as Scroll, k as Synthra, T as Transmitter } from '../index-ymMzfIlh.js';
 import '../symbols/index.js';
 import '../index-BlwaDpQl.js';
 import '../Thread-5NGNyOJb.js';

package/dist/scripts/Arrays.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/scripts/Arrays.ts"],"sourcesContent":["/* [Arrays] */\r\n\r\n// #IMPORTS\r\n\r\n    // ##THIS\r\nimport CallStack from './@arrays/Callstack.js'\r\n\r\n    // ##TYPES\r\nimport type Maths   from './Maths.js'\r\nimport type Strings from './Strings.js'\r\n\r\n// #TYPES\r\n\r\n    // ##THIS\r\nnamespace Arrays\r\n{\r\n    /**\r\n        * Tuple with the same length as `T` where every element is `U` (e.g. `Fill<[1, 2, 3], 0>` is `[0, 0, 0]`).\r\n        * @template T Source tuple (only its length is used).\r\n        * @template U Element type to fill with.\r\n    */\r\n    export type Fill<T extends any[], U, V extends any[] = []> = T extends [any, ...infer W] ? Fill<W, U, [...V, U]> : V\r\n\r\n    /**\r\n        * String literal type obtained by joining the elements of `T` with separator `U`\r\n        * (e.g. `Join<[1, 'a', true], ', '>` is `'1, a, true'`), like `Array.prototype.join` at the type level.\r\n        * Elements must be stringifiable (`Strings.STRINGIFIABLE`).\r\n        * @template T Tuple to join.\r\n        * @template U Separator. Defaults to `','`.\r\n    */\r\n    export type Join<T extends any[], U extends string = ',', V extends string = ''> = T extends [infer W extends Strings.STRINGIFIABLE, ...infer X extends Strings.STRINGIFIABLE[]]\r\n        ? Join<X, U, V extends '' ? `${W}` : `${V}${U}${W}`>\r\n        : V\r\n\r\n    /**\r\n        * `true` if at least one element type of `T` is assignable to `U`, otherwise `false`\r\n        * (e.g. `Includes<['a', 1], string>` is `true`, `Includes<[string], 'a'>` is `false`).\r\n        * @template T Tuple or array to search (readonly accepted).\r\n        * @template U Type to look for.\r\n    */\r\n    export type Includes<T extends Readonly<any[]>, U> = Extract<T[number], U> extends never ? false : true\r\n\r\n    /**\r\n        * Tuple `T` with `U` appended at the end.\r\n        * @template T Source tuple.\r\n        * @template U Element to append.\r\n    */\r\n    export type Push<T extends any[], U> = [...T, U]\r\n\r\n    /**\r\n        * Tuple `T` without its last element (`never` if `T` is empty).\r\n        * @template T Source tuple.\r\n    */\r\n    export type Pop<T extends any[]> = T extends [...infer U, any] ? U : never\r\n\r\n    /**\r\n        * Tuple `T` with `U` inserted at the start.\r\n        * @template T Source tuple.\r\n        * @template U Element to prepend.\r\n    */\r\n    export type Unshift<T extends any[], U> = [U, ...T]\r\n\r\n    /**\r\n        * Tuple `T` without its first element (`never` if `T` is empty).\r\n        * @template T Source tuple.\r\n    */\r\n    export type Shift<T extends any[]> = T extends [any, ...infer U] ? U : never\r\n\r\n    /**\r\n        * Tuple `T` padded with `U` until it has length `V` (e.g. `Pad<[1], 0, 3, true>` is `[1, 0, 0]`).\r\n        * Tuples already at least `V` long are returned unchanged.\r\n        * @template T Source tuple.\r\n        * @template U Padding element.\r\n        * @template V Target length.\r\n        * @template W `true` to pad at the end; otherwise (default `false`) pad at the start.\r\n    */\r\n    export type Pad<T extends any[], U, V extends number, W extends boolean = false, X extends any[] = T, Y extends null[] = []> = V extends Y['length']\r\n        ? X\r\n        : T extends [unknown, ...infer Z]\r\n            ? Pad<Z, U, V, W, X, [...Y, null]>\r\n            : Pad<[], U, V, W, W extends true ? [...X, U] : [U, ...X], [...Y, null]>\r\n\r\n    /**\r\n        * Length of tuple `T` as a number literal type.\r\n        * @template T Source tuple.\r\n    */\r\n    export type Length<T extends any[]> = T['length']\r\n\r\n    /**\r\n        * Tuple `T` with the element at index `U` replaced by `V` (e.g. `Set<[1, 2], 1, 'x'>` is `[1, 'x']`).\r\n        * If `U` is past the end, the gap is filled with `undefined` (e.g. `Set<[1], 3, 'x'>` is `[1, undefined, undefined, 'x']`).\r\n        * @template T Source tuple.\r\n        * @template U Index to set.\r\n        * @template V New element.\r\n    */\r\n    export type Set<T extends any[], U extends number, V, W extends any[] = []> = T extends [infer X, ...infer Y]\r\n        ? U extends W['length']\r\n            ? Set<Y, U, V, [...W, V]>\r\n            : Set<Y, U, V, [...W, X]>\r\n        : U extends W['length']\r\n            ? [...W, V]\r\n            : Maths.SmallerOrEqual<W['length'], U> extends true\r\n                ? Set<T, U, V, [...W, undefined]>\r\n                : W\r\n}\r\n\r\n// #CLASS\r\n\r\n    // ##THIS\r\n/**\r\n    * Array utilities: compile-time tuple helper types (`Arrays.Fill`, `Arrays.Join`, `Arrays.Pad`, ...)\r\n    * and the runtime {@link CallStack} class, exposed as `Arrays.CallStack`.\r\n    * @example\r\n    * ```ts\r\n    * import { Arrays } from 'upwwwards/scripts'\r\n    *\r\n    * type T = Arrays.Push<[1, 2], 3> // [1, 2, 3]\r\n    *\r\n    * const STACK = new Arrays.CallStack<(dt: number) => void>()\r\n    *\r\n    * STACK.add((dt): void => console.log(dt))\r\n    * STACK.loop(16)\r\n    * ```\r\n*/\r\nabstract class Arrays\r\n{\r\n\r\n// #PROPS\r\n\r\n    // ##STATICS\r\n\r\n    // ##PRIVATES\r\n\r\n    // ##PUBLICS\r\n\r\n// #MANAGERS\r\n\r\n    // ##SETTER\r\n\r\n    // ##GETTER\r\n    /**\r\n        * The {@link CallStack} class: an ordered list of callbacks that can be run all at once (`loop`)\r\n        * or one at a time through a generator (`gen`).\r\n        * @returns The `CallStack` constructor.\r\n    */\r\n    static get CallStack(): typeof CallStack { return CallStack }\r\n\r\n// #METHODS\r\n\r\n    // ##SET\r\n\r\n    // ##GET\r\n\r\n}\r\n\r\n// #EXPORTS\r\n\r\n    // ##THIS\r\nexport default Arrays\r\n\r\nexport type { Arrays, CallStack }"],"mappings":"AAKA,OAAO,eAAe;AAuHtB,MAAe,OACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBI,WAAW,YAA8B;AAAE,WAAO;AAAA,EAAU;AAAA;AAAA;AAAA;AAQhE;AAKA,IAAO,iBAAQ;","names":[]}
+{"version":3,"sources":["../../src/scripts/Arrays.ts"],"sourcesContent":["/* [Arrays] */\r\n\r\n// #IMPORTS\r\n\r\n    // ##THIS\r\nimport CallStack from './@arrays/Callstack.js'\r\n\r\n    // ##TYPES\r\nimport type Maths   from './Maths.js'\r\nimport type Strings from './Strings.js'\r\n\r\n// #TYPES\r\n\r\n    // ##THIS\r\nnamespace Arrays\r\n{\r\n    /**\r\n        * Tuple with the same length as `T` where every element is `U` (e.g. `Fill<[1, 2, 3], 0>` is `[0, 0, 0]`).\r\n        * @template T Source tuple (only its length is used).\r\n        * @template U Element type to fill with.\r\n    */\r\n    export type Fill<T extends any[], U, V extends any[] = []> = T extends [any, ...infer W] ? Fill<W, U, [...V, U]> : V\r\n\r\n    /**\r\n        * String literal type obtained by joining the elements of `T` with separator `U`\r\n        * (e.g. `Join<[1, 'a', true], ', '>` is `'1, a, true'`), like `Array.prototype.join` at the type level.\r\n        * Elements must be stringifiable (`Strings.STRINGIFIABLE`).\r\n        * @template T Tuple to join.\r\n        * @template U Separator. Defaults to `','`.\r\n    */\r\n    export type Join<T extends any[], U extends string = ',', V extends string = ''> = T extends [infer W extends Strings.STRINGIFIABLE, ...infer X extends Strings.STRINGIFIABLE[]]\r\n        ? Join<X, U, V extends '' ? `${W}` : `${V}${U}${W}`>\r\n        : V\r\n\r\n    /**\r\n        * `true` if at least one element type of `T` is assignable to `U`, otherwise `false`\r\n        * (e.g. `Includes<['a', 1], string>` is `true`, `Includes<[string], 'a'>` is `false`).\r\n        * @template T Tuple or array to search (readonly accepted).\r\n        * @template U Type to look for.\r\n    */\r\n    export type Includes<T extends Readonly<any[]>, U> = Extract<T[number], U> extends never ? false : true\r\n\r\n    /**\r\n        * Tuple `T` with `U` appended at the end.\r\n        * @template T Source tuple.\r\n        * @template U Element to append.\r\n    */\r\n    export type Push<T extends any[], U> = [...T, U]\r\n\r\n    /**\r\n        * Tuple `T` without its last element (`never` if `T` is empty).\r\n        * @template T Source tuple.\r\n    */\r\n    export type Pop<T extends any[]> = T extends [...infer U, any] ? U : never\r\n\r\n    /**\r\n        * Tuple `T` with `U` inserted at the start.\r\n        * @template T Source tuple.\r\n        * @template U Element to prepend.\r\n    */\r\n    export type Unshift<T extends any[], U> = [U, ...T]\r\n\r\n    /**\r\n        * Tuple `T` without its first element (`never` if `T` is empty).\r\n        * @template T Source tuple.\r\n    */\r\n    export type Shift<T extends any[]> = T extends [any, ...infer U] ? U : never\r\n\r\n    /**\r\n        * Tuple `T` padded with `U` until it has length `V` (e.g. `Pad<[1], 0, 3, true>` is `[1, 0, 0]`).\r\n        * Tuples already at least `V` long are returned unchanged.\r\n        * @template T Source tuple.\r\n        * @template U Padding element.\r\n        * @template V Target length.\r\n        * @template W `true` to pad at the end; otherwise (default `false`) pad at the start.\r\n    */\r\n    export type Pad<T extends any[], U, V extends number, W extends boolean = false, X extends any[] = T, Y extends null[] = []> = V extends Y['length']\r\n        ? X\r\n        : T extends [unknown, ...infer Z]\r\n            ? Pad<Z, U, V, W, X, [...Y, null]>\r\n            : Pad<[], U, V, W, W extends true ? [...X, U] : [U, ...X], [...Y, null]>\r\n\r\n    /**\r\n        * Length of tuple `T` as a number literal type.\r\n        * @template T Source tuple.\r\n    */\r\n    export type Length<T extends any[]> = T['length']\r\n\r\n    /**\r\n        * Tuple `T` with the element at index `U` replaced by `V` (e.g. `Set<[1, 2], 1, 'x'>` is `[1, 'x']`).\r\n        * If `U` is past the end, the gap is filled with `undefined` (e.g. `Set<[1], 3, 'x'>` is `[1, undefined, undefined, 'x']`).\r\n        * @template T Source tuple.\r\n        * @template U Index to set.\r\n        * @template V New element.\r\n    */\r\n    export type Set<T extends any[], U extends number, V, W extends any[] = []> = T extends [infer X, ...infer Y]\r\n        ? U extends W['length']\r\n            ? Set<Y, U, V, [...W, V]>\r\n            : Set<Y, U, V, [...W, X]>\r\n        : U extends W['length']\r\n            ? [...W, V]\r\n            : Maths.SmallerOrEqual<W['length'], U> extends true\r\n                ? Set<T, U, V, [...W, undefined]>\r\n                : W\r\n}\r\n\r\n// #CLASS\r\n\r\n    // ##THIS\r\n/**\r\n    * Array utilities: compile-time tuple helper types (`Arrays.Fill`, `Arrays.Join`, `Arrays.Pad`, ...)\r\n    * and the runtime {@link CallStack} class, exposed as `Arrays.CallStack`.\r\n    * @example\r\n    * ```ts\r\n    * import { Arrays } from 'upwwwards/scripts'\r\n    *\r\n    * type T = Arrays.Push<[1, 2], 3> // [1, 2, 3]\r\n    *\r\n    * const STACK = new Arrays.CallStack<(dt: number) => void>()\r\n    *\r\n    * STACK.add((dt): void => console.log(dt))\r\n    * STACK.loop(16)\r\n    * ```\r\n*/\r\nabstract class Arrays\r\n{\r\n\r\n// #PROPS\r\n\r\n    // ##STATICS\r\n\r\n    // ##PRIVATES\r\n\r\n    // ##PUBLICS\r\n\r\n// #MANAGERS\r\n\r\n    // ##SETTER\r\n\r\n    // ##GETTER\r\n    /**\r\n        * The {@link CallStack} class: an ordered list of callbacks that can be run all at once (`loop`)\r\n        * or one at a time through a generator (`gen`).\r\n        * @returns The `CallStack` constructor.\r\n    */\r\n    static get CallStack(): typeof CallStack { return CallStack }\r\n\r\n// #METHODS\r\n\r\n    // ##SET\r\n\r\n    // ##GET\r\n\r\n}\r\n\r\n// #EXPORTS\r\n\r\n    // ##THIS\r\nexport default Arrays\r\n\r\nexport type { Arrays, CallStack }\r\n\r\n"],"mappings":"AAKA,OAAO,eAAe;AAuHtB,MAAe,OACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBI,WAAW,YAA8B;AAAE,WAAO;AAAA,EAAU;AAAA;AAAA;AAAA;AAQhE;AAKA,IAAO,iBAAQ;","names":[]}

package/docs/plugins/anime.md

@@ -116,13 +116,32 @@ Up.Anime.sub(KEY, ({ Tweens }) => {
 
 ### Helper: `Split`
 
-Requires `'SplitText'` in Anime `plugins`. Collection of `SplitText` instances; `destroy` restores markup. Auto-cleaned inside `sub`.
+Requires `'SplitText'` in Anime `plugins`. Owns **one** `SplitText` per target in a private GSAP context; `destroy` restores markup. Auto-cleaned inside `sub`.
+
+`add(target, vars)` always returns a **`Split.SPLIT`** (`types`, `mask`, `chars` / `lines` / `words` / `masks`, `splitText`) — not a raw `SplitText`. On the **same target**, it is the **same object**: element arrays keep their references and are refreshed in place after a re-split.
+
+| Call | Behavior |
+| --- | --- |
+| Subset of cached types (+ compatible `mask`) | Return cache, no re-split |
+| New types and/or new `mask` | **Merge** types, `splitText.split(…)`, refresh arrays |
+| `reconstruct: true` | **Replace** cached types / mask, re-split, refresh arrays |
+
+`reconstruct` is upwwwards-only (not forwarded to GSAP). Tweens already targeting old DOM nodes stay stale after an expand / reconstruct — re-read `text.lines` / `text.words` (or rebuild tweens) if needed.
 
 ```ts
 Up.Anime.sub(KEY, ({ gsap, Split }) => {
   const split = new Split()
   const text = split.add('.hero__title', { type: 'lines,words' })
   gsap.from(text.words, { yPercent: 100, stagger: 0.05 })
+
+  // same object: union types + re-split in place
+  split.add('.hero__title', { type: 'lines,words,chars' })
+
+  // same object: subset → reuse, no re-split
+  split.add('.hero__title', { type: 'words' })
+
+  // same object: replace definition + re-split
+  split.add('.hero__title', { type: 'words', reconstruct: true })
 })
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "upwwwards",
-  "version": "0.1.9-beta.1",
+  "version": "0.1.10-beta.1",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Shared page lifecycle, frame loop, and opt-in plugins (GSAP, Lenis, Three.js) for Nuxt 4 and SvelteKit 2.",
   "author": "Morgan LE THUAUT <morgan@upwwwards.com>",