@domternal/core 0.5.0 → 0.5.1

package/dist/Extension.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Extension - Base class for all extensions
+ *
+ * Extensions provide functionality without contributing to the schema.
+ * For schema contributions, use Node (for block/inline nodes) or Mark (for inline formatting).
+ *
+ * Three-tier model:
+ * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
+ * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
+ * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
+ *
+ * @example
+ * const History = Extension.create({
+ *   name: 'history',
+ *   addOptions() {
+ *     return { depth: 100 };
+ *   },
+ *   addKeyboardShortcuts() {
+ *     return {
+ *       'Mod-z': () => this.editor.commands.undo(),
+ *       'Mod-Shift-z': () => this.editor.commands.redo(),
+ *     };
+ *   },
+ * });
+ */
+import type { ExtensionConfig, ExtensionConfigBase, ExtensionContext } from './types/ExtensionConfig.js';
+import type { SingleCommands } from './types/Commands.js';
+import type { EditorState } from '@domternal/pm/state';
+import type { EditorView } from '@domternal/pm/view';
+/**
+ * Merges extension config with parent binding support.
+ *
+ * For each function in `extendedConfig` that overrides a function in `parentConfig`,
+ * wraps the override so that `this.parent` temporarily points to the parent's version.
+ * This enables the `this.parent?.()` pattern in extend():
+ *
+ * ```typescript
+ * Paragraph.extend({
+ *   addAttributes() {
+ *     return { ...this.parent?.(), align: { default: 'left' } };
+ *   },
+ * });
+ * ```
+ */
+export declare function mergeConfigWithParentBinding(parentConfig: object, extendedConfig: object): object;
+/**
+ * Editor interface for Extension
+ * Forward declaration to avoid circular dependency
+ */
+export interface ExtensionEditorInterface {
+    readonly state: EditorState;
+    readonly view: EditorView;
+    readonly schema: unknown;
+    readonly commands: SingleCommands;
+}
+/**
+ * Base class for all extensions
+ *
+ * @typeParam Options - Extension options type
+ * @typeParam Storage - Extension storage type
+ */
+export declare class Extension<Options = unknown, Storage = unknown> {
+    /**
+     * Extension type identifier
+     * Used to distinguish between Extension, Node, and Mark
+     * Subclasses override this to 'node' or 'mark'
+     */
+    readonly type: 'extension' | 'node' | 'mark';
+    /**
+     * Unique extension name
+     */
+    readonly name: string;
+    /**
+     * Extension options (immutable after creation)
+     */
+    readonly options: Options;
+    /**
+     * Extension storage (mutable state)
+     * Accessible via editor.storage[extensionName]
+     */
+    storage: Storage;
+    /**
+     * The original configuration object
+     */
+    readonly config: ExtensionConfig<Options, Storage>;
+    /**
+     * Editor instance (set by ExtensionManager after creation)
+     * null until ExtensionManager binds it
+     */
+    editor: ExtensionEditorInterface | null;
+    /**
+     * Reference to the parent config method when using extend().
+     * Set temporarily during config method execution so overridden
+     * methods can call `this.parent?.()` to invoke the original.
+     */
+    parent?: ((...args: unknown[]) => unknown) | undefined;
+    /**
+     * Protected constructor - use Extension.create() instead
+     */
+    protected constructor(config: ExtensionConfig<Options, Storage>);
+    /**
+     * Creates a new extension instance
+     *
+     * @param config - Extension configuration
+     * @returns New extension instance
+     *
+     * @example
+     * const MyExtension = Extension.create({
+     *   name: 'myExtension',
+     *   addOptions() {
+     *     return { enabled: true };
+     *   },
+     * });
+     */
+    static create<O = unknown, S = unknown>(config: ExtensionConfig<O, S>): Extension<O, S>;
+    /**
+     * Creates a new extension with merged options
+     * Original extension is not modified
+     *
+     * **Note:** Options are merged shallowly using object spread (`...`).
+     * Nested objects are replaced entirely, not deeply merged.
+     *
+     * @param options - Options to merge with existing options
+     * @returns New extension instance with merged options
+     *
+     * @example
+     * const configured = MyExtension.configure({ enabled: false });
+     *
+     * @example
+     * // Shallow merge behavior with nested objects:
+     * // Given: options = { nested: { a: 1, b: 2 } }
+     * // configure({ nested: { b: 3 } })
+     * // Result: { nested: { b: 3 } } — 'a' is lost!
+     * // To preserve nested values, spread manually:
+     * // configure({ nested: { ...original.options.nested, b: 3 } })
+     */
+    configure(options: Partial<Options>): Extension<Options, Storage>;
+    /**
+     * Creates a new extension with extended configuration
+     * Original extension is not modified
+     *
+     * **Note:** Config is merged shallowly using object spread (`...`).
+     * Config properties (like `addCommands`, `addKeyboardShortcuts`) are
+     * replaced entirely, not combined with the base extension's config.
+     *
+     * @param extendedConfig - Configuration to extend/override
+     * @returns New extension instance with extended config
+     *
+     * @example
+     * const Extended = MyExtension.extend({
+     *   name: 'extendedExtension',
+     *   addCommands() {
+     *     return { customCommand: () => ({ tr }) => true };
+     *   },
+     * });
+     *
+     * @example
+     * // To preserve base extension's commands while adding new ones:
+     * const Extended = BaseExtension.extend({
+     *   addCommands() {
+     *     const baseCommands = BaseExtension.config.addCommands?.call(this) ?? {};
+     *     return {
+     *       ...baseCommands,
+     *       newCommand: () => ({ tr }) => true,
+     *     };
+     *   },
+     * });
+     */
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<ExtensionConfigBase<ExtendedOptions, ExtendedStorage>> & ThisType<ExtensionContext<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
+}
+//# sourceMappingURL=Extension.d.ts.map

