@domternal/core 0.5.0 → 0.5.1

package/dist/helpers/findParentNode.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Find the closest parent node matching a predicate
+ *
+ * Returns a curried function: findParentNode(predicate)(selection)
+ *
+ * @example
+ * const details = findParentNode(node => node.type.name === 'details')(selection);
+ * if (details) {
+ *   console.log(details.pos, details.node);
+ * }
+ */
+import type { Node as PMNode } from '@domternal/pm/model';
+import type { Selection } from '@domternal/pm/state';
+export interface FindParentNodeResult {
+    pos: number;
+    start: number;
+    depth: number;
+    node: PMNode;
+}
+export declare const findParentNode: (predicate: (node: PMNode) => boolean) => (selection: Selection) => FindParentNodeResult | undefined;
+//# sourceMappingURL=findParentNode.d.ts.map

package/dist/helpers/findParentNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findParentNode.d.ts","sourceRoot":"","sources":["../../src/helpers/findParentNode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,IAAI,IAAI,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,cAAc,GACxB,WAAW,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,MACpC,WAAW,SAAS,KAAG,oBAAoB,GAAG,SAiB9C,CAAC"}

package/dist/helpers/findParentNode.test.d.ts

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

package/dist/helpers/findParentNode.test.d.ts.map

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

package/dist/helpers/getMarkRange.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Get the range of a mark at a resolved position.
+ *
+ * Walks backward and forward from the position to find contiguous
+ * text nodes that share the same mark type, returning the full range.
+ */
+import type { MarkType, ResolvedPos } from '@domternal/pm/model';
+export interface MarkRange {
+    from: number;
+    to: number;
+}
+/**
+ * Returns the contiguous range of a mark around the given resolved position.
+ * Returns undefined if the mark is not present at the position.
+ */
+export declare function getMarkRange($pos: ResolvedPos, type: MarkType): MarkRange | undefined;
+//# sourceMappingURL=getMarkRange.d.ts.map

package/dist/helpers/getMarkRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMarkRange.d.ts","sourceRoot":"","sources":["../../src/helpers/getMarkRange.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEjE,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,QAAQ,GACb,SAAS,GAAG,SAAS,CAgCvB"}

package/dist/helpers/getMarkRange.test.d.ts

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

package/dist/helpers/getMarkRange.test.d.ts.map

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

