@pixerate/editor 0.23.0 → 0.24.0

package/dist/registry-evKTP4ls.d.ts

@@ -0,0 +1,354 @@
+import { J as JsonSchema, S as SchemaValidationError } from './schema-DYDGdYL9.js';
+
+/**
+ * Keyboard chords in a platform-neutral notation.
+ *
+ * | token | macOS | Windows / Linux |
+ * |---|---|---|
+ * | `Mod` | ⌘ Command | Ctrl |
+ * | `Ctrl` | ⌃ Control | Ctrl (same key as `Mod`: conflicts are reported) |
+ * | `Meta` / `Cmd` | ⌘ Command | Win / Super |
+ * | `Alt` / `Option` | ⌥ Option | Alt |
+ * | `Shift` | ⇧ Shift | Shift |
+ *
+ * Keys are stored as `KeyboardEvent.code` values (`KeyZ`, `Digit1`, `BracketRight`,
+ * `PageDown`), so Option/Alt chords work on macOS (where Option changes `event.key`).
+ */
+type Platform = 'mac' | 'windows' | 'linux';
+declare const PLATFORMS: readonly Platform[];
+/** A parsed chord. `mod` is the platform's primary modifier. */
+interface Chord {
+    /** `KeyboardEvent.code` of the key, e.g. `KeyZ`. */
+    key: string;
+    mod?: boolean;
+    ctrl?: boolean;
+    meta?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+}
+/** The modifiers a chord needs on one platform (`mod` resolved to `meta` or `ctrl`). */
+interface EffectiveChord {
+    key: string;
+    ctrl: boolean;
+    meta: boolean;
+    alt: boolean;
+    shift: boolean;
+}
+/** The current platform from `navigator` (`linux` when unknown, e.g. in Node). */
+declare function detectPlatform(): Platform;
+/** `KeyboardEvent.code` for a key token (`Z`, `1`, `]`, `PageDown`, `F5`, `KeyZ`), or `null`. */
+declare function keyToCode(token: string): string | null;
+/** Neutral text for a code: `KeyZ` → `Z`, `BracketRight` → `]`, `ArrowUp` → `Up`. */
+declare function codeToKeyText(code: string): string;
+/**
+ * Parses chord text (`Mod+Shift+Z`, `Alt+]`, `⌥⇧⌘K`, `CmdOrCtrl+K`). Throws on unknown
+ * modifiers or keys. The last `+`-separated token is the key (`+` itself is `Plus`).
+ */
+declare function parseChord(text: string): Chord;
+/** Canonical platform-neutral text: `Mod+Ctrl+Meta+Alt+Shift+<key>`. */
+declare function chordToString(chord: Chord): string;
+/** Canonical spelling of chord text (`shift+cmdorctrl+z` → `Mod+Shift+Z`). Throws when invalid. */
+declare function normalizeChord(text: string): string;
+/** The modifiers a chord needs on `platform`: `Mod` is ⌘ (meta) on macOS and Ctrl elsewhere. */
+declare function effectiveChord(chord: string | Chord, platform: Platform): EffectiveChord;
+/** Identity of an effective chord, for conflict detection (`Ctrl+Shift+KeyZ`). */
+declare function effectiveChordKey(chord: string | Chord, platform: Platform): string;
+/**
+ * Display text: `⌥⇧⌘K` on macOS, `Ctrl+Alt+Shift+K` on Windows / Linux (`Meta` shows as
+ * `Win` / `Super`). Invalid text is returned unchanged.
+ */
+declare function formatShortcut(chord: string | Chord, platform?: Platform): string;
+/** Minimal keyboard event surface (DOM `KeyboardEvent` satisfies it). */
+interface KeyboardEventLike {
+    key?: string;
+    code?: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    target?: EventTarget | null | unknown;
+    defaultPrevented?: boolean;
+    preventDefault?: () => void;
+}
+/** `event.code`, or one derived from `event.key` for synthetic events without a code. */
+declare function eventCode(event: KeyboardEventLike): string;
+/**
+ * The key code a shortcut event is matched by: `event.code` (layout-independent, so
+ * Option/Alt chords work on macOS and punctuation chords follow the physical key),
+ * except that a letter key producing a different Latin letter without Alt (AZERTY,
+ * QWERTZ, Dvorak) uses the produced letter, as browsers and operating systems do.
+ */
+declare function shortcutCode(event: KeyboardEventLike): string;
+/** The code a printable `event.key` names on a US layout (`z` → `KeyZ`, `]` → `BracketRight`). */
+declare function codeFromKey(key: string): string | null;
+/**
+ * Whether a keyboard event comes from a text-entry element: `<input>`, `<textarea>`,
+ * `<select>`, a `contenteditable` element (or a descendant) or a ProseMirror editor.
+ * Falls back to `document.activeElement` when the event has no element target.
+ */
+declare function isEditableEventTarget(event: {
+    target?: unknown;
+}): boolean;
+
+/** One key binding: a chord that runs `command`, optionally only in one scope / on some platforms. */
+interface ShortcutBinding {
+    command: string;
+    /** Chord text (`Mod+Shift+Z`) or a parsed chord. */
+    chord: string | Chord;
+    /** Scope (e.g. `canvas`, `spreadsheet`); scoped bindings win over global ones. Omit for global. */
+    scope?: string;
+    /** Platforms the binding exists on (default: all). E.g. `Mod+Y` redo only off macOS. */
+    platforms?: readonly Platform[];
+    /** Also fire while focus is in an input, textarea or contenteditable (default `false`). */
+    allowInEditable?: boolean;
+}
+/** Shortcut declaration on a command: chord text, or an object for platform / scope specifics. */
+type ShortcutInput = string | Omit<ShortcutBinding, 'command'> | ReadonlyArray<string | Omit<ShortcutBinding, 'command'>>;
+/** Expands a command's `shortcut` declaration into bindings. */
+declare function toShortcutBindings(command: string, input: ShortcutInput | undefined, scope?: string): ShortcutBinding[];
+interface ShortcutConflict {
+    /** Scope shared by the bindings (`undefined` = global). */
+    scope?: string;
+    /** Effective chord, e.g. `Ctrl+KeyZ`. */
+    chord: string;
+    /** Commands bound to it (two or more). */
+    commands: string[];
+}
+interface ShortcutMatch {
+    command: string;
+    binding: ShortcutBinding;
+}
+interface ShortcutResolveOptions {
+    /** Active scopes, most specific first. Bindings in these scopes win over global ones. */
+    scopes?: string | readonly string[];
+    /** Resolve even when the event comes from a text input (default: per binding). */
+    allowInEditable?: boolean;
+    /** Override the map's platform. */
+    platform?: Platform;
+}
+interface ShortcutMapOptions {
+    /** Platform used to resolve `Mod` (default: detected from `navigator` on every resolve). */
+    platform?: Platform;
+    /**
+     * `platform` (default): `Mod` means ⌘ on macOS and Ctrl elsewhere, exactly.
+     * `either`: `Mod` (and `Ctrl` / `Meta`) match ⌘ or Ctrl on every platform.
+     */
+    modifierMode?: 'platform' | 'either';
+}
+/**
+ * Keyboard shortcuts as data: default bindings plus user overrides, resolved from
+ * `KeyboardEvent`s by `event.code` (so Option/Alt chords work on macOS), with scopes
+ * (scoped bindings win), conflict detection per platform and display formatting.
+ */
+declare class ShortcutMap {
+    private defaults;
+    private overrides;
+    private readonly listeners;
+    private readonly options;
+    constructor(bindings?: readonly ShortcutBinding[], options?: ShortcutMapOptions);
+    get platform(): Platform;
+    private entry;
+    private changed;
+    /** Subscribes to binding changes. Returns an unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /** Adds default bindings (throws on invalid chord text). Returns a function removing them. */
+    bind(bindings: ShortcutBinding | readonly ShortcutBinding[]): () => void;
+    /**
+     * User override for a command: replaces all of its default bindings with `chords`
+     * (an empty list unbinds it). Throws on invalid chord text.
+     */
+    setOverride(command: string, chords: string | Chord | ReadonlyArray<string | Chord | Omit<ShortcutBinding, 'command'>>): void;
+    /** Removes a user override (the defaults apply again). */
+    clearOverride(command: string): void;
+    /** User overrides as plain data (`{ command: ['Mod+K'] }`), e.g. to persist them. */
+    getOverrides(): Record<string, string[]>;
+    /** Restores overrides saved with `getOverrides` (replacing the current ones). */
+    setOverrides(overrides: Record<string, readonly string[]>): void;
+    private active;
+    /** Effective bindings on `platform` (defaults without overridden commands, plus overrides). */
+    bindings(platform?: Platform): ShortcutBinding[];
+    /** Canonical chord text bound to `command` on `platform` (first = primary). */
+    forCommand(command: string, platform?: Platform): string[];
+    /**
+     * The command a keydown event runs, or `null`. Events from text inputs are ignored
+     * unless the binding (or `options`) allows them. Bindings in the active scopes
+     * (in order) win over global bindings; bindings in other scopes never match.
+     * Keys are matched by `event.code`, except that a letter key producing another Latin
+     * letter (AZERTY, QWERTZ, Dvorak) matches that letter when Alt is not held, so
+     * `Mod+Z` follows the Z label (see `shortcutCode`).
+     */
+    resolve(event: KeyboardEventLike, options?: ShortcutResolveOptions): ShortcutMatch | null;
+    private matches;
+    /**
+     * Groups of bindings that share an effective chord in one scope on `platform`
+     * (e.g. `Mod+Y` and `Ctrl+Y` collide off macOS). A scoped binding shadowing a
+     * global one is not a conflict.
+     */
+    findConflicts(platform?: Platform): ShortcutConflict[];
+    /** Conflicts on every platform, keyed by platform (only platforms with conflicts). */
+    findAllConflicts(): Partial<Record<Platform, ShortcutConflict[]>>;
+}
+
+/** Object JSON Schema describing a command's parameters. */
+type CommandParamsSchema = JsonSchema & {
+    type: 'object';
+};
+/**
+ * Metadata and implementation of one command. Menus, shortcuts, the palette and agent
+ * tools all run commands by id, so every entry point shares enablement and validation.
+ */
+interface CommandSpec<TContext = any, TParams = any, TResult = unknown> {
+    /** Unique id, e.g. `history.undo` or `canvas.alignLeft`. */
+    id: string;
+    label: string;
+    /** Group / menu name shown next to the label, e.g. `Edit` or `Arrange`. */
+    group?: string;
+    /** Extra search terms for the palette. */
+    keywords?: readonly string[];
+    description?: string;
+    /** Object JSON Schema for `params`. Unknown keys are rejected unless `additionalProperties` allows them. */
+    params?: CommandParamsSchema;
+    /** Default shortcut(s): platform-neutral chord text such as `Mod+Shift+Z`. */
+    shortcut?: ShortcutInput;
+    /** Scope the command (and its shortcuts) belong to, e.g. `canvas`. Omit for global commands. */
+    scope?: string;
+    /**
+     * Whether the command can run: `true` (or `undefined`), `false`, or a reason string
+     * ("Nothing to undo"). Receives the params a caller named, so a command acting on the
+     * selection can still run on targets passed explicitly (`params` is `undefined` for menus).
+     */
+    enabled?: (context: TContext, params: TParams | undefined) => boolean | string | undefined;
+    run: (context: TContext, params: TParams) => TResult;
+    /**
+     * Runs inside the registry's `history.batch(label, …)`, so all history entries the
+     * command records become one undo step and a throw rolls back its partial changes.
+     */
+    undoable?: boolean;
+    /** The command only reads state (agent tools mark it read-only). */
+    readOnly?: boolean;
+    /** Hide from the palette and `list()` unless `includeHidden` (still runnable by id). */
+    hidden?: boolean;
+}
+type CommandErrorCode = 'unknown_command' | 'disabled' | 'invalid_params' | 'failed';
+type CommandResult<T = unknown> = {
+    ok: true;
+    id: string;
+    result: T;
+} | {
+    ok: false;
+    id: string;
+    code: CommandErrorCode;
+    message: string;
+    details?: SchemaValidationError[];
+};
+/** A command as listed for menus, palettes and agents. */
+interface CommandEntry {
+    id: string;
+    label: string;
+    group?: string;
+    keywords?: readonly string[];
+    description?: string;
+    params?: CommandParamsSchema;
+    scope?: string;
+    /** Canonical chord text bound on the registry's platform (first = primary). */
+    shortcuts: string[];
+    enabled: boolean;
+    /** Why the command is disabled (only when `enabled` is false). */
+    disabledReason?: string;
+    undoable: boolean;
+    readOnly: boolean;
+}
+interface CommandListOptions<TContext = any> {
+    /** Only global commands plus commands of these scopes. */
+    scope?: string | readonly string[];
+    enabledOnly?: boolean;
+    includeHidden?: boolean;
+    /** Context for the enablement check (default: the registry's context). */
+    context?: TContext;
+}
+/** Minimal history surface (`HistoryManager` satisfies it). */
+interface CommandHistoryTarget {
+    batch(name: string, fn: () => void): void;
+}
+interface CommandRegistryOptions<TContext = any> {
+    /** Default context passed to `enabled` / `run` (a value or a getter). */
+    context?: TContext | (() => TContext);
+    /** Wraps `undoable` commands in one history step (see `CommandSpec.undoable`). */
+    history?: CommandHistoryTarget;
+    /** Options for the registry's `ShortcutMap`. */
+    shortcuts?: ShortcutMapOptions;
+}
+declare class CommandRegistryError extends Error {
+    readonly code: 'duplicate_command' | 'invalid_command';
+    constructor(code: CommandRegistryError['code'], message: string);
+}
+/**
+ * Registry of commands: one id per action, shared by shortcuts (`shortcuts`), the
+ * command palette (`list` + `rankCommands`) and agent tools (`createCommandToolProvider`).
+ */
+declare class CommandRegistry<TContext = any> {
+    /** Shortcut bindings of the registered commands (plus any user overrides). */
+    readonly shortcuts: ShortcutMap;
+    private readonly commands;
+    private readonly listeners;
+    private readonly options;
+    private version;
+    private muted;
+    constructor(options?: CommandRegistryOptions<TContext>);
+    /** Monotonic counter bumped on every change (useful as a snapshot key). */
+    getVersion(): number;
+    /** The default context. */
+    get context(): TContext;
+    /**
+     * Registers a command (or several) and returns a function that unregisters it.
+     * Throws a `CommandRegistryError` for a duplicate or invalid id, or invalid chord text.
+     */
+    register(spec: CommandSpec<TContext> | readonly CommandSpec<TContext>[]): () => void;
+    /** Removes a command by id. Returns whether it was registered. */
+    unregister(id: string): boolean;
+    private unbindQuietly;
+    has(id: string): boolean;
+    get(id: string): CommandSpec<TContext> | undefined;
+    /** Registered ids in registration order. */
+    ids(): string[];
+    /** Whether `id` can run now (`{ enabled, reason }`); `params` are the targets a caller named. */
+    isEnabled(id: string, params?: unknown, context?: TContext): {
+        enabled: boolean;
+        reason?: string;
+    };
+    /** Commands for menus, palettes and agents, with their current enablement. */
+    list(options?: CommandListOptions<TContext>): CommandEntry[];
+    private check;
+    private invoke;
+    /**
+     * Runs a command synchronously and returns a structured result; never throws.
+     * A command whose `run` returns a promise yields `{ ok: true, result: promise }`
+     * (use `executeAsync` to await it and catch its rejection).
+     */
+    execute<T = unknown>(id: string, params?: unknown, context?: TContext): CommandResult<T>;
+    /** Like `execute`, but awaits async commands (rejections become `failed` results). */
+    executeAsync<T = unknown>(id: string, params?: unknown, context?: TContext): Promise<CommandResult<T>>;
+    /**
+     * Resolves a keydown event to a command (see `ShortcutMap.resolve`) and runs it when
+     * enabled, calling `preventDefault()`. Disabled commands leave the event alone, so the
+     * browser or a focused editor can still handle it. Returns the result, or `null`.
+     */
+    handleKeyDown(event: KeyboardEventLike, options?: ShortcutResolveOptions & {
+        context?: TContext;
+    }): CommandResult | null;
+    /** Display-ready primary shortcut of a command (`⇧⌘Z` / `Ctrl+Shift+Z`), or `undefined`. */
+    shortcutFor(id: string, platform?: Platform): string | undefined;
+    /**
+     * Subscribes to changes: commands registered or removed, shortcut overrides, executed
+     * commands and `invalidate()` calls (e.g. when enablement inputs change).
+     */
+    subscribe(listener: () => void): () => void;
+    /** Tells subscribers that enablement may have changed (e.g. the selection changed). */
+    invalidate(): void;
+    private notify;
+}
+declare function createCommandRegistry<TContext = any>(options?: CommandRegistryOptions<TContext>): CommandRegistry<TContext>;
+/** Identity helper that types a command spec. */
+declare function defineCommand<TContext = any, TParams = any, TResult = unknown>(spec: CommandSpec<TContext, TParams, TResult>): CommandSpec<TContext, TParams, TResult>;
+
+export { formatShortcut as A, isEditableEventTarget as B, CommandRegistry as C, keyToCode as D, type EffectiveChord as E, normalizeChord as F, parseChord as G, shortcutCode as H, toShortcutBindings as I, type KeyboardEventLike as K, type Platform as P, type ShortcutBinding as S, type CommandResult as a, type CommandEntry as b, type CommandSpec as c, type Chord as d, type CommandErrorCode as e, type CommandHistoryTarget as f, type CommandListOptions as g, type CommandParamsSchema as h, CommandRegistryError as i, type CommandRegistryOptions as j, PLATFORMS as k, type ShortcutConflict as l, type ShortcutInput as m, ShortcutMap as n, type ShortcutMapOptions as o, type ShortcutMatch as p, type ShortcutResolveOptions as q, chordToString as r, codeFromKey as s, codeToKeyText as t, createCommandRegistry as u, defineCommand as v, detectPlatform as w, effectiveChord as x, effectiveChordKey as y, eventCode as z };