package/dist/Extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Extension.d.ts","sourceRoot":"","sources":["../src/Extension.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACzG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,GACrB,MAAM,CAsBR;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;CACnC;AAED;;;;;GAKG;AACH,qBAAa,SAAS,CAAC,OAAO,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO;IACzD;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,CAAe;IAE3D;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAEnD;;;OAGG;IACH,MAAM,EAAE,wBAAwB,GAAG,IAAI,CAAQ;IAE/C;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;IAEvD;;OAEG;IACH,SAAS,aAAa,MAAM,EAAE,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC;IAuB/D;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACpC,MAAM,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;IAIlB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC;IAcjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,CAAC,eAAe,GAAG,OAAO,EAAE,eAAe,GAAG,OAAO,EACzD,cAAc,EAAE,OAAO,CAAC,mBAAmB,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC,GAC5E,QAAQ,CAAC,gBAAgB,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC,GAC7D,SAAS,CAAC,eAAe,EAAE,eAAe,CAAC;CAK/C"}

package/dist/Extension.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Extension.test.d.ts.map

package/dist/Extension.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Extension.test.d.ts","sourceRoot":"","sources":["../src/Extension.test.ts"],"names":[],"mappings":""}

package/dist/ExtensionManager.d.ts

@@ -0,0 +1,283 @@
+/**
+ * ExtensionManager - Manages extensions and schema
+ *
+ * Handles:
+ * - Extension lifecycle (flatten, resolve, bind)
+ * - Schema building from Node/Mark extensions
+ * - Plugin collection from all extensions
+ * - Extension storage management
+ * - Conflict detection (AD-7)
+ */
+import { Schema } from '@domternal/pm/model';
+import type { Plugin, Transaction } from '@domternal/pm/state';
+import type { NodeViewConstructor } from '@domternal/pm/view';
+import type { AnyExtension } from './types/EditorOptions.js';
+import type { CommandMap } from './types/Commands.js';
+import type { ToolbarItem } from './types/Toolbar.js';
+/**
+ * Error event props for safeCall
+ */
+interface ErrorEventProps {
+    error: Error;
+    context: string;
+}
+/**
+ * Editor interface for ExtensionManager
+ * Forward declaration to avoid circular dependency
+ */
+export interface ExtensionManagerEditor {
+    readonly schema: Schema;
+    emit?(event: 'error', props: ErrorEventProps): void;
+}
+/**
+ * Context attached to node view constructors for framework wrappers.
+ * Accessible via `(constructor as any).__domternalContext`.
+ */
+export interface NodeViewContext {
+    editor: ExtensionManagerEditor;
+    extension: {
+        name: string;
+        options: Record<string, unknown>;
+    };
+}
+/**
+ * Options for ExtensionManager constructor
+ */
+export interface ExtensionManagerOptions {
+    /**
+     * Extensions to process
+     * If provided, schema is built from extensions
+     */
+    extensions?: AnyExtension[] | undefined;
+    /**
+     * Direct schema (backward compatibility with Step 1.3)
+     * If provided, extensions are ignored for schema building
+     */
+    schema?: Schema | undefined;
+}
+export declare class ExtensionManager {
+    /**
+     * Processed extensions (flattened, sorted by priority)
+     */
+    private readonly _extensions;
+    /**
+     * ProseMirror schema (built from extensions or passed directly)
+     */
+    private readonly _schema;
+    /**
+     * Reference to the editor instance
+     */
+    readonly editor: ExtensionManagerEditor;
+    /**
+     * Extension storage (keyed by extension name)
+     */
+    private readonly _storage;
+    /**
+     * Whether the manager has been destroyed
+     */
+    private isDestroyed;
+    /**
+     * Cached plugins (built lazily)
+     */
+    private _plugins;
+    /**
+     * Cached commands (collected lazily)
+     */
+    private _commands;
+    /**
+     * Cached toolbar items (collected lazily)
+     */
+    private _toolbarItems;
+    /**
+     * Cached node views (collected lazily)
+     */
+    private _nodeViews;
+    /**
+     * Creates a new ExtensionManager
+     *
+     * @param options - Extensions or direct schema
+     * @param editor - Editor instance
+     */
+    constructor(options: ExtensionManagerOptions, editor: ExtensionManagerEditor);
+    /**
+     * Gets the processed extensions array
+     */
+    get extensions(): readonly AnyExtension[];
+    /**
+     * Gets the ProseMirror schema
+     */
+    get schema(): Schema;
+    /**
+     * Gets extension storage (accessed via editor.storage)
+     */
+    get storage(): Record<string, unknown>;
+    /**
+     * Gets plugins from all extensions
+     * Cached after first call
+     */
+    get plugins(): Plugin[];
+    /**
+     * Gets commands from all extensions
+     */
+    get commands(): CommandMap;
+    /**
+     * Gets toolbar items from all extensions
+     * Cached after first call
+     */
+    get toolbarItems(): ToolbarItem[];
+    /**
+     * Gets node views from all Node extensions that define addNodeView
+     */
+    get nodeViews(): Record<string, NodeViewConstructor>;
+    /**
+     * Clears all caches (plugins, commands)
+     * Call when extensions change dynamically
+     */
+    clearAllCaches(): void;
+    /**
+     * Recursively flattens extensions by expanding addExtensions()
+     * This allows extension bundles like StarterKit to work
+     */
+    private flattenExtensions;
+    /**
+     * Removes duplicate extensions by name, keeping the last occurrence.
+     * This allows parent extensions to auto-include children via addExtensions()
+     * while letting users override with explicitly configured versions.
+     */
+    private deduplicateExtensions;
+    /**
+     * Sorts extensions by priority (higher priority first)
+     * Default priority is 100
+     */
+    private resolveExtensions;
+    /**
+     * Detects duplicate extension names (AD-7: Schema Conflict Detection)
+     * @throws Error if duplicate names found
+     */
+    private detectConflicts;
+    /**
+     * Validates that all extension dependencies are present
+     * @throws Error if required dependency is missing
+     */
+    private checkDependencies;
+    /**
+     * Sets editor reference on all extensions
+     */
+    private bindEditorToExtensions;
+    /**
+     * Collects global attributes from all extensions.
+     * Returns a map of type name -> attribute specs to merge.
+     */
+    private collectGlobalAttributes;
+    /**
+     * Applies global attributes to a node or mark spec.
+     * Merges extra attrs into spec.attrs, wraps parseDOM getAttrs to parse
+     * global attributes from DOM elements, and wraps toDOM to inject rendered
+     * global HTML attributes into the output.
+     */
+    private applyGlobalAttributes;
+    /**
+     * Builds ProseMirror Schema from Node and Mark extensions
+     */
+    private buildSchema;
+    /**
+     * Initializes storage for all extensions
+     */
+    private initializeStorage;
+    /**
+     * Builds all ProseMirror plugins from extensions
+     */
+    private buildPlugins;
+    /**
+     * Collects keyboard shortcuts from all extensions
+     * Returns ProseMirror-compatible commands for keymap plugin
+     *
+     * Note: Extensions should return PM-compatible commands from addKeyboardShortcuts()
+     */
+    private collectKeyboardShortcuts;
+    /**
+     * Collects input rules from all extensions
+     */
+    private collectInputRules;
+    /**
+     * Collects commands from all extensions
+     *
+     * Note: Commands with the same name will be overwritten by later extensions
+     * (lower priority extensions override higher priority). This is intentional
+     * to allow customization of built-in commands.
+     */
+    private collectCommands;
+    /**
+     * Collects toolbar items from all extensions
+     */
+    private collectToolbarItems;
+    /**
+     * Collects node views from all Node extensions.
+     * Returns a map of node name to NodeViewConstructor for EditorView.
+     *
+     * Each constructor is annotated with `__domternalContext` containing
+     * the editor and extension metadata so framework wrappers (React, Vue)
+     * can access them without changing the ProseMirror calling convention.
+     */
+    private collectNodeViews;
+    /**
+     * Validates that the schema has required nodes
+     * @throws Error if schema is missing 'doc' or 'text' nodes
+     */
+    validateSchema(): void;
+    /**
+     * Cleans up the extension manager
+     * Calls onDestroy on all extensions and clears all caches
+     */
+    destroy(): void;
+    /**
+     * Safely executes a function, catching and reporting errors
+     * Prevents a single extension error from crashing the entire editor
+     *
+     * Handles both synchronous errors and async promise rejections.
+     *
+     * @param fn - Function to execute
+     * @param context - Context for error reporting (e.g., 'Bold.onUpdate')
+     * @returns The function result, or undefined if an error occurred
+     */
+    safeCall<T>(fn: () => T, context: string): T | undefined;
+    /**
+     * Calls onBeforeCreate on all extensions
+     */
+    callOnBeforeCreate(): void;
+    /**
+     * Calls onCreate on all extensions
+     */
+    callOnCreate(): void;
+    /**
+     * Calls onUpdate on all extensions
+     */
+    callOnUpdate(): void;
+    /**
+     * Calls onSelectionUpdate on all extensions
+     */
+    callOnSelectionUpdate(): void;
+    /**
+     * Calls onTransaction on all extensions
+     * @param props - Transaction props
+     */
+    callOnTransaction(props: {
+        transaction: Transaction;
+    }): void;
+    /**
+     * Calls onFocus on all extensions
+     * @param props - Focus event props
+     */
+    callOnFocus(props: {
+        event: FocusEvent;
+    }): void;
+    /**
+     * Calls onBlur on all extensions
+     * @param props - Blur event props
+     */
+    callOnBlur(props: {
+        event: FocusEvent;
+    }): void;
+}
+export {};
+//# sourceMappingURL=ExtensionManager.d.ts.map