package/dist/helpers/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Helper utilities for @domternal/core
+ */
+export { createDocument, type CreateDocumentOptions } from './createDocument.js';
+export { isNodeEmpty, isDocumentEmpty, type IsNodeEmptyOptions, } from './isNodeEmpty.js';
+export { callOrReturn } from './callOrReturn.js';
+export { markInputRule, markInputRulePatterns, type MarkInputRuleOptions, } from './markInputRule.js';
+export { wrappingInputRule, notInsideList, type WrappingInputRuleOptions, } from './wrappingInputRule.js';
+export { textblockTypeInputRule, type TextblockTypeInputRuleOptions, } from './textblockTypeInputRule.js';
+export { textInputRule, type TextInputRuleOptions, } from './textInputRule.js';
+export { nodeInputRule, type NodeInputRuleOptions, } from './nodeInputRule.js';
+export { isValidUrl, type IsValidUrlOptions, } from './isValidUrl.js';
+export { generateHTML, generateJSON, generateText, type GenerateHTMLOptions, type GenerateJSONOptions, type GenerateTextOptions, } from './ssr.js';
+export { getMarkRange, type MarkRange } from './getMarkRange.js';
+export { findParentNode, type FindParentNodeResult, } from './findParentNode.js';
+export { findChildren, type FindChildResult } from './findChildren.js';
+export { defaultBlockAt } from './defaultBlockAt.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EACL,WAAW,EACX,eAAe,EACf,KAAK,kBAAkB,GACxB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,KAAK,wBAAwB,GAC9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,sBAAsB,EACtB,KAAK,6BAA6B,GACnC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,aAAa,EACb,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,aAAa,EACb,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,UAAU,EACV,KAAK,iBAAiB,GACvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/helpers/inputRulesPlugin.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Custom inputRules plugin with built-in Backspace undo.
+ *
+ * Two enhancements over ProseMirror's built-in inputRules plugin:
+ *
+ * 1. Preserves undo state across appendTransaction (e.g. TrailingNode).
+ *    PM's plugin clears state on any docChanged transaction, so
+ *    appendTransaction handlers that fire after an input rule erase the
+ *    undo info before the user can press Backspace.
+ *
+ * 2. Handles Backspace directly via handleKeyDown (highest priority in
+ *    ProseMirror's event dispatch) so no other keymap can intercept it
+ *    first. If the plugin has stored undo state, Backspace inverts the
+ *    input rule steps and restores the original typed text.
+ */
+import { Plugin } from '@domternal/pm/state';
+import type { InputRule } from '@domternal/pm/inputrules';
+/**
+ * Creates an input rules plugin with built-in Backspace undo.
+ *
+ * Drop-in replacement for ProseMirror's `inputRules({ rules })`.
+ */
+export declare function inputRulesPlugin({ rules }: {
+    rules: InputRule[];
+}): Plugin;
+//# sourceMappingURL=inputRulesPlugin.d.ts.map

package/dist/helpers/inputRulesPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputRulesPlugin.d.ts","sourceRoot":"","sources":["../../src/helpers/inputRulesPlugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AA6G1D;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,KAAK,EAAE,EAAE;IAAE,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,GAAG,MAAM,CA4C1E"}

package/dist/helpers/isNodeEmpty.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Check if a ProseMirror node is empty
+ */
+import type { Node as PMNode } from '@domternal/pm/model';
+/**
+ * Options for isNodeEmpty check
+ */
+export interface IsNodeEmptyOptions {
+    /**
+     * Check child nodes recursively
+     * @default true
+     */
+    checkChildren?: boolean;
+    /**
+     * Ignore hardBreak nodes when checking emptiness
+     * @default true
+     */
+    ignoreHardBreaks?: boolean;
+}
+/**
+ * Checks if a ProseMirror node is considered empty
+ *
+ * A node is considered empty if:
+ * - It has no content (childCount === 0)
+ * - It only contains empty child nodes (when checkChildren is true)
+ * - It only contains hardBreaks (when ignoreHardBreaks is true)
+ *
+ * @param node - ProseMirror node to check
+ * @param options - Options for emptiness check
+ * @returns true if node is empty
+ *
+ * @example
+ * ```ts
+ * // Check if document is empty
+ * const empty = isNodeEmpty(editor.state.doc);
+ *
+ * // Check without recursion
+ * const empty = isNodeEmpty(node, { checkChildren: false });
+ * ```
+ */
+export declare function isNodeEmpty(node: PMNode, options?: IsNodeEmptyOptions): boolean;
+/**
+ * Checks if a document node is empty
+ *
+ * Convenience wrapper for isNodeEmpty with document-specific defaults.
+ * A document is empty if it only contains empty paragraphs or no content.
+ *
+ * @param doc - Document node to check
+ * @returns true if document is empty
+ */
+export declare function isDocumentEmpty(doc: PMNode): boolean;
+//# sourceMappingURL=isNodeEmpty.d.ts.map

package/dist/helpers/isNodeEmpty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNodeEmpty.d.ts","sourceRoot":"","sources":["../../src/helpers/isNodeEmpty.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,IAAI,IAAI,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAqCT;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAKpD"}

package/dist/helpers/isNodeEmpty.test.d.ts

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

package/dist/helpers/isNodeEmpty.test.d.ts.map

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

package/dist/helpers/isValidUrl.d.ts

@@ -0,0 +1,31 @@
+/**
+ * URL Validation Helper
+ *
+ * Provides a utility for validating URLs.
+ */
+/**
+ * Options for URL validation
+ */
+export interface IsValidUrlOptions {
+    /**
+     * List of allowed URL protocols
+     * @default ['http:', 'https:']
+     */
+    protocols?: string[];
+}
+/**
+ * Checks if a string is a valid URL
+ *
+ * @param url - The string to validate
+ * @param options - Validation options
+ * @returns True if the string is a valid URL with an allowed protocol
+ *
+ * @example
+ * ```ts
+ * isValidUrl('https://example.com'); // true
+ * isValidUrl('javascript:alert(1)'); // false (protocol not allowed)
+ * isValidUrl('not a url'); // false
+ * ```
+ */
+export declare function isValidUrl(url: string, options?: IsValidUrlOptions): boolean;
+//# sourceMappingURL=isValidUrl.d.ts.map

package/dist/helpers/isValidUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isValidUrl.d.ts","sourceRoot":"","sources":["../../src/helpers/isValidUrl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAST"}

package/dist/helpers/isValidUrl.test.d.ts

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

package/dist/helpers/isValidUrl.test.d.ts.map

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

package/dist/helpers/markInputRule.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Mark Input Rule Helper
+ *
+ * Creates input rules for applying marks based on regex patterns.
+ * Used for markdown-style shortcuts like **bold**, *italic*, ~~strike~~, etc.
+ */
+import { InputRule } from '@domternal/pm/inputrules';
+import type { MarkType } from '@domternal/pm/model';
+/**
+ * Options for creating a mark input rule
+ */
+export interface MarkInputRuleOptions {
+    /**
+     * The regex pattern to match.
+     * Must have a capture group for the content to be marked.
+     *
+     * @example
+     * // Match **text**
+     * /(?:\*\*)([^*]+)(?:\*\*)$/
+     */
+    find: RegExp;
+    /**
+     * The mark type to apply
+     */
+    type: MarkType;
+    /**
+     * Whether Backspace can undo this input rule immediately after it fires.
+     * @default true
+     */
+    undoable?: boolean;
+    /**
+     * Optional: get attributes from the match
+     *
+     * @param match - The regex match array
+     * @returns Mark attributes or null to skip
+     */
+    getAttributes?: (match: RegExpMatchArray) => Record<string, unknown> | null;
+}
+/**
+ * Creates an input rule that applies a mark to matched text.
+ *
+ * When the user types text matching the pattern, the delimiters are removed
+ * and the mark is applied to the content.
+ *
+ * @example
+ * // **text** → applies bold mark to "text"
+ * markInputRule({
+ *   find: /(?:\*\*)([^*]+)(?:\*\*)$/,
+ *   type: schema.marks.bold,
+ * });
+ *
+ * @example
+ * // `text` → applies code mark to "text"
+ * markInputRule({
+ *   find: /(?:`)([^`]+)(?:`)$/,
+ *   type: schema.marks.code,
+ * });
+ *
+ * @param options - Configuration options
+ * @returns ProseMirror InputRule
+ */
+export declare function markInputRule(options: MarkInputRuleOptions): InputRule;
+/**
+ * Pre-built regex patterns for common mark input rules
+ */
+export declare const markInputRulePatterns: {
+    /**
+     * Bold: **text** or __text__
+     * Matches text wrapped in double asterisks or underscores
+     */
+    readonly bold: RegExp;
+    /**
+     * Strike: ~~text~~
+     * Matches text wrapped in double tildes
+     */
+    readonly strike: RegExp;
+    /**
+     * Code: `text`
+     * Matches text wrapped in backticks
+     */
+    readonly code: RegExp;
+    /**
+     * Highlight: ==text==
+     * Matches text wrapped in double equals
+     */
+    readonly highlight: RegExp;
+};
+//# sourceMappingURL=markInputRule.d.ts.map

package/dist/helpers/markInputRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markInputRule.d.ts","sourceRoot":"","sources":["../../src/helpers/markInputRule.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;;OAOG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,QAAQ,CAAC;IAEf;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC7E;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAmCtE;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAChC;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;CAEK,CAAC"}

package/dist/helpers/markInputRule.test.d.ts

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

package/dist/helpers/markInputRule.test.d.ts.map

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

package/dist/helpers/nodeInputRule.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Node Input Rule Helper
+ *
+ * Creates input rules that replace matched text with a node.
+ * Used for nodes like HorizontalRule, Image, Emoji, etc.
+ */
+import { InputRule } from '@domternal/pm/inputrules';
+import type { NodeType, Attrs } from '@domternal/pm/model';
+import type { EditorState } from '@domternal/pm/state';
+export interface NodeInputRuleOptions {
+    /**
+     * The regex pattern to match.
+     */
+    find: RegExp;
+    /**
+     * The node type to insert.
+     */
+    type: NodeType;
+    /**
+     * Whether Backspace can undo this input rule immediately after it fires.
+     * @default true
+     */
+    undoable?: boolean;
+    /**
+     * Node attributes, or a function that computes them from the match.
+     */
+    getAttributes?: Attrs | null | ((match: RegExpMatchArray, state: EditorState) => Attrs | null);
+}
+/**
+ * Creates an input rule that replaces matched text with a node.
+ *
+ * @example
+ * // `:smile:` inserts an emoji node
+ * nodeInputRule({
+ *   find: /:([a-zA-Z0-9_+-]+):$/,
+ *   type: schema.nodes.emoji,
+ *   getAttributes: (match) => ({ name: match[1] }),
+ * });
+ */
+export declare function nodeInputRule(options: NodeInputRuleOptions): InputRule;
+//# sourceMappingURL=nodeInputRule.d.ts.map

package/dist/helpers/nodeInputRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeInputRule.d.ts","sourceRoot":"","sources":["../../src/helpers/nodeInputRule.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,QAAQ,CAAC;IAEf;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,aAAa,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,WAAW,KAAK,KAAK,GAAG,IAAI,CAAC,CAAC;CAChG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAYtE"}

package/dist/helpers/normalizeColor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Normalizes browser-computed color values (rgb/rgba) to hex format.
+ * Browsers convert hex colors to rgb() in element.style, causing
+ * isActive mismatches when comparing stored values after HTML re-parsing.
+ */
+export declare function normalizeColor(color: string): string;
+//# sourceMappingURL=normalizeColor.d.ts.map

package/dist/helpers/normalizeColor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeColor.d.ts","sourceRoot":"","sources":["../../src/helpers/normalizeColor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASpD"}

package/dist/helpers/normalizeColor.test.d.ts

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

package/dist/helpers/normalizeColor.test.d.ts.map

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

package/dist/helpers/specBuilder.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared helpers for building ProseMirror node/mark specs.
+ *
+ * Used by both Node.createNodeSpec() and Mark.createMarkSpec() to
+ * eliminate duplicated attribute conversion and HTML attribute building.
+ */
+import type { AttributeSpecs } from '../types/AttributeSpec.js';
+/**
+ * Converts extension AttributeSpecs to ProseMirror-compatible `attrs` object.
+ *
+ * @example
+ * spec.attrs = buildProseMirrorAttrs(attributeSpecs);
+ */
+export declare function buildProseMirrorAttrs(attributeSpecs: AttributeSpecs): Record<string, {
+    default?: unknown;
+}>;
+/**
+ * Builds an HTML attributes object from a node/mark's attrs using the
+ * attribute specs' renderHTML functions.
+ *
+ * Used inside toDOM wrappers for both nodes and marks.
+ *
+ * @example
+ * const htmlAttrs = buildHTMLAttributes(node.attrs, attrSpecs);
+ * return renderFn.call(instance, { node, HTMLAttributes: htmlAttrs });
+ */
+export declare function buildHTMLAttributes(attrs: Record<string, unknown>, attrSpecs: AttributeSpecs): Record<string, unknown>;
+//# sourceMappingURL=specBuilder.d.ts.map

package/dist/helpers/specBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specBuilder.d.ts","sourceRoot":"","sources":["../../src/helpers/specBuilder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEhE;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,cAAc,GAC7B,MAAM,CAAC,MAAM,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAevC;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,cAAc,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoBzB"}

package/dist/helpers/specBuilder.test.d.ts

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

package/dist/helpers/specBuilder.test.d.ts.map

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

package/dist/helpers/ssr.d.ts

@@ -0,0 +1,80 @@
+import type { AnyExtension, JSONContent } from '../types/index.js';
+export interface GenerateHTMLOptions {
+    /**
+     * Custom document implementation. If not provided, uses native document
+     * in browser or linkedom in Node.js.
+     */
+    document?: Document;
+}
+/**
+ * Generate HTML string from JSON content.
+ *
+ * @param content - The JSON content to convert
+ * @param extensions - Extensions that define the schema
+ * @param options - Optional configuration
+ * @returns HTML string
+ *
+ * @example
+ * ```ts
+ * const html = generateHTML(
+ *   { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Hello' }] }] },
+ *   [Document, Paragraph, Text]
+ * );
+ * // Returns: '<p>Hello</p>'
+ * ```
+ */
+export declare function generateHTML(content: JSONContent, extensions: AnyExtension[], options?: GenerateHTMLOptions): string;
+export interface GenerateJSONOptions {
+    /**
+     * Custom document implementation. If not provided, uses native document
+     * in browser or linkedom in Node.js.
+     */
+    document?: Document;
+}
+/**
+ * Generate JSON content from HTML string.
+ *
+ * @param html - The HTML string to convert
+ * @param extensions - Extensions that define the schema
+ * @param options - Optional configuration
+ * @returns JSON content object
+ *
+ * @example
+ * ```ts
+ * const json = generateJSON(
+ *   '<p>Hello</p>',
+ *   [Document, Paragraph, Text]
+ * );
+ * // Returns: { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Hello' }] }] }
+ * ```
+ */
+export declare function generateJSON(html: string, extensions: AnyExtension[], options?: GenerateJSONOptions): JSONContent;
+export interface GenerateTextOptions {
+    /**
+     * Separator between block elements.
+     * @default '\n\n'
+     */
+    blockSeparator?: string;
+}
+/**
+ * Generate plain text from JSON content.
+ *
+ * @param content - The JSON content to extract text from
+ * @param extensions - Extensions that define the schema
+ * @param options - Optional configuration
+ * @returns Plain text string
+ *
+ * @example
+ * ```ts
+ * const text = generateText(
+ *   { type: 'doc', content: [
+ *     { type: 'paragraph', content: [{ type: 'text', text: 'Hello' }] },
+ *     { type: 'paragraph', content: [{ type: 'text', text: 'World' }] }
+ *   ]},
+ *   [Document, Paragraph, Text]
+ * );
+ * // Returns: 'Hello\n\nWorld'
+ * ```
+ */
+export declare function generateText(content: JSONContent, extensions: AnyExtension[], options?: GenerateTextOptions): string;
+//# sourceMappingURL=ssr.d.ts.map

package/dist/helpers/ssr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr.d.ts","sourceRoot":"","sources":["../../src/helpers/ssr.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAiDnE,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,YAAY,EAAE,EAC1B,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAcR;AAED,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,YAAY,EAAE,EAC1B,OAAO,GAAE,mBAAwB,GAChC,WAAW,CAab;AAED,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,YAAY,EAAE,EAC1B,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAMR"}

package/dist/helpers/ssr.test.d.ts

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

package/dist/helpers/ssr.test.d.ts.map

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

package/dist/helpers/textInputRule.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Text Input Rule Helper
+ *
+ * Creates input rules for simple text replacements (e.g. `--` to em dash).
+ */
+import { InputRule } from '@domternal/pm/inputrules';
+export interface TextInputRuleOptions {
+    /**
+     * The regex pattern to match.
+     */
+    find: RegExp;
+    /**
+     * The replacement text.
+     */
+    replace: string;
+    /**
+     * Whether Backspace can undo this input rule immediately after it fires.
+     * @default true
+     */
+    undoable?: boolean;
+}
+/**
+ * Creates an input rule that replaces matched text with a string.
+ *
+ * @example
+ * // `--` converts to em dash
+ * textInputRule({ find: /--$/, replace: '\u2014' });
+ *
+ * @example
+ * // Non-undoable replacement
+ * textInputRule({ find: /->$/, replace: '\u2192', undoable: false });
+ */
+export declare function textInputRule(options: TextInputRuleOptions): InputRule;
+//# sourceMappingURL=textInputRule.d.ts.map

package/dist/helpers/textInputRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textInputRule.d.ts","sourceRoot":"","sources":["../../src/helpers/textInputRule.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAQtE"}

package/dist/helpers/textblockTypeInputRule.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Textblock Type Input Rule Helper
+ *
+ * Drop-in replacement for ProseMirror's textblockTypeInputRule that exposes
+ * the `undoable` option so extension authors can opt out of Backspace undo.
+ */
+import { InputRule } from '@domternal/pm/inputrules';
+import type { NodeType, Attrs } from '@domternal/pm/model';
+export interface TextblockTypeInputRuleOptions {
+    /**
+     * The regex pattern to match. Should start with `^` so it only
+     * fires at the start of a textblock.
+     */
+    find: RegExp;
+    /**
+     * The node type to change the textblock to.
+     */
+    type: NodeType;
+    /**
+     * Whether Backspace can undo this input rule immediately after it fires.
+     * @default true
+     */
+    undoable?: boolean;
+    /**
+     * Node attributes, or a function that computes them from the match.
+     */
+    getAttributes?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+}
+/**
+ * Creates an input rule that changes the type of a textblock.
+ *
+ * @example
+ * // `## ` at start of line converts to heading level 2
+ * textblockTypeInputRule({
+ *   find: /^(#{1,4})\s$/,
+ *   type: schema.nodes.heading,
+ *   getAttributes: (match) => ({ level: match[1].length }),
+ * });
+ */
+export declare function textblockTypeInputRule(options: TextblockTypeInputRuleOptions): InputRule;
+//# sourceMappingURL=textblockTypeInputRule.d.ts.map

package/dist/helpers/textblockTypeInputRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textblockTypeInputRule.d.ts","sourceRoot":"","sources":["../../src/helpers/textblockTypeInputRule.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE3D,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,QAAQ,CAAC;IAEf;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,aAAa,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,gBAAgB,KAAK,KAAK,GAAG,IAAI,CAAC,CAAC;CAC5E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,6BAA6B,GAAG,SAAS,CAexF"}