@cascadetui/core 0.1.1

package/lib/debounce.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Debounce controller that manages debounce instances for a specific scope
+ */
+export declare class DebounceController {
+    private scopeId;
+    constructor(scopeId: string | number);
+    /**
+     * Debounces the provided function with the given ID
+     *
+     * @param id Unique identifier within this scope
+     * @param ms Milliseconds to wait before executing
+     * @param fn Function to execute
+     */
+    debounce<R>(id: string | number, ms: number, fn: () => Promise<R>): Promise<R>;
+    /**
+     * Clear a specific debounce timer in this scope
+     *
+     * @param id The debounce ID to clear
+     */
+    clearDebounce(id: string | number): void;
+    /**
+     * Clear all debounce timers in this scope
+     */
+    clear(): void;
+}
+/**
+ * Creates a new debounce controller for a specific scope
+ *
+ * @param scopeId Unique identifier for this debounce scope
+ * @returns A DebounceController for the specified scope
+ */
+export declare function createDebounce(scopeId: string | number): DebounceController;
+/**
+ * Clears all debounce timers for a specific scope
+ *
+ * @param scopeId The scope identifier
+ */
+export declare function clearDebounceScope(scopeId: string | number): void;
+/**
+ * Clears all active debounce timers across all scopes
+ */
+export declare function clearAllDebounces(): void;

package/lib/env.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Environment variable registry
+ *
+ * Usage:
+ * ```ts
+ * import { registerEnvVar, env } from "./lib/env.ts";
+ *
+ * // Register environment variables
+ * registerEnvVar({
+ *   name: "DEBUG",
+ *   description: "Enable debug logging",
+ *   type: "boolean",
+ *   default: false
+ * });
+ *
+ * registerEnvVar({
+ *   name: "PORT",
+ *   description: "Server port number",
+ *   type: "number",
+ *   default: 3000
+ * });
+ *
+ * // Access environment variables
+ * if (env.DEBUG) {
+ *   console.log("Debug mode enabled");
+ * }
+ *
+ * const port = env.PORT; // number
+ * ```
+ */
+export interface EnvVarConfig {
+    name: string;
+    description: string;
+    default?: string | boolean | number;
+    type?: "string" | "boolean" | "number";
+}
+export declare const envRegistry: Record<string, EnvVarConfig>;
+export declare function registerEnvVar(config: EnvVarConfig): void;
+export declare function clearEnvCache(): void;
+export declare function generateEnvMarkdown(): string;
+export declare function generateEnvColored(): string;
+export declare const env: Record<string, any>;

package/lib/extmarks-history.d.ts