package/dist/ExtensionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionManager.d.ts","sourceRoot":"","sources":["../src/ExtensionManager.ts"],"names":[],"mappings":"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"}

package/dist/ExtensionManager.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ExtensionManager.test.d.ts.map

package/dist/ExtensionManager.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionManager.test.d.ts","sourceRoot":"","sources":["../src/ExtensionManager.test.ts"],"names":[],"mappings":""}

package/dist/Mark.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Mark - Base class for mark extensions
+ *
+ * Marks define inline formatting that can be applied to text.
+ * Examples: Bold, Italic, Link, Code, etc.
+ *
+ * Three-tier model:
+ * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
+ * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
+ * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
+ *
+ * @example
+ * const Bold = Mark.create({
+ *   name: 'bold',
+ *   parseHTML() {
+ *     return [
+ *       { tag: 'strong' },
+ *       { tag: 'b' },
+ *       { style: 'font-weight=bold' },
+ *     ];
+ *   },
+ *   renderHTML({ HTMLAttributes }) {
+ *     return ['strong', HTMLAttributes, 0];
+ *   },
+ * });
+ */
+import type { MarkSpec, MarkType } from '@domternal/pm/model';
+import { Extension, type ExtensionEditorInterface } from './Extension.js';
+import type { MarkConfig, MarkContext } from './types/MarkConfig.js';
+/**
+ * Extended editor interface for Mark
+ * Includes schema access for MarkType getter
+ */
+export interface MarkEditorInterface extends ExtensionEditorInterface {
+    readonly schema: {
+        marks: Record<string, MarkType>;
+    };
+}
+/**
+ * Base class for mark extensions
+ *
+ * @typeParam Options - Mark options type
+ * @typeParam Storage - Mark storage type
+ */
+export declare class Mark<Options = unknown, Storage = unknown> extends Extension<Options, Storage> {
+    /**
+     * Mark type identifier
+     * Distinguishes marks from extensions and nodes
+     */
+    readonly type: "mark";
+    /**
+     * The original configuration object
+     * Typed as MarkConfig for mark-specific properties
+     */
+    readonly config: MarkConfig<Options, Storage>;
+    /**
+     * Editor instance with schema access
+     * null until set by ExtensionManager
+     */
+    editor: MarkEditorInterface | null;
+    /**
+     * Protected constructor - use Mark.create() instead
+     */
+    protected constructor(config: MarkConfig<Options, Storage>);
+    /**
+     * Whether this mark represents visual formatting.
+     * Returns false for semantic marks (links, comments) that should
+     * survive `unsetAllMarks`. Defaults to true.
+     */
+    get isFormatting(): boolean;
+    /**
+     * Get the ProseMirror MarkType from schema
+     *
+     * This is a lazy getter because schema doesn't exist at mark creation time.
+     * Schema is built FROM marks by ExtensionManager.
+     *
+     * Returns null if editor is not yet initialized.
+     * Always check editor is set before using markType.
+     */
+    get markType(): MarkType | null;
+    /**
+     * Get MarkType or throw if not initialized.
+     * Use in contexts where editor is guaranteed to be set (like addCommands).
+     */
+    get markTypeOrThrow(): MarkType;
+    /**
+     * Creates a new mark instance
+     *
+     * @param config - Mark configuration
+     * @returns New mark instance
+     *
+     * @example
+     * const Bold = Mark.create({
+     *   name: 'bold',
+     *   parseHTML() {
+     *     return [{ tag: 'strong' }, { tag: 'b' }];
+     *   },
+     * });
+     */
+    static create<O = unknown, S = unknown>(config: MarkConfig<O, S>): Mark<O, S>;
+    /**
+     * Creates a new mark with merged options
+     * Original mark is not modified
+     *
+     * **Note:** Options are merged shallowly using object spread (`...`).
+     * Nested objects are replaced entirely, not deeply merged.
+     *
+     * @param options - Options to merge with existing options
+     * @returns New mark instance with merged options
+     *
+     * @example
+     * const CustomBold = Bold.configure({ HTMLAttributes: { class: 'custom-bold' } });
+     *
+     * @example
+     * // Shallow merge behavior with nested objects:
+     * // Given: options = { HTMLAttributes: { class: 'a', id: 'b' } }
+     * // configure({ HTMLAttributes: { class: 'c' } })
+     * // Result: { HTMLAttributes: { class: 'c' } } — 'id' is lost!
+     * // To preserve nested values, spread manually:
+     * // configure({ HTMLAttributes: { ...original.options.HTMLAttributes, class: 'c' } })
+     */
+    configure(options: Partial<Options> & {
+        isFormatting?: boolean;
+    }): Mark<Options, Storage>;
+    /**
+     * Creates a new mark with extended configuration
+     * Original mark is not modified
+     *
+     * **Note:** Config is merged shallowly using object spread (`...`).
+     * Config properties (like `addAttributes`, `parseHTML`) are
+     * replaced entirely, not combined with the base mark's config.
+     *
+     * @param extendedConfig - Configuration to extend/override
+     * @returns New mark instance with extended config
+     *
+     * @example
+     * const CustomBold = Bold.extend({
+     *   name: 'customBold',
+     *   addAttributes() {
+     *     return { ...this.parent?.(), weight: { default: 'bold' } };
+     *   },
+     * });
+     *
+     * @example
+     * // To preserve base mark's parse rules while adding new ones:
+     * const Extended = BaseMark.extend({
+     *   parseHTML() {
+     *     const baseRules = BaseMark.config.parseHTML?.call(this) ?? [];
+     *     return [...baseRules, { tag: 'custom-tag' }];
+     *   },
+     * });
+     */
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<MarkConfig<ExtendedOptions, ExtendedStorage>> & ThisType<MarkContext<ExtendedOptions, ExtendedStorage>>): Mark<ExtendedOptions, ExtendedStorage>;
+    /**
+     * Creates a ProseMirror MarkSpec from this mark's configuration
+     *
+     * Called by ExtensionManager when building the schema.
+     * Converts our config format to ProseMirror's MarkSpec format.
+     *
+     * @returns ProseMirror MarkSpec
+     */
+    createMarkSpec(): MarkSpec;
+}
+//# sourceMappingURL=Mark.d.ts.map

