@owomark/core 0.1.5 → 0.1.7

package/dist/public-zMo7BR9l.d.ts

@@ -0,0 +1,469 @@
+/** A position within a specific block. */
+type VirtualPosition = {
+    blockId: string;
+    offset: number;
+};
+/** A selection expressed as two virtual positions. */
+type VirtualSelection = {
+    anchor: VirtualPosition;
+    focus: VirtualPosition;
+};
+/** Convert a linear character offset to a VirtualPosition. */
+declare function linearToVirtualPosition(doc: OwoMarkDocument, linearOffset: number): VirtualPosition;
+/** Convert a linear OwoMarkSelection to a VirtualSelection. */
+declare function linearToVirtual(doc: OwoMarkDocument, selection: OwoMarkSelection): VirtualSelection;
+/** Convert a VirtualPosition to a linear character offset. */
+declare function virtualPositionToLinear(doc: OwoMarkDocument, vpos: VirtualPosition): number;
+/** Convert a VirtualSelection to a linear OwoMarkSelection. */
+declare function virtualToLinear(doc: OwoMarkDocument, vsel: VirtualSelection): OwoMarkSelection;
+/** Check if two virtual positions point to the same location. */
+declare function virtualPositionsEqual(a: VirtualPosition, b: VirtualPosition): boolean;
+/** Check if a virtual selection is collapsed (cursor, no range). */
+declare function isVirtualSelectionCollapsed(vsel: VirtualSelection): boolean;
+/** Get the block index for a VirtualPosition, or -1 if not found. */
+declare function getBlockIndexForPosition(doc: OwoMarkDocument, vpos: VirtualPosition): number;
+
+type BlockType = 'paragraph' | 'heading' | 'unordered-list' | 'ordered-list' | 'blockquote' | 'code-fence' | 'side-annotation' | 'side-note-definition' | 'directive-container' | 'custom-block' | 'thematic-break' | 'math-block' | 'table' | 'html-block' | 'reference-definition';
+type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+type Leaf = {
+    text: string;
+};
+type DecoratorType = InlineTokenType;
+type Decorator = {
+    type: DecoratorType;
+    style?: string;
+    syntaxKey?: string;
+    leaves: Leaf[];
+};
+type ContainerKind = 'blockquote' | 'unordered-list' | 'ordered-list' | 'list-item';
+type ContainerFrame = {
+    kind: ContainerKind;
+    depth: number;
+    markerRaw: string;
+};
+type SideAnnotationSourceKind = 'inline' | 'continuation-chain' | 'container' | 'reference-container';
+type SideAnnotationMemberBlockType = 'paragraph' | 'heading' | 'unordered-list' | 'ordered-list' | 'blockquote' | 'code-fence' | 'directive-container' | 'custom-block' | 'thematic-break' | 'math-block' | 'table' | 'html-block' | 'reference-definition';
+type SideAnnotationMemberBlock = {
+    type: SideAnnotationMemberBlockType;
+    raw: string;
+    syntaxRaw: string;
+    depth: number;
+    ancestry: ContainerFrame[];
+    customBlockKey?: string | null;
+    customBlockAttributes?: Record<string, JsonValue> | null;
+    headingLevel?: HeadingLevel;
+    language?: string | null;
+    directiveName?: string | null;
+    referenceLabel?: string | null;
+    referenceDestination?: string | null;
+    referenceTitle?: string | null;
+};
+type BlockBase = {
+    raw: string;
+    /**
+     * `syntaxRaw` strips surrounding container prefixes that belong to ancestor
+     * containers rather than the block's own syntax.
+     */
+    syntaxRaw: string;
+    id: string;
+    sourceKey: string;
+    startLine: number;
+    endLine: number;
+    depth: number;
+    ancestry: ContainerFrame[];
+    decorators: Decorator[];
+    tokenizationContextKey: string;
+};
+type BlockNode = (BlockBase & {
+    type: 'heading';
+    headingLevel: HeadingLevel;
+}) | (BlockBase & {
+    type: 'code-fence';
+    language: string;
+    isFenceBoundary?: boolean;
+}) | (BlockBase & {
+    type: 'side-annotation';
+    sideAnnotationKind: SideAnnotationSourceKind;
+    sideType: string;
+    sideTypeSymbol: string;
+    annotationText: string | null;
+    noteRef?: string | null;
+    orphan?: boolean;
+    members: SideAnnotationMemberBlock[];
+}) | (BlockBase & {
+    type: 'side-note-definition';
+    sideNoteId: string;
+    sideType: string;
+    sideTypeSymbol: string;
+    content: string;
+}) | (BlockBase & {
+    type: 'directive-container';
+    directiveName: string;
+}) | (BlockBase & {
+    type: 'custom-block';
+    customBlockKey: string;
+    customBlockRuntime: CustomBlockRuntimeBinding;
+    customBlockAttributes: Record<string, JsonValue>;
+}) | (BlockBase & {
+    type: 'reference-definition';
+    referenceLabel: string;
+    referenceDestination: string;
+    referenceTitle?: string | null;
+}) | (BlockBase & {
+    type: 'math-block';
+}) | (BlockBase & {
+    type: 'table';
+}) | (BlockBase & {
+    type: 'html-block';
+}) | (BlockBase & {
+    type: 'paragraph' | 'unordered-list' | 'ordered-list' | 'blockquote' | 'thematic-break';
+});
+type ConformanceInlineNode = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'strong';
+    children: ConformanceInlineNode[];
+} | {
+    kind: 'emphasis';
+    children: ConformanceInlineNode[];
+} | {
+    kind: 'delete';
+    children: ConformanceInlineNode[];
+} | {
+    kind: 'inlineCode';
+    text: string;
+} | {
+    kind: 'inlineMath';
+    text: string;
+} | {
+    kind: 'html';
+    text: string;
+} | {
+    kind: 'link';
+    children: ConformanceInlineNode[];
+    url: string;
+} | {
+    kind: 'image';
+    alt: ConformanceInlineNode[];
+    url: string;
+};
+type ConformanceTableCell = {
+    inline: ConformanceInlineNode[];
+};
+type ConformanceTableRow = {
+    cells: ConformanceTableCell[];
+};
+type ConformanceContainerNode = {
+    kind: 'blockquote' | 'unordered-list' | 'ordered-list' | 'list-item';
+    depth: number;
+};
+type ConformanceBlockNode = {
+    kind: 'paragraph';
+    ancestry: ConformanceContainerNode[];
+    inline: ConformanceInlineNode[];
+} | {
+    kind: 'heading';
+    ancestry: ConformanceContainerNode[];
+    depth: 1 | 2 | 3 | 4 | 5 | 6;
+    inline: ConformanceInlineNode[];
+} | {
+    kind: 'blockquote';
+    ancestry: ConformanceContainerNode[];
+    depth: number;
+    inline: ConformanceInlineNode[];
+} | {
+    kind: 'listItem';
+    ancestry: ConformanceContainerNode[];
+    ordered: boolean;
+    task: 'checked' | 'unchecked' | null;
+    inline: ConformanceInlineNode[];
+} | {
+    kind: 'table';
+    ancestry: ConformanceContainerNode[];
+    rows: ConformanceTableRow[];
+} | {
+    kind: 'codeFence';
+    ancestry: ConformanceContainerNode[];
+    language: string | null;
+    lines: string[];
+} | {
+    kind: 'mathBlock';
+    ancestry: ConformanceContainerNode[];
+    lines: string[];
+} | {
+    kind: 'htmlBlock';
+    ancestry: ConformanceContainerNode[];
+    raw: string;
+} | {
+    kind: 'thematicBreak';
+    ancestry: ConformanceContainerNode[];
+};
+type ConformanceDocument = {
+    blocks: ConformanceBlockNode[];
+};
+type OwoMarkDocumentTrace = {
+    blockIds: string[];
+    blockTypes: BlockType[];
+    tokenizationContextKeys: string[];
+    referenceDefinitionCount: number;
+};
+type OwoMarkDocument = {
+    blocks: BlockNode[];
+    conformance: ConformanceDocument;
+    referenceDefinitions: MarkdownReferenceDefinition[];
+    trace: OwoMarkDocumentTrace;
+    previewBlocks: PreviewBlock[];
+};
+type OwoMarkSelection = {
+    anchor: number;
+    focus: number;
+};
+type CompositionState = {
+    active: boolean;
+    range: VirtualSelection | null;
+};
+declare const INLINE_TOKEN_TYPES: readonly ["text", "strong-marker", "strong", "emphasis-marker", "emphasis", "custom-inline-marker", "custom-inline", "code-marker", "code", "link-bracket", "link-text", "link-url", "reference-bracket", "reference-label", "image-marker", "image-alt", "image-url", "heading-marker", "list-marker", "task-marker", "task-marker-checked", "table-separator", "blockquote-marker", "fence-marker", "fence-lang", "code-block-text", "strikethrough-marker", "strikethrough", "math-marker", "math-text", "hr", "html"];
+type InlineTokenType = (typeof INLINE_TOKEN_TYPES)[number];
+declare const CLASSLESS_INLINE_TOKEN_TYPES: readonly ["text"];
+type InlineToken = {
+    type: InlineTokenType;
+    text: string;
+    start: number;
+    end: number;
+    syntaxKey?: string;
+};
+type MarkdownReferenceDefinition = {
+    label: string;
+    destination: string;
+    title?: string | null;
+};
+type InlineScannerMatch = {
+    end: number;
+    tokens: InlineToken[];
+};
+type ParserExtensionScope = 'inline' | 'block' | 'container-block';
+type ParserDiffScope = 'characterization' | 'reference-diff';
+type ParserExtensionConsumer = 'preview' | 'editor' | 'shared-state' | 'processor';
+type InlineExtensionPriority = 'before-code-span' | 'before-link' | 'before-emphasis';
+type InlineExtensionHostBlockType = 'paragraph' | 'heading' | 'unordered-list' | 'ordered-list' | 'blockquote' | 'table';
+type InlineSyntaxExtension = {
+    key: string;
+    scope: 'inline';
+    priority: InlineExtensionPriority;
+    canNestIn: readonly InlineExtensionHostBlockType[];
+    closingRule: 'matched-delimiter';
+    degradePolicy: 'emit-text-when-unclosed';
+    diffScope: ParserDiffScope;
+    consumerImpact: 'decorators-expose-syntax-key';
+    matcher: (raw: string, index: number, baseOffset: number) => InlineScannerMatch | null;
+};
+type ParserExtensionParent = 'root' | InlineExtensionHostBlockType | 'list-item' | 'code-fence' | 'side-annotation' | 'side-note-definition' | 'directive-container' | 'custom-block' | 'thematic-break' | 'math-block' | 'html-block' | 'reference-definition';
+type ParserExtensionContext = {
+    lines: readonly string[];
+    startIndex: number;
+    offset: number;
+    line: string;
+    syntaxLine: string;
+    containerPrefix: string;
+    ancestry: ContainerFrame[];
+    parent: ParserExtensionParent;
+};
+type CustomBlockRuntimeBinding = {
+    key: string;
+    previewKind: 'custom';
+    sharedStateDirtyReason: 'custom-block-change';
+    processorFallback: 'render-raw' | 'skip-block' | 'unwrap-children';
+    attributeKeys?: readonly string[];
+};
+type StructuredSyntaxLine = {
+    raw: string;
+    syntax: string;
+    prefixLength: number;
+};
+type ParserCustomBlockMatch = {
+    raw: string;
+    syntaxRaw: string;
+    lines?: readonly StructuredSyntaxLine[];
+    attributes?: Record<string, JsonValue>;
+};
+type ParserExtensionMatch = {
+    nextIndex: number;
+    block: ParserCustomBlockMatch;
+};
+type BlockExtensionPriority = 'after-container-prefix' | 'before-paragraph-fallback';
+type ContainerBlockExtensionPriority = 'after-container-prefix' | 'before-paragraph-fallback';
+type BlockSyntaxExtension = {
+    key: string;
+    scope: 'block';
+    priority: BlockExtensionPriority;
+    canNestIn: readonly ParserExtensionParent[];
+    closingRule: 'single-line' | 'blank-line' | 'explicit-closer' | 'matched-delimiter';
+    degradePolicy: 'emit-paragraph' | 'emit-raw';
+    diffScope: ParserDiffScope;
+    consumerImpact: readonly ParserExtensionConsumer[];
+    runtime?: CustomBlockRuntimeBinding | null;
+    match: (context: ParserExtensionContext) => ParserExtensionMatch | null;
+};
+type ContainerBlockSyntaxExtension = {
+    key: string;
+    scope: 'container-block';
+    priority: ContainerBlockExtensionPriority;
+    canNestIn: readonly ParserExtensionParent[];
+    canContain: readonly BlockType[];
+    closingRule: 'indent-dedent' | 'blank-line' | 'explicit-closer' | 'matched-delimiter';
+    degradePolicy: 'emit-paragraph' | 'emit-raw' | 'unwrap-children';
+    diffScope: ParserDiffScope;
+    consumerImpact: readonly ParserExtensionConsumer[];
+    runtime?: CustomBlockRuntimeBinding | null;
+    match: (context: ParserExtensionContext) => ParserExtensionMatch | null;
+};
+type TokenizeInlineOptions = {
+    extensions?: readonly InlineSyntaxExtension[];
+    blockType?: InlineExtensionHostBlockType;
+    referenceDefinitions?: readonly MarkdownReferenceDefinition[];
+};
+type TokenizeBlockExtensionOptions = {
+    extensions?: readonly BlockSyntaxExtension[];
+    containerExtensions?: readonly ContainerBlockSyntaxExtension[];
+};
+type TokenizeBlockOptions = {
+    inline?: TokenizeInlineOptions;
+    block?: TokenizeBlockExtensionOptions;
+};
+type ParseMarkdownOptions = {
+    inline?: TokenizeInlineOptions;
+    block?: TokenizeBlockExtensionOptions;
+};
+/**
+ * Extended block type for host consumption.
+ * Derived from BlockType — remaps code-fence to code-block
+ * and adds empty for blank paragraphs.
+ */
+type BlockContextType = Exclude<BlockType, 'code-fence'> | 'code-block' | 'empty';
+/**
+ * Rich block context at the current cursor position.
+ * Hosts consume this instead of implementing their own block identification.
+ */
+type BlockContext = {
+    /** High-level block category at cursor */
+    type: BlockContextType;
+    /** Heading level (1-6) when type is 'heading' */
+    headingLevel?: HeadingLevel;
+    /** Code fence language when type is 'code-block' */
+    language?: string;
+    /** Nesting depth (lists, blockquotes) */
+    depth: number;
+    /** Block index in document */
+    blockIndex: number;
+    /** Stable block ID */
+    blockId: string;
+};
+type BlockContextListener = (context: BlockContext) => void;
+/**
+ * Block types that can be inserted via toolbar or command palette.
+ * Maps directly to dispatch command IDs.
+ */
+type BlockInsertType = 'code-fence' | 'blockquote' | 'math' | 'table' | 'image' | 'thematic-break';
+type OwoMarkCommands = {
+    focus(): void;
+    undo(): void;
+    redo(): void;
+    toggleBold(): void;
+    toggleItalic(): void;
+    insertLink(url?: string): void;
+    insertCodeFence(language?: string): void;
+    insertMath(): void;
+    insertSideAnnotation(type?: string): void;
+    getMarkdown(): string;
+    setMarkdown(markdown: string): void;
+    /** Replace markdown with explicit selection target and undo support. */
+    replaceMarkdown(markdown: string, selection: OwoMarkSelection): void;
+};
+type DirtyRange = {
+    startBlock: number;
+    endBlock: number;
+};
+type PreviewBlockKind = 'paragraph' | 'heading' | 'unordered-list' | 'ordered-list' | 'blockquote' | 'code-fence' | 'thematic-break' | 'table' | 'math-block' | 'html-block' | 'custom';
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type PreviewBlock = {
+    /**
+     * Content-based identity: `{renderKey}#{occurrenceIndex}`.
+     * Stable across blank line edits — only changes when block content changes.
+     * Used as the DOM wrapper lifecycle key by the virtual preview engine.
+     * For line-range positional mapping (scroll sync), use startLine/endLine.
+     */
+    blockId: string;
+    kind: PreviewBlockKind;
+    raw: string;
+    startLine: number;
+    endLine: number;
+    renderKey: string;
+    language?: string | null;
+    headingLevel?: HeadingLevel;
+    attributes?: Record<string, JsonValue>;
+};
+/**
+ * A block transform enriches PreviewBlocks during projection.
+ *
+ * Transforms run in `projectToPreviewBlocks` — the single source of truth
+ * for both preview rendering and static build. This guarantees identical
+ * block output in both pipelines.
+ *
+ * Examples: image size extraction, custom block attribute injection.
+ */
+type BlockTransform = (block: PreviewBlock) => PreviewBlock;
+type PreviewDirtyReason = 'text-edit' | 'structure-edit' | 'theme-change' | 'renderer-change' | 'custom-block-change' | 'full-rebuild';
+type OwoMarkSharedState = {
+    document: OwoMarkDocument;
+    previewBlocks: PreviewBlock[];
+    dirtyRange: DirtyRange | null;
+    dirtyReason: PreviewDirtyReason | null;
+    selection: OwoMarkSelection | null;
+    compositionActive: boolean;
+    visibleBlockIds: string[];
+    /** Bumps only when preview-relevant state changes. */
+    version: number;
+    /** Bumps only when markdown / preview block content changes. */
+    contentVersion: number;
+    /** Bumps only when editor UI state changes (selection/composition). */
+    uiVersion: number;
+    markdown: string;
+};
+type OwoMarkSharedStateStore = {
+    getState(): OwoMarkSharedState;
+    subscribe(listener: (state: OwoMarkSharedState) => void): () => void;
+    subscribeWithSelector<T>(selector: (state: OwoMarkSharedState) => T, listener: (selected: T, state: OwoMarkSharedState) => void, isEqual?: (prev: T, next: T) => boolean): () => void;
+};
+/**
+ * Minimal interface for connecting to shared state.
+ * Both OwoMarkCore and browser-host editor adapters satisfy this.
+ */
+type OwoMarkEditorLike = {
+    getMarkdown(): string;
+    setMarkdown(markdown: string): void;
+    onChange(callback: (markdown: string) => void): () => void;
+    onSelectionChange(callback: (selection: OwoMarkSelection) => void): () => void;
+    onCompositionStateChange(callback: (active: boolean) => void): () => void;
+};
+type OwoMarkSharedStateController = OwoMarkSharedStateStore & {
+    setMarkdown(markdown: string): void;
+    updateVisibleBlockIds(ids: string[]): void;
+    getEditorInstance(): OwoMarkEditorLike | null;
+    connectEditor(instance: OwoMarkEditorLike): () => void;
+    /** Change theme key, re-derive all renderKeys, and emit 'theme-change'. */
+    setThemeKey(themeKey: string): void;
+    /** Signal that the host renderer pipeline changed. Invalidates all blocks. */
+    notifyRendererChange(): void;
+    /** Signal that a custom block plugin changed. Invalidates all blocks. */
+    notifyCustomBlockChange(): void;
+};
+type HistoryEntry = {
+    markdown: string;
+    selection: OwoMarkSelection;
+};
+
+export { type ParserExtensionParent as $, type ContainerKind as A, type BlockType as B, type CompositionState as C, type DirtyRange as D, type CustomBlockRuntimeBinding as E, type Decorator as F, type DecoratorType as G, type HeadingLevel as H, type InlineTokenType as I, type JsonValue as J, type HistoryEntry as K, INLINE_TOKEN_TYPES as L, type InlineExtensionHostBlockType as M, type InlineScannerMatch as N, type OwoMarkSelection as O, type PreviewBlockKind as P, type JsonPrimitive as Q, type Leaf as R, type OwoMarkCommands as S, type TokenizeInlineOptions as T, type OwoMarkDocumentTrace as U, type VirtualSelection as V, type OwoMarkEditorLike as W, type OwoMarkSharedState as X, type OwoMarkSharedStateStore as Y, type ParserDiffScope as Z, type ParserExtensionConsumer as _, type OwoMarkDocument as a, type ParserExtensionScope as a0, type PreviewDirtyReason as a1, type SideAnnotationMemberBlock as a2, type SideAnnotationMemberBlockType as a3, type SideAnnotationSourceKind as a4, type TokenizeBlockExtensionOptions as a5, type VirtualPosition as a6, getBlockIndexForPosition as a7, isVirtualSelectionCollapsed as a8, linearToVirtual as a9, linearToVirtualPosition as aa, virtualPositionToLinear as ab, virtualPositionsEqual as ac, virtualToLinear as ad, type BlockContext as b, type BlockInsertType as c, type BlockContextListener as d, type InlineToken as e, type PreviewBlock as f, type BlockNode as g, type BlockContextType as h, type ContainerBlockSyntaxExtension as i, type ParseMarkdownOptions as j, type ConformanceDocument as k, type BlockTransform as l, type OwoMarkSharedStateController as m, type InlineExtensionPriority as n, type InlineSyntaxExtension as o, type TokenizeBlockOptions as p, type BlockExtensionPriority as q, type BlockSyntaxExtension as r, CLASSLESS_INLINE_TOKEN_TYPES as s, type ConformanceBlockNode as t, type ConformanceContainerNode as u, type ConformanceInlineNode as v, type ConformanceTableCell as w, type ConformanceTableRow as x, type ContainerBlockExtensionPriority as y, type ContainerFrame as z };

