@miliastry/quasar 1.0.6 → 1.1.0

package/dist/types/Transformers/RainbowTransformer.d.ts

@@ -0,0 +1,17 @@
+import { DocumentModel } from '../Model/DocumentModel';
+import { Transformer, TransformResult } from './Transformer';
+export interface RainbowOptions {
+    saturation: number;
+    lightness: number;
+    spread: number;
+    offset: number;
+    selectionRange?: {
+        start: number;
+        end: number;
+    };
+}
+export declare class RainbowTransformer implements Transformer {
+    private options;
+    constructor(options?: Partial<RainbowOptions>);
+    transform(document: DocumentModel): TransformResult;
+}

package/dist/types/Transformers/SineWaveTransformer.d.ts

@@ -0,0 +1,17 @@
+import { DocumentModel } from '../Model/DocumentModel';
+import { Transformer, TransformResult } from './Transformer';
+export interface SineWaveOptions {
+    minSize: number;
+    maxSize: number;
+    frequency: number;
+    step: 'char' | 'word';
+    selectionRange?: {
+        start: number;
+        end: number;
+    };
+}
+export declare class SineWaveTransformer implements Transformer {
+    private options;
+    constructor(options?: Partial<SineWaveOptions>);
+    transform(document: DocumentModel): TransformResult;
+}

package/dist/types/Transformers/Transformer.d.ts

@@ -0,0 +1,17 @@
+import { DocumentModel } from '../Model/DocumentModel';
+import { Transaction } from '../Transactions/Transaction';
+export interface TransformResult {
+    document: DocumentModel;
+    transaction?: Transaction;
+}
+export interface Transformer {
+    /**
+     * Transforms a DocumentModel.
+     * Should ideally return a Transaction that contains the operations applied.
+     */
+    transform(document: DocumentModel): TransformResult;
+}
+/**
+ * Helper to apply a transformer.
+ */
+export declare function applyTransformer(document: DocumentModel, transformer: Transformer): TransformResult;

package/dist/types/Types/core.d.ts

