upwwwards 0.0.0-stage → 0.1.1-beta.1

package/LICENSE

@@ -0,0 +1,278 @@
+upwwwards Standard "No Charge" License
+======================================
+
+Copyright (c) 2026 Morgan Le Thuaut. All rights reserved.
+
+This license is a proprietary software license. It is not an open-source
+license (it is not OSI-approved). It is provided as a practical template
+inspired by common “standard use / no charge” models; it is not legal advice.
+Have counsel review it before relying on it commercially.
+
+
+I. DEFINITIONS
+
+  “License” means these terms.
+
+  “Copyright Holder” means Morgan Le Thuaut.
+
+  “Licensee” or “you” means the individual or legal entity exercising rights
+  under this License.
+
+  “Software” means the upwwwards library and any related packages, plugins,
+  tools, documentation, or materials made available by the Copyright Holder
+  under this License (including npm distributions and updates).
+
+  “Permitted Use” means implementing and/or using the Software, as provided,
+  in a website, web application, digital product, or similar end-user-facing
+  experience that you (or your client) own or operate — including commercial
+  projects — where the Software is a dependency or runtime of that experience.
+
+  Permitted Use also includes developing, distributing, and operating software
+  packages, libraries, frameworks, and developer tools that use the Software as
+  a dependency, provided that such products are not Competitive Products.
+
+  “Competitive Product” means a software product whose primary purpose
+  is to provide substantially similar functionality to the Software itself,
+  and which is marketed or distributed as a substitute for the Software.
+
+  A product shall not be considered a Competitive Product solely because
+  it uses the Software as a dependency, integrates its APIs, or provides
+  additional functionality built on top of the Software.
+
+
+II. GRANT OF LICENSE
+
+  Subject to this License, the Copyright Holder grants you a non-exclusive,
+  worldwide, royalty-free license to use, reproduce, display, and implement
+  the Software solely for Permitted Uses. This grant continues for so long as
+  this License remains in effect and is not terminated under Section VI.
+
+  You may modify the Software solely for your own internal use or for use in
+  a Permitted Use, provided that such modifications are not distributed as a
+  standalone library or as part of a Competitive Product. For clarity, this
+  permission includes maintaining private forks or modified copies of the
+  Software solely for internal use or for a Permitted Use.
+
+  You may distribute the Software as a dependency of your own software package
+  (for example, declaring it in package.json so that npm, pnpm, or yarn installs
+  it for consumers of your package), provided that:
+
+  (a) the Software is not redistributed as a standalone product;
+
+  (b) the Software is not modified for that redistribution (consumers must
+      receive the Software as published by the Copyright Holder, typically via
+      the official package registry entry);
+
+  (c) the distribution is solely intended to enable a Permitted Use; and
+
+  (d) the distribution does not grant recipients any rights beyond those
+      expressly granted under this License (recipients are licensed directly
+      under this License, not under broader terms of your package).
+
+  This dependency permission includes direct and transitive dependencies, as
+  well as Software bundled into or distributed with packages solely to enable
+  a Permitted Use. In all cases, the Software remains subject to this License
+  and may not be redistributed as a standalone product or Competitive Product.
+
+  No other rights are granted, whether by implication, estoppel, or otherwise.
+  In particular, except for the modification and dependency-distribution
+  rights above, this License does not grant you rights to create derivative
+  works for public or commercial distribution as a library, or to sublicense
+  the Software except as necessary to deliver a Permitted Use (for example,
+  bundling minified runtime code — including your Permitted Use modifications —
+  into your deployed website or application).
+
+
+III. RESTRICTIONS
+
+  You may not, without prior written consent of the Copyright Holder:
+
+  (a) use the Software for any purpose other than a Permitted Use;
+
+  (b) use the Software to develop, operate, or distribute a Competitive Product;
+
+  (c) fork, clone, or republish the Software’s source code as a separate
+      public project, package, or repository, or otherwise distribute a fork
+      or clone of the Software to third parties, except as expressly permitted
+      under Section II;
+
+  (d) modify the Software and distribute, publish, or sell the modified
+      version (or a substantial portion of it) to third parties, except as
+      expressly permitted under Section II for modifications included in a
+      Permitted Use deployment;
+
+  (e) reverse engineer, decompile, or disassemble the Software in order to
+      build a Competitive Product (interoperability analysis strictly limited
+      to integrating the Software into a Permitted Use is not restricted by
+      this clause where such restriction is prohibited by applicable law);
+
+  (f) remove, obscure, or alter any proprietary notices, copyright notices,
+      or branding included with the Software. This restriction does not require
+      displaying the Copyright Holder’s branding or trademarks in the user
+      interface of a Permitted Use deployment. Copyright and license notices
+      must be retained in the Software distribution or accompanying
+      documentation, where technically and reasonably practicable;
+
+  (g) redistribute the Software on a standalone basis (including republishing
+      it on package registries under another name or as a competing package),
+      except as expressly allowed by Section II for dependency distribution
+      or bundling inside a Permitted Use deployment.
+
+
+IV. OWNERSHIP
+
+  The Software is licensed, not sold. All right, title, and interest in and
+  to the Software — including copyrights, trademarks, trade secrets, and
+  other intellectual property — remain the exclusive property of the
+  Copyright Holder and its licensors. This License does not transfer any
+  ownership rights to you.
+
+
+V. NO WARRANTY
+
+  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 NON-INFRINGEMENT. IN NO EVENT SHALL
+  THE COPYRIGHT HOLDER 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, TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW.
+
+
+VI. TERMINATION
+
+  This License may be terminated only as expressly provided in this Section VI.
+  The Copyright Holder may not revoke the License at its discretion for users
+  who remain in compliance with its terms.
+
+  (a) Notice and cure. If you breach this License, the Copyright Holder may
+      terminate it only after giving you written notice describing the breach
+      with reasonable particularity and allowing a cure period of thirty (30)
+      days (or longer if stated in the notice). If you cure the breach within
+      that period, this License does not terminate by reason of that notice.
+
+  (b) Effect of termination. If this License terminates under Section VI(a)
+      because the breach was not cured in time, then, except as provided in
+      Section VI(c), you must cease new use of the Software and destroy copies
+      in your possession that are not covered by Section VI(c).
+
+  (c) Grandfathered Permitted Uses. Termination does not require you to
+      recall, disable, or rebuild:
+        (i)   websites, applications, or other products already delivered to
+              a client or end users under a Permitted Use before termination;
+        (ii)  production deployments already live under a Permitted Use before
+              termination; or
+        (iii) copies of a specific Software version you lawfully obtained and
+              embedded in such delivered or published work before termination.
+
+      For those grandfathered artifacts only, the rights needed to keep them
+      running under a Permitted Use continue on a perpetual, royalty-free basis
+      even after termination, and do not require a new license grant. Ordinary
+      maintenance of those artifacts is included and may cover bug fixes,
+      security updates to dependencies, rebuilds for updated toolchains (for
+      example a newer Node.js or bundler), and other changes reasonably
+      necessary to keep an already delivered or already live project operating
+      as previously shipped. That maintenance right does not authorize new
+      projects, new distributions, or using the Software to start work that was
+      not already covered under Section VI(c)(i)–(iii) before termination.
+
+  (d) Survival. Sections IV, V, VI, and VII survive termination.
+
+
+VII. MISCELLANEOUS
+
+  (a) Amendments. The Copyright Holder may update this License by publishing a
+      revised text with the Software.
+
+        (i)   Versions you already obtained remain under the License terms that
+              applied when you obtained them.
+
+        (ii)  New Software versions first published after revised terms are
+              published are offered under those revised terms. By downloading,
+              installing, or using such a later version, you accept the then-
+              current terms for that version only (to the extent such acceptance
+              is recognized under applicable law).
+
+        (iii) Patch, bug-fix, or security releases that the Copyright Holder
+              expressly designates as continuing under the same License text as
+              a prior version may be obtained and used under that prior text,
+              even if a newer License text exists for other releases.
+
+      Nothing in this Section VII(a) allows the Copyright Holder to re-license,
+      by amendment alone, a Software version you already lawfully obtained.
+
+  (b) Entire agreement. This License constitutes the entire agreement regarding
+      the Software, unless you have a separate written agreement with the
+      Copyright Holder that expressly supersedes it.
+
+  (c) Severability. If any provision is held unenforceable, the remainder stays
+      in effect.
+
+  (d) No waiver. Failure to enforce any provision is not a waiver of future
+      enforcement.
+
+  (e) Governing law and jurisdiction. This License is governed by the laws of
+      France, excluding its conflict-of-law rules. Any dispute arising out of or
+      in connection with this License shall be submitted to the competent courts
+      of France, subject to any mandatory rules of jurisdiction and applicable
+      consumer protection laws.
+
+
+FAQ (informative only; does not modify the License)
+---------------------------------------------------
+
+  Q: Can I use upwwwards in a paid client website or SaaS product UI?
+  A: Yes — that is a Permitted Use, including commercial projects.
+
+  Q: Can AI tools generate code that calls upwwwards APIs?
+  A: Yes. Generating integration code for a Permitted Use is fine. Shipping a
+     Competitive Product or republishing the Software source is not.
+
+  Q: If the License is terminated, do my client sites have to go offline?
+  A: No. Section VI(c) grandfathers delivered and already-published Permitted
+     Uses (and the Software versions embedded in them). Termination stops new
+     use and new projects, after notice and an uncured breach.
+
+  Q: Can I patch or fork the Software for my own app?
+  A: Yes. Section II allows private forks and modifications for internal use or
+     a Permitted Use (including shipping those mods inside a client deployment).
+     Publishing a public fork or alternate package is not allowed.
+
+  Q: Must client sites show upwwwards branding?
+  A: No. Section III(f) keeps copyright/license notices in the distribution
+     where practicable, but does not require UI trademarks or branding.
+
+  Q: Can my npm package (e.g. my-framework) depend on upwwwards?
+  A: Yes. Section II allows distributing the Software as a dependency of your
+     own package so installs pull the official upwwwards package, provided it
+     enables a Permitted Use, is not a Competitive Product, and is not a
+     modified or rebranded standalone republish of the Software.
+
+  Q: If my package is MIT (or another OSS license), does that open-source
+     upwwwards?
+  A: No. Section II(d) is clear: recipients of your package are licensed for
+     the Software only under this License, not under broader terms of your
+     package. Publishing an MIT (or similar) wrapper that depends on upwwwards
+     does not make upwwwards open source; your users must still comply with
+     this License for the Software itself.
+
+  Q: Is the license perpetual for my client’s shipped site?
+  A: For grandfathered delivered / already-live Permitted Uses, Section VI(c)
+     keeps the rights needed to run those artifacts perpetual and royalty-free,
+     even if your License later terminates. That does not cover new projects
+     after termination.
+
+  Q: What counts as a Competitive Product?
+  A: A package that mainly reproduces upwwwards’ functionality and is marketed
+     as a substitute can be competitive. A package that depends on upwwwards to
+     add complementary features (for example a larger site framework, router,
+     or UI toolkit that uses upwwwards for page lifecycle / animation) is not
+     automatically a Competitive Product solely for that reason.
+
+  Q: What is allowed at a glance?
+  A: Use in client/commercial sites: yes. Private patches for your project: yes.
+     npm package depending on upwwwards: yes. Distributed modified fork: no.
+     Competing / rebranded standalone package: no.
+
+  Q: Is this MIT / Apache / GPL?
+  A: No. This is a proprietary no-charge standard-use license.

