stitchkit 0.100.2 → 0.100.3

package/dist/{index-k5hsfc3j.js → index-zsvzhjtk.js}

@@ -1,6 +1,6 @@
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/internal/canonical-json.ts
 function compareCodeUnits(left, right) {

package/dist/observability/bounded-logger.d.ts

@@ -16,6 +16,8 @@ export interface BoundedLoggerOptions {
     };
     readonly bounds?: BoundedLoggerBounds;
     readonly sensitiveUrlPatterns?: readonly RegExp[];
+    /** Exact secret values masked in every string — see `SanitizeOptions.sensitiveValues`. */
+    readonly sensitiveValues?: readonly string[];
 }
 /** Decorate any canonical logger with context, redaction, and hard bounds. */
 export declare function createBoundedLogger(options: BoundedLoggerOptions): StitchLogger;

package/dist/observability/bounded-logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bounded-logger.d.ts","sourceRoot":"","sources":["../../src/observability/bounded-logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKvD,eAAO,MAAM,oBAAoB,mBAW/B,CAAC;AAEH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,0GAA0G;IAC1G,QAAQ,CAAC,iBAAiB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE;QAChB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnD;AAwDD,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,YAAY,CAiD/E"}
+{"version":3,"file":"bounded-logger.d.ts","sourceRoot":"","sources":["../../src/observability/bounded-logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKvD,eAAO,MAAM,oBAAoB,mBAW/B,CAAC;AAEH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,0GAA0G;IAC1G,QAAQ,CAAC,iBAAiB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE;QAChB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClD,0FAA0F;IAC1F,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAwDD,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,YAAY,CAkD/E"}

package/dist/observability/sanitize.d.ts

@@ -17,6 +17,12 @@ export interface SanitizeOptions {
     sensitivePaths?: readonly string[];
     /** Patterns whose matching portions are masked in every string, including messages. */
     sensitiveUrlPatterns?: readonly RegExp[];
+    /**
+     * Exact secret values masked wherever they occur in any string — a
+     * provider's key has no shape a pattern could guess. `secretValuesFromEnv`
+     * collects them from the environment.
+     */
+    sensitiveValues?: readonly string[];
     /** Cap on the serialised payload — anything larger collapses to a preview. Default 16 KB. */
     maxBytes?: number;
     /** Recursion limit — deeper nesting collapses to a marker. Default 20. */

package/dist/observability/sanitize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/observability/sanitize.ts"],"names":[],"mappings":"AAOA,8EAA8E;AAC9E,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEjC,+CAA+C;AAC/C,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,8EAA8E;IAC9E,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,uFAAuF;IACvF,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;;;OAaG;IACH,oBAAoB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACxD,mEAAmE;IACnE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,mCAAmC;AACnC,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,8BAA8B;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,cAAc,CAAC,EAAE,IAAI,CAAC;CACvB;AAyED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,eAAoB,GAAG,SAAS,CAsM/E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,SAAoB,GAAG,SAAS,CAgBzF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,eAAoB,GAC5B,SAAS,GAAG,IAAI,CAOlB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAqBvD"}
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/observability/sanitize.ts"],"names":[],"mappings":"AAOA,8EAA8E;AAC9E,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEjC,+CAA+C;AAC/C,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,8EAA8E;IAC9E,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,uFAAuF;IACvF,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC;;;;OAIG;IACH,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;;;OAaG;IACH,oBAAoB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACxD,mEAAmE;IACnE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,mCAAmC;AACnC,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,8BAA8B;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,cAAc,CAAC,EAAE,IAAI,CAAC;CACvB;AAmGD;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,eAAoB,GAAG,SAAS,CA6L/E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,SAAoB,GAAG,SAAS,CAgBzF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,eAAoB,GAC5B,SAAS,GAAG,IAAI,CAOlB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAqBvD"}

package/dist/observability/secret-values.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The secret values an environment holds, to be masked by value.
+ *
+ * A pattern masks what it can recognise — a bot token, a bearer header — and a
+ * provider's API key, a webhook secret or a database password looks like any
+ * other string. The environment already says which values are secret: by the
+ * variable's name. So the schema names the secrets, not the code that logs:
+ * a key added to the environment is masked from its first line.
+ */
+export interface SecretValuesOptions {
+    /**
+     * Shorter values are not collected. Default 8: a short value occurs in
+     * ordinary text by itself, and masking it there would spoil lines without
+     * protecting anything.
+     */
+    readonly minLength?: number;
+}
+/**
+ * Every secret value in `env`: variables named as a token, secret, key,
+ * password or credential, the password and secret query values inside any URL
+ * variable (`DATABASE_URL`), and each of them URL-encoded too. For a logger's
+ * and an operator channel's `sensitiveValues`.
+ */
+export declare function secretValuesFromEnv(env: Readonly<Record<string, unknown>>, options?: SecretValuesOptions): string[];
+//# sourceMappingURL=secret-values.d.ts.map

package/dist/observability/secret-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-values.d.ts","sourceRoot":"","sources":["../../src/observability/secret-values.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAaD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACtC,OAAO,GAAE,mBAAwB,GAChC,MAAM,EAAE,CAYV"}

package/dist/react/keyboard/hooks.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The React binding of the key layers and zones: hooks only, no component and
+ * no provider. The stack is one per window, created by the first layer that
+ * mounts, so a layer inside a portal is on the same stack as the page.
+ */
+import { type RefObject } from 'react';
+import { type KeyLayerKind } from './layers.js';
+import { type NavZoneOptions, type ZoneItemId, type ZoneOrientation } from './zone.js';
+export interface KeyLayerOptions {
+    readonly kind: KeyLayerKind;
+    /** Return `true` when the key was taken: its default is prevented and no layer below hears it. */
+    onKey(event: KeyboardEvent): boolean;
+    /** Default `true`. Becoming active puts the layer on top of its kind. */
+    readonly active?: boolean;
+    /**
+     * The element the layer belongs to. Given, the layer is heard only while the
+     * element is mounted, visible and not `inert`, and it outranks layers of its
+     * kind whose elements contain it.
+     */
+    readonly scope?: RefObject<Element | null>;
+    /** Default `'skip'`: keys pressed in fields and `data-local-keys` areas, except Escape, pass it by. */
+    readonly fields?: 'skip' | 'include';
+}
+/** Put a layer on the window's key stack for as long as the component is mounted. */
+export declare function useKeyLayer(options: KeyLayerOptions): void;
+export interface EscapeLayerOptions {
+    readonly kind: 'overlay' | 'local' | 'route';
+    /** Close one level. Return `false` when there was nothing to close, and the layer below is asked. */
+    onEscape(): unknown;
+    readonly active?: boolean;
+    readonly scope?: RefObject<Element | null>;
+}
+/** One Escape closes one level: the first layer that takes it is the only one that hears it. */
+export declare function useEscapeLayer(options: EscapeLayerOptions): void;
+/** Spread on the zone's element. */
+export interface NavZoneProps {
+    readonly ref: (element: HTMLElement | null) => void;
+    readonly role: 'listbox' | 'tablist' | undefined;
+    readonly 'aria-orientation': ZoneOrientation;
+    readonly 'aria-label': string | undefined;
+    readonly 'data-keyboard-zone': '';
+    readonly onKeyDown: (event: {
+        readonly nativeEvent: KeyboardEvent;
+    }) => void;
+}
+/** Spread on each item's element. */
+export interface NavZoneItemProps {
+    readonly ref: (element: HTMLElement | null) => void;
+    readonly tabIndex: 0 | -1;
+    readonly role: 'option' | 'tab' | undefined;
+    readonly 'aria-selected': boolean | undefined;
+    readonly 'aria-current': 'true' | undefined;
+    readonly onFocus: () => void;
+}
+export interface NavZone<Id extends ZoneItemId> {
+    /** Spread on the zone's element; it carries the element's `ref`. */
+    readonly zoneProps: NavZoneProps;
+    /** The zone's element, for what else needs it — an Escape layer scoped to the zone. */
+    readonly element: RefObject<HTMLElement | null>;
+    itemProps(id: Id): NavZoneItemProps;
+    /** The tab stop: the item focus is on or was last on, else the chosen one, else the first. */
+    readonly current: Id | null;
+    /** Put focus on `id`, or on the current item — to move into this zone from another. */
+    focus(id?: Id): boolean;
+}
+/**
+ * A list the arrows move through with real focus. See `zone.ts` for the
+ * modes, the cross axis and what happens past an end.
+ */
+export declare function useNavZone<Id extends ZoneItemId>(options: NavZoneOptions<Id>): NavZone<Id>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/react/keyboard/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/react/keyboard/hooks.ts"],"names":[],"mappings":"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"}

package/dist/react/keyboard/layers.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Who gets a key: one listener, a fixed order of layers, and the innermost
+ * layer of a kind first.
+ *
+ * A page with a menu, a dialog, a list and section shortcuts usually ends up
+ * with a `keydown` listener per concern, and their order is the order they
+ * happened to mount in: Escape closes the dialog and the page behind it, an
+ * arrow in a dialog switches the section underneath. Here every concern is a
+ * layer on one stack, asked in a fixed order until one of them takes the key:
+ *
+ *   overlay → local → route → zone → global
+ *
+ * - **overlay** — something modal. While one is live, nothing below it hears a
+ *   key at all, handled or not.
+ * - **local** — a component that has the user's attention without being modal:
+ *   an open command menu, an editor's own mode.
+ * - **route** — the page's "go up one level": Escape closes the open entity.
+ * - **zone** — a list the keys move through when focus is not in any list
+ *   (see `zone.ts`).
+ * - **global** — shortcuts of the whole screen, such as switching sections.
+ *
+ * Within a kind the innermost layer wins: of two layers whose elements nest,
+ * the inner one; otherwise the one activated last. React runs a child's effects
+ * before its parent's, so activation order alone would let a page's layer
+ * shadow the panel inside it when both mount together — the element tree is
+ * what says which is inside which.
+ *
+ * The listener sits on the window, in the bubbling phase: everything closer to
+ * the key — a widget's own `onKeyDown`, a text field, a popover that closes on
+ * Escape — hears it first and keeps it by `preventDefault` or
+ * `stopPropagation`. A layer only gets what nobody nearer wanted.
+ */
+export type KeyLayerKind = 'overlay' | 'local' | 'route' | 'zone' | 'global';
+/** The part of a `keydown` event the stack reads; a DOM `KeyboardEvent` is one. */
+export interface LayerKeyEvent {
+    readonly key: string;
+    readonly repeat: boolean;
+    readonly isComposing: boolean;
+    readonly defaultPrevented: boolean;
+    readonly target: EventTarget | null;
+    preventDefault(): void;
+}
+/** The part of an element the stack reads to decide whether a layer is live and where it sits. */
+export interface LayerScope<S> {
+    readonly isConnected: boolean;
+    contains(other: S | null): boolean;
+    closest(selectors: string): unknown;
+    checkVisibility?(): boolean;
+}
+/**
+ * Where keys belong to the element rather than to the page: fields, controls
+ * that move on arrows themselves, and any area marked `data-local-keys`.
+ */
+export declare const KEY_FIELD_SELECTOR: string;
+/** The nearest element matching `selectors` from an event target, or `null`. */
+export declare function closestFromTarget(target: EventTarget | null, selectors: string): unknown;
+/** The key was pressed in a field or an area that keeps its keys. */
+export declare function isKeyFieldTarget(target: EventTarget | null): boolean;
+export interface KeyLayerState<E extends LayerKeyEvent, S extends LayerScope<S>> {
+    readonly kind: KeyLayerKind;
+    /** Default `true`. A layer that is not active is skipped; becoming active puts it on top of its kind. */
+    readonly active?: boolean;
+    /**
+     * The element the layer belongs to. Given, the layer is live only while the
+     * element is connected, visible and outside any `inert` subtree, and it is
+     * ordered by nesting against layers of its kind. `null` means "declared, not
+     * mounted": the layer is skipped.
+     */
+    readonly scope?: () => S | null;
+    /**
+     * `'skip'` (default): keys pressed in a field or a `data-local-keys` area do
+     * not reach the layer — except Escape, which a field that wants it keeps by
+     * `preventDefault`. `'include'`: the layer hears them too.
+     */
+    readonly fields?: 'skip' | 'include';
+    /** Return `true` when the key was taken: its default is prevented and no layer below hears it. */
+    onKey(event: E): boolean;
+}
+export interface KeyLayerHandle<E extends LayerKeyEvent, S extends LayerScope<S>> {
+    update(state: KeyLayerState<E, S>): void;
+    remove(): void;
+}
+/** Where the stack listens. A `Window` is one. */
+export interface KeyListenerTarget<E> {
+    addEventListener(type: 'keydown', listener: (event: E) => void): void;
+    removeEventListener(type: 'keydown', listener: (event: E) => void): void;
+}
+export interface KeyLayerStack<E extends LayerKeyEvent, S extends LayerScope<S>> {
+    add(state: KeyLayerState<E, S>): KeyLayerHandle<E, S>;
+    /** Offer one key to the layers; `true` when one took it. The installed listener calls this. */
+    dispatch(event: E): boolean;
+}
+/**
+ * A stack listening on `target`. The listener is attached with the first
+ * layer and detached with the last, so a page without layers carries none.
+ */
+export declare function createKeyLayerStack<E extends LayerKeyEvent, S extends LayerScope<S>>(target: KeyListenerTarget<E>): KeyLayerStack<E, S>;
+//# sourceMappingURL=layers.d.ts.map

package/dist/react/keyboard/layers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layers.d.ts","sourceRoot":"","sources":["../../../src/react/keyboard/layers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAU7E,mFAAmF;AACnF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IACpC,cAAc,IAAI,IAAI,CAAC;CACxB;AAED,kGAAkG;AAClG,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC;IACnC,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,eAAe,CAAC,IAAI,OAAO,CAAC;CAC7B;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAUpB,CAAC;AAeZ,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAExF;AAED,qEAAqE;AACrE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,OAAO,CAGpE;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC;IAC7E,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,yGAAyG;IACzG,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,kGAAkG;IAClG,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC;IAC9E,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;IACzC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,kDAAkD;AAClD,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI,CAAC;IACtE,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI,CAAC;CAC1E;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC;IAC7E,GAAG,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACtD,+FAA+F;IAC/F,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;CAC7B;AAwDD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAClF,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAC3B,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CA6CrB"}

package/dist/react/keyboard/zone.d.ts

@@ -0,0 +1,139 @@
+/**
+ * A list the arrow keys move through — with real focus.
+ *
+ * A zone is an ordered set of items, one of which is the tab stop (roving
+ * tabindex): Tab enters the zone at that item, the arrows move DOM focus
+ * between items, Tab leaves. Focus is the browser's own, so a screen reader
+ * follows it, `:focus-visible` draws it and the browser scrolls to it; there is
+ * no second "highlighted" state beside focus for a page to keep in sync.
+ *
+ * Two modes, by what moving means:
+ *
+ * - **select** — moving is choosing: the arrow calls `onChange(id, 'arrow')`
+ *   (a sidebar whose item opens as you move).
+ * - **highlight** — moving only points; Enter chooses with
+ *   `onChange(id, 'confirm')` (a list where opening is expensive).
+ *
+ * Each zone keeps its own pointed item, so two zones on a page never share one.
+ * The cross axis leaves the zone on purpose: `onEnter` (→ in a vertical zone)
+ * goes into what the item opens, `onExit` (←) back out; past either end the
+ * zone either loops or hands the key to `onBoundary`. A key the zone does not
+ * take bubbles on — to the layers, where a section switch may want it.
+ *
+ * This file has no framework in it: `useNavZone` is a thin React binding.
+ */
+import { type LayerKeyEvent } from './layers.js';
+export type ZoneOrientation = 'vertical' | 'horizontal';
+export type ZoneMove = 'next' | 'previous' | 'first' | 'last';
+export type ZoneIntent = {
+    readonly type: 'move';
+    readonly move: ZoneMove;
+} | {
+    readonly type: 'enter';
+} | {
+    readonly type: 'exit';
+} | {
+    readonly type: 'confirm';
+};
+/** Marks a zone's element; a key pressed inside it belongs to that zone. */
+export declare const ZONE_ATTRIBUTE = "data-keyboard-zone";
+export interface NextZoneIndexInput {
+    readonly length: number;
+    /** The current index; `-1` when nothing is current. */
+    readonly index: number;
+    readonly move: ZoneMove;
+    readonly loop: boolean;
+}
+/**
+ * Where a move lands: an index, or the end it ran past. From nothing current,
+ * `next` lands on the first item and `previous` on the last. An empty zone has
+ * no index: every move runs past an end.
+ */
+export declare function nextZoneIndex({ length, index, move, loop, }: NextZoneIndexInput): number | 'before-start' | 'after-end';
+export interface ZoneKey {
+    readonly key: string;
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly metaKey: boolean;
+    readonly shiftKey: boolean;
+}
+/** What a key means to a zone of this orientation; `null` for keys a zone leaves alone. */
+export declare function zoneIntent(event: ZoneKey, orientation: ZoneOrientation): ZoneIntent | null;
+export type ZoneItemId = string | number;
+export type ZoneChangeCause = 'arrow' | 'confirm';
+export interface NavZoneOptions<Id extends ZoneItemId> {
+    /** The items in order. An id not listed here has no place in the zone. */
+    readonly items: readonly Id[];
+    /** The chosen item, or `null`. The zone never holds it: it reports changes. */
+    readonly value: Id | null;
+    onChange(id: Id, cause: ZoneChangeCause): void;
+    /** Default `'select'`. */
+    readonly mode?: 'select' | 'highlight';
+    /** Default `'vertical'`. */
+    readonly orientation?: ZoneOrientation;
+    /**
+     * Default `'listbox'`: the zone is a listbox and its items options, marked
+     * `aria-selected`. `'tablist'`: tabs. `'none'`: the items keep their own
+     * semantics (links, buttons) and the chosen one is marked `aria-current`.
+     */
+    readonly role?: 'listbox' | 'tablist' | 'none';
+    /** Default `false`: moving past an end goes to `onBoundary`. `true`: it wraps. */
+    readonly loop?: boolean;
+    /**
+     * The cross-axis forward key (→ in a vertical zone), and Enter in select
+     * mode. Returning `false` leaves the key to the page; anything else takes it —
+     * so do `onExit` and `onBoundary`.
+     */
+    onEnter?(id: Id): unknown;
+    /** The cross-axis backward key (← in a vertical zone). */
+    onExit?(): unknown;
+    /** A move past an end of a zone that does not loop. */
+    onBoundary?(side: 'start' | 'end'): unknown;
+    /**
+     * Default `true`. An active zone takes its arrows when focus is in no zone
+     * at all — the first arrow on a page puts focus on the zone's current item.
+     * Of several active zones the innermost, then the last activated, does.
+     */
+    readonly active?: boolean;
+    /** The zone's accessible name. */
+    readonly label?: string;
+    /**
+     * Focus went to an item that has no element yet — a row of a virtualized
+     * list outside the rendered range. Scroll it in; focus lands on it as soon as
+     * its element mounts.
+     */
+    onReveal?(id: Id): void;
+}
+/** The part of an item element the zone drives. An `HTMLElement` is one. */
+export interface ZoneItemElement {
+    focus(options?: {
+        preventScroll?: boolean;
+    }): void;
+    scrollIntoView?(options?: {
+        block?: 'nearest';
+        inline?: 'nearest';
+    }): void;
+}
+export interface ZoneKeyEvent extends LayerKeyEvent, ZoneKey {
+}
+export interface NavZoneController<Id extends ZoneItemId> {
+    update(options: NavZoneOptions<Id>): void;
+    readonly options: NavZoneOptions<Id>;
+    /** The tab stop: the pointed item, else the chosen one, else the first. */
+    current(): Id | null;
+    /** A key pressed inside the zone's element (`zone` is that element). `true` when taken. */
+    keyDown(event: ZoneKeyEvent, zone: unknown): boolean;
+    /** A key pressed outside every zone, offered by the zone's layer. `true` when taken. */
+    keyFromOutside(event: ZoneKeyEvent): boolean;
+    /** An item received focus by any means — a click, Tab, a move. */
+    focused(id: Id): void;
+    /**
+     * Put focus on `id`, or on the current item — now, or when its element mounts.
+     * `false` when there is no item to focus.
+     */
+    focus(id?: Id): boolean;
+    setItemElement(id: Id, element: ZoneItemElement | null): void;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createNavZone<Id extends ZoneItemId>(initial: NavZoneOptions<Id>): NavZoneController<Id>;
+//# sourceMappingURL=zone.d.ts.map

package/dist/react/keyboard/zone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/react/keyboard/zone.ts"],"names":[],"mappings":"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"}

package/dist/telegram/crypto.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The two cryptographic steps Telegram's protocols share: an HMAC-SHA-256 over
+ * WebCrypto, so it runs on Bun, Node and anything with `crypto.subtle`, and a
+ * comparison that does not say where two values first differ.
+ */
+export declare function hmacSha256(key: ArrayBuffer | Uint8Array, message: string): Promise<ArrayBuffer>;
+export declare function toHex(buffer: ArrayBuffer): string;
+/**
+ * Compare two strings without leaking where they first differ.
+ *
+ * A plain `===` on a digest returns as soon as one byte disagrees, and the time
+ * it took is a measurement of how much of the digest was right. The whole point
+ * of the comparison is that an attacker cannot get a partial answer.
+ */
+export declare function digestsEqual(a: string, b: string): boolean;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/telegram/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/telegram/crypto.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,WAAW,GAAG,UAAU,EAC7B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,CAStB;AAED,wBAAgB,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAIjD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAO1D"}

package/dist/telegram/html/check.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Would Telegram refuse this markup as it stands? The strict counterpart of
+ * the lenient parse: no repair, the first thing Telegram would stop at.
+ *
+ * For markup a person typed and should hear about before it is sent — an
+ * editor warning that Telegram will refuse the text — rather than markup to be
+ * repaired, which is `sanitizeTelegramHtml`'s. The screens test chat refuses
+ * with it, so a bot's test fails where production would.
+ */
+export type TelegramHtmlProblem = {
+    readonly kind: 'bare-character';
+} | {
+    readonly kind: 'unsupported-tag';
+    readonly tag: string;
+} | {
+    readonly kind: 'unmatched-end-tag';
+} | {
+    readonly kind: 'unclosed-tag';
+};
+export interface TelegramHtmlCheck {
+    readonly problem?: TelegramHtmlProblem;
+    /** The visible text up to the problem, or all of it. */
+    readonly text: string;
+}
+export declare function checkTelegramHtml(markup: string): TelegramHtmlCheck;
+//# sourceMappingURL=check.d.ts.map

package/dist/telegram/html/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../src/telegram/html/check.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAyBH,MAAM,MAAM,mBAAmB,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE,GACnC;IAAE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;CAAE,GACtC;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,CAAC;AAEtC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,CAAC;IACvC,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAgBnE"}

package/dist/telegram/html/nodes.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Telegram's HTML parse mode as a tree, and the rules that tree obeys.
+ *
+ * Telegram accepts a small, fixed subset of HTML and refuses the whole message
+ * over one tag outside it, one bare `<` or one entity nested where it may not
+ * be. Every bot that sends text written by someone else — a model, an editor,
+ * an owner's greeting — has to turn arbitrary markup into that subset, and every
+ * bot that sends a long text has to cut it without cutting a tag in half. Both
+ * are answered once here, on a tree: markup is parsed into nodes that can only
+ * express what Telegram accepts, and everything else — cleaning, cutting,
+ * measuring, previewing — is a walk over those nodes.
+ *
+ * The nesting rules are Telegram's (Bot API, "Formatting options"): bold,
+ * italic, underline, strikethrough and spoiler may contain and be contained by
+ * anything except `pre` and `code`; a block quotation is never inside another;
+ * all other entities never contain each other.
+ */
+/** Text formatting that nests freely, except inside `pre` and `code`. */
+export type TelegramHtmlStyle = 'b' | 'i' | 'u' | 's' | 'tg-spoiler';
+export interface TelegramHtmlTextNode {
+    readonly kind: 'text';
+    /** The text as a reader sees it — entities decoded, nothing escaped. */
+    readonly text: string;
+}
+interface ElementBase {
+    readonly kind: 'element';
+    readonly children: readonly TelegramHtmlNode[];
+}
+export type TelegramHtmlElement = (ElementBase & {
+    readonly tag: TelegramHtmlStyle | 'code';
+}) | (ElementBase & {
+    readonly tag: 'a';
+    readonly href: string;
+}) | (ElementBase & {
+    readonly tag: 'pre';
+    readonly language?: string;
+}) | (ElementBase & {
+    readonly tag: 'blockquote';
+    readonly expandable: boolean;
+}) | (ElementBase & {
+    readonly tag: 'tg-emoji';
+    readonly emojiId: string;
+}) | (ElementBase & {
+    readonly tag: 'tg-time';
+    readonly unix: number;
+    readonly format?: string;
+});
+export type TelegramHtmlNode = TelegramHtmlTextNode | TelegramHtmlElement;
+export type TelegramHtmlTag = TelegramHtmlElement['tag'];
+/** Telegram's limit for a message's text, after its markup is parsed. */
+export declare const TELEGRAM_TEXT_LIMIT = 4096;
+/** Telegram's limit for a media caption, after its markup is parsed. */
+export declare const TELEGRAM_CAPTION_LIMIT = 1024;
+export declare function isStyle(tag: string): tag is TelegramHtmlStyle;
+/** Holds only text: no element of any kind inside. */
+export declare function holdsOnlyText(tag: TelegramHtmlTag): boolean;
+/** Rendered whole or not at all: its text is one thing, never cut. */
+export declare function isAtomic(tag: TelegramHtmlTag): boolean;
+/**
+ * Whether an element of `tag` may open inside `ancestors` (outermost first).
+ * A style is refused only under an element that holds text alone; any other
+ * element is refused under any element that is not a style.
+ */
+export declare function mayOpenInside(tag: TelegramHtmlTag, ancestors: readonly TelegramHtmlTag[]): boolean;
+/** The visible text of nodes: what Telegram counts against its limits. */
+export declare function textOf(nodes: readonly TelegramHtmlNode[]): string;
+/** The same element holding other children. */
+export declare function withChildren(element: TelegramHtmlElement, children: readonly TelegramHtmlNode[]): TelegramHtmlElement;
+export {};
+//# sourceMappingURL=nodes.d.ts.map

package/dist/telegram/html/nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../../src/telegram/html/nodes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,yEAAyE;AACzE,MAAM,MAAM,iBAAiB,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,YAAY,CAAC;AAErE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAChD;AAED,MAAM,MAAM,mBAAmB,GAC3B,CAAC,WAAW,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAAA;CAAE,CAAC,GAC5D,CAAC,WAAW,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GAC5D,CAAC,WAAW,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACnE,CAAC,WAAW,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,GAC5E,CAAC,WAAW,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,GACtE,CAAC,WAAW,GAAG;IACb,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC,CAAC;AAEP,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,GAAG,mBAAmB,CAAC;AAE1E,MAAM,MAAM,eAAe,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAEzD,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,OAAQ,CAAC;AACzC,wEAAwE;AACxE,eAAO,MAAM,sBAAsB,OAAQ,CAAC;AAU5C,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,iBAAiB,CAE7D;AAED,sDAAsD;AACtD,wBAAgB,aAAa,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAE3D;AAED,sEAAsE;AACtE,wBAAgB,QAAQ,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,eAAe,EACpB,SAAS,EAAE,SAAS,eAAe,EAAE,GACpC,OAAO,CAGT;AAED,0EAA0E;AAC1E,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,CAIjE;AAED,+CAA+C;AAC/C,wBAAgB,YAAY,CAC1B,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,mBAAmB,CAErB"}

package/dist/telegram/html/parse.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Markup in, a tree Telegram accepts out — whatever the markup was.
+ *
+ * The parser is lenient on purpose: its input is text someone else wrote, and
+ * the only useful answer to a tag Telegram does not know is to keep the words
+ * and lose the tag. Synonyms become Telegram's tags (`strong` → `b`), block
+ * tags (`p`, `div`, `li`, `br`, headings) become line breaks, a link keeps only
+ * an `href` with a scheme Telegram opens, an element opened where Telegram
+ * forbids it stays text, and a closing tag closes the element it names along
+ * with whatever was left open inside it. No DOM and nothing executed, so the
+ * same parse serves a server and a browser preview.
+ */
+import { type TelegramHtmlNode } from './nodes.js';
+export type Token = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'entity';
+    readonly text: string;
+    readonly named: boolean;
+    readonly telegram: boolean;
+} | {
+    readonly type: 'bare';
+    readonly char: string;
+} | {
+    readonly type: 'tag';
+    readonly closing: boolean;
+    readonly name: string;
+    readonly attributes: ReadonlyMap<string, string>;
+};
+/** Markup as tokens: tags, entities, runs of text, and the bare `<`, `>`, `&` Telegram refuses. */
+export declare function tokenize(markup: string): Generator<Token>;
+/** Parse markup into the tree Telegram accepts. Never throws. */
+export declare function parseTelegramHtml(markup: string): TelegramHtmlNode[];
+//# sourceMappingURL=parse.d.ts.map

package/dist/telegram/html/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/telegram/html/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAIL,KAAK,gBAAgB,EAEtB,MAAM,SAAS,CAAC;AAiDjB,MAAM,MAAM,KAAK,GACb;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IACE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClD,CAAC;AAkBN,mGAAmG;AACnG,wBAAiB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,CAsD1D;AAwMD,iEAAiE;AACjE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAapE"}

package/dist/telegram/html/render.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The tree back to markup, and the operations that go through the tree:
+ * cleaning, cutting to Telegram's limits, measuring.
+ *
+ * Telegram's limits count the text after the markup is parsed — 4096 for a
+ * message, 1024 for a caption — so a long text is cut by what the reader
+ * sees, never by the length of its tags. A cut prefers a paragraph break, then
+ * a line break, then a space, then any place that does not split a character
+ * or a custom emoji; every element open across the cut is closed in one part
+ * and opened again, with its attributes, in the next. Length is counted in
+ * UTF-16 code units, the unit of Telegram's entity offsets: a text within the
+ * limit by this count is within it however Telegram counts.
+ */
+import { type TelegramHtmlNode } from './nodes.js';
+/** `&`, `<` and `>` as Telegram's HTML requires them, and `"` for attributes. */
+export declare function escapeTelegramHtml(text: string): string;
+/** The markup Telegram parses back into exactly these nodes. */
+export declare function renderTelegramHtml(nodes: readonly TelegramHtmlNode[]): string;
+/** Any markup as markup Telegram accepts: its tags, its nesting, its escaping. */
+export declare function sanitizeTelegramHtml(markup: string): string;
+/** What the reader sees: the text of the markup, entities decoded. */
+export declare function telegramHtmlText(markup: string): string;
+export interface TelegramHtmlLimitOptions {
+    /** Visible characters per part. Default 4096 — a message; 1024 for a caption. */
+    readonly limit?: number;
+}
+/**
+ * Cut markup into parts Telegram accepts one by one, each within `limit`
+ * visible characters and each valid on its own. Markup that fits is one part;
+ * text with nothing visible is no parts.
+ */
+export declare function splitTelegramHtml(markup: string, options?: TelegramHtmlLimitOptions): string[];
+export interface TelegramHtmlTruncateOptions extends TelegramHtmlLimitOptions {
+    /** Appended when text was cut. Default `…`. */
+    readonly ellipsis?: string;
+}
+/** Markup cut to `limit` visible characters, the ellipsis included, still valid. */
+export declare function truncateTelegramHtml(markup: string, options?: TelegramHtmlTruncateOptions): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/telegram/html/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/telegram/html/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAIL,KAAK,gBAAgB,EAGtB,MAAM,SAAS,CAAC;AAGjB,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMvD;AA4BD,gEAAgE;AAChE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,CAS7E;AAED,kFAAkF;AAClF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEvD;AA+FD,MAAM,WAAW,wBAAwB;IACvC,iFAAiF;IACjF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,wBAA6B,GACrC,MAAM,EAAE,CAkBV;AAED,MAAM,WAAW,2BAA4B,SAAQ,wBAAwB;IAC3E,+CAA+C;IAC/C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,oFAAoF;AACpF,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,2BAAgC,GACxC,MAAM,CAWR"}

package/dist/telegram/init-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-data.d.ts","sourceRoot":"","sources":["../../src/telegram/init-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;GAOG;AACH,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsB3B,CAAC;AAEN,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,MAAM,WAAW,gBAAgB;IAC/B,4EAA4E;IAC5E,IAAI,CAAC,EAAE,oBAAoB,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,wCAAwC;IACxC,QAAQ,EAAE,IAAI,CAAC;IACf,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACvC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,uBAAuB,GAC/B,cAAc,GACd,oBAAoB,GACpB,WAAW,GACX,SAAS,CAAC;AAEd,MAAM,MAAM,4BAA4B,GACpC;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE,GACzD;IACE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,0EAA0E;IAC1E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEN,MAAM,WAAW,6BAA6B;IAC5C,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAiDD;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,4BAA4B,CAAC,CAuEvC"}
+{"version":3,"file":"init-data.d.ts","sourceRoot":"","sources":["../../src/telegram/init-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;;;;;GAOG;AACH,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsB3B,CAAC;AAEN,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,MAAM,WAAW,gBAAgB;IAC/B,4EAA4E;IAC5E,IAAI,CAAC,EAAE,oBAAoB,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,wCAAwC;IACxC,QAAQ,EAAE,IAAI,CAAC;IACf,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACvC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,uBAAuB,GAC/B,cAAc,GACd,oBAAoB,GACpB,WAAW,GACX,SAAS,CAAC;AAEd,MAAM,MAAM,4BAA4B,GACpC;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE,GACzD;IACE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,0EAA0E;IAC1E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEN,MAAM,WAAW,6BAA6B;IAC5C,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAWD;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,4BAA4B,CAAC,CAuEvC"}