@@ -0,0 +1,104 @@
+/**
+ * DocumentEngine — Core Types
+ *
+ * The foundational types for the entire Language Platform.
+ * Every layer builds on these.
+ */
+import type { Diagnostic } from './diagnostics';
+/** Stable identifier that survives incremental re-parses */
+export type NodeId = string & {
+    readonly __brand: 'NodeId';
+};
+export declare function createNodeId(): NodeId;
+/**
+ * Reset the node ID counter. Test-only: lets a suite assert on stable IDs.
+ * Never call this while a document tree is alive — reusing IDs across live
+ * trees would break every `Map<NodeId, …>` in the engine.
+ */
+export declare function __resetNodeIdCounter(): void;
+/**
+ * The semantic kind of a node in the document tree.
+ *
+ * Language-agnostic at the core — BBCode tags, Markdown headings,
+ * HTML elements, etc. all map to these.
+ */
+export type NodeKind = 'document' | 'paragraph' | 'text' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'color' | 'font_size' | 'font' | 'code' | 'inline_code' | 'spoiler' | 'heading' | 'center' | 'right' | 'left' | 'url' | 'email' | 'profile' | 'image' | 'video' | 'audio' | 'imagemap' | 'imagemap_area' | 'svg' | 'quote' | 'notice' | 'spoilerbox' | 'box' | 'boxw' | 'list' | 'list_item' | 'zalgo' | 'aesthetic' | 'sparkle' | 'bubble' | 'flower' | 'gradient' | 'grow' | 'sinewave' | 'rainbow' | 'paint' | 'spacing' | 'empty_line'
+/**
+ * Una etiqueta de cierre que no cerró nada y que no debe verse.
+ *
+ * Nace cuando un cierre llega tarde: su etiqueta ya se cerró sola porque un
+ * cierre anterior pasó por encima de ella (ver `Parser.ts`, modo legacy).
+ * osu! tira esos cierres, así que el renderer los omite.
+ *
+ * Existe como nodo, y no como texto, por dos razones. Conserva su rango, que
+ * es lo que necesita el parser incremental para saber a qué nodo pertenece
+ * cada carácter. Y el exportador puede saltárselo: escrito como texto volvía
+ * a salir por el otro lado convertido en etiqueta viva, y el documento no
+ * era estable al reexportarlo.
+ */
+ | 'discarded_tag' | 'group' | 'wnotice' | 'align' | 'tables' | 'table_row' | 'table_col' | 'table_th' | 'gallery' | 'columns' | 'separator' | 'scroll' | 'sup' | 'sub' | 'abbr' | 'mark' | 'kbd' | 'tooltip' | 'flip' | 'raw' | 'plain' | 'effect' | 'anim' | 'container' | 'style_tag' | 'guild' | 'map' | 'custom' | 'error' | 'unknown';
+export type NodeAttributes = Record<string, string | number | boolean | null | undefined>;
+export interface NodeMetadata {
+    /** Arbitrary extensions data (plugins can add here) */
+    [key: string]: unknown;
+}
+export interface SourceRange {
+    start: number;
+    end: number;
+}
+/**
+ * The primary user-facing node in the Document Model.
+ *
+ * This is the Red Tree node — mutable, with identity.
+ * It wraps/holds reference to the Green Tree node for structural info.
+ */
+export interface DocumentNode {
+    /** Stable ID that survives incremental re-parses */
+    id: NodeId;
+    /** Monotonically increasing version number for change tracking */
+    version: number;
+    /** Semantic kind */
+    kind: NodeKind;
+    /** Raw text content (for text leaves) */
+    text: string;
+    /** Tag-level attributes (e.g. color=#ff0000, size=150) */
+    attributes: NodeAttributes;
+    /** Arbitrary metadata (extensible by plugins) */
+    metadata: NodeMetadata;
+    /** Child nodes */
+    children: DocumentNode[];
+    /** Diagnostics attached to this specific node */
+    diagnostics: Diagnostic[];
+    /** Source position in the original text (for mapping back) */
+    sourceRange: SourceRange | null;
+    /** Reference back to parent (null for root) */
+    parentId: NodeId | null;
+    /** Whether this node is "synthetic" (not from source, e.g. auto-generated) */
+    isSynthetic: boolean;
+}
+export interface DocumentSnapshot {
+    root: DocumentNode;
+    source: string;
+    language: string;
+    version: number;
+    createdAt: number;
+}
+export type DocumentChangeKind = 'node_inserted' | 'node_deleted' | 'node_updated' | 'node_moved' | 'attribute_changed' | 'text_changed' | 'source_changed' | 'full_rebuild';
+export interface DocumentChangeEvent {
+    kind: DocumentChangeKind;
+    nodeId: NodeId;
+    /** The affected node (after the change) */
+    node: DocumentNode | null;
+    /** Previous version of the node (before the change) */
+    previousNode: DocumentNode | null;
+    /** Additional context data */
+    metadata?: Record<string, unknown>;
+}
+export declare function createDocumentNode(kind: NodeKind, text?: string, attributes?: NodeAttributes, children?: DocumentNode[]): DocumentNode;
+export declare function cloneNode(node: DocumentNode, deep?: boolean): DocumentNode;
+/** Get the text content of a node and all its descendants */
+export declare function getNodeText(node: DocumentNode): string;
+/** Walk all descendants in pre-order */
+export declare function walkPreOrder(node: DocumentNode, visitor: (n: DocumentNode, depth: number) => void | 'skip', depth?: number): void;
+/** Find a node by ID */
+export declare function findById(root: DocumentNode, id: NodeId): DocumentNode | null;

package/dist/types/Types/diagnostics.d.ts

