ranuts 0.4.1-alpha.1 → 0.5.0

package/docs/API.md

@@ -8,16 +8,17 @@ constraints, conventions) read [../CLAUDE.md](../CLAUDE.md) first.
 Import from the **subpath** that owns the symbol, e.g. `import { debounce } from
 'ranuts/utils'`. The root `ranuts` barrel re-exports the utils + visual surface.
 
-**413 exports** across 6 entry points. Generated at 2026-08-18T13:16:54.528Z.
+**422 exports** across 7 entry points.
 
 ## Entry points
 
-- [`ranuts/utils`](#ranuts-utils) — Browser and general-purpose utilities · _browser + node_ · 327 exports
+- [`ranuts/utils`](#ranuts-utils) — Browser and general-purpose utilities · _browser + node_ · 333 exports
 - [`ranuts/sw`](#ranuts-sw) — Service Worker caching strategies and the precache protocol · _service worker only_ · 9 exports
-- [`ranuts/node`](#ranuts-node) — Node server utilities (fs / http / ws / middleware) · _node only_ · 26 exports
 - [`ranuts/visual`](#ranuts-visual) — 2D rendering engine (Canvas / WebGL / WebGPU) · _browser only_ · 16 exports
 - [`ranuts/i18n`](#ranuts-i18n) — Framework-agnostic i18n engine (also re-exported from ranuts/utils) · _browser + node_ · 9 exports
 - [`ranuts/vnode`](#ranuts-vnode) — Snabbdom-style virtual DOM · _browser_ · 26 exports
+- [`ranuts/stream`](#ranuts-stream) — SSE parsing, a provider-neutral model-stream fold, and the token budget that decides when a history stops fitting · _browser + node_ · 20 exports
+- [`ranuts/conversation`](#ranuts-conversation) — Project an append-only event log into renderable conversation nodes · _browser + node_ · 9 exports
 
 ## `ranuts/utils`
 
@@ -34,6 +35,7 @@ import { /* … */ } from 'ranuts/utils';
 - `addNumSym(value: string | number, flag?: string | number) => string`
 - `adoptSheetText(shadowRoot: ShadowRoot, cssText: string, marker?: string) => void` — Inject dynamic styles supplied at runtime (a component's `sheet` property, say).
 - `adoptStyles(shadowRoot: ShadowRoot, cssText: string, marker?: string) => void` — Inject a component's static styles into a shadow root.
+- `alignCrossAxis(align: PlacementAlign, anchorStart: number, anchorSize: number, floatingSize: number) => number` — Where a floating panel starts along the cross axis, given how
 - `appendUrl(url: string, params?: Record<string, string>) => string` — Turn an object into a query string and append it to a URL
 - `arrayBufferToString(buffer: ArrayBuffer | Uint8Array) => string` — Decode bytes into a string using the sniffed encoding. Required when reading
 - `autosizeTextarea(element: HTMLTextAreaElement) => (() => void)` — Make a `<textarea>` grow and shrink with its content, so a long message is
@@ -55,18 +57,19 @@ import { /* … */ } from 'ranuts/utils';
 - `compose<T>(middleware: Array<Middleware<T>>) => ComposedMiddleware<T>` — Run a chain of async functions as if it were sequential
 - `computePlacement(options: ComputePlacementOptions) => ComputedPlacement` — Position a floating panel relative to an anchor rect: flips to the opposite
 - `concatBytes(chunks: readonly Uint8Array[]) => Uint8Array` — Join byte chunks into one buffer, in order.
-- `connection() => number | undefined` — Current network status: type, throughput, and whether the connection changed
+- `connection() => NetworkInformation | undefined` — Current network status: type, throughput, and whether the connection changed
 - `convertImageToBase64(file: File) => Promise<convertImageToBase64Return>` — Convert an image to base64
 - `cosinePalette(t: number, a: RGB, b: RGB, c: RGB, d: RGB) => RGB` — Inigo Quilez cosine gradient palette: `a + b * cos(2π(c·t + d))`. Each of `a,b,c,d` is an RGB triple; `t` is the position 0..1. Returns an RGB triple.
 - `crc32(data: Uint8Array) => number` — CRC32 checksum (IEEE 802.3 polynomial), the one ZIP stores per entry.
 - `create(tagName: string, options?: ElementCreationOptions) => Chain`
+- `createBottomFollower(options: BottomFollowerOptions) => BottomFollower` — Creates a bottom-follow controller for one scrollport.
 - `createData(params?: Record<string, unknown>) => Record<string, unknown>` — Build the standard envelope that accompanies a report — page URL, referrer,
 - `createDocumentFragment(list: Element[]) => DocumentFragment | undefined` — Create a DocumentFragment
 - `createDoubleTapDetector(options?: DoubleTapDetectorOptions) => DoubleTapDetector` — Double-tap detection over raw `(x, y, time)` samples — pointer-type-agnostic,
 - `createHandoff<T>({ dbName, storeName, key }: HandoffOptions) => Handoff<T>` — A one-shot value handoff between two pages of the same origin, backed by
 - `createI18n<TDict extends StringValues<TDict> = MessageDict>(config?: I18nConfig<TDict>) => I18nCore<TDict>` — Create and register the global i18n singleton.
 - `createLocalePath(config: LocalePathConfig) => LocalePath` — Create the set of locale path conversion functions.
-- `createObjectURL(src: Blob | ArrayBuffer | Response) => Promise<string>`
+- `createObjectURL(src: string | Blob | ArrayBuffer | Response) => Promise<string>`
 - `createPortBridge(port: MessagePort) => PortBridge` — Build a bridge on any MessagePort (a Web Worker, a SharedWorker, or a port from a completed handshake).
 - `createRaceGuard() => RaceGuard` — Bump-and-compare guard against a stale async response overwriting a newer
 - `createSignal<T = unknown>(value: T, options?: SignalOptions<T>) => [() => T, (newValue: T) => void]` — Create a minimal signal with optional event broadcasting, returned as
@@ -80,15 +83,17 @@ import { /* … */ } from 'ranuts/utils';
 - `decodeTextBytes(bytes: Uint8Array, encodings?: string[]) => string` — Decode text bytes, trying encodings in order until one holds.
 - `deferred<T = void>() => Deferred<T>` — A promise plus its `resolve` / `reject`, for the case where the thing that
 - `delay(ms: number) => Promise<void>` — Resolve after `ms` milliseconds. Uses the bare `setTimeout`, so it works in
-- `detectLanguage(text: string, sampleSize?: number) => TextLanguage` — Decide a text's primary language from the ratio of CJK to Latin characters.
+- `detectLanguage(text: string, sampleSize?: number) => TextLanguage` — Decide a text's primary script from character ratios. Pure statistics, no
+- `diffLines(oldText: string, newText: string, options?: DiffOptions) => DiffHunk[]` — Diffs two texts by line.
 - `durationHandler<T, U>(handler: (...args: T[]) => U, ...params: T[]) => ((a: number) => Promise<U>)` — Run a function repeatedly at a fixed interval
 - `encodeUrl(url: string) => string` — Encode a URL to a percent-encoded form, excluding already-encoded sequences.
 - `escapeHtml(string?: string | number | null) => string`
 - `fanShapedByArc(ctx: CanvasRenderingContext2D, maxRadius: number, start: number, end: number, gutter: number) => void` — Trace a pie slice with arc(), including the gutter between slices.
 - `fenceCode(body: string, lang?: string) => string` — Wrap text in a Markdown code fence long enough to survive backticks inside it.
 - `fetchMaybeGzip(input: RequestInfo | URL, init?: RequestInit) => Promise<Uint8Array>` — Fetch a resource that may be delivered gzipped or already
-- `filterObj(obj: Record<string, unknown>, list: Array<string>) => Record<string, unknown>` — Return a new object without the properties whose values appear in `list` — typically used to drop empty strings and nulls
+- `filterObj(obj: Record<string, unknown>, list: Array<string>) => Record<string, unknown>` — Return a new object without the listed keys — typically used to drop fields before sending an object on
 - `fit(value: number, a1: number, a2: number, b1: number, b2: number) => number` — Remap `value` from `[a1, a2]` onto `[b1, b2]` and clamp to the output range — the shader `fit`.
+- `formatBytes(bytes: number) => string` — Format a byte count for a person to read.
 - `formatDate(value?: DateInput, pattern?: string) => string` — Format a date with a token pattern. Accepts a timestamp, a date string, a
 - `formatDuration(seconds: number) => string` — Format an elapsed number of **seconds** as a colon-separated clock duration,
 - `formatJson(value: string | object, onError?: (error: Error) => void, indent?: number) => string` — Pretty-print JSON. Accepts an object or a JSON string (single quotes are
@@ -155,8 +160,6 @@ import { /* … */ } from 'ranuts/utils';
 - `luma(r: number, g: number, b: number) => number` — Perceived brightness (luma) of an RGB colour using Rec. 601 weights. Channels may be 0..1 or 0..255 — the result keeps that scale.
 - `matchMediaQuery(query: string) => boolean` — Read whether a media query currently matches, synchronously. Returns false under SSR.
 - `mathjs(a: number, type: string, b: number) => ComputeNumberResult`
-- `md5(str: string) => string` — MD5 hash function implementation
-- `memoize<T extends Func>(fn: T | unknown) => ((...args: Parameters<T>) => ReturnType<T>)` — Former name of `once`. The name is misleading — it does not cache per
 - `merge(a: Obj, b?: Obj) => Obj` — Merge objects
 - `mergeExports(obj: Record<string, string>, exports: Record<string, string>) => Record<string, string>` — Copy an exports object onto `obj`, then freeze it
 - `navigatorLanguage() => TextLanguage` — Map the browser UI language into the same buckets (the default when there is
@@ -192,7 +195,7 @@ import { /* … */ } from 'ranuts/utils';
 - `removeClassToElement(element: Element, removeClass: string) => void` — Remove a class from an element
 - `replaceOld(source: any, name: string, replacement: (...args: unknown[]) => unknown, isForced?: boolean) => () => void` — Replace a property on an object, wrapping whatever was there before.
 - `report({ url, type, payload }: BeaconPayload) => boolean` — Send a telemetry beacon. Prefers `navigator.sendBeacon` (does not block
-- `requestUrlToBuffer(src: string, options: Partial<RequestUrlToArraybufferOption>) => Promise<requestUrlToArraybufferReturn>` — Fetch a URL as an ArrayBuffer
+- `requestUrlToBuffer{ (src: string, options?: Partial<RequestUrlToArraybufferOption<'' | 'arraybuffer'>>): Promise<requestUrlToArraybufferReturn>; <T extends XML… (+2 overloads)` — Fetch a URL as an ArrayBuffer by default, or as the requested XHR response type
 - `resolveLocale(options: ResolveLocaleOptions) => string` — Resolve which of your supported locales to use, from the usual chain:
 - `rewriteZip(bytes: Uint8Array, options?: RewriteZipOptions) => Promise<Uint8Array>` — Rebuild an archive with some entries replaced and/or new entries appended.
 - `rgbaString(r: number, g: number, b: number, a: number) => string` — Build a CSS `rgba()` string. Alpha is 0–100 rather than 0–1, matching the
@@ -220,8 +223,6 @@ import { /* … */ } from 'ranuts/utils';
 - `srgbToLinear(c: number) => number` — Convert one sRGB channel (0..1) to linear-light (IEC 61966-2-1 transfer function).
 - `strParse(str?: string, sep?: string | RegExp, eq?: string | RegExp) => Record<string, string>` — Parse a delimited string into an object, e.g.
 - `throttle<T extends (...args: any[]) => any>(fn: T, delay?: number) => Throttled<T>` — Throttle — under a burst of calls, run at a fixed interval: the first call
-- `timeFormat(time: number) => string` — Format a number of seconds as a colon-separated duration
-- `timestampToTime(timestamp?: number | string) => Date & { format?: Function; }` — Turn a timestamp into a `Date` carrying a `format` method.
 - `toFullWidth(value: string) => string` — Convert half-width characters to full-width (the inverse of `toHalfWidth`)
 - `toHalfWidth(value: string) => string` — Convert full-width characters to half-width (digits, letters, punctuation and
 - `toString(value: string | number) => string`
@@ -264,6 +265,8 @@ import { /* … */ } from 'ranuts/utils';
 
 - `interface AcceptPortBridgeOptions`
 - `interface BeaconPayload`
+- `interface BottomFollower` — Imperative bottom-follow controller.
+- `interface BottomFollowerOptions` — How to construct a follower.
 - `interface BridgeManagerOptions`
 - `interface BroadcastPayload`
 - `interface CallToPayload`
@@ -271,6 +274,9 @@ import { /* … */ } from 'ranuts/utils';
 - `interface ComputePlacementOptions`
 - `interface Debounced`
 - `interface Deferred` — Promise primitives that JavaScript does not ship: an externally settled promise and a
+- `interface DiffHunk` — A run of changed lines plus the context around it.
+- `interface DiffLine` — One line of a diff, carrying both line numbers so a gutter can show either side.
+- `interface DiffOptions` — How to compute a diff.
 - `interface DoubleTapDetector`
 - `interface DoubleTapDetectorOptions`
 - `interface FormatRelativeOptions`
@@ -325,17 +331,20 @@ import { /* … */ } from 'ranuts/utils';
 
 - `type CurrentDevice`
 - `type DateInput` — Accepted everywhere a moment in time is taken; `undefined` means "now".
+- `type DiffLineKind` — What happened to one line.
 - `type EasingFn` — One easing function: (elapsed, from, delta, duration) => current value
 - `type ImgSource` — A bitmap container usable both as a drawImage source and as a render target
 - `type LocaleChangeHandler`
 - `type LocaleMessages` — Locale → dictionary. Parameterised by the dictionary shape so an app can hand in its own
 - `type MessageDict`
-- `type Placement`
+- `type Placement` — A side, optionally suffixed with a cross-axis alignment — the same grammar
+- `type PlacementAlign` — Where the panel lines up along the cross axis: with the anchor's leading
+- `type PlacementSide` — The side of the anchor a floating panel sits on.
 - `type RelativeStyle` — `'compact'` is ours; the other three are `Intl.RelativeTimeFormat` styles.
 - `type RGB` — An RGB triple with each channel in 0..1 (linear or sRGB depending on the operation).
 - `type SpeechErrorKind` — `denied` means the user or the browser refused the microphone — worth surfacing.
 - `type StringValues` — "An object whose values are all strings" — the constraint the dictionary type parameter
-- `type TextLanguage` — Coarse language bucket: Chinese / English / other only
+- `type TextLanguage` — Coarse script bucket: the four writing systems that need different handling, plus
 - `type TranslateParams`
 - `type TruncatePosition` — Which end of the string gets dropped when it is too long.
 
@@ -350,9 +359,7 @@ import { /* … */ } from 'ranuts/utils';
 - `const cubic: SpeedType`
 - `const DEFAULT_CHANNEL: "default"`
 - `const expo: SpeedType`
-- `const FMT: Record<string, string[]>`
 - `const HEX_COLOR_REGEX: RegExp` — `#rgb` / `#rrggbb` (the `#` is required)
-- `const isClient: boolean` — Whether a `window` existed **when this module was first imported**.
 - `const MessageCodec: { encode(data: any): string; decode<T = any>(encodedStr: string): T | null; encodeFile(file: File): Promise<string>; decodeFile(encoded: st…` — Message codec.
 - `const MimeType: Map<string, string>`
 - `const MOBILE_MEDIA_QUERY: "(max-width: 768px)"` — Viewport breakpoint, matching where the mobile layout takes over
@@ -392,55 +399,6 @@ import { /* … */ } from 'ranuts/sw';
 - `interface ServePrecacheOptions`
 - `interface SWScope` — Minimal view of the SW global the helpers touch, so they can be unit-tested with a stub.
 
-## `ranuts/node`
-
-Node server utilities (fs / http / ws / middleware) · runtime: **node only** · source: `src/node/index.ts`
-
-```ts
-import { /* … */ } from 'ranuts/node';
-```
-
-### Functions
-
-- `appendFile(path: string, content: string) => Promise<Ranuts.Identification>` — Append content to an existing file
-- `bodyMiddleware(options?: Partial<ServerBody>) => MiddlewareFunction`
-- `connect(connectMiddleware: ConnectMiddleware) => MiddlewareFunction`
-- `get({ url }: Request) => Promise<Response>`
-- `getIPAdress() => string | undefined`
-- `default(req: Req) => ParseUrl | undefined` — Parse an IncomingMessage's request URL; the return type is always ParseUrl
-- `prompt({ message, stream, defaultResponse }: PromptOption) => Promise<boolean>`
-- `queryFileInfo(path: string) => Promise<Ranuts.Identification>` — Stat a file — typically to tell a file from a directory via data.isDirectory()
-- `readDir(options: Options) => Array<string>`
-- `readFile(path: string, format?: BufferEncoding) => FilePromiseResult` — Read a file, returning a status code and the content on success
-- `readStream(option: ReadOption) => ReadStream`
-- `runCommand(command: string, args: string[]) => Promise<void>`
-- `startTask() => symbol`
-- `staticMiddleware(option?: Partial<Option>) => MiddlewareFunction`
-- `taskEnd(symbol: symbol) => number | bigint`
-- `traverse(dir: string, callback: Caller, pre?: string) => Promise<any>` — Walk every directory recursively, running a function for each file found
-- `traverseSync(dir: string, callback: Caller, pre?: string) => void` — Synchronous: walk every directory recursively, running a function for each file found
-- `watchFile(path: string, interval?: number) => Promise<Ranuts.Identification>` — Watch a file for changes and report its status
-- `writeFile(path: string, content: string) => Promise<Ranuts.Identification>` — Write a file at the given path, truncating it if it exists and creating it if it does not
-- `writeStream(option: WriteOption) => WriteStream`
-- `WSS(this: any, server: http.Server) => void` — Create a WebSocket Server
-
-### Classes
-
-- `class Router`
-- `class Server`
-
-### Interfaces
-
-- `interface Context`
-
-### Constants
-
-- `const isColorSupported: boolean`
-
-### Other
-
-- `default`
-
 ## `ranuts/visual`
 
 2D rendering engine (Canvas / WebGL / WebGPU) · runtime: **browser only** · source: `src/utils/visual/index.ts`
@@ -558,3 +516,66 @@ import { /* … */ } from 'ranuts/vnode';
 
 - `namespace is` — Type guards — array / string / primitive / VNode
 
+## `ranuts/stream`
+
+SSE parsing, a provider-neutral model-stream fold, and the token budget that decides when a history stops fitting · runtime: **browser + node** · source: `src/stream/index.ts`
+
+```ts
+import { /* … */ } from 'ranuts/stream';
+```
+
+### Functions
+
+- `addUsage(total: TokenUsage | undefined, next: TokenUsage | undefined) => TokenUsage` — Adds two usage reports.
+- `createStreamAccumulator() => StreamAccumulator` — Creates a fold over one streamed response.
+- `estimateTokens(text: string) => number` — Estimates how many tokens a string costs.
+- `mapEventStream(source: ByteSource, map: (event: ServerSentEvent) => readonly StreamChunk[]) => AsyncGenerator<StreamChunk>` — Maps SSE events onto StreamChunk values using a caller-supplied vendor mapping.
+- `parseEventStream(source: ByteSource) => AsyncGenerator<ServerSentEvent>` — Parses a byte stream as `text/event-stream`.
+- `planCompaction(sizes: readonly number[], limits: CompactionLimits) => CompactionPlan` — Decides how much of a history no longer fits.
+
+### Interfaces
+
+- `interface CompactionLimits` — What a compaction has to fit under, and what it may not touch.
+- `interface CompactionPlan` — What to do with a history that has grown.
+- `interface ReasoningBlock` — Model reasoning, when the provider exposes it. Kept separate from TextBlock
+- `interface ServerSentEvent` — One parsed `text/event-stream` event.
+- `interface StreamAccumulator` — Stateful fold over one response's chunks.
+- `interface StreamSnapshot` — Immutable view of everything received so far.
+- `interface TextBlock` — Assistant prose addressed to the user.
+- `interface TokenUsage` — Token counts reported for one response. Every field is optional: providers differ.
+- `interface ToolCallBlock` — One tool invocation requested by the model.
+
+### Types
+
+- `type ByteSource` — Anything `for await` can walk that yields byte chunks — a `fetch` body, or a fake.
+- `type ContentBlock` — One completed unit of assistant output.
+- `type ContentBlockType` — Discriminator for the content a block accumulates.
+- `type FinishReason` — Why the response ended.
+- `type StreamChunk` — One normalized event from a streamed response.
+
+## `ranuts/conversation`
+
+Project an append-only event log into renderable conversation nodes · runtime: **browser + node** · source: `src/conversation/index.ts`
+
+```ts
+import { /* … */ } from 'ranuts/conversation';
+```
+
+### Functions
+
+- `createConversationEngine<Event>(options: ConversationEngineOptions<Event>) => ConversationEngine<Event>` — Creates an engine over a set of definitions.
+
+### Interfaces
+
+- `interface ConversationEngine` — A running conversation projection.
+- `interface ConversationEngineOptions` — How to construct an engine.
+- `interface ConversationMatch` — A definition's claim on one event.
+- `interface ConversationNode` — One live node, as a view sees it.
+- `interface ConversationNodeDefinition` — One independently registered event-to-node state machine.
+- `interface ConversationReader` — Strictly-backward lookup offered to a definition while it starts a node.
+
+### Types
+
+- `type ConversationPublication` — When subscribers should see the result of one accepted event.
+- `type FrameScheduler` — Defers work to the next paint, or to a microtask where there is no paint.
+

package/package.json

@@ -1,29 +1,25 @@
 {
   "name": "ranuts",
-  "version": "0.4.1-alpha.1",
+  "version": "0.5.0",
   "description": "Tree-shakeable TypeScript utility library: DOM/BOM helpers, string/object/number/color utils, debounce/throttle/compose, a 2D rendering engine and a virtual DOM.",
-  "main": "dist/index.umd.cjs",
+  "main": "dist/index.js",
   "module": "dist/index.js",
   "type": "module",
+  "sideEffects": [
+    "./dist/iife/**"
+  ],
   "types": "dist/index.d.ts",
   "engines": {
-    "node": ">=23.10.0"
+    "node": ">=24.0.0"
   },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/umd/index.umd.cjs"
-    },
-    "./node": {
-      "types": "./dist/src/node/index.d.ts",
-      "import": "./dist/src/node/index.js",
-      "require": "./dist/umd/node/node.umd.cjs"
+      "import": "./dist/index.js"
     },
     "./utils": {
       "types": "./dist/src/utils/index.d.ts",
-      "import": "./dist/src/utils/index.js",
-      "require": "./dist/umd/utils/utils.umd.cjs"
+      "import": "./dist/src/utils/index.js"
     },
     "./visual": {
       "types": "./dist/src/utils/visual/index.d.ts",
@@ -40,6 +36,14 @@
     "./vnode": {
       "types": "./dist/src/vnode/index.d.ts",
       "import": "./dist/src/vnode/index.js"
+    },
+    "./stream": {
+      "types": "./dist/src/stream/index.d.ts",
+      "import": "./dist/src/stream/index.js"
+    },
+    "./conversation": {
+      "types": "./dist/src/conversation/index.d.ts",
+      "import": "./dist/src/conversation/index.js"
     }
   },
   "repository": {
@@ -89,14 +93,14 @@
   "license": "MIT",
   "devDependencies": {
     "@types/node": "26.1.2",
-    "@vitest/coverage-v8": "4.1.10",
+    "@vitest/coverage-v8": "4.1.11",
     "@webgpu/types": "0.1.71",
     "jsdom": "29.1.1",
     "terser": "5.49.2",
     "tsx": "4.23.10",
     "typescript": "7.0.2",
     "vite": "8.2.1",
-    "vitest": "4.1.10"
+    "vitest": "4.1.11"
   },
   "dependencies": {
     "jschardet": "3.1.4"
@@ -105,9 +109,10 @@
     "build": "sh ./bin/build.sh",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
+    "verify:package": "node bin/verify-package.mjs",
     "tsc": "tsc --noEmit",
     "dev": "vite --host",
     "doc:api": "tsx ./bin/generate-api-docs.ts",
-    "prepublish": "npm run build"
+    "doc:api:check": "tsx ./bin/generate-api-docs.ts --check"
   }
 }

package/dist/bin/generate-api-docs.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/build/build.es.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/build/build.umd.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/build/build.umd.node.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/build/build.umd.utils.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/chain-CTywmh_H.js

@@ -1 +0,0 @@
-var e=["svg","path","g","circle","rect","line","polyline","polygon","ellipse","text","tspan","textPath","defs","marker","radialGradient","stop","linearGradient","clipPath","mask","pattern","image","use","symbol","foreignObject","feGaussianBlur","feColorMatrix"],t=class t{listener;element;constructor(e,t){this.element=this.create(e,t),this.listener=/* @__PURE__ */new Map}create=(t,n)=>e.includes(t)?document.createElementNS("http://www.w3.org/2000/svg",t,n):document.createElement(t,n);setAttribute=(e,t)=>(this.element.setAttribute(e,t),this);removeAttribute=e=>(this.element.removeAttribute(e),this);append=e=>(this.element.appendChild(e),this);remove=e=>(this.element.removeChild(e),this);setTextContent=e=>(this.element.textContent=e,this);setStyle=(e,t)=>(this.element.style.setProperty(e,t),this);addElementByType=(e,n)=>{e instanceof t&&n.appendChild(e.element),e instanceof HTMLElement&&n.appendChild(e)};addChild=e=>{if(Array.isArray(e)){const t=document.createDocumentFragment();e.forEach(e=>{this.addElementByType(e,t)}),this.element.appendChild(t)}else this.addElementByType(e,this.element);return this};listen=(e,t,n)=>{let s=this.listener.get(e);s||(s=/* @__PURE__ */new Map,this.listener.set(e,s));const i=s.get(t.name);return i===t&&console.warn(`${i.name} listener has been added to ${e} event, please remove it first.`),this.element.addEventListener(e,t,n),s.set(t.name,t),this};clearListener=(e,t,n)=>{this.element.removeEventListener(e,t,n);const s=this.listener.get(e);return s?s.delete(t.name):console.warn(`No ${e} event listener has been added.`),this};clearAllListener=()=>{for(const[e,t]of this.listener){for(const[n,s]of t)this.element.removeEventListener(e,s),t.delete(n);this.listener.delete(e)}return this}},n=(e,n)=>new t(e,n);export{n,t};