@@ -0,0 +1,17 @@
+import type { Extmark } from "./extmarks";
+export interface ExtmarksSnapshot {
+    extmarks: Map<number, Extmark>;
+    nextId: number;
+}
+export declare class ExtmarksHistory {
+    private undoStack;
+    private redoStack;
+    saveSnapshot(extmarks: Map<number, Extmark>, nextId: number): void;
+    undo(): ExtmarksSnapshot | null;
+    redo(): ExtmarksSnapshot | null;
+    pushRedo(snapshot: ExtmarksSnapshot): void;
+    pushUndo(snapshot: ExtmarksSnapshot): void;
+    clear(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+}

package/lib/extmarks.d.ts

@@ -0,0 +1,89 @@
+import type { EditBuffer } from "../edit-buffer";
+import type { EditorView } from "../editor-view";
+export interface Extmark {
+    id: number;
+    start: number;
+    end: number;
+    virtual: boolean;
+    styleId?: number;
+    priority?: number;
+    data?: any;
+    typeId: number;
+}
+export interface ExtmarkOptions {
+    start: number;
+    end: number;
+    virtual?: boolean;
+    styleId?: number;
+    priority?: number;
+    data?: any;
+    typeId?: number;
+    metadata?: any;
+}
+/**
+ * WARNING: This is simulating extmarks in the edit buffer
+ * and will move to a real native implementation in the future.
+ * Use with caution.
+ */
+export declare class ExtmarksController {
+    private editBuffer;
+    private editorView;
+    private extmarks;
+    private extmarksByTypeId;
+    private metadata;
+    private nextId;
+    private destroyed;
+    private history;
+    private typeNameToId;
+    private typeIdToName;
+    private nextTypeId;
+    private originalMoveCursorLeft;
+    private originalMoveCursorRight;
+    private originalSetCursorByOffset;
+    private originalMoveUpVisual;
+    private originalMoveDownVisual;
+    private originalDeleteCharBackward;
+    private originalDeleteChar;
+    private originalInsertText;
+    private originalInsertChar;
+    private originalDeleteRange;
+    private originalSetText;
+    private originalReplaceText;
+    private originalClear;
+    private originalNewLine;
+    private originalDeleteLine;
+    private originalEditorViewDeleteSelectedText;
+    private originalUndo;
+    private originalRedo;
+    constructor(editBuffer: EditBuffer, editorView: EditorView);
+    private wrapCursorMovement;
+    private wrapDeletion;
+    private wrapInsertion;
+    private wrapEditorViewDeleteSelectedText;
+    private setupContentChangeListener;
+    private deleteExtmarkById;
+    private findVirtualExtmarkContaining;
+    private adjustExtmarksAfterInsertion;
+    adjustExtmarksAfterDeletion(deleteOffset: number, length: number): void;
+    private offsetToPosition;
+    private positionToOffset;
+    private updateHighlights;
+    private offsetExcludingNewlines;
+    create(options: ExtmarkOptions): number;
+    delete(id: number): boolean;
+    get(id: number): Extmark | null;
+    getAll(): Extmark[];
+    getVirtual(): Extmark[];
+    getAtOffset(offset: number): Extmark[];
+    getAllForTypeId(typeId: number): Extmark[];
+    clear(): void;
+    private saveSnapshot;
+    private restoreSnapshot;
+    private wrapUndoRedo;
+    registerType(typeName: string): number;
+    getTypeId(typeName: string): number | null;
+    getTypeName(typeId: number): string | null;
+    getMetadataFor(extmarkId: number): any;
+    destroy(): void;
+}
+export declare function createExtmarksController(editBuffer: EditBuffer, editorView: EditorView): ExtmarksController;

package/lib/hast-styled-text.d.ts

@@ -0,0 +1,17 @@
+import { StyledText } from "./styled-text";
+import { SyntaxStyle } from "../syntax-style";
+export interface HASTText {
+    type: "text";
+    value: string;
+}
+export interface HASTElement {
+    type: "element";
+    tagName: string;
+    properties?: {
+        className?: string;
+    };
+    children: HASTNode[];
+}
+export type HASTNode = HASTText | HASTElement;
+export type { StyleDefinition } from "../syntax-style";
+export declare function hastToStyledText(hast: HASTNode, syntaxStyle: SyntaxStyle): StyledText;

package/lib/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./border";
+export * from "./KeyHandler";
+export * from "./ascii.font";
+export * from "./hast-styled-text";
+export * from "./RGBA";
+export * from "./parse.keypress";
+export * from "./scroll-acceleration";
+export * from "./stdin-buffer";
+export * from "./styled-text";
+export * from "./yoga.options";
+export * from "./parse.mouse";
+export * from "./selection";
+export * from "./env";
+export * from "./tree-sitter-styled-text";
+export * from "./tree-sitter";
+export * from "./data-paths";
+export * from "./extmarks";
+export * from "./terminal-palette";

package/lib/keymapping.d.ts

@@ -0,0 +1,25 @@
+export interface KeyBinding<Action extends string = string> {
+    name: string;
+    ctrl?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+    super?: boolean;
+    action: Action;
+}
+export type KeyAliasMap = Record<string, string>;
+export declare const defaultKeyAliases: KeyAliasMap;
+export declare function mergeKeyAliases(defaults: KeyAliasMap, custom: KeyAliasMap): KeyAliasMap;
+export declare function mergeKeyBindings<Action extends string>(defaults: KeyBinding<Action>[], custom: KeyBinding<Action>[]): KeyBinding<Action>[];
+export declare function getKeyBindingKey<Action extends string>(binding: KeyBinding<Action>): string;
+export declare function buildKeyBindingsMap<Action extends string>(bindings: KeyBinding<Action>[], aliasMap?: KeyAliasMap): Map<string, Action>;
+/**
+ * Converts a key binding to a human-readable string representation
+ * @param binding The key binding to stringify
+ * @returns A string like "ctrl+shift+y" or just "escape"
+ * @example
+ * keyBindingToString({ name: "y", ctrl: true, shift: true }) // "ctrl+shift+y"
+ * keyBindingToString({ name: "escape" }) // "escape"
+ * keyBindingToString({ name: "c", ctrl: true }) // "ctrl+c"
+ * keyBindingToString({ name: "s", super: true }) // "super+s"
+ */
+export declare function keyBindingToString<Action extends string>(binding: KeyBinding<Action>): string;

package/lib/objects-in-viewport.d.ts

@@ -0,0 +1,24 @@
+import type { ViewportBounds } from "../types";
+interface ViewportObject {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    zIndex: number;
+}
+/**
+ * Returns objects that overlap with the viewport bounds.
+ *
+ * @param viewport - The viewport bounds to check against
+ * @param objects - Array of objects MUST be sorted by position (y for column, x for row direction)
+ * @param direction - Primary scroll direction: "column" (vertical) or "row" (horizontal)
+ * @param padding - Extra padding around viewport to include nearby objects
+ * @param minTriggerSize - Minimum array size to use binary search optimization
+ * @returns Array of visible objects sorted by zIndex
+ *
+ * @remarks
+ * Objects must be pre-sorted by their start position (y for column direction, x for row direction).
+ * Unsorted input will produce incorrect results.
+ */
+export declare function getObjectsInViewport<T extends ViewportObject>(viewport: ViewportBounds, objects: T[], direction?: "row" | "column", padding?: number, minTriggerSize?: number): T[];
+export {};

package/lib/output.capture.d.ts

@@ -0,0 +1,24 @@
+import { Writable } from "stream";
+import { EventEmitter } from "events";
+export type CapturedOutput = {
+    stream: "stdout" | "stderr";
+    output: string;
+};
+export declare class Capture extends EventEmitter {
+    private output;
+    constructor();
+    get size(): number;
+    write(stream: "stdout" | "stderr", data: string): void;
+    claimOutput(): string;
+    private clear;
+}
+export declare class CapturedWritableStream extends Writable {
+    private stream;
+    private capture;
+    isTTY: boolean;
+    columns: number;
+    rows: number;
+    constructor(stream: "stdout" | "stderr", capture: Capture);
+    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    getColorDepth(): number;
+}

package/lib/parse.keypress-kitty.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedKey } from "./parse.keypress";
+export declare function parseKittyKeyboard(sequence: string): ParsedKey | null;