@@ -0,0 +1,85 @@
+/**
+ * DocumentEngine — Diagnostic Types
+ *
+ * Diagnostics are messages attached to specific nodes or ranges
+ * in the document tree. Inspired by VSCode's diagnostic model.
+ */
+import type { Range } from './tokens';
+import type { NodeId, NodeKind } from './core';
+export type DiagnosticSeverity = 'hint' | 'info' | 'warning' | 'error';
+export declare const DIAGNOSTIC_SEVERITY: Record<DiagnosticSeverity, number>;
+export type DiagnosticTag = 'unnecessary' | 'deprecated' | 'unused' | 'redundant';
+export interface Diagnostic {
+    /** Machine-readable code (e.g. 'invalid-color', 'missing-close-tag') */
+    code: string;
+    /** Human-readable message */
+    message: string;
+    /** Severity level */
+    severity: DiagnosticSeverity;
+    /** Optional tags for additional categorization */
+    tags: DiagnosticTag[];
+    /** Source range in the original text */
+    range: Range | null;
+    /** Node ID this diagnostic is attached to */
+    nodeId: NodeId | null;
+    /** Node kind for context */
+    nodeKind: NodeKind | null;
+    /** Source of this diagnostic (built-in, plugin name, etc.) */
+    source: string;
+    /** Optional related information */
+    related?: DiagnosticRelatedInfo[];
+    /** Optional fix suggestions */
+    fixes?: DiagnosticFix[];
+}
+export interface DiagnosticRelatedInfo {
+    message: string;
+    range: Range | null;
+    nodeId: NodeId | null;
+}
+export interface DiagnosticFix {
+    description: string;
+    /** Whether this fix is automatic or requires user confirmation */
+    isAutomatic: boolean;
+    /** The operations to apply as a fix */
+    operations: FixOperation[];
+}
+export type FixOperation = {
+    kind: 'replace_text';
+    range: Range;
+    newText: string;
+} | {
+    kind: 'insert_text';
+    position: number;
+    text: string;
+} | {
+    kind: 'delete_range';
+    range: Range;
+} | {
+    kind: 'wrap_in_tag';
+    tagName: string;
+    range: Range;
+};
+export interface DiagnosticCollection {
+    /** All diagnostics */
+    items: Diagnostic[];
+    /** Count by severity */
+    errorCount: number;
+    warningCount: number;
+    infoCount: number;
+    hintCount: number;
+    /** Quick access: only errors */
+    errors: Diagnostic[];
+    /** Quick access: only warnings */
+    warnings: Diagnostic[];
+}
+export declare function createDiagnosticCollection(): DiagnosticCollection;
+export declare function createDiagnostic(code: string, message: string, severity: DiagnosticSeverity, options?: {
+    nodeId?: NodeId | null;
+    nodeKind?: NodeKind | null;
+    range?: Range | null;
+    tags?: DiagnosticTag[];
+    source?: string;
+    related?: DiagnosticRelatedInfo[];
+    fixes?: DiagnosticFix[];
+}): Diagnostic;
+export declare function addDiagnostic(collection: DiagnosticCollection, diagnostic: Diagnostic): void;

package/dist/types/Types/index.d.ts

@@ -0,0 +1,11 @@
+export type { Token, TokenKind, TokenStream, Trivia, TriviaKind, Range } from './tokens';
+export { createToken, createTrivia, range, rangeLength, rangeContains, ArrayTokenStream } from './tokens';
+export type { DocumentNode, NodeId, NodeKind, NodeAttributes, NodeMetadata, DocumentSnapshot, DocumentChangeEvent, DocumentChangeKind, SourceRange, } from './core';
+export { createNodeId, createDocumentNode, cloneNode, getNodeText, walkPreOrder, findById } from './core';
+export type { Diagnostic, DiagnosticSeverity, DiagnosticTag, DiagnosticCollection, DiagnosticRelatedInfo, DiagnosticFix, FixOperation, } from './diagnostics';
+export { createDiagnosticCollection, createDiagnostic, addDiagnostic, DIAGNOSTIC_SEVERITY } from './diagnostics';
+export type { Operation, OperationKind, InsertNodeOperation, DeleteNodeOperation, ReplaceNodeOperation, MoveNodeOperation, UpdateAttributesOperation, SetTextOperation, InsertTextOperation, DeleteTextOperation, ReplaceTextOperation, WrapInTagOperation, UnwrapNodeOperation, SplitNodeOperation, MergeNodesOperation, } from './operations';
+export { createOperationId, operationLabel } from './operations';
+export type { Query, QuerySelector, QueryCombinator, QueryStep, QueryMatch, QueryResult } from './queries';
+export { query } from './queries';
+export type { SymbolInfo, SymbolKind, Reference, SymbolTableData, SymbolSearchResult } from './symbols';