package/dist/Mark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mark.d.ts","sourceRoot":"","sources":["../src/Mark.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAa,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,KAAK,wBAAwB,EAAgC,MAAM,gBAAgB,CAAC;AACxG,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIrE;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,wBAAwB;IACnE,QAAQ,CAAC,MAAM,EAAE;QACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;KACjC,CAAC;CACH;AAED;;;;;GAKG;AACH,qBAAa,IAAI,CAAC,OAAO,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,CAAE,SAAQ,SAAS,CACvE,OAAO,EACP,OAAO,CACR;IACC;;;OAGG;IACH,SAAkB,IAAI,EAAG,MAAM,CAAU;IAEzC;;;OAGG;IACH,SAAiB,MAAM,EAAE,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAEtD;;;OAGG;IACM,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAQ;IAEnD;;OAEG;IACH,SAAS,aAAa,MAAM,EAAE,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC;IAI1D;;;;OAIG;IACH,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED;;;;;;;;OAQG;IACH,IAAI,QAAQ,IAAI,QAAQ,GAAG,IAAI,CAK9B;IAED;;;OAGG;IACH,IAAI,eAAe,IAAI,QAAQ,CAS9B;IAED;;;;;;;;;;;;;OAaG;WACa,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAC7C,MAAM,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IAIb;;;;;;;;;;;;;;;;;;;;OAoBG;IACM,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC;IAclG;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACM,MAAM,CAAC,eAAe,GAAG,OAAO,EAAE,eAAe,GAAG,OAAO,EAClE,cAAc,EAAE,OAAO,CAAC,UAAU,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC,GACnE,QAAQ,CAAC,WAAW,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC,GACxD,IAAI,CAAC,eAAe,EAAE,eAAe,CAAC;IAMzC;;;;;;;OAOG;IACH,cAAc,IAAI,QAAQ;CA+F3B"}

package/dist/Mark.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for Mark class
+ */
+export {};
+//# sourceMappingURL=Mark.test.d.ts.map

package/dist/Mark.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mark.test.d.ts","sourceRoot":"","sources":["../src/Mark.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}