package/lib/parse.keypress.d.ts

@@ -0,0 +1,26 @@
+import { Buffer } from "node:buffer";
+export declare const nonAlphanumericKeys: string[];
+export type KeyEventType = "press" | "repeat" | "release";
+export interface ParsedKey {
+    name: string;
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+    option: boolean;
+    sequence: string;
+    number: boolean;
+    raw: string;
+    eventType: KeyEventType;
+    source: "raw" | "kitty";
+    code?: string;
+    super?: boolean;
+    hyper?: boolean;
+    capsLock?: boolean;
+    numLock?: boolean;
+    baseCode?: number;
+    repeated?: boolean;
+}
+export type ParseKeypressOptions = {
+    useKittyKeyboard?: boolean;
+};
+export declare const parseKeypress: (s?: Buffer | string, options?: ParseKeypressOptions) => ParsedKey | null;

package/lib/parse.mouse.d.ts

@@ -0,0 +1,30 @@
+export type MouseEventType = "down" | "up" | "move" | "drag" | "drag-end" | "drop" | "over" | "out" | "scroll";
+export interface ScrollInfo {
+    direction: "up" | "down" | "left" | "right";
+    delta: number;
+}
+export type RawMouseEvent = {
+    type: MouseEventType;
+    button: number;
+    x: number;
+    y: number;
+    modifiers: {
+        shift: boolean;
+        alt: boolean;
+        ctrl: boolean;
+    };
+    scroll?: ScrollInfo;
+};
+export declare class MouseParser {
+    private mouseButtonsPressed;
+    private static readonly SCROLL_DIRECTIONS;
+    reset(): void;
+    private decodeInput;
+    parseMouseEvent(data: Buffer): RawMouseEvent | null;
+    parseAllMouseEvents(data: Buffer): RawMouseEvent[];
+    private parseMouseSequenceAt;
+    private parseSgrSequence;
+    private parseBasicSequence;
+    private decodeSgrEvent;
+    private decodeBasicEvent;
+}