package/dist/types/Types/operations.d.ts

@@ -0,0 +1,109 @@
+/**
+ * DocumentEngine — Operation & Transaction Types
+ *
+ * Operations are the atomic units of change in the document.
+ * Every modification goes through operations, never direct mutation.
+ *
+ * Inspired by ProseMirror and Roslyn.
+ */
+import type { NodeId, NodeAttributes } from './core';
+import type { RedNode } from '../Syntax/RedNode';
+export type OperationKind = 'insert_node' | 'delete_node' | 'replace_node' | 'move_node' | 'update_attributes' | 'set_text' | 'insert_text' | 'delete_text' | 'replace_text' | 'wrap_in_tag' | 'unwrap_node' | 'split_node' | 'merge_nodes';
+export interface BaseOperation {
+    kind: OperationKind;
+    /** Stable ID for the operation (for undo/redo pairing) */
+    id: string;
+    /** Whether this operation can be undone */
+    undoable: boolean;
+    /** Timestamp */
+    timestamp: number;
+}
+export interface InsertNodeOperation extends BaseOperation {
+    kind: 'insert_node';
+    parentId: NodeId;
+    index: number;
+    node: RedNode;
+}
+export interface DeleteNodeOperation extends BaseOperation {
+    kind: 'delete_node';
+    nodeId: NodeId;
+    /** The deleted node (stored for undo) */
+    node: RedNode;
+    parentId: NodeId;
+    index: number;
+}
+export interface ReplaceNodeOperation extends BaseOperation {
+    kind: 'replace_node';
+    nodeId: NodeId;
+    newNode: RedNode;
+    oldNode: RedNode;
+}
+export interface MoveNodeOperation extends BaseOperation {
+    kind: 'move_node';
+    nodeId: NodeId;
+    fromParentId: NodeId;
+    fromIndex: number;
+    toParentId: NodeId;
+    toIndex: number;
+}
+export interface UpdateAttributesOperation extends BaseOperation {
+    kind: 'update_attributes';
+    nodeId: NodeId;
+    newAttributes: NodeAttributes;
+    oldAttributes: NodeAttributes;
+}
+export interface SetTextOperation extends BaseOperation {
+    kind: 'set_text';
+    nodeId: NodeId;
+    newText: string;
+    oldText: string;
+}
+export interface InsertTextOperation extends BaseOperation {
+    kind: 'insert_text';
+    nodeId: NodeId;
+    position: number;
+    text: string;
+}
+export interface DeleteTextOperation extends BaseOperation {
+    kind: 'delete_text';
+    nodeId: NodeId;
+    position: number;
+    length: number;
+    text: string;
+}
+export interface ReplaceTextOperation extends BaseOperation {
+    kind: 'replace_text';
+    nodeId: NodeId;
+    position: number;
+    length: number;
+    newText: string;
+    oldText: string;
+}
+export interface WrapInTagOperation extends BaseOperation {
+    kind: 'wrap_in_tag';
+    nodeId: NodeId;
+    tagName: string;
+    attributes: NodeAttributes;
+}
+export interface UnwrapNodeOperation extends BaseOperation {
+    kind: 'unwrap_node';
+    nodeId: NodeId;
+    parentId: NodeId;
+    children: RedNode[];
+}
+export interface SplitNodeOperation extends BaseOperation {
+    kind: 'split_node';
+    nodeId: NodeId;
+    position: number;
+    leftNode: RedNode;
+    rightNode: RedNode;
+}
+export interface MergeNodesOperation extends BaseOperation {
+    kind: 'merge_nodes';
+    leftNodeId: NodeId;
+    rightNodeId: NodeId;
+    mergedNode: RedNode;
+}
+export type Operation = InsertNodeOperation | DeleteNodeOperation | ReplaceNodeOperation | MoveNodeOperation | UpdateAttributesOperation | SetTextOperation | InsertTextOperation | DeleteTextOperation | ReplaceTextOperation | WrapInTagOperation | UnwrapNodeOperation | SplitNodeOperation | MergeNodesOperation;
+export declare function createOperationId(): string;
+export declare function operationLabel(op: Operation): string;