package/dist/schema-DYDGdYL9.d.cts

@@ -0,0 +1,41 @@
+/**
+ * JSON-Schema-lite: the subset of JSON Schema used by MCP tool `inputSchema`s,
+ * plus a small validator for tool-call arguments. Unknown keywords are ignored.
+ */
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+interface JsonSchema {
+    type?: JsonSchemaType | readonly JsonSchemaType[];
+    description?: string;
+    title?: string;
+    enum?: readonly unknown[];
+    const?: unknown;
+    default?: unknown;
+    properties?: {
+        readonly [key: string]: JsonSchema;
+    };
+    required?: readonly string[];
+    additionalProperties?: boolean | JsonSchema;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    [keyword: string]: unknown;
+}
+interface SchemaValidationError {
+    /** JSON-pointer-like path to the offending value, e.g. `/node/id` (`""` is the root). */
+    path: string;
+    message: string;
+}
+/**
+ * Validates `value` against `schema` and returns every error found (an empty
+ * array means valid). Supports `type` (incl. arrays of types), `enum`, `const`,
+ * `properties`, `required`, `additionalProperties`, `items`, `minItems`,
+ * `maxItems`, `minimum`, `maximum`, `minLength`, `maxLength` and `pattern`.
+ */
+declare function validateJsonSchema(value: unknown, schema: JsonSchema | undefined, path?: string): SchemaValidationError[];
+
+export { type JsonSchema as J, type SchemaValidationError as S, type JsonSchemaType as a, validateJsonSchema as v };

