gclass-anims 1.0.0-beta.13 → 1.0.0-beta.14

package/AnimToggle.js

@@ -44,7 +44,7 @@ function readReducedOverride() {
 //   - Otherwise, if the user HAS an explicit stored choice, respect it
 //     (override wins), even under reduced motion.
 //   - Otherwise (no stored value) fall back to the default, which is ON unless
-//     reduced motion is detected — in which case animations are off.
+//     reduced motion is detected - in which case animations are off.
 function getEnabled() {
   if (forcedReduced) return false
   return stored === null ? !reduced : stored

package/Animations.js

@@ -35,7 +35,7 @@ export const finalOpacity = (target) => {
 // TextPlugin tweens take their endpoints from the LIVE DOM: the `.typewriter`
 // play callbacks pass `el.innerHTML` as the text to type. The tween's from
 // state ("") is applied the instant the tween is created, and a teardown that
-// kills the tween mid-flight leaves that wiped state behind — so a later
+// kills the tween mid-flight leaves that wiped state behind - so a later
 // engine re-init reading `el.innerHTML` again would type an empty (or
 // partially-typed) string forever. Stash the full HTML on first sight and
 // reuse it. The stash only refreshes from SETTLED content: never while a
@@ -111,7 +111,7 @@ export function spawnBlur (target , delay , dur , ease){
 //   right - hidden on the left, wipes open rightward (left -> right)
 // The `from` inset is mirrored in the Config entry so
 // `.scroll`/`.scroll-progress`/`.leave` reversal and `.appear` all know the
-// hidden state. No opacity is involved — pure clip wipe.
+// hidden state. No opacity is involved - pure clip wipe.
 const CLIP_FROM = {
     up: "inset(0% 0% 100% 0%)",
     down: "inset(100% 0% 0% 0%)",
@@ -123,13 +123,13 @@ export function spawnClipReveal (target , delay , dur , ease , dir = "up"){
     return gsap.fromTo(target , {clipPath: from} , {clipPath:"inset(0% 0% 0% 0%)" , ease:easeOf(ease) , duration:dur , delay:delay})
 }
 
-// Curtain reveal: opens outward from the horizontal centre — a vertical slit in
+// Curtain reveal: opens outward from the horizontal centre - a vertical slit in
 // the middle widens left and right until the whole box is shown.
 export function curtainHorizontal (target , delay , dur , ease){
     return gsap.fromTo(target , {clipPath:"inset(0% 50% 0% 50%)"} , {clipPath:"inset(0% 0% 0% 0%)" , ease:easeOf(ease) , duration:dur , delay:delay})
 }
 
-// Curtain reveal: opens outward from the vertical centre — a horizontal slit in
+// Curtain reveal: opens outward from the vertical centre - a horizontal slit in
 // the middle widens up and down until the whole box is shown.
 export function curtainVertical (target , delay , dur , ease){
     return gsap.fromTo(target , {clipPath:"inset(50% 0% 50% 0%)"} , {clipPath:"inset(0% 0% 0% 0%)" , ease:easeOf(ease) , duration:dur , delay:delay})
@@ -235,7 +235,7 @@ const fillEaseOf = (el , fallbackEase) => {
     return m ? m.slice("fill-ease-".length) : fallbackEase
 }
 
-// Stroke-draw reveal (strokes only — filled SVGs are deliberately out of
+// Stroke-draw reveal (strokes only - filled SVGs are deliberately out of
 // scope for now). Explicit fromTo endpoints so the animation's hidden state
 // matches this class's Config `from` metadata exactly: `.scroll-progress`
 // scrubs between those two values and `.leave`/`.scroll` reversal tweens back
@@ -267,7 +267,7 @@ export function drawsvg (target , delay , dur , ease){
 // separate paths draw correctly. Adapted from the official DrawSVGPlugin
 // helper, with one addition: splitting REPLACES the source path in the DOM,
 // so the result is cached on that element and reused while the segments are
-// still live — an engine re-init (StrictMode remount, route change) must not
+// still live - an engine re-init (StrictMode remount, route change) must not
 // churn the DOM a second time. Attributes are copied verbatim; filled SVGs
 // are simply untouched territory for now.
 export function splitPaths (paths){
@@ -288,7 +288,7 @@ export function splitPaths (paths){
         let i = attributes.length
         while (i--) {
             const attr = attributes[i]
-            // Don't copy GSAP wiring or appear/scroll triggers — children are
+            // Don't copy GSAP wiring or appear/scroll triggers - children are
             // animated via the returned timeline, not as independent spawns.
             // Copying "appear" caused appearObserver → split → appear loop.
             if (attr.nodeName === "class") {
@@ -352,7 +352,7 @@ export function drawsvgSplit (target , delay , dur , ease){
 
 // Scramble plumbing. Only the element's TOP-LEVEL TEXT runs are scrambled:
 // each run is wrapped in its own span and tweened separately, while real child
-// elements (links, icons, ...) are left completely untouched — their markup
+// elements (links, icons, ...) are left completely untouched - their markup
 // survives the animation intact. Wraps are cached on the element so replays
 // (engine re-inits, .appear re-triggers) reuse the same spans instead of
 // churning the DOM.
@@ -412,7 +412,7 @@ export function scrambleVars (target){
 }
 
 // Scramble spawn: the text starts empty and resolves into the real content
-// through garbage characters — no opacity involved, the scramble IS the
+// through garbage characters - no opacity involved, the scramble IS the
 // reveal. Unlike typewriter there is no opacity fade to hide behind, so the
 // package default "back" ease would visually finish at ~36% of `dur` (back.out
 // crosses ~99% early and the reveal index clamps): unless an explicit ease-*
@@ -537,7 +537,7 @@ export function shake (delay , target , amount , dur , ease){
 export function bell (delay , target , amount , dur , ease){
     const tl = gsap.timeline()
     tl.set(target , {transformOrigin : "50% 0%"})
-    // A quick toll that overshoots and damps down — reads as a physical strike
+    // A quick toll that overshoots and damps down - reads as a physical strike
     // instead of a symmetrical wiggle.
     .to(target , {rotate:amount , duration:dur * 0.12 , ease:"power2.out"})
     .to(target , {rotate:-amount * 0.7, duration:dur * 0.18 , ease:"power2.inOut"})
@@ -592,7 +592,7 @@ export function radiate (delay , target , amount , dur , ease , zIndex){
     window.addEventListener("scroll", schedule, { passive: true })
     window.addEventListener("resize", schedule, { passive: true })
     // Killing the tween (teardown, hover/click rebuilds) must clean up exactly
-    // like natural completion — otherwise clones + listeners leak.
+    // like natural completion - otherwise clones + listeners leak.
     const cleanup = () => {
         clone.remove()
         window.removeEventListener("scroll", schedule)
@@ -627,7 +627,7 @@ export function marquee (target , dir , duration , xOffset = 0 , yOffset = 0 , n
     const horizontal = dir === "left" || dir === "right"
     // Anchor the track to the top-left corner so its two identical copies tile
     // the container exactly. The track is positioned absolutely, out of the
-    // container's flex layout — otherwise a `justify-center` (or any alignment)
+    // container's flex layout - otherwise a `justify-center` (or any alignment)
     // on the container centers the overflowing track and shifts the tile seam,
     // which opens a gap on the trailing edge at some point in the loop.
     target.style.position = "relative"
@@ -635,7 +635,7 @@ export function marquee (target , dir , duration , xOffset = 0 , yOffset = 0 , n
 
     // Rebuilds over the SAME element (engine restarts, StrictMode remounts)
     // must reuse the existing track. Re-creating it would swallow the old
-    // absolute track as the first "child", repeat THAT as the tiling unit —
+    // absolute track as the first "child", repeat THAT as the tiling unit -
     // every copy stacks at the same offset and scrollWidth collapses.
     let track = target._gcTrack
     if (!track || !track.isConnected) {
@@ -668,7 +668,7 @@ export function marquee (target , dir , duration , xOffset = 0 , yOffset = 0 , n
     const unitSize = horizontal ? measurer.scrollWidth : measurer.scrollHeight
     measurer.remove()
 
-    // Nothing to tile (empty content) — return an inert tween rather than one
+    // Nothing to tile (empty content) - return an inert tween rather than one
     // dividing by a zero-width unit.
     if (!unitSize) return gsap.fromTo(track, {}, { duration: 0 })
 

package/CHANGELOG.md

@@ -7,21 +7,21 @@ All notable changes to `gclass-anims` will be documented in this file.
 
 ## [1.0.0-beta.12] - 2026-08-26
 
-- Fixed `scramble` with `scroll-progress` throwing `can't convert undefined to object` — `computeTo` (`Listeners.js:424`) and scrub `to` builder (`Listeners.js:867`) now guard `from` (`scramble` has no `from`).
+- Fixed `scramble` with `scroll-progress` throwing `can't convert undefined to object` - `computeTo` (`Listeners.js:424`) and scrub `to` builder (`Listeners.js:867`) now guard `from` (`scramble` has no `from`).
 
 ## [1.0.0-beta.11] - 2026-08-26
 
-- Fixed `.draw-split` infinite loop when paired with `.appear` — `splitPaths` (`Animations.js:244`) now strips `appear`/`scroll`/`scroll-progress`/`draw`/`draw-split`/`data-gsap-*` from cloned segments, marks children with `data-gsap-split` + `contain:paint`/`will-change:transform` isolation, and prevents `appearObserver` (`Listeners.js:1559`) re-triggering. Also isolated `draw-split` demos in docs.
+- Fixed `.draw-split` infinite loop when paired with `.appear` - `splitPaths` (`Animations.js:244`) now strips `appear`/`scroll`/`scroll-progress`/`draw`/`draw-split`/`data-gsap-*` from cloned segments, marks children with `data-gsap-split` + `contain:paint`/`will-change:transform` isolation, and prevents `appearObserver` (`Listeners.js:1559`) re-triggering. Also isolated `draw-split` demos in docs.
 
 ## [1.0.0-beta.10] - 2026-08-26
 
-- Added `.randomize-<prop>-[min]-[max]` — randomize spawn start values per element (e.g. `randomize-rotation-[-90]-[90]`, `randomize-x-[-40]-[40]`). Re-rolls on every replay (`.scroll` re-enter, `.appear`).
-- Added `.draw` — stroke-draw reveal for SVG paths using DrawSVGPlugin (`drawSVG: 0% → 100%`).
-- Added `.draw-split` — draws multi-segment SVG paths sequentially at constant pen speed (splits paths with multiple `M` commands into individual strokes).
-- Added `.scramble` — text resolves from empty through scrambled characters into real content (ScrambleTextPlugin). Supports `.reveal-delay-N`, `.chars-[...]`, `.amount-N`, `.scramble-rtl`.
-- Added `.scramble-all` — variant of scramble with no empty start; the finished string flips to garbage as a whole then sweeps back.
-- Added `.scroll-frame` — use a scrollable container as the ScrollTrigger scroller for nested `.scroll` / `.scroll-progress` elements (innermost `.scroll-frame` ancestor wins).
-- Fixed `spawn-text-*` (SplitText) not working correctly on flex containers — text runs are now wrapped in block containers before splitting to preserve flex layout, spacing, and line grouping.
+- Added `.randomize-<prop>-[min]-[max]` - randomize spawn start values per element (e.g. `randomize-rotation-[-90]-[90]`, `randomize-x-[-40]-[40]`). Re-rolls on every replay (`.scroll` re-enter, `.appear`).
+- Added `.draw` - stroke-draw reveal for SVG paths using DrawSVGPlugin (`drawSVG: 0% → 100%`).
+- Added `.draw-split` - draws multi-segment SVG paths sequentially at constant pen speed (splits paths with multiple `M` commands into individual strokes).
+- Added `.scramble` - text resolves from empty through scrambled characters into real content (ScrambleTextPlugin). Supports `.reveal-delay-N`, `.chars-[...]`, `.amount-N`, `.scramble-rtl`.
+- Added `.scramble-all` - variant of scramble with no empty start; the finished string flips to garbage as a whole then sweeps back.
+- Added `.scroll-frame` - use a scrollable container as the ScrollTrigger scroller for nested `.scroll` / `.scroll-progress` elements (innermost `.scroll-frame` ancestor wins).
+- Fixed `spawn-text-*` (SplitText) not working correctly on flex containers - text runs are now wrapped in block containers before splitting to preserve flex layout, spacing, and line grouping.
 
 ## [1.0.0-beta.9] - Previous release
 

package/Config.js

@@ -8,11 +8,11 @@ import {
 } from './Animations.js'
 
 // ---------------------------------------------------------------------------
-// GClass configuration — THE single place to add / remove / tweak animations.
+// GClass configuration - THE single place to add / remove / tweak animations.
 //
 // `animations` is an array of entries. Each entry is a plain object; the engine
 // inspects which fields are present and wires up the matching behaviour
-// automatically — no engine edits needed:
+// automatically - no engine edits needed:
 //
 //   sel        - the className you put on elements (e.g. ".spawn-up")
 //
@@ -98,10 +98,10 @@ export const animations = [
   { sel: ".typewriter-split", typewriter: true, typewriterSplit: true, from: { opacity: 0 }, play: (el, delay, dur, ease) => null },
 
   // Scramble reveal: the text resolves out of garbage characters (ScrambleText).
-  // No opacity change — the scramble IS the spawn. Only the element's own text
+  // No opacity change - the scramble IS the spawn. Only the element's own text
   // runs animate; nested elements (links, icons) are preserved untouched.
   // Deliberately NO `from`: the scramble manages its own DOM (segment spans),
-  // so the generic TextPlugin-based reversal would destroy it — `.scroll`
+  // so the generic TextPlugin-based reversal would destroy it - `.scroll`
   // exit simply freezes the revealed state and re-entry replays fresh.
   // `scramble: true` gives `.scroll-progress` a true scrub branch (like
   // `.count`), since the generic from/to scrub can't express a text tween.
@@ -119,7 +119,7 @@ export const animations = [
   // Custom-function animation: counts from the `.spawn-num-N` value (N = the
   // starting number) up to whatever number is in the element (falling back to 0
   // when no `.spawn-num-N` class is present). `play` just wraps a helper from
-  // Animations.js — nothing else is special, so it still gets
+  // Animations.js - nothing else is special, so it still gets
   // order/scroll/leave/appear automatically.
   { sel: ".count", count: true, text: false, from: { opacity: 0 }, play: (el, delay, dur, ease) => countUp(el, delay, dur, ease) },
 
@@ -136,7 +136,7 @@ export const animations = [
   { sel: ".curtain-horizontal", text: false, from: { clipPath: "inset(0% 50% 0% 50%)" }, play: (el, delay, dur, ease) => curtainHorizontal(el, delay, dur, ease) },
   { sel: ".curtain-vertical", text: false, from: { clipPath: "inset(50% 0% 50% 0%)" }, play: (el, delay, dur, ease) => curtainVertical(el, delay, dur, ease) },
 
-  // Stroke-draw reveals (strokes only — filled SVGs are a separate plan).
+  // Stroke-draw reveals (strokes only - filled SVGs are a separate plan).
   // The hidden state is a fully undrawn stroke (`drawSVG: "0%"`): that's what
   // `.scroll-progress` scrubs up from and what leave/scroll reversal returns
   // to. `.draw` animates its target(s) as one stroke; `.draw-split` first

package/LICENSE

@@ -1,35 +1,197 @@
-MIT License
-
+gclass-anims - A Tailwind-style utility layer on top of GSAP
 Copyright (c) 2026 Saturn-sepehr
+SPDX-License-Identifier: LGPL-3.0-only
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, version 3 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+---
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
 
 ---
 
 Third-party notice
 
 This project depends on GSAP (GreenSock Animation Platform), which is NOT
-covered by the MIT license above and is distributed separately.
+covered by the LGPL-3.0 above and is distributed separately.
 
 GSAP is used under the Webflow Standard No-Charge GSAP License and is installed
 as a dependency from npm. GSAP remains the property of Webflow, Inc. / GreenSock
-and is subject to its own license terms, which take precedence over this MIT
+and is subject to its own license terms, which take precedence over this LGPL-3.0
 license with respect to GSAP itself.
 
-See https://gsap.com/standard-license/ for the applicable GSAP terms.
+See https://gsap.com/standard-license/ for the applicable GSAP terms.

package/Listeners.js

@@ -35,7 +35,7 @@ export function resolveHandler(name) {
 // to the FROM state of spawn tweens, so each element enters from its own pose.
 // GSAP evaluates function values on tween BUILD, and the engine always kills +
 // rebuilds tweens on replay (.scroll re-enter, .appear re-insert), so every
-// replay re-rolls automatically — no invalidate/repeatRefresh bookkeeping.
+// replay re-rolls automatically - no invalidate/repeatRefresh bookkeeping.
 //
 // The class is the guard: hasRandom() is a cheap className probe and nothing
 // below allocates or patches anything unless it passes, so elements without
@@ -50,7 +50,7 @@ export function resolveHandler(name) {
 //     tweens back to rest instead of sticking at the rolled value.
 //   • Timeline-mediated builders (count/scramble/draw-split) construct via
 //     Timeline methods, not the exported gsap.fromTo, so they sit outside the
-//     injection — irrelevant in practice, since their props aren't randomize
+//     injection - irrelevant in practice, since their props aren't randomize
 //     targets.
 const RANDOMIZE_RE = /^randomize-(\w+)-\[(-?[\d.]+)\]-\[(-?[\d.]+)\]$/
 const hasRandom = (el) => typeof el.className === "string" && /\brandomize-/.test(el.className)
@@ -76,7 +76,7 @@ const randomEnds = (keys) => Object.fromEntries(keys.map((k) => [
 // values into every from-state the config builds. Config helpers hardcode
 // their from literals inside Animations.js, so the injection hooks the only
 // interception point available: play() builds its tweens SYNCHRONOUSLY, which
-// makes a scoped gsap.fromTo swap safe — patch, let the config construct,
+// makes a scoped gsap.fromTo swap safe - patch, let the config construct,
 // restore in finally{}. Without .randomize-* this is a bare passthrough.
 const invokePlay = (config, el, delay, dur, ease) => {
     if (!hasRandom(el)) return config.play(el, delay, dur, ease)
@@ -128,7 +128,7 @@ export default function initListeners() {
         //     say) still gets tagged when one of its children animates.
         //   • Suppression requires the element ITSELF to carry data-gsap-wired
         //     (set when a previous run animated it). Freshly mounted content
-        //     under a preserved root therefore still plays its entrance — only
+        //     under a preserved root therefore still plays its entrance - only
         //     DOM that survived from an earlier run stays frozen.
         const isPreserved = (el) => {
             if (!el.dataset.gsapWired) return false
@@ -207,7 +207,7 @@ export default function initListeners() {
         }
 
         // Capture the element's first (resting) bounds. A later layout change
-        // morphs from this snapshot to the live position — a vanilla FLIP.
+        // morphs from this snapshot to the live position - a vanilla FLIP.
         const captureFlip = (node) => {
             if (!node.classList?.contains("flip")) return
             const config = findSpawn(node)
@@ -466,8 +466,8 @@ export default function initListeners() {
         // whitespace) must not become tween targets; they are kept as inert text
         // nodes so the natural gap is preserved and never animated.
         const RTL_JOIN_BREAK = /[\u200C\u200D\s]/
-        // A real Arabic/Persian joining letter. Any other visible character —
-        // Latin, digits, punctuation (، ؟ ؛ . ! …) — is NOT a joining letter: it
+        // A real Arabic/Persian joining letter. Any other visible character -
+        // Latin, digits, punctuation (، ؟ ؛ . ! …) - is NOT a joining letter: it
         // must not give the preceding letter a trailing Zero-Width-Joiner (which
         // would render it in its connecting form instead of its correct END form),
         // but it should still be split into its own span so it animates too.
@@ -560,7 +560,7 @@ export default function initListeners() {
         // flex ITEMS, so justify-content/gap would apply per letter, whitespace-
         // only text nodes stop rendering (spaces vanish) and line grouping reads
         // garbage. Loose text runs are therefore pre-wrapped in plain block
-        // divs — real boxes with normal inline flow inside — and the wrappers
+        // divs - real boxes with normal inline flow inside - and the wrappers
         // are undone whenever the split reverts. Non-text children (icons etc.)
         // stay put, keeping their own flex-item status and the gaps around them.
         const wrapFlexTarget = (el) => {
@@ -644,7 +644,7 @@ export default function initListeners() {
         // FULL reveal (first part starting to last part finishing) takes X
         // seconds, no matter how many chars/words/lines it got split into.
         // GSAP staggered tweens actually finish at `duration + stagger * (n-1)`,
-        // so `dur` can't be handed straight to `duration` as before — instead we
+        // so `dur` can't be handed straight to `duration` as before - instead we
         // solve for `duration`/`stagger` together so they always sum to `dur`.
         // An explicit `.stagger-N` class is honored as-is; only `duration` is
         // back-solved in that case so the last part still lands on `dur`.
@@ -741,7 +741,7 @@ export default function initListeners() {
         // and lets the single ScrollTrigger.refresh() at the end reconcile layout.
         gsap.utils.toArray(".pin").forEach(setupPin)
 
-        // Scroll-driven extras — class-driven ScrollTrigger behaviours that don't
+        // Scroll-driven extras - class-driven ScrollTrigger behaviours that don't
         // fit the spawn/loop machinery (no `play`/`build`), handled like `.pin`:
         //   .parallax-N            - element drifts relative to scroll. N is a
         //                            speed factor: 1 = static, <1 = slower,
@@ -1322,7 +1322,7 @@ export default function initListeners() {
 
         // `hover-<name>` and `click-<name>` trigger one of the loop animations on
         // mouseenter/mousedown. The element is wrapped in a parent div that acts as
-        // the stable hover/click hit area, while the element itself animates — so
+        // the stable hover/click hit area, while the element itself animates - so
         // the WHOLE box moves/scales instead of just its text, and the area never
         // shifts under the cursor. Marquee is skipped (its build restructures the
         // DOM).
@@ -1469,7 +1469,7 @@ export default function initListeners() {
 
         // Per-entry `setup` hook: a "special abilities" extension point. Any
         // config entry with a `setup(el, ctx)` function runs it once for every
-        // matching element at wiring time — for behaviour that doesn't fit the
+        // matching element at wiring time - for behaviour that doesn't fit the
         // scroll/order/loop machinery. If it RETURNS a function, that's treated
         // as a teardown and invoked when the whole engine is torn down, so
         // side-effects (listeners, observers, timers) can be cleaned up.
@@ -1520,7 +1520,7 @@ export default function initListeners() {
                     // to <body>, which adds `body` as a second scope alongside the
                     // node's former parent. Running animateFlip per scope re-enters
                     // playFlip on the same element, killing the in-flight tween and
-                    // clearing its transform — snapping the element into place.
+                    // clearing its transform - snapping the element into place.
                     // Dedupe across scopes so each element flips exactly once.
                     const toFlip = new Set()
                     flipRoots.forEach((scope) => {
@@ -1692,7 +1692,7 @@ export default function initListeners() {
             tw?.kill()
         })
         textSplits.forEach((s) => {
-            // Splits inside a tagged preserve region keep their spans — the
+            // Splits inside a tagged preserve region keep their spans - the
             // next run will skip those elements, and reverting here would
             // visibly strip their finished animation. Everything else reverts
             // cleanly (and drops out of splitCache so a reused element can be

package/README.md

@@ -62,7 +62,7 @@ export default {
 
 ## Usage
 
-Add utility classes to your markup. Everything is class-driven — no config.
+Add utility classes to your markup. Everything is class-driven - no config.
 
 ```html
 <div class="spawn-up">reveals sliding up on scroll</div>
@@ -98,5 +98,5 @@ customAnims.push({
 
 ## License
 
-MIT — except GSAP, which is used under the Webflow Standard No-Charge GSAP
-License and is not bundled or redistributed.
+LGPL-3.0-only - except GSAP, which is used under the Webflow Standard No-Charge GSAP
+License and is not bundled or redistributed. See `LICENSE`.

package/index.d.ts

@@ -189,7 +189,7 @@ export function scrambleVars(target: TweenTarget): {
  * Scramble spawn: the text starts empty and resolves into its real content
  * through garbage characters (ScrambleTextPlugin). No opacity change; nested
  * elements are preserved. Defaults to a linear ease so `.time-N` is the true
- * total reveal time — an explicit `.ease-*` class overrides. Modifiers read
+ * total reveal time - an explicit `.ease-*` class overrides. Modifiers read
  * from the element: .reveal-delay-N, .chars-[...], .amount-N, .scramble-all
  * (whole-string scramble-and-sweep, no empty-start typing), .scramble-rtl.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gclass-anims",
-  "version": "1.0.0-beta.13",
-  "description": "A Tailwind-style utility layer on top of GSAP. Framework-agnostic — works in vanilla JS, React, Vue, Svelte, or any bundler.",
+  "version": "1.0.0-beta.14",
+  "description": "A Tailwind-style utility layer on top of GSAP. Framework-agnostic - works in vanilla JS, React, Vue, Svelte, or any bundler.",
   "type": "module",
   "main": "index.js",
   "module": "index.js",
@@ -34,7 +34,7 @@
     "framework-agnostic",
     "css-classes"
   ],
-  "license": "MIT",
+  "license": "LGPL-3.0-only",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Saturn-sepehr/GClass.git",