package/dist/registry-C849sxCo.d.ts

@@ -0,0 +1,74 @@
+import { P as PreviewBlockKind } from './public-zMo7BR9l.js';
+
+type OwoFeatureFlagKey = 'enableSideAnnotation' | 'enableMath' | 'enableComponents';
+type OwoSemanticDescriptorFamily = 'syntax' | 'component' | 'runtime' | 'editor';
+type OwoDescriptorBase = {
+    key: string;
+    family: OwoSemanticDescriptorFamily;
+    specIds: readonly string[];
+    featureFlag?: OwoFeatureFlagKey | null;
+};
+type OwoSyntaxDescriptor = OwoDescriptorBase & {
+    family: 'syntax';
+    syntaxKind: 'block' | 'container-block' | 'inline' | 'support';
+    consumes: readonly ('parser' | 'processor' | 'preview' | 'rehype' | 'runtime')[];
+    aliases?: readonly string[];
+};
+type OwoComponentKind = 'block-container' | 'block-parent' | 'block-child' | 'inline-text';
+type OwoComponentPayloadStrategy = 'none' | 'single-code-block' | 'code-tabs' | 'optional-summary' | 'inline-text';
+type OwoComponentDescriptor = OwoDescriptorBase & {
+    family: 'component';
+    directiveName: string;
+    componentName: string;
+    componentKind: OwoComponentKind;
+    allowedAttrs: readonly string[];
+    requiredAttrs: readonly string[];
+    requiredParent: string | null;
+    allowedChildDirectives: readonly string[];
+    payloadStrategy: OwoComponentPayloadStrategy;
+};
+type OwoRuntimeProjectionStrategy = 'plain' | 'group-adjacent' | 'custom-single' | 'custom-grouped';
+type OwoRuntimeBlockDescriptor = OwoDescriptorBase & {
+    family: 'runtime';
+    blockType: string;
+    previewKind: PreviewBlockKind;
+    customBlockKey?: string | null;
+    projectionStrategy: OwoRuntimeProjectionStrategy;
+    rendererMode: 'html-worker-safe' | 'dom-main-thread';
+    rendererPriority: 'realtime' | 'deferred';
+    workerRendererId?: string | null;
+    heavy?: boolean;
+    processorFallback?: 'render-raw' | 'skip-block' | 'unwrap-children' | null;
+    attributeKeys?: readonly string[] | null;
+    sharedStateDirtyReason?: 'custom-block-change' | null;
+};
+type OwoEditorEntryPresentation = {
+    label: string;
+    category: string;
+};
+type OwoEditorEntryDescriptor = OwoDescriptorBase & {
+    family: 'editor';
+    commandId: string;
+    entryKind: 'block' | 'insert' | 'format' | 'component';
+    labelKey: string;
+    categoryKey: string;
+    keywords: readonly string[];
+    slashMenu: boolean;
+    toolbarEligible: boolean;
+    priority?: number;
+    shortcut?: string;
+    descriptionKey?: string;
+    templateKey?: string | null;
+};
+
+type RegistryDescriptor = {
+    key: string;
+};
+type OwoDescriptorRegistry<TDescriptor extends RegistryDescriptor> = {
+    list(): readonly TDescriptor[];
+    get(key: string): TDescriptor | undefined;
+};
+declare function createDescriptorRegistry<TDescriptor extends RegistryDescriptor>(descriptors: readonly TDescriptor[], familyName: string): OwoDescriptorRegistry<TDescriptor>;
+declare function requireDescriptor<TDescriptor extends RegistryDescriptor>(registry: OwoDescriptorRegistry<TDescriptor>, key: string, familyName: string): TDescriptor;
+
+export { type OwoComponentDescriptor as O, type OwoComponentKind as a, type OwoComponentPayloadStrategy as b, type OwoDescriptorRegistry as c, type OwoEditorEntryDescriptor as d, type OwoEditorEntryPresentation as e, type OwoFeatureFlagKey as f, type OwoRuntimeBlockDescriptor as g, type OwoSyntaxDescriptor as h, createDescriptorRegistry as i, requireDescriptor as r };