package/lib/queue.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generic processing queue that handles asynchronous job processing
+ */
+export declare class ProcessQueue<T> {
+    private processor;
+    private queue;
+    private processing;
+    private autoProcess;
+    constructor(processor: (item: T) => Promise<void> | void, autoProcess?: boolean);
+    enqueue(item: T): void;
+    private processQueue;
+    clear(): void;
+    isProcessing(): boolean;
+    size(): number;
+}

package/lib/renderable.validations.d.ts

@@ -0,0 +1,12 @@
+import type { RenderableOptions, Renderable } from "../Renderable";
+import type { PositionTypeString, OverflowString } from "./yoga.options";
+export declare function validateOptions(id: string, options: RenderableOptions<Renderable>): void;
+export declare function isValidPercentage(value: any): value is `${number}%`;
+export declare function isMarginType(value: any): value is number | "auto" | `${number}%`;
+export declare function isPaddingType(value: any): value is number | `${number}%`;
+export declare function isPositionType(value: any): value is number | "auto" | `${number}%`;
+export declare function isPositionTypeType(value: any): value is PositionTypeString;
+export declare function isOverflowType(value: any): value is OverflowString;
+export declare function isDimensionType(value: any): value is number | "auto" | `${number}%`;
+export declare function isFlexBasisType(value: any): value is number | "auto" | undefined;
+export declare function isSizeType(value: any): value is number | `${number}%` | undefined;

package/lib/scroll-acceleration.d.ts

@@ -0,0 +1,43 @@
+export interface ScrollAcceleration {
+    tick(now?: number): number;
+    reset(): void;
+}
+export declare class LinearScrollAccel implements ScrollAcceleration {
+    tick(_now?: number): number;
+    reset(): void;
+}
+/**
+ * macOS-inspired scroll acceleration.
+ *
+ * The class measures the time between consecutive scroll events and keeps a short
+ * moving window of the latest intervals. The average interval determines which
+ * multiplier to apply so that quick bursts accelerate and slower gestures stay precise.
+ *
+ * For intuition, treat the streak as a continuous timeline and compare it with the
+ * exponential distance curve from the pointer-acceleration research post:
+ *   d(t) = v₀ * ( t + A * (exp(t/τ) - 1 - t/τ) ).
+ * Small t stays near the base multiplier, medium streaks settle on multiplier1, and
+ * sustained bursts reach multiplier2, mirroring how the exponential curve bends up.
+ *
+ * Options:
+ * - threshold1: upper bound (ms) of the "medium" band. Raise to delay the ramp.
+ * - threshold2: upper bound (ms) of the "fast" band. Lower to demand tighter bursts.
+ * - multiplier1: scale for medium speed streaks.
+ * - multiplier2: scale for sustained fast streaks.
+ * - baseMultiplier: scale for relaxed scrolling; set to 1 for linear behaviour.
+ */
+export declare class MacOSScrollAccel implements ScrollAcceleration {
+    private opts;
+    private lastTickTime;
+    private velocityHistory;
+    private readonly historySize;
+    private readonly streakTimeout;
+    private readonly minTickInterval;
+    constructor(opts?: {
+        A?: number;
+        tau?: number;
+        maxMultiplier?: number;
+    });
+    tick(now?: number): number;
+    reset(): void;
+}

package/lib/selection.d.ts