package/README.md

@@ -1,3 +1,188 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# upwwwards
+
+**One shared page lifecycle, one frame loop, and opt-in plugins for Nuxt 4 and SvelteKit 2.**
+
+Every feature in your app subscribes to the same cues — leave, enter, ready — and the same `requestAnimationFrame` budget, instead of each one wiring its own router hooks, scroll library, GSAP context, or render loop. Plugins (Scroll, Anime, Synthra, …) are optional; the core works on its own.
+
+*(Think of it as a conductor: the framework is the stage, `Up` keeps everyone on the same beat.)*
+
+**Free for commercial use** under a proprietary Standard “No Charge” license (not OSI open source). Details: [docs/advanced/license.md](docs/advanced/license.md) · [`LICENSE`](LICENSE)
+
+**Requirements:** Nuxt 4 or SvelteKit 2 · Vite 7 · TypeScript recommended · Version `0.1.0-beta.1`
+
+| You want… | upwwwards gives you… |
+| --- | --- |
+| Leave / enter / ready that matches the router | `Up.Event` + `Up.Adapter` |
+| One `requestAnimationFrame` budget for the app | `Up.Thread` |
+| Viewport metrics, cache, “wait before ready” | `Up.App` |
+| GSAP / Lenis / Three without ad-hoc glue | Opt-in [plugins](docs/plugins.md) |
+| The same spine on Nuxt *or* SvelteKit | Vite `adapter: 'nuxt' \| 'svelte'` |
+
+---
+
+## Install
+
+```bash
+npm install upwwwards
+```
+
+`pnpm add`, `yarn add`, and `bun add` work the same way.
+
+Peer dependencies are optional and match what you enable (`gsap`, `lenis`, `three`, …). See [Getting started](docs/getting-started.md).
+
+---
+
+## Quick start
+
+Two steps (Vite plugin, then root layout). After that you should see `LIFE` then `LOAD` in the console on first paint (and again after each client navigation).
+
+**Glossary:** `DEATH` = leave · `LIFE` = enter · `LOAD` = ready. Build on `LIFE`, tear down on `DEATH`.
+
+### Nuxt 4
+
+**1 — Vite plugin** — `nuxt.config.ts`:
+
+```ts
+import initializer from 'upwwwards/initializers/vite'
+
+export default defineNuxtConfig({
+  vite: {
+    plugins: [initializer({ adapter: 'nuxt' })]
+  }
+})
+```
+
+**2 — Start once** — `app/layouts/default.vue`:
+
+```vue
+<script lang="ts" setup>
+import Up from 'upwwwards'
+
+const router = useRouter()
+const { hook } = useNuxtApp()
+
+Up.set({ hook, router })
+
+Up.Event.sub([
+  ['DEATH', () => console.log('DEATH')],
+  ['LIFE',  () => console.log('LIFE')],
+  ['LOAD',  () => console.log('LOAD')]
+])
+</script>
+
+<template>
+  <slot />
+</template>
+```
+
+### SvelteKit 2
+
+**1 — Vite plugin** — `vite.config.ts`:
+
+```ts
+import { sveltekit } from '@sveltejs/kit/vite'
+import { defineConfig } from 'vite'
+import initializer from 'upwwwards/initializers/vite'
+
+export default defineConfig({
+  plugins: [
+    initializer({ adapter: 'svelte' }),
+    sveltekit()
+  ]
+})
+```
+
+**2 — Start once** — `src/routes/+layout.svelte`:
+
+```svelte
+<script lang="ts">
+  import { beforeNavigate, onNavigate, afterNavigate } from '$app/navigation'
+  import Up from 'upwwwards'
+
+  let { children } = $props()
+
+  Up.set({ beforeNavigate, onNavigate, afterNavigate })
+
+  Up.Event.sub([
+    ['DEATH', () => console.log('DEATH')],
+    ['LIFE',  () => console.log('LIFE')],
+    ['LOAD',  () => console.log('LOAD')]
+  ])
+</script>
+
+{@render children()}
+```
+
+If nothing logs on first paint, subscribe earlier (right after `Up.set`) — [getting-started — First load](docs/getting-started.md#first-load-note).
+
+Full walkthrough + SSR: **[Getting started](docs/getting-started.md)** · Mental model: **[concepts](docs/concepts.md)**
+
+---
+
+## What you get
+
+- **Common spine** — `Up.Adapter`, `Up.App`, `Up.Thread`, `Up.Event` on both hosts  
+- **Predictable page cycle** — construct on `LIFE`, destroy on `DEATH`  
+- **Opt-in plugins** — Scroll (Lenis), Anime (GSAP), Synthra (Three.js), Screen, Observer, Transmitter, Puppeteer (DOM helpers)  
+- **Build-time wiring** — adapter selection, generated types, optional Classter CSS  
+- **SSR helpers** — `upwwwards/contexts/nuxt` or `…/sveltekit`  
+- **Standalone scripts** — `Wait`, `Logs`, `Maths`, … from `upwwwards/scripts` (no `Up.set` needed)
+
+Compared to wiring router hooks + GSAP Context + Lenis yourself: one place to subscribe, one teardown story, one frame scheduler.
+
+---
+
+## Showcase (Anime)
+
+**Optional** — needs `plugins: ['Anime']` and `npm install gsap`. Skip on a first read; more patterns: **[docs/recipes.md](docs/recipes.md)**.
+
+```ts
+import Up from 'upwwwards'
+
+const KEY = Symbol('Hero')
+
+function build() {
+  Up.Anime.sub(KEY, ({ gsap }) => {
+    gsap.from('.hero', { opacity: 0, y: 40, duration: 0.8 })
+  })
+}
+
+function teardown() {
+  Up.Anime.unsub(KEY)
+}
+
+Up.Event.sub([
+  ['LIFE', build],
+  ['DEATH', teardown]
+])
+```
+
+---
+
+## Documentation
+
+Docs live in this repo (`docs/`, this README, [`llms.txt`](llms.txt)). A hosted site and changelog are planned.
+
+| Path | Start here if… |
+| --- | --- |
+| [docs/getting-started.md](docs/getting-started.md) | You are wiring a project today |
+| [docs/concepts.md](docs/concepts.md) | You want the mental model |
+| [docs/core.md](docs/core.md) | You need `App` / `Thread` / `Event` detail |
+| [docs/recipes.md](docs/recipes.md) | You want copy-paste patterns |
+| [docs/faq.md](docs/faq.md) | Something behaves unexpectedly |
+| [docs/compatibility.md](docs/compatibility.md) | Host / peer version matrix |
+| [docs/plugins.md](docs/plugins.md) | You enable Scroll, Anime, Synthra, … |
+| [docs/scripts.md](docs/scripts.md) | Standalone utilities |
+| [docs/index.md](docs/index.md) | Full map |
+
+API pages use 🟢 **Essentials** · 🟡 **Going further** · ⬛ **Under the hood** — only Essentials is required.
+
+Layers: [initializers](docs/initializers.md) · [adapters](docs/adapters.md) · [contexts](docs/contexts.md) · [classter](docs/classter.md) · [symbols](docs/advanced/symbols.md)
+
+## License
+
+See the summary at the top, [`LICENSE`](LICENSE), and [docs/advanced/license.md](docs/advanced/license.md).
+
+## For AI agents
+
+[`llms.txt`](llms.txt) → [getting-started](docs/getting-started.md) → [concepts](docs/concepts.md) → [core](docs/core.md). Prefer public entry points; don’t assume MIT/Apache rights.

package/dist/Classter-BvYgmPAa.d.ts

@@ -0,0 +1,148 @@
+import { Property, SpreadElement, Expression, PrivateIdentifier, Pattern } from 'estree';
+
+declare const run: unique symbol;
+declare const runProperties: unique symbol;
+declare const push: unique symbol;
+declare const check: unique symbol;
+declare namespace Classter {
+    /**
+        * Attribute / prop name scanned for class tokens (e.g. `"class"`, or a custom name such as `"innerClass"`).
+    */
+    type IDENTIFIER = string;
+}
+/**
+    * Base of Classter, the optional atomic-CSS generator, shared by the framework analyzers
+    * `Vue` (`upwwwards/classter/Vue`) and `Svelte` (`upwwwards/classter/Svelte`).
+    *
+    * Templates and HTML are scanned for class tokens shaped `alias:value`, `alias:[value]` or `alias:value:pseudo`:
+    * - `alias` is a shortcut of a CSS property (`pa` for `padding`, `ba-co` for `background-color`, see `props`; extend with {@link Classter.addAlias}).
+    * - a bracketed value may also contain `:` or `[`, and `_` stands for a space (`ma:[0_auto]` gives `margin:0 auto`).
+    * - `pseudo` is `:before` or `:after` (`co:[#fff]:before`).
+    *
+    * Each valid token becomes one CSS rule, collected into the stylesheet returned by {@link Classter.get}.
+    * The Vite plugin serves it as the virtual module `classter.css`. All state is static and shared by the subclasses.
+*/
+declare abstract class Classter {
+    #private;
+    /**
+        * Sets the "stylesheet changed" flag; the Vite plugin resets it to `false` after reloading `classter.css`.
+        * Shared across the inheritance hierarchy.
+        * @internal
+    */
+    static set updated(b: boolean);
+    /**
+        * Enables / disables warnings about unknown aliases and expressions that cannot be analyzed statically.
+        * Set to `false` by the `silent` option of the Vite plugin. Shared across the inheritance hierarchy.
+    */
+    static set warn(b: boolean);
+    /**
+        * Sets the component file extension (`.vue` / `.svelte`) whose files are passed to `analyze`; set by the Vite plugin from the adapter.
+        * Shared across the inheritance hierarchy.
+        * @internal
+    */
+    static set ext(s: string);
+    /**
+        * Attribute names whose values are scanned as class lists: `"class"` plus names added with {@link Classter.addClassIdentifiers}.
+    */
+    static get CLASS_IDENTIFIERS(): Classter.IDENTIFIER[];
+    /**
+        * Attribute names whose object-literal values are scanned for class identifiers (added with {@link Classter.addAttributesIdentifiers}).
+    */
+    static get ATTRIBUTES_IDENTIFIERS(): Classter.IDENTIFIER[];
+    /**
+        * `true` when at least one new rule was registered since the flag was last reset.
+    */
+    static get updated(): boolean;
+    /**
+        * Whether warnings about unknown aliases and expressions that cannot be analyzed statically are logged. Default `true`.
+    */
+    static get warn(): boolean;
+    /**
+        * Component file extension (`.vue` / `.svelte`) whose files are passed to `analyze`; empty until set by the Vite plugin.
+    */
+    static get ext(): string;
+    /**
+        * Builds the stylesheet from every registered token: one rule per token, with the token escaped as class selector
+        * (e.g. `.pa\:1rem{padding:1rem}`).
+        * @returns Concatenated CSS rules, or an empty string when no token is registered.
+    */
+    static get(): string;
+    /**
+        * Adds attribute / prop names whose values are scanned as class lists, in addition to `class`.
+        * Usually set through `classter.identifiers.class` of the Vite plugin.
+        * @param identifiers Names to add (each stored in lowercase and kebab-case, e.g. `innerClass` gives `innerclass` and `inner-class`).
+    */
+    static addClassIdentifiers(identifiers: Classter.IDENTIFIER[]): void;
+    /**
+        * Adds attribute / prop names whose object-literal values are scanned for class identifiers
+        * (e.g. `attrs` for `attrs={{ class: 'pa:1rem' }}`). Usually set through `classter.identifiers.attributes` of the Vite plugin.
+        * @param identifiers Names to add (each stored in lowercase and kebab-case).
+    */
+    static addAttributesIdentifiers(identifiers: Classter.IDENTIFIER[]): void;
+    /**
+        * Registers custom aliases, each mapping a shortcut to a CSS property, on the shared alias table.
+        * Usually set through `classter.alias` of the Vite plugin.
+        * Logs a warning and skips the entry when the key is not lowercase letters / hyphens (optionally prefixed with `@`),
+        * when the key is already used, or when the property is not a valid name (letters, digits, `_`, `-`).
+        * @param alias Map of shortcut keys to CSS property names.
+        * @example
+        * ```ts
+        * import Vue from 'upwwwards/classter/Vue'
+        *
+        * Vue.addAlias({ 'my-pa': 'padding', 'ac-co': 'accent-color' }) // 'ac-co' is already defined: warns and is skipped
+        *
+        * // <div class="my-pa:1rem"> now generates .my-pa\:1rem{padding:1rem}
+        * ```
+    */
+    static addAlias(alias: Record<string, string>): void;
+    /**
+        * Splits a whitespace-separated class string and registers each token; falsy values are ignored.
+        * @param _class Class attribute content (coerced via `toString`).
+        * @param id Source file id for warnings.
+        * @internal
+    */
+    static [run](_class: string | number | bigint | boolean | RegExp | null | undefined, id: string): void;
+    /**
+        * Walks ESTree object properties: either push keys as class tokens, or follow class-identifier values.
+        * Recurses into nested `ObjectExpression` spreads.
+        * @param props Object properties (and spreads).
+        * @param checkKey When `true`, treat property keys as class tokens; otherwise resolve class-identifier values.
+        * @param id Source file id for warnings.
+        * @internal
+    */
+    static [runProperties](props: (Property | SpreadElement)[], checkKey: boolean, id: string): void;
+    /**
+        * Analyzes a component source file and registers the class tokens it contains.
+        * Base implementation does nothing; overridden by `Vue` and `Svelte`. Called by the Vite plugin on transform.
+        * @param code Source file contents.
+        * @param id Source file id, used in warnings.
+    */
+    static analyze(code: string, id: string): void;
+    /**
+        * Analyzes raw HTML with a lightweight scan: only double-quoted `class="..."` attributes are read
+        * (custom class identifiers are ignored).
+        * @param code Raw HTML / markup string.
+        * @param id Source file id, used in warnings.
+    */
+    static analyzeHTML(code: string, id: string): void;
+    /**
+        * Registers one token: parses `alias:value[:pseudo]`, resolves the alias, validates the value and pseudo-element,
+        * and stores the declaration (sets `updated` on first insert). Tokens not shaped like `alias:value` are ignored silently.
+        * @param _class Single class token (e.g. `pa:1rem` or `co:[#fff]:before`).
+        * @param id Source file id for unknown-alias warnings.
+        * @internal
+    */
+    static [push](_class: string, id: string): void;
+    /**
+        * Walks an ESTree expression and extracts class tokens where statically knowable.
+        * Supports arrays, `+` of literals, logical / conditional, literals, templates, and objects.
+        * Identifiers and member expressions are intentionally skipped (runtime values).
+        * @param expression ESTree node to inspect.
+        * @param toString When `true`, mimic string coercion (objects not expanded as class maps; arrays with length ≠ 1 skipped).
+        * @param id Source file id for warnings.
+        * @internal
+    */
+    static [check](expression: Expression | PrivateIdentifier | Pattern, toString: boolean, id: string): void;
+}
+
+export { Classter as C };