package/dist/semantic/components/index.d.ts

@@ -0,0 +1,9 @@
+import { c as OwoDescriptorRegistry, O as OwoComponentDescriptor } from '../../registry-C849sxCo.js';
+export { a as OwoComponentKind, b as OwoComponentPayloadStrategy } from '../../registry-C849sxCo.js';
+import '../../public-zMo7BR9l.js';
+
+declare const componentRegistry: OwoDescriptorRegistry<OwoComponentDescriptor>;
+declare function getComponentDescriptor(key: string): OwoComponentDescriptor;
+declare function getComponentDescriptorByDirective(directiveName: string): OwoComponentDescriptor | undefined;
+
+export { OwoComponentDescriptor, componentRegistry, getComponentDescriptor, getComponentDescriptorByDirective };

package/dist/semantic/components/index.js

@@ -0,0 +1,11 @@
+import {
+  componentRegistry,
+  getComponentDescriptor,
+  getComponentDescriptorByDirective
+} from "../../chunk-WXVKSKP3.js";
+import "../../chunk-OOH46GIF.js";
+export {
+  componentRegistry,
+  getComponentDescriptor,
+  getComponentDescriptorByDirective
+};

package/dist/semantic/editor/index.d.ts

@@ -0,0 +1,9 @@
+import { c as OwoDescriptorRegistry, d as OwoEditorEntryDescriptor, e as OwoEditorEntryPresentation } from '../../registry-C849sxCo.js';
+import '../../public-zMo7BR9l.js';
+
+declare const editorEntryRegistry: OwoDescriptorRegistry<OwoEditorEntryDescriptor>;
+declare function getEditorEntryDescriptor(key: string): OwoEditorEntryDescriptor;
+declare function getEditorEntryDescriptorByCommandId(commandId: string): OwoEditorEntryDescriptor | undefined;
+declare function resolveEditorEntryPresentation(descriptor: OwoEditorEntryDescriptor): OwoEditorEntryPresentation;
+
+export { editorEntryRegistry, getEditorEntryDescriptor, getEditorEntryDescriptorByCommandId, resolveEditorEntryPresentation };