package/dist/schema-DYDGdYL9.d.ts

@@ -0,0 +1,41 @@
+/**
+ * JSON-Schema-lite: the subset of JSON Schema used by MCP tool `inputSchema`s,
+ * plus a small validator for tool-call arguments. Unknown keywords are ignored.
+ */
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+interface JsonSchema {
+    type?: JsonSchemaType | readonly JsonSchemaType[];
+    description?: string;
+    title?: string;
+    enum?: readonly unknown[];
+    const?: unknown;
+    default?: unknown;
+    properties?: {
+        readonly [key: string]: JsonSchema;
+    };
+    required?: readonly string[];
+    additionalProperties?: boolean | JsonSchema;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    [keyword: string]: unknown;
+}
+interface SchemaValidationError {
+    /** JSON-pointer-like path to the offending value, e.g. `/node/id` (`""` is the root). */
+    path: string;
+    message: string;
+}
+/**
+ * Validates `value` against `schema` and returns every error found (an empty
+ * array means valid). Supports `type` (incl. arrays of types), `enum`, `const`,
+ * `properties`, `required`, `additionalProperties`, `items`, `minItems`,
+ * `maxItems`, `minimum`, `maximum`, `minLength`, `maxLength` and `pattern`.
+ */
+declare function validateJsonSchema(value: unknown, schema: JsonSchema | undefined, path?: string): SchemaValidationError[];
+
+export { type JsonSchema as J, type SchemaValidationError as S, type JsonSchemaType as a, validateJsonSchema as v };