@@ -0,0 +1,63 @@
+import { Renderable, type ViewportBounds } from "..";
+import { fonts } from "./ascii.font";
+export declare class Selection {
+    private _anchor;
+    private _focus;
+    private _selectedRenderables;
+    private _touchedRenderables;
+    private _isActive;
+    private _isDragging;
+    private _isStart;
+    constructor(anchorRenderable: Renderable, anchor: {
+        x: number;
+        y: number;
+    }, focus: {
+        x: number;
+        y: number;
+    });
+    get isStart(): boolean;
+    set isStart(value: boolean);
+    get anchor(): {
+        x: number;
+        y: number;
+    };
+    get focus(): {
+        x: number;
+        y: number;
+    };
+    set focus(value: {
+        x: number;
+        y: number;
+    });
+    get isActive(): boolean;
+    set isActive(value: boolean);
+    get isDragging(): boolean;
+    set isDragging(value: boolean);
+    get bounds(): ViewportBounds;
+    updateSelectedRenderables(selectedRenderables: Renderable[]): void;
+    get selectedRenderables(): Renderable[];
+    updateTouchedRenderables(touchedRenderables: Renderable[]): void;
+    get touchedRenderables(): Renderable[];
+    getSelectedText(): string;
+}
+export interface LocalSelectionBounds {
+    anchorX: number;
+    anchorY: number;
+    focusX: number;
+    focusY: number;
+    isActive: boolean;
+}
+export declare function convertGlobalToLocalSelection(globalSelection: Selection | null, localX: number, localY: number): LocalSelectionBounds | null;
+export declare class ASCIIFontSelectionHelper {
+    private getText;
+    private getFont;
+    private localSelection;
+    constructor(getText: () => string, getFont: () => keyof typeof fonts);
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    shouldStartSelection(localX: number, localY: number, width: number, height: number): boolean;
+    onLocalSelectionChanged(localSelection: LocalSelectionBounds | null, width: number, height: number): boolean;
+}

package/lib/singleton.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Ensures a value is initialized once per process,
+ * persists across Bun hot reloads, and is type-safe.
+ */
+export declare function singleton<T>(key: string, factory: () => T): T;
+export declare function destroySingleton(key: string): void;
+export declare function hasSingleton(key: string): boolean;

package/lib/stdin-buffer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * StdinBuffer buffers input and emits complete sequences.
+ *
+ * This is necessary because stdin data events can arrive in partial chunks,
+ * especially for escape sequences like mouse events. Without buffering,
+ * partial sequences can be misinterpreted as regular keypresses.
+ *
+ * For example, the mouse SGR sequence `\x1b[<35;20;5m` might arrive as:
+ * - Event 1: `\x1b`
+ * - Event 2: `[<35`
+ * - Event 3: `;20;5m`
+ *
+ * The buffer accumulates these until a complete sequence is detected.
+ * Call the `process()` method to feed input data.
+ */
+import { EventEmitter } from "events";
+export type StdinBufferOptions = {
+    /**
+     * Maximum time to wait for sequence completion (default: 10ms)
+     * After this time, the buffer is flushed even if incomplete
+     */
+    timeout?: number;
+};
+export type StdinBufferEventMap = {
+    data: [string];
+    paste: [string];
+};
+/**
+ * Buffers stdin input and emits complete sequences via the 'data' event.
+ * Handles partial escape sequences that arrive across multiple chunks.
+ */
+export declare class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
+    private buffer;
+    private timeout;
+    private readonly timeoutMs;
+    private pasteMode;
+    private pasteBuffer;
+    constructor(options?: StdinBufferOptions);
+    process(data: string | Buffer): void;
+    flush(): string[];
+    clear(): void;
+    getBuffer(): string;
+    destroy(): void;
+}

package/lib/styled-text.d.ts