package/dist/types/Types/queries.d.ts

@@ -0,0 +1,67 @@
+/**
+ * DocumentEngine — Query Types
+ *
+ * CSS-inspired query selectors for the document tree.
+ * Enables queries like: `paragraph > bold`, `quote text`, `[color]`
+ */
+import type { NodeKind } from './core';
+import type { RedNode } from '../Syntax/RedNode';
+export type QuerySelector = {
+    type: 'kind';
+    kind: NodeKind;
+} | {
+    type: 'tag';
+    tag: string;
+} | {
+    type: 'attribute';
+    name: string;
+    value?: string;
+} | {
+    type: 'has_attribute';
+    name: string;
+} | {
+    type: 'text';
+    pattern: string;
+} | {
+    type: 'has_child';
+    selector: QuerySelector;
+} | {
+    type: 'has_descendant';
+    selector: QuerySelector;
+} | {
+    type: 'nth_child';
+    n: number;
+} | {
+    type: 'first_child';
+} | {
+    type: 'last_child';
+} | {
+    type: 'position';
+    min?: number;
+    max?: number;
+} | {
+    type: 'depth';
+    min?: number;
+    max?: number;
+};
+export type QueryCombinator = 'child' | 'descendant' | 'adjacent' | 'sibling';
+export interface QueryStep {
+    selector: QuerySelector[];
+    combinator: QueryCombinator | 'root';
+}
+export interface Query {
+    steps: QueryStep[];
+}
+export interface QueryMatch {
+    node: RedNode;
+    /** How well this node matches (for sorting results) */
+    score: number;
+    /** The specific selectors that matched */
+    matchedSelectors: string[];
+}
+export declare function query(selector: string): Query;
+export interface QueryResult {
+    matches: QueryMatch[];
+    total: number;
+    time: number;
+}

package/dist/types/Types/symbols.d.ts

@@ -0,0 +1,42 @@
+/**
+ * DocumentEngine — Symbol Types
+ *
+ * Symbol system for definitions and references in BBCode documents.
+ * Enables: go-to-definition, find-all-references, rename, etc.
+ *
+ * Inspired by Language Server Protocol (LSP).
+ */
+import type { NodeId, SourceRange } from './core';
+export type SymbolKind = 'tag' | 'id_definition' | 'id_reference' | 'class' | 'property' | 'variable' | 'function' | 'module' | 'snippet' | 'template' | 'other';
+export interface SymbolInfo {
+    /** Unique ID for this symbol */
+    id: string;
+    /** Symbol name (e.g. 'hero', 'my-block') */
+    name: string;
+    /** Symbol kind */
+    kind: SymbolKind;
+    /** The node that defines this symbol */
+    definitionNodeId: NodeId;
+    /** Source range of the definition */
+    definitionRange: SourceRange;
+    /** Container node (e.g. the document) */
+    containerNodeId: NodeId;
+    /** All references to this symbol */
+    references: Reference[];
+    /** Additional data */
+    data?: Record<string, unknown>;
+}
+export interface Reference {
+    nodeId: NodeId;
+    range: SourceRange;
+    kind: 'definition' | 'reference' | 'implementation';
+}
+export interface SymbolTableData {
+    symbols: Map<string, SymbolInfo>;
+    /** Quick lookup: node ID → symbol */
+    nodeToSymbol: Map<NodeId, string>;
+}
+export interface SymbolSearchResult {
+    symbol: SymbolInfo;
+    score: number;
+}

package/dist/types/Types/tokens.d.ts