package/dist/serializers/index.cjs

@@ -9,7 +9,7 @@
 
 
 
-var _chunkCL37JGFWcjs = require('../chunk-CL37JGFW.cjs');
+var _chunkSML64VJGcjs = require('../chunk-SML64VJG.cjs');
 
 
 
@@ -27,7 +27,8 @@ var _chunkCL37JGFWcjs = require('../chunk-CL37JGFW.cjs');
 
 
 
-var _chunkAA4ZEVCCcjs = require('../chunk-AA4ZEVCC.cjs');
+var _chunkXNORY7M6cjs = require('../chunk-XNORY7M6.cjs');
+require('../chunk-D27YFC46.cjs');
 
 
 
@@ -54,5 +55,5 @@ var _chunkAA4ZEVCCcjs = require('../chunk-AA4ZEVCC.cjs');
 
 
 
-exports.MARKDOWN_MENTION_SPLIT_REGEX = _chunkAA4ZEVCCcjs.MARKDOWN_MENTION_SPLIT_REGEX; exports.MENTION_REGEX = _chunkAA4ZEVCCcjs.MENTION_REGEX; exports.PIXERATE_DOCUMENT_MIME = _chunkCL37JGFWcjs.PIXERATE_DOCUMENT_MIME; exports.escapeHtml = _chunkAA4ZEVCCcjs.escapeHtml; exports.extractMentions = _chunkAA4ZEVCCcjs.extractMentions; exports.extractMentionsFromDoc = _chunkAA4ZEVCCcjs.extractMentionsFromDoc; exports.getClipboardData = _chunkCL37JGFWcjs.getClipboardData; exports.getEditorMarkdown = _chunkAA4ZEVCCcjs.getEditorMarkdown; exports.getEditorText = _chunkAA4ZEVCCcjs.getEditorText; exports.getSchemaSignature = _chunkCL37JGFWcjs.getSchemaSignature; exports.htmlToPlainText = _chunkAA4ZEVCCcjs.htmlToPlainText; exports.markdownToTipTapHtml = _chunkAA4ZEVCCcjs.markdownToTipTapHtml; exports.parseMentionSegments = _chunkAA4ZEVCCcjs.parseMentionSegments; exports.parseRichClipboardPayload = _chunkCL37JGFWcjs.parseRichClipboardPayload; exports.plainTextToParagraphHtml = _chunkCL37JGFWcjs.plainTextToParagraphHtml; exports.plainTextToSlice = _chunkAA4ZEVCCcjs.plainTextToSlice; exports.plainTextToTipTapHtml = _chunkAA4ZEVCCcjs.plainTextToTipTapHtml; exports.preprocessMarkdownFileLinks = _chunkAA4ZEVCCcjs.preprocessMarkdownFileLinks; exports.preprocessMarkdownMentions = _chunkAA4ZEVCCcjs.preprocessMarkdownMentions; exports.readRichClipboard = _chunkCL37JGFWcjs.readRichClipboard; exports.rtfToPlainText = _chunkCL37JGFWcjs.rtfToPlainText; exports.sanitizeHtml = _chunkAA4ZEVCCcjs.sanitizeHtml; exports.sanitizeImportedHtml = _chunkCL37JGFWcjs.sanitizeImportedHtml; exports.serializeRichClipboardPayload = _chunkCL37JGFWcjs.serializeRichClipboardPayload; exports.stripMarkdownCode = _chunkAA4ZEVCCcjs.stripMarkdownCode;
+exports.MARKDOWN_MENTION_SPLIT_REGEX = _chunkXNORY7M6cjs.MARKDOWN_MENTION_SPLIT_REGEX; exports.MENTION_REGEX = _chunkXNORY7M6cjs.MENTION_REGEX; exports.PIXERATE_DOCUMENT_MIME = _chunkSML64VJGcjs.PIXERATE_DOCUMENT_MIME; exports.escapeHtml = _chunkXNORY7M6cjs.escapeHtml; exports.extractMentions = _chunkXNORY7M6cjs.extractMentions; exports.extractMentionsFromDoc = _chunkXNORY7M6cjs.extractMentionsFromDoc; exports.getClipboardData = _chunkSML64VJGcjs.getClipboardData; exports.getEditorMarkdown = _chunkXNORY7M6cjs.getEditorMarkdown; exports.getEditorText = _chunkXNORY7M6cjs.getEditorText; exports.getSchemaSignature = _chunkSML64VJGcjs.getSchemaSignature; exports.htmlToPlainText = _chunkXNORY7M6cjs.htmlToPlainText; exports.markdownToTipTapHtml = _chunkXNORY7M6cjs.markdownToTipTapHtml; exports.parseMentionSegments = _chunkXNORY7M6cjs.parseMentionSegments; exports.parseRichClipboardPayload = _chunkSML64VJGcjs.parseRichClipboardPayload; exports.plainTextToParagraphHtml = _chunkSML64VJGcjs.plainTextToParagraphHtml; exports.plainTextToSlice = _chunkXNORY7M6cjs.plainTextToSlice; exports.plainTextToTipTapHtml = _chunkXNORY7M6cjs.plainTextToTipTapHtml; exports.preprocessMarkdownFileLinks = _chunkXNORY7M6cjs.preprocessMarkdownFileLinks; exports.preprocessMarkdownMentions = _chunkXNORY7M6cjs.preprocessMarkdownMentions; exports.readRichClipboard = _chunkSML64VJGcjs.readRichClipboard; exports.rtfToPlainText = _chunkSML64VJGcjs.rtfToPlainText; exports.sanitizeHtml = _chunkXNORY7M6cjs.sanitizeHtml; exports.sanitizeImportedHtml = _chunkSML64VJGcjs.sanitizeImportedHtml; exports.serializeRichClipboardPayload = _chunkSML64VJGcjs.serializeRichClipboardPayload; exports.stripMarkdownCode = _chunkXNORY7M6cjs.stripMarkdownCode;
 //# sourceMappingURL=index.cjs.map