package/dist/semantic/editor/index.js

@@ -0,0 +1,13 @@
+import {
+  editorEntryRegistry,
+  getEditorEntryDescriptor,
+  getEditorEntryDescriptorByCommandId,
+  resolveEditorEntryPresentation
+} from "../../chunk-3KTK7CSS.js";
+import "../../chunk-OOH46GIF.js";
+export {
+  editorEntryRegistry,
+  getEditorEntryDescriptor,
+  getEditorEntryDescriptorByCommandId,
+  resolveEditorEntryPresentation
+};

package/dist/semantic/index.d.ts

@@ -0,0 +1,7 @@
+export { O as OwoComponentDescriptor, a as OwoComponentKind, b as OwoComponentPayloadStrategy, c as OwoDescriptorRegistry, d as OwoEditorEntryDescriptor, e as OwoEditorEntryPresentation, f as OwoFeatureFlagKey, g as OwoRuntimeBlockDescriptor, h as OwoSyntaxDescriptor, i as createDescriptorRegistry, r as requireDescriptor } from '../registry-C849sxCo.js';
+export { validateComponentDescriptors, validateEditorEntryDescriptors, validateRuntimeDescriptors, validateSyntaxDescriptors } from './shared/index.js';
+export { MATH_FENCE_RE, MULTI_LINE_MATH_BLOCK_CLOSE_RE, MULTI_LINE_MATH_BLOCK_OPEN_RE, MathFenceNormalizationLineMapping, MathFenceNormalizationRewrite, SIDE_ANNOTATION_RENDERER_KEY_BY_TYPE, SIDE_ANNOTATION_SYMBOL_BY_KEYWORD, SIDE_ANNOTATION_TAIL_RE, SIDE_ANNOTATION_TYPE_SYMBOLS, SIDE_ANNOTATION_TYPE_SYMBOLS_SORTED, SIDE_ANNOTATION_TYPE_TABLE, SIDE_CONTINUATION_TAIL_RE, SIDE_NOTE_DEFINITION_RE, SIDE_NOTE_REF_RE, SINGLE_LINE_MATH_BLOCK_RE, SideAnnotationType, SideAnnotationTypeDescriptor, SideAnnotationTypeSymbol, collectMathFenceNormalizationRewrites, getSyntaxDescriptor, isFenceOnlyMathLine, isMultiLineMathBlockClose, isMultiLineMathBlockOpen, isSingleLineMathBlock, mathSyntaxDescriptor, parseInlineSideAnnotationFromText, parseInlineSideAnnotationText, parseSideDirectiveLabel, parseSideNoteDefinitionRaw, sideAnnotationSyntaxDescriptors, sideAnnotationTypeDescriptors, stripInlineSideAnnotationTail, stripSideContinuationTail, syntaxRegistry } from './syntax/index.js';
+export { componentRegistry, getComponentDescriptor, getComponentDescriptorByDirective } from './components/index.js';
+export { getRuntimeBlockDescriptor, getRuntimeBlockDescriptorByBlockType, getRuntimeBlockDescriptorByPreviewKind, runtimeBlockRegistry } from './runtime/index.js';
+export { editorEntryRegistry, getEditorEntryDescriptor, getEditorEntryDescriptorByCommandId, resolveEditorEntryPresentation } from './editor/index.js';
+import '../public-zMo7BR9l.js';