@@ -0,0 +1,75 @@
+/**
+ * DocumentEngine — Token & Trivia Types
+ *
+ * Tokens are the output of the Lexer and input to the Parser.
+ * Trivia is whitespace, newlines, formatting that is preserved
+ * but not semantically meaningful — inspired by Roslyn.
+ */
+export type TriviaKind = 'whitespace' | 'newline' | 'carriage_return' | 'comment' | 'line_continuation';
+export interface Trivia {
+    kind: TriviaKind;
+    text: string;
+    range: Range;
+}
+export interface Range {
+    start: number;
+    end: number;
+}
+export declare function range(start: number, end: number): Range;
+export declare function rangeLength(r: Range): number;
+export declare function rangeContains(r: Range, pos: number): boolean;
+export type TokenKind = 'open_tag' | 'close_tag' | 'self_closing_tag' | 'text' | 'newline' | 'whitespace' | 'attribute_name' | 'attribute_value' | 'equals' | 'quote' | 'end_of_file' | 'error';
+export interface Token {
+    kind: TokenKind;
+    text: string;
+    range: Range;
+    /** Tag name or attribute name if applicable */
+    name?: string;
+    /** Full raw tag text including brackets: [b], [/color], [*] */
+    tagText?: string;
+    /** Raw attribute string (everything between tag name and closing ]) */
+    attrs?: string;
+    /** Trivia attached BEFORE this token (whitespace, newlines) */
+    leadingTrivia: Trivia[];
+    /** Trivia attached AFTER this token */
+    trailingTrivia: Trivia[];
+}
+export interface TokenStream {
+    /** Peek at the current token without consuming */
+    peek(): Token;
+    /** Consume and return the current token, advance */
+    advance(): Token;
+    /** Look ahead n tokens (0 = next) */
+    lookAhead(n: number): Token;
+    /** Whether we've consumed all tokens */
+    isEof(): boolean;
+    /** Get current position in the stream */
+    position(): number;
+    /** Reset to a position */
+    seek(pos: number): void;
+    /** Get all remaining tokens */
+    remaining(): Token[];
+    /** Get all tokens */
+    getAll(): Token[];
+}
+export declare function createToken(kind: TokenKind, text: string, start: number, end: number, options?: {
+    name?: string;
+    tagText?: string;
+    attrs?: string;
+    leadingTrivia?: Trivia[];
+    trailingTrivia?: Trivia[];
+}): Token;
+export declare function createTrivia(kind: TriviaKind, text: string, start: number, end: number): Trivia;
+export declare class ArrayTokenStream implements TokenStream {
+    private tokens;
+    private pos;
+    constructor(tokens: Token[]);
+    peek(): Token;
+    advance(): Token;
+    lookAhead(n: number): Token;
+    isEof(): boolean;
+    position(): number;
+    seek(pos: number): void;
+    remaining(): Token[];
+    getAll(): Token[];
+}

package/dist/types/Utils/BBCodeGenerator.d.ts

@@ -0,0 +1,21 @@
+export type GeneratorTheme = 'forum_post' | 'beatmap_desc' | 'random_chat';
+export declare class BBCodeGenerator {
+    private nouns;
+    private adjectives;
+    private verbs;
+    private players;
+    private colors;
+    private randomInt;
+    private pick;
+    private generateSentence;
+    private generateParagraph;
+    private generateHeading;
+    private generateHighlight;
+    private generateList;
+    private generateNotice;
+    private generateBox;
+    generate(theme?: GeneratorTheme): string;
+    private generateForumPost;
+    private generateBeatmapDesc;
+    private generateRandomChat;
+}

package/dist/types/Utils/ColorMath.d.ts