package/dist/serializers/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"],"names":[],"mappings":"AAAA,0GAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,gsDAAC","file":"/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"}
+{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"],"names":[],"mappings":"AAAA,0GAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,gsDAAC","file":"/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"}

package/dist/serializers/index.d.cts

@@ -1,9 +1,10 @@
 import { Schema, Slice } from '@tiptap/pm/model';
-import { t as TrackedChangesView, h as MentionEntity } from '../track-changes-BSF58RK0.cjs';
+import { n as TrackedChangesView, a as MentionEntity } from '../track-changes-BK5sVf4_.cjs';
 import '@tiptap/core';
 import '@tiptap/extension-mention';
 import '@tiptap/suggestion';
 import '@tiptap/pm/state';
+import '../comment-store-BEMgVlAA.cjs';
 
 interface PlainTextOptions {
     /**

package/dist/serializers/index.d.ts

@@ -1,9 +1,10 @@
 import { Schema, Slice } from '@tiptap/pm/model';
-import { t as TrackedChangesView, h as MentionEntity } from '../track-changes-BSF58RK0.js';
+import { n as TrackedChangesView, a as MentionEntity } from '../track-changes-CDjCrwKe.js';
 import '@tiptap/core';
 import '@tiptap/extension-mention';
 import '@tiptap/suggestion';
 import '@tiptap/pm/state';
+import '../comment-store-BEMgVlAA.js';
 
 interface PlainTextOptions {
     /**

package/dist/serializers/index.js

@@ -9,7 +9,7 @@ import {
   rtfToPlainText,
   sanitizeImportedHtml,
   serializeRichClipboardPayload
-} from "../chunk-JJDLPEWL.js";
+} from "../chunk-3LV6RRPH.js";
 import {
   MARKDOWN_MENTION_SPLIT_REGEX,
   MENTION_REGEX,
@@ -27,7 +27,8 @@ import {
   preprocessMarkdownMentions,
   sanitizeHtml,
   stripMarkdownCode
-} from "../chunk-MJZBNWG7.js";
+} from "../chunk-PGNZKFQS.js";
+import "../chunk-5S3Z4PPF.js";
 export {
   MARKDOWN_MENTION_SPLIT_REGEX,
   MENTION_REGEX,

package/dist/sourcemap-C8AH3MBQ.d.cts

@@ -0,0 +1,91 @@
+import { P as PromptValues, T as Template, a as PromptDiagnostic } from './tokens-D7yXvUU6.cjs';
+
+interface ResolveTemplatesOptions {
+    bindings?: Record<string, string>;
+    maxDepth?: number;
+    /**
+     * Values for `{variable}` slots and `{?variable}` sections. When omitted,
+     * variables, defaults and section tags are left exactly as written.
+     */
+    values?: PromptValues;
+}
+/**
+ * Recursively resolves template tags `{{template_name}}` in a given text.
+ * A tag that would recurse into itself is replaced with `TEMPLATE_LOOP_ERROR`,
+ * and a tag nested deeper than `maxDepth` with `TEMPLATE_DEPTH_ERROR`; the rest
+ * of the text still resolves normally.
+ *
+ * Pass `options.values` to also fill variables (falling back to their
+ * `{name|default}`) and evaluate `{?name}…{/name}` / `{!name}…{/name}`
+ * sections, including those inside template bodies. See `resolvePrompt` for
+ * the source map and diagnostics.
+ */
+declare function resolveTemplates(text: string, templates?: Template[], options?: ResolveTemplatesOptions): string;
+/**
+ * Replaces `{variableName}` with values from a dictionary, falling back to a
+ * `{variableName|default}` when no value is supplied, and evaluates
+ * `{?name}…{/name}` / `{!name}…{/name}` sections. Variables with neither a
+ * value nor a default are left as written. Templates are not expanded.
+ */
+declare function resolveVariables(text: string, values: PromptValues): string;
+/**
+ * Extracts unique template names referenced in text.
+ */
+declare function extractTemplateNames(text: string): string[];
+/**
+ * Extracts unique variable names referenced in text, including names used by
+ * conditional section tags (`amount` for `{?amount>100}…{/amount}`).
+ * Defaults and descriptions are stripped.
+ */
+declare function extractVariableNames(text: string): string[];
+/**
+ * Extracts unique instruction names referenced in text.
+ */
+declare function extractInstructionNames(text: string): string[];
+
+/**
+ * One contiguous piece of resolved output and the raw range it came from.
+ *
+ * - `raw`: copied verbatim; offsets map character by character.
+ * - `template`: the expansion of a `{{template}}` tag.
+ * - `variable`: a substituted value or `|default` for a `{variable}` tag.
+ * - `conditional`: a section tag, or a whole removed section. These segments
+ *   are empty in the resolved text (`resolvedStart === resolvedEnd`).
+ *
+ * Offsets inside non-raw segments map to the start of their raw range.
+ */
+interface SourceMapSegment {
+    resolvedStart: number;
+    resolvedEnd: number;
+    source: "raw" | "template" | "variable" | "conditional";
+    rawStart: number;
+    rawEnd: number;
+    templateName?: string;
+    /** Variable substituted (`variable`) or tested (`conditional`). */
+    variableName?: string;
+    /** For `variable` segments: whether a supplied value or the default was used. */
+    valueSource?: "value" | "default";
+}
+/**
+ * Resolves templates in text while tracking character offset mapping
+ * between the raw input and the fully resolved output.
+ *
+ * Pass `options.values` to also substitute variables and evaluate conditional
+ * sections (see `resolvePrompt`); without it the output is unchanged from the
+ * template-only behavior.
+ */
+declare function resolveTemplatesWithMapping(text: string, templates?: Template[], templateBindings?: Record<string, string>, options?: Pick<ResolveTemplatesOptions, "maxDepth" | "values">): {
+    text: string;
+    map: SourceMapSegment[];
+    diagnostics: PromptDiagnostic[];
+};
+/**
+ * Maps an offset in resolved text back to the corresponding offset in raw text.
+ */
+declare function mapResolvedOffsetToRaw(resolvedOffset: number, map: SourceMapSegment[]): number;
+/**
+ * Maps an offset in raw text to the corresponding offset in resolved text.
+ */
+declare function mapRawOffsetToResolved(rawOffset: number, map: SourceMapSegment[]): number;
+
+export { type ResolveTemplatesOptions as R, type SourceMapSegment as S, extractTemplateNames as a, extractVariableNames as b, mapResolvedOffsetToRaw as c, resolveTemplatesWithMapping as d, extractInstructionNames as e, resolveVariables as f, mapRawOffsetToResolved as m, resolveTemplates as r };