@markput/react 0.12.0 → 0.14.0

package/index.d.ts

@@ -10763,22 +10763,144 @@ declare function annotate(markup: Markup, params: {
  */
 declare function denote(value: string, callback: (mark: MarkToken) => string, markups: Markup[]): string;
 //#endregion
-//#region ../../core/src/features/arrownav/ArrowNavFeature.d.ts
-declare class ArrowNavFeature {
+//#region ../../core/src/shared/editorContracts.d.ts
+type TokenPath = readonly number[];
+type TokenAddress = {
+  readonly path: TokenPath;
+  readonly parseGeneration: number;
+};
+type Result<T, Reason extends string> = {
+  ok: true;
+  value: T;
+} | {
+  ok: false;
+  reason: Reason;
+};
+type DomRef = (element: HTMLElement | null) => void;
+type RawRange = {
+  readonly start: number;
+  readonly end: number;
+};
+type RawSelection = {
+  readonly range: RawRange;
+  readonly direction?: 'forward' | 'backward';
+};
+type NodeLocationResult = Result<{
+  readonly address: TokenAddress;
+  readonly tokenElement: HTMLElement;
+  readonly textElement?: HTMLElement;
+  readonly rowElement?: HTMLElement;
+}, 'notIndexed' | 'outsideEditor' | 'control'>;
+type RawSelectionResult = Result<RawSelection, 'notIndexed' | 'outsideEditor' | 'control' | 'mixedBoundary' | 'invalidBoundary'>;
+type BoundaryPositionResult = Result<number, 'notIndexed' | 'outsideEditor' | 'control' | 'invalidBoundary' | 'composing'>;
+type EditResult = {
+  ok: true;
+  value: string;
+  accepted: 'immediate' | 'pendingControlledEcho';
+} | {
+  ok: false;
+  reason: 'readOnly' | 'invalidRange' | 'stale';
+};
+type CaretRecovery = {
+  readonly kind: 'caret';
+  readonly rawPosition: number;
+  readonly affinity?: 'before' | 'after';
+} | {
+  readonly kind: 'selection';
+  readonly selection: RawSelection;
+};
+type OptionalMarkFieldPatch = {
+  readonly kind: 'set';
+  readonly value: string;
+} | {
+  readonly kind: 'clear';
+};
+type MarkPatch = {
+  readonly value?: string;
+  readonly meta?: OptionalMarkFieldPatch;
+  readonly slot?: OptionalMarkFieldPatch;
+};
+type MarkSnapshot = {
+  readonly value: string;
+  readonly meta: string | undefined;
+  readonly slot: string | undefined;
+  readonly readOnly: boolean;
+};
+type MarkInfo = {
+  readonly address: TokenAddress;
+  readonly depth: number;
+  readonly hasNestedMarks: boolean;
+  readonly key: string;
+};
+type TokenShapeSnapshot = {
+  readonly kind: 'text';
+} | {
+  readonly kind: 'mark';
+  readonly descriptor: MarkupDescriptor;
+  readonly descriptorIndex: number;
+};
+type DomIndex = {
+  readonly generation: number;
+};
+type CaretLocation = {
+  readonly address: TokenAddress;
+  readonly role: 'row' | 'token' | 'text' | 'markDescendant';
+};
+type DomDiagnostic = {
+  readonly kind: 'missingRole' | 'stalePath' | 'outsideEditor' | 'controlBoundary' | 'mixedBoundary' | 'invalidBoundary' | 'renderReentry' | 'recoveryFailed' | 'missingContainer' | 'ambiguousStructure';
+  readonly path?: TokenPath;
+  readonly reason: string;
+};
+type EditSource = 'input' | 'paste' | 'cut' | 'overlay' | 'mark' | 'block' | 'drag';
+//#endregion
+//#region ../../core/src/features/caret/CaretFeature.d.ts
+declare class CaretFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  readonly recovery: Signal<CaretRecovery | undefined>;
+  readonly location: Signal<CaretLocation | undefined>;
+  readonly selecting: Signal<"drag" | "all" | undefined>;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
+  placeAt(rawPosition: number, affinity?: 'before' | 'after'): Result<void, 'notIndexed' | 'invalidBoundary'>;
+  focus(address: TokenAddress, boundary?: 'start' | 'end'): Result<void, 'notIndexed' | 'stale'>;
 }
 //#endregion
-//#region ../../core/src/features/block-editing/BlockEditFeature.d.ts
-declare class BlockEditFeature {
-  #private;
-  private readonly store;
-  constructor(store: Store);
-  enable(): void;
-  disable(): void;
+//#region ../../core/src/shared/signals/signal.d.ts
+interface Signal<T> {
+  (): T;
+  (value: T | undefined): void;
+}
+type SignalValues<T> = { [K in keyof T]: T[K] extends Signal<infer V> | Computed<infer V> ? V : T[K] };
+interface Computed<T> {
+  (): T;
+}
+interface Event<T = void> {
+  (payload: T): void;
+  read(): T | undefined;
+}
+//#endregion
+//#region ../../core/src/features/props/PropsFeature.d.ts
+declare class PropsFeature {
+  private readonly _store;
+  readonly value: Signal<string | undefined>;
+  readonly defaultValue: Signal<string | undefined>;
+  readonly onChange: Signal<((value: string) => void) | undefined>;
+  readonly options: Signal<CoreOption[]>;
+  readonly readOnly: Signal<boolean>;
+  readonly layout: Signal<"inline" | "block">;
+  readonly draggable: Signal<boolean | DraggableConfig>;
+  readonly showOverlayOn: Signal<OverlayTrigger>;
+  readonly Span: Signal<_$react.ElementType | undefined>;
+  readonly Mark: Signal<_$react.ElementType | undefined>;
+  readonly Overlay: Signal<_$react.ElementType | undefined>;
+  readonly className: Signal<string | undefined>;
+  readonly style: Signal<CSSProperties$1 | undefined>;
+  readonly slots: Signal<CoreSlots | undefined>;
+  readonly slotProps: Signal<CoreSlotProps | undefined>;
+  constructor(_store: Store);
+  set(values: Partial<SignalValues<typeof this>>): void;
 }
 //#endregion
 //#region ../../core/src/store/BlockStore.d.ts
@@ -10813,8 +10935,8 @@ declare class BlockRegistry {
   get(token: object): BlockStore;
 }
 //#endregion
-//#region ../../core/src/features/clipboard/CopyFeature.d.ts
-declare class CopyFeature {
+//#region ../../core/src/features/clipboard/ClipboardFeature.d.ts
+declare class ClipboardFeature {
   #private;
   private readonly store;
   constructor(store: Store);
@@ -10822,231 +10944,207 @@ declare class CopyFeature {
   disable(): void;
 }
 //#endregion
-//#region ../../core/src/features/drag/DragFeature.d.ts
-declare class DragFeature {
+//#region ../../core/src/features/dom/DomFeature.d.ts
+declare class DomFeature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  readonly index: Computed<DomIndex | undefined>;
+  readonly container: Signal<HTMLElement | null>;
+  readonly diagnostics: Event<DomDiagnostic>;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
+  compositionStarted(): void;
+  compositionEnded(): void;
+  controlFor(ownerPath?: TokenPath): DomRef;
+  childrenFor(ownerPath: TokenPath): DomRef;
+  reconcile(): void;
+  locateNode(node: Node): NodeLocationResult;
+  placeCaretAtRawPosition(rawPosition: number, affinity?: 'before' | 'after'): Result<void, 'notIndexed' | 'invalidBoundary'>;
+  focusAddress(address: TokenAddress, boundary?: 'start' | 'end'): Result<void, 'notIndexed' | 'stale'>;
+  rawPositionFromBoundary(node: Node, offset: number, affinity?: 'before' | 'after'): BoundaryPositionResult;
+  readRawSelection(): RawSelectionResult;
 }
 //#endregion
-//#region ../../core/src/features/editable/ContentEditableFeature.d.ts
-declare class ContentEditableFeature {
+//#region ../../core/src/features/drag/DragFeature.d.ts
+declare class DragFeature {
   #private;
   private readonly store;
+  readonly action: Event<DragAction>;
   constructor(store: Store);
   enable(): void;
   disable(): void;
-  sync(): void;
 }
 //#endregion
-//#region ../../core/src/features/events/SystemListenerFeature.d.ts
-declare class SystemListenerFeature {
+//#region ../../core/src/features/keyboard/KeyboardFeature.d.ts
+declare class KeyboardFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
 }
 //#endregion
-//#region ../../core/src/features/focus/FocusFeature.d.ts
-declare class FocusFeature {
-  #private;
-  private readonly store;
-  constructor(store: Store);
+//#region ../../core/src/features/lifecycle/LifecycleFeature.d.ts
+declare class LifecycleFeature implements Feature {
+  readonly mounted: Event<void>;
+  readonly unmounted: Event<void>;
+  readonly rendered: Event<void>;
   enable(): void;
   disable(): void;
 }
 //#endregion
-//#region ../../core/src/shared/classes/MarkputHandler.d.ts
-declare class MarkputHandler {
+//#region ../../core/src/features/mark/MarkController.d.ts
+declare class MarkController {
+  #private;
   private readonly store;
-  constructor(store: Store);
-  get container(): HTMLDivElement | null;
-  get overlay(): HTMLElement | null;
-  focus(): void;
+  private readonly address;
+  private readonly snapshot;
+  constructor(store: Store, address: TokenAddress, snapshot: MarkSnapshot, shape: TokenShapeSnapshot);
+  static fromToken(store: Store, token: MarkToken): MarkController;
+  get value(): string;
+  get meta(): string | undefined;
+  get slot(): string | undefined;
+  get readOnly(): boolean;
+  remove(): EditResult;
+  update(patch: MarkPatch): EditResult;
 }
 //#endregion
-//#region ../../core/src/shared/classes/KeyGenerator.d.ts
-declare class KeyGenerator {
-  #private;
-  get(object: object): number | undefined;
+//#region ../../core/src/features/slots/types.d.ts
+interface MarkSlot {
+  (): (token: Token) => readonly [Slot, Record<string, unknown>];
 }
-//#endregion
-//#region ../../core/src/shared/classes/NodeProxy.d.ts
-declare class NodeProxy {
-  #private;
-  get target(): HTMLElement | undefined;
-  set target(value: Node | HTMLElement | EventTarget | undefined | null);
-  get next(): NodeProxy;
-  get prev(): NodeProxy;
-  get isSpan(): boolean;
-  get isMark(): boolean;
-  get isEditable(): boolean;
-  get isCaretAtBeginning(): boolean;
-  get isCaretAtEnd(): boolean;
-  get index(): number;
-  get caret(): number;
-  set caret(value: number);
-  get length(): number;
-  get content(): string;
-  set content(value: string | undefined);
-  get head(): HTMLElement | null;
-  get tail(): HTMLElement | null;
-  get isFocused(): boolean;
-  constructor(target: Node | EventTarget | null | undefined, store: Store);
-  setCaretToEnd(): void;
-  focus(): void;
-  clear(): void;
+interface OverlaySlot {
+  (): (option?: CoreOption, defaultComponent?: Slot) => readonly [Slot, Record<string, unknown>];
 }
 //#endregion
-//#region ../../core/src/shared/signals/signal.d.ts
-interface Signal<T> {
-  (): T;
-  (value: T | undefined): void;
-}
-type SignalValues<T> = { [K in keyof T]: T[K] extends Signal<infer V> | Computed<infer V> ? V : T[K] };
-interface Computed<T> {
-  (): T;
-}
-interface Event<T = void> {
-  (payload: T): void;
-  read(): T | undefined;
+//#region ../../core/src/features/slots/SlotsFeature.d.ts
+declare class SlotsFeature implements Feature {
+  private readonly _store;
+  readonly isBlock: Computed<boolean>;
+  readonly isDraggable: Computed<boolean>;
+  readonly containerComponent: Computed<Slot>;
+  readonly containerProps: Computed<{
+    className: string | undefined;
+    style?: CSSProperties$1;
+    [key: string]: unknown;
+  }>;
+  readonly blockComponent: Computed<Slot>;
+  readonly blockProps: Computed<Record<string, unknown> | undefined>;
+  readonly spanComponent: Computed<Slot>;
+  readonly spanProps: Computed<Record<string, unknown> | undefined>;
+  constructor(_store: Store);
+  enable(): void;
+  disable(): void;
 }
 //#endregion
-//#region ../../core/src/features/input/InputFeature.d.ts
-declare class InputFeature {
-  #private;
-  private readonly store;
-  constructor(store: Store);
+//#region ../../core/src/features/mark/MarkFeature.d.ts
+declare class MarkFeature implements Feature {
+  private readonly _store;
+  readonly enabled: Computed<boolean>;
+  readonly slot: MarkSlot;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
 }
 //#endregion
 //#region ../../core/src/features/overlay/OverlayFeature.d.ts
-declare class OverlayFeature {
+declare class OverlayFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  readonly match: Signal<OverlayMatch | undefined>;
+  readonly element: Signal<HTMLElement | null>;
+  readonly slot: OverlaySlot;
+  readonly select: Event<{
+    mark: Token;
+    match: OverlayMatch;
+  }>;
+  readonly close: Event<void>;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
 }
 //#endregion
+//#region ../../core/src/features/parsing/tokenIndex.d.ts
+type TokenIndex = {
+  readonly generation: number;
+  pathFor(token: Token): TokenPath | undefined;
+  addressFor(path: TokenPath): TokenAddress | undefined;
+  resolve(path: TokenPath): Token | undefined;
+  resolveAddress(address: TokenAddress, expected?: TokenShapeSnapshot): Result<Token, 'stale'>;
+  key(path: TokenPath): string;
+  equals(a: TokenPath, b: TokenPath): boolean;
+};
+//#endregion
 //#region ../../core/src/features/parsing/ParseFeature.d.ts
-declare class ParseFeature {
+declare class ParsingFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  readonly tokens: Signal<Token[]>;
+  readonly index: Computed<TokenIndex>;
+  readonly parser: Computed<Parser | undefined>;
+  readonly reparse: Event<void>;
+  constructor(_store: Store);
+  parseValue(value: string): Token[];
+  acceptTokens(tokens: Token[]): void;
   enable(): void;
   disable(): void;
-  sync(): void;
+  sync(value?: string): void;
 }
 //#endregion
-//#region ../../core/src/features/selection/TextSelectionFeature.d.ts
-declare class TextSelectionFeature {
+//#region ../../core/src/features/value/ValueFeature.d.ts
+declare class ValueFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  readonly current: Signal<string>;
+  readonly isControlledMode: Computed<boolean>;
+  readonly change: Event<void>;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
+  replaceRange(range: RawRange, replacement: string, options?: {
+    recover?: CaretRecovery;
+    source?: EditSource;
+  }): EditResult;
+  replaceAll(next: string, options?: {
+    recover?: CaretRecovery;
+    source?: EditSource;
+  }): EditResult;
 }
 //#endregion
-//#region ../../core/src/features/slots/types.d.ts
-interface MarkSlot {
-  (): (token: Token) => readonly [Slot, Record<string, unknown>];
+//#region ../../core/src/shared/classes/MarkputHandler.d.ts
+declare class MarkputHandler {
+  private readonly store;
+  constructor(store: Store);
+  get container(): HTMLElement | null;
+  get overlay(): HTMLElement | null;
+  focus(): void;
 }
-interface OverlaySlot {
-  (): (option?: CoreOption, defaultComponent?: Slot) => readonly [Slot, Record<string, unknown>];
+//#endregion
+//#region ../../core/src/shared/classes/KeyGenerator.d.ts
+declare class KeyGenerator {
+  #private;
+  get(object: object): number | undefined;
 }
 //#endregion
 //#region ../../core/src/store/Store.d.ts
 declare class Store {
   readonly key: KeyGenerator;
   readonly blocks: BlockRegistry;
-  readonly nodes: {
-    focus: NodeProxy;
-    input: NodeProxy;
-  };
-  readonly props: {
-    value: Signal<string | undefined>;
-    defaultValue: Signal<string | undefined>;
-    onChange: Signal<((value: string) => void) | undefined>;
-    options: Signal<CoreOption[]>;
-    readOnly: Signal<boolean>;
-    layout: Signal<"inline" | "block">;
-    draggable: Signal<boolean | DraggableConfig>;
-    showOverlayOn: Signal<OverlayTrigger>;
-    Span: Signal<_$react.ElementType | undefined>;
-    Mark: Signal<_$react.ElementType | undefined>;
-    Overlay: Signal<_$react.ElementType | undefined>;
-    className: Signal<string | undefined>;
-    style: Signal<CSSProperties$1 | undefined>;
-    slots: Signal<CoreSlots | undefined>;
-    slotProps: Signal<CoreSlotProps | undefined>;
-  };
-  readonly state: {
-    tokens: Signal<Token[]>;
-    previousValue: Signal<string | undefined>;
-    innerValue: Signal<string | undefined>;
-    recovery: Signal<Recovery | undefined>;
-    container: Signal<HTMLDivElement | null>;
-    overlay: Signal<HTMLElement | null>;
-    selecting: Signal<"drag" | "all" | undefined>;
-    overlayMatch: Signal<OverlayMatch | undefined>;
-  };
-  readonly computed: {
-    hasMark: Computed<boolean>;
-    isBlock: Computed<boolean>;
-    isDraggable: Computed<boolean>;
-    parser: Computed<Parser | undefined>;
-    currentValue: Computed<string>;
-    containerComponent: Computed<Slot>;
-    containerProps: Computed<{
-      className: string | undefined;
-      style?: CSSProperties$1;
-      [key: string]: unknown;
-    }>;
-    blockComponent: Computed<Slot>;
-    blockProps: Computed<Record<string, unknown> | undefined>;
-    spanComponent: Computed<Slot>;
-    spanProps: Computed<Record<string, unknown> | undefined>;
-    overlay: OverlaySlot;
-    mark: MarkSlot;
-  };
-  readonly emit: {
-    /** Fires after user input or programmatic mark change — triggers serialization, `onChange`, and re-parse */change: Event<void>; /** Triggers a re-parse of tokens from the current content */
-    reparse: Event<void>; /** Removes a mark token from editor content */
-    markRemove: Event<{
-      token: Token;
-    }>; /** Fires when the user selects an overlay option — annotates markup into the current input span */
-    overlaySelect: Event<{
-      mark: Token;
-      match: OverlayMatch;
-    }>; /** Dismisses the overlay by clearing the current `overlayMatch` */
-    overlayClose: Event<void>; /** Post-render DOM alignment: aligns `contentEditable` attributes and `textContent` of child elements to token state. Emitted synchronously by `FocusFeature` inside the `rendered` handler (framework layout-effect phase). Load-bearing for post-commit DOM consistency — do not delete without reproducing this timing. */
-    sync: Event<void>; /** Dispatches drag-mode row operations (reorder, add, delete, duplicate) */
-    drag: Event<DragAction>; /** Fires after the framework has committed new token elements to the DOM — kicks off sync and focus recovery */
-    rendered: Event<void>; /** Lifecycle: editor component added to the DOM — enables all features */
-    mounted: Event<void>; /** Lifecycle: editor component removed from the DOM — disables all features and cleans up subscriptions */
-    unmounted: Event<void>;
-  };
+  readonly props: PropsFeature;
   readonly handler: MarkputHandler;
-  readonly feature: {
-    overlay: OverlayFeature;
-    focus: FocusFeature;
-    input: InputFeature;
-    blockEditing: BlockEditFeature;
-    arrowNav: ArrowNavFeature;
-    system: SystemListenerFeature;
-    textSelection: TextSelectionFeature;
-    contentEditable: ContentEditableFeature;
-    drag: DragFeature;
-    copy: CopyFeature;
-    parse: ParseFeature;
-  };
+  readonly lifecycle: LifecycleFeature;
+  readonly value: ValueFeature;
+  readonly mark: MarkFeature;
+  readonly overlay: OverlayFeature;
+  readonly slots: SlotsFeature;
+  readonly caret: CaretFeature;
+  readonly keyboard: KeyboardFeature;
+  readonly dom: DomFeature;
+  readonly drag: DragFeature;
+  readonly clipboard: ClipboardFeature;
+  readonly parsing: ParsingFeature;
   constructor();
-  setProps(values: Partial<SignalValues<typeof this.props>>): void;
 }
 //#endregion
 //#region ../../core/src/shared/types.d.ts
@@ -11119,21 +11217,12 @@ type OverlayMatch<TOption = CoreOption> = {
    * Html element, in which was a overlayMatch
    */
   node: Node;
-  /**
-   * Start position of a overlayMatch
-   */
-  index: number;
+  range: RawRange;
   /**
    * OverlayMatch's option
    */
   option: TOption;
 };
-type Recovery = {
-  anchor: NodeProxy;
-  isNext?: boolean;
-  caret: number;
-  childIndex?: number;
-};
 type OverlayTrigger = Array<'change' | 'selectionChange'> | 'change' | 'selectionChange' | 'none';
 type CSSProperties$1 = Properties<string | number>;
 type DataAttributes = Record<`data${Capitalize<string>}`, string | number | boolean | undefined>;
@@ -11174,47 +11263,13 @@ type DragAction = {
   index: number;
 };
 interface DragActions {
-  drag: {
+  action: {
     (action: DragAction): void;
   };
 }
-//#endregion
-//#region ../../core/src/features/mark/MarkHandler.d.ts
-interface RefAccessor<T> {
-  current: T | null;
-}
-declare class MarkHandler<T extends HTMLElement = HTMLElement> {
-  #private;
-  readonly ref: RefAccessor<T>;
-  constructor(param: {
-    ref: RefAccessor<T>;
-    store: Store;
-    token: MarkToken;
-  });
-  get readOnly(): boolean | undefined;
-  set readOnly(value: boolean | undefined);
-  get content(): string;
-  set content(value: string);
-  get value(): string | undefined;
-  set value(v: string | undefined);
-  get meta(): string | undefined;
-  set meta(v: string | undefined);
-  get slot(): string | undefined;
-  get depth(): number;
-  get hasChildren(): boolean;
-  get parent(): MarkToken | undefined;
-  get tokens(): Token[];
-  change: (props: {
-    content: string;
-    value?: string;
-    meta?: string;
-  }) => void;
-  remove: () => void;
-}
-//#endregion
-//#region ../../core/src/features/mark/types.d.ts
-interface MarkOptions {
-  controlled?: boolean;
+interface Feature {
+  enable(): void;
+  disable(): void;
 }
 //#endregion
 //#region src/types.d.ts
@@ -11348,7 +11403,10 @@ interface MarkedInputProps<TMarkProps = MarkProps, TOverlayProps extends CoreOpt
 declare function MarkedInput<TMarkProps = MarkProps, TOverlayProps extends CoreOption['overlay'] = OverlayProps>(props: MarkedInputProps<TMarkProps, TOverlayProps>): _$react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/lib/hooks/useMark.d.ts
-declare const useMark: <T extends HTMLElement = HTMLElement>(options?: MarkOptions) => MarkHandler<T>;
+declare const useMark: () => MarkController;
+//#endregion
+//#region src/lib/hooks/useMarkInfo.d.ts
+declare const useMarkInfo: () => MarkInfo;
 //#endregion
 //#region src/lib/hooks/useOverlay.d.ts
 interface OverlayHandler {
@@ -11372,5 +11430,5 @@ type ObjectSelector = Record<string, Selectable<unknown> | unknown>;
 declare function useMarkput<T>(selector: (store: Store) => Selectable<T>): T;
 declare function useMarkput<R extends ObjectSelector>(selector: (store: Store) => R): SignalValues<R>;
 //#endregion
-export { MarkHandler, type MarkProps, type MarkToken, MarkedInput, type MarkedInputProps, MarkputHandler, type Markup, type Option, type OverlayHandler, type OverlayProps, type TextToken, type Token, annotate, denote, useMark, useMarkput, useOverlay };
+export { MarkController, type MarkProps, type MarkToken, MarkedInput, type MarkedInputProps, MarkputHandler, type Markup, type Option, type OverlayHandler, type OverlayProps, type TextToken, type Token, annotate, denote, useMark, useMarkInfo, useMarkput, useOverlay };
 //# sourceMappingURL=index.d.ts.map