@@ -0,0 +1,92 @@
+export type Easing = "linear" | "easeIn" | "easeOut" | "easeInOut" | "easeIO" | "parabola" | "half-parabola" | string;
+export declare function solveCubicBezierY(x: number, x1: number, y1: number, x2: number, y2: number): number;
+/**
+ * Set by EffectMath at module load. ColorMath cannot import it directly —
+ * EffectMath depends on ColorMath — and `ease` is the only place that
+ * needs it, so the dependency is injected rather than inverted.
+ */
+type ExpressionFn = (vars: Record<string, number>) => number;
+/** @internal Wire the expression compiler into `ease`. */
+export declare function __setExpressionCompiler(fn: (src: string) => ExpressionFn | null): void;
+/**
+ * Resuelve una vez todo lo que en `ease` no depende de `t`, y devuelve la
+ * función que sí lo hace.
+ *
+ * `evaluateEffect` llama a `ease` UNA VEZ POR CARÁCTER con la misma cadena de
+ * suavizado. Para `bezier(a,b,c,d)` eso significaba volver a lanzar la
+ * expresión regular y cuatro `parseFloat` sobre la misma cadena en cada
+ * carácter; para `expr(...)`, un `slice` por carácter. Compilar arriba del
+ * bucle deja el trabajo por carácter en la aritmética que de verdad varía.
+ *
+ * Medido sobre 150 líneas de `[gradient …;easing=bezier(...)]` (19 KiB): el
+ * render pasó de 16,4 ms a 1,2 ms.
+ */
+export declare function compileEase(easing: Easing, center?: number, power?: number): (t: number) => number;
+export declare function ease(t: number, easing: Easing, center?: number, power?: number): number;
+export declare function hslToHex(h: number, s: number, l: number): string;
+/**
+ * A hex colour token to RGB.
+ *
+ * Accepts `#rgb`, `#rgba`, `#rrggbb` and `#rrggbbaa`, hash optional.
+ * Anything else returns black instead of `NaN`: these strings come from
+ * BBCode attributes and from a text field the user is mid-way through
+ * typing, and a `NaN` channel propagates into `#NaNNaNNaN`, corrupting
+ * the whole gradient rather than the one bad stop.
+ *
+ * Parsed by char code rather than by regex + `parseInt`. This runs once
+ * per character per colour layer per keystroke — two calls for every
+ * `mixHex` — and the regex version was the single largest cost in
+ * compiling a long document.
+ */
+export declare function hexToRgb(hex: string): [number, number, number];
+/** True when a token is a hex colour `hexToRgb` can read exactly. */
+export declare function isHexColor(value: string): boolean;
+export declare function hexToHsl(hex: string): [number, number, number];
+export declare function mixHex(color1: string, color2: string, weight: number): string;
+export declare function mixMultiple(colors: string[], weight: number): string;
+export interface ColorStop {
+    color: string;
+    position: number;
+}
+/**
+ * Sample a stop list at `weight`.
+ *
+ * `perceptual` interpolates in OKLab instead of sRGB. The difference
+ * shows wherever two stops differ in hue: an sRGB ramp from blue to
+ * yellow dips through a desaturated grey at the midpoint, while OKLab
+ * holds chroma. Two conversions per character, so it stays opt-in.
+ */
+export declare function mixMultipleStops(stops: ColorStop[], weight: number, perceptual?: boolean): string;
+/**
+ * Convert a hex colour to OKLab [L, a, b] components.
+ * L (lightness) in [0, 1], a/b (opponent axes) roughly in [-0.4, 0.4].
+ */
+export declare function hexToOklab(hex: string): [number, number, number];
+/**
+ * Calculate the perceptual distance between two hex colours using OKLab.
+ * Returns a value in [0, ~0.4] where:
+ *   < 0.02  ≈ imperceptible difference
+ *   < 0.05  ≈ small but noticeable
+ *   > 0.1   ≈ very noticeable
+ */
+export declare function perceptualDistance(hex1: string, hex2: string): number;
+/**
+ * `perceptualDistance` for callers that already hold both OKLab triples.
+ *
+ * Gradient detection converts a colour to OKLab once per stop and then asks
+ * for distances between neighbours, between chord endpoints and against an
+ * ideal ramp — each of which re-derived both triples from their hex strings.
+ * The results are identical; this just stops paying for the conversion again.
+ */
+export declare function perceptualDistanceOklab(c1: readonly [number, number, number], c2: readonly [number, number, number]): number;
+/**
+ * Mix two hex colours in OKLab space for perceptually uniform interpolation.
+ */
+export declare function mixHexOklab(color1: string, color2: string, weight: number): string;
+/**
+ * `mixHexOklab` for callers that already hold both OKLab triples — the same
+ * saving as {@link perceptualDistanceOklab}, for the ideal-ramp comparison
+ * that mixes the *same* two endpoints once per colour in the sequence.
+ */
+export declare function mixOklabToHex(c1: readonly [number, number, number], c2: readonly [number, number, number], weight: number): string;
+export {};