@@ -0,0 +1,63 @@
+import type { TextChunk } from "../text-buffer";
+import { type ColorInput } from "./RGBA";
+declare const BrandedStyledText: unique symbol;
+export type Color = ColorInput;
+export interface StyleAttrs {
+    fg?: Color;
+    bg?: Color;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    dim?: boolean;
+    reverse?: boolean;
+    blink?: boolean;
+}
+export declare function isStyledText(obj: any): obj is StyledText;
+export declare class StyledText {
+    [BrandedStyledText]: boolean;
+    chunks: TextChunk[];
+    constructor(chunks: TextChunk[]);
+}
+export declare function stringToStyledText(content: string): StyledText;
+export type StylableInput = string | number | boolean | TextChunk;
+export declare const black: (input: StylableInput) => TextChunk;
+export declare const red: (input: StylableInput) => TextChunk;
+export declare const green: (input: StylableInput) => TextChunk;
+export declare const yellow: (input: StylableInput) => TextChunk;
+export declare const blue: (input: StylableInput) => TextChunk;
+export declare const magenta: (input: StylableInput) => TextChunk;
+export declare const cyan: (input: StylableInput) => TextChunk;
+export declare const white: (input: StylableInput) => TextChunk;
+export declare const brightBlack: (input: StylableInput) => TextChunk;
+export declare const brightRed: (input: StylableInput) => TextChunk;
+export declare const brightGreen: (input: StylableInput) => TextChunk;
+export declare const brightYellow: (input: StylableInput) => TextChunk;
+export declare const brightBlue: (input: StylableInput) => TextChunk;
+export declare const brightMagenta: (input: StylableInput) => TextChunk;
+export declare const brightCyan: (input: StylableInput) => TextChunk;
+export declare const brightWhite: (input: StylableInput) => TextChunk;
+export declare const bgBlack: (input: StylableInput) => TextChunk;
+export declare const bgRed: (input: StylableInput) => TextChunk;
+export declare const bgGreen: (input: StylableInput) => TextChunk;
+export declare const bgYellow: (input: StylableInput) => TextChunk;
+export declare const bgBlue: (input: StylableInput) => TextChunk;
+export declare const bgMagenta: (input: StylableInput) => TextChunk;
+export declare const bgCyan: (input: StylableInput) => TextChunk;
+export declare const bgWhite: (input: StylableInput) => TextChunk;
+export declare const bold: (input: StylableInput) => TextChunk;
+export declare const italic: (input: StylableInput) => TextChunk;
+export declare const underline: (input: StylableInput) => TextChunk;
+export declare const strikethrough: (input: StylableInput) => TextChunk;
+export declare const dim: (input: StylableInput) => TextChunk;
+export declare const reverse: (input: StylableInput) => TextChunk;
+export declare const blink: (input: StylableInput) => TextChunk;
+export declare const fg: (color: Color) => (input: StylableInput) => TextChunk;
+export declare const bg: (color: Color) => (input: StylableInput) => TextChunk;
+export declare const link: (url: string) => (input: StylableInput) => TextChunk;
+/**
+ * Template literal handler for styled text (non-cached version).
+ * Returns a StyledText object containing chunks of text with optional styles.
+ */
+export declare function t(strings: TemplateStringsArray, ...values: StylableInput[]): StyledText;
+export {};

package/lib/terminal-capability-detection.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Terminal capability response detection utilities.
+ *
+ * Detects various terminal capability response sequences:
+ * - DECRPM (DEC Request Mode): ESC[?...;N$y where N is 0,1,2,3,4
+ * - CPR (Cursor Position Report): ESC[row;colR (used for width detection)
+ * - XTVersion: ESC P >| ... ESC \
+ * - Kitty Graphics: ESC _ G ... ESC \
+ * - Kitty Keyboard Query: ESC[?Nu where N is 0,1,2,etc
+ * - DA1 (Device Attributes): ESC[?...c
+ * - Pixel Resolution: ESC[4;height;widtht
+ */
+/**
+ * Check if a sequence is a terminal capability response.
+ * Returns true if the sequence matches any known capability response pattern.
+ */
+export declare function isCapabilityResponse(sequence: string): boolean;
+/**
+ * Check if a sequence is a pixel resolution response.
+ * Format: ESC[4;height;widtht
+ */
+export declare function isPixelResolutionResponse(sequence: string): boolean;
+/**
+ * Parse pixel resolution from response sequence.
+ * Returns { width, height } or null if not a valid resolution response.
+ */
+export declare function parsePixelResolution(sequence: string): {
+    width: number;
+    height: number;
+} | null;