@gravity-ui/markdown-editor 14.11.1 → 14.12.0

package/build/cjs/core/ExtensionsManager.js

@@ -1,5 +1,5 @@
 "use strict";
-var _ExtensionsManager_schemaRegistry, _ExtensionsManager_parserRegistry, _ExtensionsManager_serializerRegistry, _ExtensionsManager_nodeViewCreators, _ExtensionsManager_markViewCreators, _ExtensionsManager_pmTransformers, _ExtensionsManager_mdForMarkup, _ExtensionsManager_mdForText, _ExtensionsManager_extensions, _ExtensionsManager_builder, _ExtensionsManager_spec, _ExtensionsManager_deps, _ExtensionsManager_plugins, _ExtensionsManager_actions, _ExtensionsManager_nodeViews, _ExtensionsManager_markViews;
+var _ExtensionsManager_schemaRegistry, _ExtensionsManager_parserRegistry, _ExtensionsManager_serializerRegistry, _ExtensionsManager_nodeViewCreators, _ExtensionsManager_markViewCreators, _ExtensionsManager_pmTransformers, _ExtensionsManager_mdForMarkup, _ExtensionsManager_mdForText, _ExtensionsManager_extensions, _ExtensionsManager_builder, _ExtensionsManager_spec, _ExtensionsManager_deps, _ExtensionsManager_plugins, _ExtensionsManager_actions, _ExtensionsManager_nodeViews, _ExtensionsManager_markViews, _ExtensionsManager_serializerDynamicModifier, _ExtensionsManager_parserDynamicModifier;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtensionsManager = void 0;
 const tslib_1 = require("tslib");
@@ -11,10 +11,10 @@ const SchemaSpecRegistry_1 = require("./SchemaSpecRegistry");
 const SerializerTokensRegistry_1 = require("./SerializerTokensRegistry");
 class ExtensionsManager {
     constructor({ extensions, options = {} }) {
-        var _a, _b, _c, _d;
-        _ExtensionsManager_schemaRegistry.set(this, new SchemaSpecRegistry_1.SchemaSpecRegistry());
-        _ExtensionsManager_parserRegistry.set(this, new ParserTokensRegistry_1.ParserTokensRegistry());
-        _ExtensionsManager_serializerRegistry.set(this, new SerializerTokensRegistry_1.SerializerTokensRegistry());
+        var _a, _b, _c, _d, _e, _f, _g;
+        _ExtensionsManager_schemaRegistry.set(this, void 0);
+        _ExtensionsManager_parserRegistry.set(this, void 0);
+        _ExtensionsManager_serializerRegistry.set(this, void 0);
         _ExtensionsManager_nodeViewCreators.set(this, new Map());
         _ExtensionsManager_markViewCreators.set(this, new Map());
         _ExtensionsManager_pmTransformers.set(this, []);
@@ -28,6 +28,8 @@ class ExtensionsManager {
         _ExtensionsManager_actions.set(this, {});
         _ExtensionsManager_nodeViews.set(this, {});
         _ExtensionsManager_markViews.set(this, {});
+        _ExtensionsManager_serializerDynamicModifier.set(this, void 0);
+        _ExtensionsManager_parserDynamicModifier.set(this, void 0);
         this.processNode = (name, { spec, fromMd, toMd: toMd, view }) => {
             tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_schemaRegistry, "f").addNode(name, spec);
             tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").addToken(fromMd.tokenName || name, fromMd.tokenSpec);
@@ -44,10 +46,17 @@ class ExtensionsManager {
                 tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_markViewCreators, "f").set(name, view);
             }
         };
+        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_schemaRegistry, new SchemaSpecRegistry_1.SchemaSpecRegistry(undefined, (_a = options.dynamicModifiers) === null || _a === void 0 ? void 0 : _a.schema), "f");
+        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_parserRegistry, new ParserTokensRegistry_1.ParserTokensRegistry(), "f");
+        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_serializerRegistry, new SerializerTokensRegistry_1.SerializerTokensRegistry(), "f");
+        if (options.dynamicModifiers) {
+            tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_parserDynamicModifier, (_b = options.dynamicModifiers) === null || _b === void 0 ? void 0 : _b.parser, "f");
+            tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_serializerDynamicModifier, (_c = options.dynamicModifiers) === null || _c === void 0 ? void 0 : _c.serializer, "f");
+        }
         tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_extensions, extensions, "f");
-        const mdPreset = (_b = (_a = options.mdOpts) === null || _a === void 0 ? void 0 : _a.preset) !== null && _b !== void 0 ? _b : 'default';
-        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_mdForMarkup, new markdown_it_1.default(mdPreset, (_c = options.mdOpts) !== null && _c !== void 0 ? _c : {}), "f");
-        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_mdForText, new markdown_it_1.default(mdPreset, (_d = options.mdOpts) !== null && _d !== void 0 ? _d : {}), "f");
+        const mdPreset = (_e = (_d = options.mdOpts) === null || _d === void 0 ? void 0 : _d.preset) !== null && _e !== void 0 ? _e : 'default';
+        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_mdForMarkup, new markdown_it_1.default(mdPreset, (_f = options.mdOpts) !== null && _f !== void 0 ? _f : {}), "f");
+        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_mdForText, new markdown_it_1.default(mdPreset, (_g = options.mdOpts) !== null && _g !== void 0 ? _g : {}), "f");
         if (options.linkifyTlds) {
             tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f").linkify.tlds(options.linkifyTlds, true);
             tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f").linkify.tlds(options.linkifyTlds, true);
@@ -79,14 +88,21 @@ class ExtensionsManager {
         tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_spec, "f").nodes().forEach(this.processNode);
         tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_spec, "f").marks().forEach(this.processMark);
     }
+    createParser(schema, mdInstance) {
+        return tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").createParser(schema, mdInstance, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_pmTransformers, "f"), tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_parserDynamicModifier, "f"));
+    }
     createDeps() {
+        const actions = new ActionsManager_1.ActionsManager();
         const schema = tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_schemaRegistry, "f").createSchema();
+        const markupParser = this.createParser(schema, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f"));
+        const textParser = this.createParser(schema, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f"));
+        const serializer = tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").createSerializer(tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_serializerDynamicModifier, "f"));
         tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_deps, {
             schema,
-            actions: new ActionsManager_1.ActionsManager(),
-            markupParser: tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").createParser(schema, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f"), tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_pmTransformers, "f")),
-            textParser: tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").createParser(schema, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f"), tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_pmTransformers, "f")),
-            serializer: tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").createSerializer(),
+            actions,
+            markupParser,
+            textParser,
+            serializer,
         }, "f");
     }
     createDerived() {
@@ -101,4 +117,4 @@ class ExtensionsManager {
     }
 }
 exports.ExtensionsManager = ExtensionsManager;
-_ExtensionsManager_schemaRegistry = new WeakMap(), _ExtensionsManager_parserRegistry = new WeakMap(), _ExtensionsManager_serializerRegistry = new WeakMap(), _ExtensionsManager_nodeViewCreators = new WeakMap(), _ExtensionsManager_markViewCreators = new WeakMap(), _ExtensionsManager_pmTransformers = new WeakMap(), _ExtensionsManager_mdForMarkup = new WeakMap(), _ExtensionsManager_mdForText = new WeakMap(), _ExtensionsManager_extensions = new WeakMap(), _ExtensionsManager_builder = new WeakMap(), _ExtensionsManager_spec = new WeakMap(), _ExtensionsManager_deps = new WeakMap(), _ExtensionsManager_plugins = new WeakMap(), _ExtensionsManager_actions = new WeakMap(), _ExtensionsManager_nodeViews = new WeakMap(), _ExtensionsManager_markViews = new WeakMap();
+_ExtensionsManager_schemaRegistry = new WeakMap(), _ExtensionsManager_parserRegistry = new WeakMap(), _ExtensionsManager_serializerRegistry = new WeakMap(), _ExtensionsManager_nodeViewCreators = new WeakMap(), _ExtensionsManager_markViewCreators = new WeakMap(), _ExtensionsManager_pmTransformers = new WeakMap(), _ExtensionsManager_mdForMarkup = new WeakMap(), _ExtensionsManager_mdForText = new WeakMap(), _ExtensionsManager_extensions = new WeakMap(), _ExtensionsManager_builder = new WeakMap(), _ExtensionsManager_spec = new WeakMap(), _ExtensionsManager_deps = new WeakMap(), _ExtensionsManager_plugins = new WeakMap(), _ExtensionsManager_actions = new WeakMap(), _ExtensionsManager_nodeViews = new WeakMap(), _ExtensionsManager_markViews = new WeakMap(), _ExtensionsManager_serializerDynamicModifier = new WeakMap(), _ExtensionsManager_parserDynamicModifier = new WeakMap();

package/build/cjs/core/ParserTokensRegistry.d.ts

@@ -1,9 +1,10 @@
 import type MarkdownIt from 'markdown-it';
 import type { Schema } from 'prosemirror-model';
+import { MarkdownParserDynamicModifier } from './markdown/MarkdownParser';
 import { TransformFn } from './markdown/ProseMirrorTransformer';
 import type { Parser, ParserToken } from './types/parser';
 export declare class ParserTokensRegistry {
     #private;
     addToken(name: string, token: ParserToken): this;
-    createParser(schema: Schema, tokenizer: MarkdownIt, pmTransformers: TransformFn[]): Parser;
+    createParser(schema: Schema, tokenizer: MarkdownIt, pmTransformers: TransformFn[], dynamicModifier?: MarkdownParserDynamicModifier): Parser;
 }

package/build/cjs/core/ParserTokensRegistry.js

@@ -12,8 +12,8 @@ class ParserTokensRegistry {
         tslib_1.__classPrivateFieldGet(this, _ParserTokensRegistry_tokens, "f")[name] = token;
         return this;
     }
-    createParser(schema, tokenizer, pmTransformers) {
-        return new MarkdownParser_1.MarkdownParser(schema, tokenizer, tslib_1.__classPrivateFieldGet(this, _ParserTokensRegistry_tokens, "f"), pmTransformers);
+    createParser(schema, tokenizer, pmTransformers, dynamicModifier) {
+        return new MarkdownParser_1.MarkdownParser(schema, tokenizer, tslib_1.__classPrivateFieldGet(this, _ParserTokensRegistry_tokens, "f"), pmTransformers, dynamicModifier);
     }
 }
 exports.ParserTokensRegistry = ParserTokensRegistry;

package/build/cjs/core/SchemaDynamicModifier.d.ts

@@ -0,0 +1,3 @@
+export declare type TokenAttrs = {
+    [name: string]: unknown;
+};

package/build/cjs/core/SchemaDynamicModifier.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaDynamicModifier = void 0;
+/** @internal */
+class SchemaDynamicModifier {
+    constructor(config) {
+        this.nodeSpecsProcessors = new Map(Object.entries(config));
+    }
+    processNodeSpec(name, nodeSpec) {
+        let updatedSpec = nodeSpec;
+        this.nodeSpecsProcessors.forEach((processor, elementType) => {
+            if (name === elementType &&
+                processor.allowedAttrs &&
+                processor.allowedAttrs.length > 0 &&
+                nodeSpec) {
+                updatedSpec = Object.assign(Object.assign({}, nodeSpec), { attrs: Object.assign(Object.assign({}, nodeSpec.attrs), processor.allowedAttrs.reduce((acc, key) => {
+                        acc[key] = { default: null };
+                        return acc;
+                    }, {})) });
+            }
+        });
+        return updatedSpec;
+    }
+}
+exports.SchemaDynamicModifier = SchemaDynamicModifier;

package/build/cjs/core/SchemaSpecRegistry.d.ts

@@ -1,7 +1,8 @@
 import { MarkSpec, NodeSpec, Schema } from 'prosemirror-model';
+import { SchemaDynamicModifier } from './SchemaDynamicModifier';
 export declare class SchemaSpecRegistry {
     #private;
-    constructor(topNode?: string);
+    constructor(topNode?: string, dynamicModifier?: SchemaDynamicModifier);
     addNode(name: string, spec: NodeSpec): this;
     addMark(name: string, spec: MarkSpec): this;
     createSchema(): Schema<string, string>;

package/build/cjs/core/SchemaSpecRegistry.js

@@ -1,16 +1,21 @@
 "use strict";
-var _SchemaSpecRegistry_spec;
+var _SchemaSpecRegistry_spec, _SchemaSpecRegistry_dynamicModifier;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaSpecRegistry = void 0;
 const tslib_1 = require("tslib");
 const prosemirror_model_1 = require("prosemirror-model");
 class SchemaSpecRegistry {
-    constructor(topNode) {
+    constructor(topNode, dynamicModifier) {
         _SchemaSpecRegistry_spec.set(this, void 0);
+        _SchemaSpecRegistry_dynamicModifier.set(this, void 0);
         tslib_1.__classPrivateFieldSet(this, _SchemaSpecRegistry_spec, { topNode, nodes: {}, marks: {} }, "f");
+        tslib_1.__classPrivateFieldSet(this, _SchemaSpecRegistry_dynamicModifier, dynamicModifier, "f");
     }
     addNode(name, spec) {
-        tslib_1.__classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f").nodes[name] = spec;
+        const modifiedSpec = tslib_1.__classPrivateFieldGet(this, _SchemaSpecRegistry_dynamicModifier, "f")
+            ? tslib_1.__classPrivateFieldGet(this, _SchemaSpecRegistry_dynamicModifier, "f").processNodeSpec(name, spec)
+            : spec;
+        tslib_1.__classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f").nodes[name] = modifiedSpec;
         return this;
     }
     addMark(name, spec) {
@@ -22,4 +27,4 @@ class SchemaSpecRegistry {
     }
 }
 exports.SchemaSpecRegistry = SchemaSpecRegistry;
-_SchemaSpecRegistry_spec = new WeakMap();
+_SchemaSpecRegistry_spec = new WeakMap(), _SchemaSpecRegistry_dynamicModifier = new WeakMap();

package/build/cjs/core/SerializerTokensRegistry.d.ts

@@ -1,7 +1,8 @@
+import { MarkdownSerializerDynamicModifier } from './markdown/MarkdownSerializerDynamicModifier';
 import type { Serializer, SerializerMarkToken, SerializerNodeToken } from './types/serializer';
 export declare class SerializerTokensRegistry {
     #private;
     addNode(name: string, node: SerializerNodeToken): this;
     addMark(name: string, mark: SerializerMarkToken): this;
-    createSerializer(): Serializer;
+    createSerializer(dynamicModifier?: MarkdownSerializerDynamicModifier): Serializer;
 }

package/build/cjs/core/SerializerTokensRegistry.js

@@ -17,8 +17,8 @@ class SerializerTokensRegistry {
         tslib_1.__classPrivateFieldGet(this, _SerializerTokensRegistry_marks, "f")[name] = mark;
         return this;
     }
-    createSerializer() {
-        return new MarkdownSerializer_1.MarkdownSerializer(tslib_1.__classPrivateFieldGet(this, _SerializerTokensRegistry_nodes, "f"), tslib_1.__classPrivateFieldGet(this, _SerializerTokensRegistry_marks, "f"));
+    createSerializer(dynamicModifier) {
+        return new MarkdownSerializer_1.MarkdownSerializer(tslib_1.__classPrivateFieldGet(this, _SerializerTokensRegistry_nodes, "f"), tslib_1.__classPrivateFieldGet(this, _SerializerTokensRegistry_marks, "f"), dynamicModifier);
     }
 }
 exports.SerializerTokensRegistry = SerializerTokensRegistry;

package/build/cjs/core/index.d.ts

@@ -9,3 +9,5 @@ export type { Extension, ExtensionAuto, ExtensionWithOptions, ExtensionDeps, Ext
 export type { Parser, ParserToken } from './types/parser';
 export type { Serializer, SerializerState, SerializerNodeToken, SerializerMarkToken, } from './types/serializer';
 export type { NodeViewConstructor, MarkViewConstructor } from './types/node-views';
+export type { MarkdownParserDynamicModifierConfig } from './markdown/MarkdownParser';
+export type { MarkdownSerializerDynamicModifierConfig } from './markdown/MarkdownSerializerDynamicModifier';

package/build/cjs/core/markdown/MarkdownParser.d.ts

@@ -1,9 +1,10 @@
 import type { Match } from 'linkify-it';
 import type MarkdownIt from 'markdown-it';
+import type Token from 'markdown-it/lib/token';
 import { Mark, Node, NodeType, Schema } from 'prosemirror-model';
 import type { Parser, ParserToken } from '../types/parser';
 import { TransformFn } from './ProseMirrorTransformer';
-declare type TokenAttrs = {
+export declare type TokenAttrs = {
     [name: string]: unknown;
 };
 export declare class MarkdownParser implements Parser {
@@ -17,7 +18,8 @@ export declare class MarkdownParser implements Parser {
     tokens: Record<string, ParserToken>;
     tokenizer: MarkdownIt;
     pmTransformers: TransformFn[];
-    constructor(schema: Schema, tokenizer: MarkdownIt, tokens: Record<string, ParserToken>, pmTransformers: TransformFn[]);
+    dynamicModifier: MarkdownParserDynamicModifier | null;
+    constructor(schema: Schema, tokenizer: MarkdownIt, tokens: Record<string, ParserToken>, pmTransformers: TransformFn[], dynamicModifier?: MarkdownParserDynamicModifier);
     validateLink(url: string): boolean;
     normalizeLink(url: string): string;
     normalizeLinkText(url: string): string;
@@ -30,6 +32,7 @@ export declare class MarkdownParser implements Parser {
     private getTokenType;
     private handlePrimitiveToken;
     private handleMark;
+    private getNodeSchema;
     private handleNode;
     private handleBlock;
     private handleToken;
@@ -41,4 +44,5 @@ export declare class MarkdownParser implements Parser {
     private closeMark;
     private parseTokens;
 }
-export {};
+export declare type ProcessNodeAttrs = (token: Token, attrs: TokenAttrs, allowedAttrs?: string[]) => TokenAttrs;
+export declare type ProcessNode = (node: Node) => Node;

package/build/cjs/core/markdown/MarkdownParser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MarkdownParser = void 0;
+exports.MarkdownParserDynamicModifier = exports.MarkdownParser = void 0;
 const prosemirror_model_1 = require("prosemirror-model");
 const logger_1 = require("../../logger");
 const ProseMirrorTransformer_1 = require("./ProseMirrorTransformer");
@@ -12,14 +12,23 @@ var TokenType;
     TokenType["close"] = "close";
     TokenType["default"] = "default";
 })(TokenType || (TokenType = {}));
+/**
+ * Remove suffixes from the node name.
+ * Crops specified `openSuffix` and `closeSuffix` from the end of the given `tokName`.
+ */
+function cropNodeName(tokName, openSuffix, closeSuffix) {
+    const regex = new RegExp(`(${openSuffix})$|(${closeSuffix})$`);
+    return tokName.replace(regex, '');
+}
 class MarkdownParser {
-    constructor(schema, tokenizer, tokens, pmTransformers) {
+    constructor(schema, tokenizer, tokens, pmTransformers, dynamicModifier) {
         this.stack = [];
         this.schema = schema;
         this.marks = prosemirror_model_1.Mark.none;
         this.tokens = tokens;
         this.tokenizer = tokenizer;
         this.pmTransformers = pmTransformers;
+        this.dynamicModifier = dynamicModifier !== null && dynamicModifier !== void 0 ? dynamicModifier : null;
     }
     validateLink(url) {
         return this.tokenizer.validateLink(url);
@@ -40,6 +49,9 @@ class MarkdownParser {
             let mdItTokens;
             try {
                 mdItTokens = this.tokenizer.parse(text, {});
+                if (this.dynamicModifier) {
+                    mdItTokens = this.dynamicModifier.processTokens(mdItTokens, text);
+                }
             }
             catch (err) {
                 const e = err;
@@ -68,11 +80,20 @@ class MarkdownParser {
     }
     //#region helpers
     getTokenAttrs(token, tokenSpec, tokenStream, i) {
-        if (tokenSpec.getAttrs)
-            return tokenSpec.getAttrs(token, tokenStream, i);
-        else if (tokenSpec.attrs instanceof Function)
-            return tokenSpec.attrs(token);
-        return tokenSpec.attrs;
+        let attrs = {};
+        if (tokenSpec.getAttrs) {
+            attrs = tokenSpec.getAttrs(token, tokenStream, i);
+        }
+        else if (tokenSpec.attrs instanceof Function) {
+            attrs = tokenSpec.attrs(token);
+        }
+        else {
+            attrs = tokenSpec.attrs;
+        }
+        if (this.dynamicModifier) {
+            attrs = this.dynamicModifier.processAttrs(token, attrs !== null && attrs !== void 0 ? attrs : {});
+        }
+        return attrs;
     }
     getTokenSpec(token) {
         var _a;
@@ -80,12 +101,14 @@ class MarkdownParser {
         let tokName = ((_a = token.meta) === null || _a === void 0 ? void 0 : _a['pm-node']) || token.type;
         // Cropping _open and _close from node name end
         // e.g. paragraph_open -> paragraph
-        tokName = tokName.replace(new RegExp(`(${openSuffix})$|(${closeSuffix})$`), '');
+        tokName = cropNodeName(tokName, openSuffix, closeSuffix);
         let tokenSpec;
-        if (tokName in this.tokens)
+        if (tokName in this.tokens) {
             tokenSpec = this.tokens[tokName];
-        if (!tokenSpec)
+        }
+        if (!tokenSpec) {
             throw new RangeError(`No token spec for token: ${JSON.stringify(token)}`);
+        }
         return tokenSpec;
     }
     // Getting token type from its name
@@ -139,14 +162,18 @@ class MarkdownParser {
             }
         }
     }
+    getNodeSchema(tokenSpec) {
+        const spec = this.schema.nodes[tokenSpec.name];
+        return spec;
+    }
     handleNode(_token, tokenSpec, attrs) {
-        const schemaSpec = this.schema.nodes[tokenSpec.name];
+        const schemaSpec = this.getNodeSchema(tokenSpec);
         // Adding node as is, becasuse it doesn't contain content.
         this.addNode(schemaSpec, attrs);
     }
     handleBlock(token, tokenSpec, attrs) {
         var _a;
-        const schemaSpec = this.schema.nodes[tokenSpec.name];
+        const schemaSpec = this.getNodeSchema(tokenSpec);
         if (tokenSpec.noCloseToken) {
             this.openNode(schemaSpec, attrs);
             if (tokenSpec.contentField === 'children' && ((_a = token.children) === null || _a === void 0 ? void 0 : _a.length)) {
@@ -189,9 +216,13 @@ class MarkdownParser {
     //#endregion
     //#region state methods
     addNode(type, attrs, content) {
-        const node = type.createAndFill(attrs, content, this.marks);
-        if (!node)
+        let node = type.createAndFill(attrs, content, this.marks);
+        if (!node) {
             return null;
+        }
+        if (this.dynamicModifier) {
+            node = this.dynamicModifier.processNodes(node);
+        }
         this.push(node);
         return node;
     }
@@ -200,11 +231,13 @@ class MarkdownParser {
     }
     closeNode() {
         // Marks operate within a node. Therefore, when we close the node, we reset the existing marks.
-        if (this.marks.length)
+        if (this.marks.length) {
             this.marks = prosemirror_model_1.Mark.none;
+        }
         const info = this.stack.pop();
-        if (info)
+        if (info) {
             return this.addNode(info.type, info.attrs, info.content);
+        }
         return null;
     }
     addText(text) {
@@ -252,3 +285,39 @@ function maybeMerge(a, b) {
 function withoutTrailingNewline(str) {
     return str[str.length - 1] === '\n' || str.endsWith('\\n') ? str.slice(0, str.length - 1) : str;
 }
+/** @internal */
+class MarkdownParserDynamicModifier {
+    constructor(config) {
+        this.elementProcessors = new Map(Object.entries(config));
+    }
+    processTokens(tokens, rawMarkup) {
+        return tokens.map((token, index) => {
+            const processor = this.elementProcessors.get(cropNodeName(token.type, openSuffix, ''));
+            if (!processor || !processor.processToken || processor.processToken.length === 0) {
+                return token;
+            }
+            return processor.processToken.reduce((currentToken, process) => {
+                return process(currentToken, index, rawMarkup);
+            }, token);
+        });
+    }
+    processAttrs(token, attrs) {
+        const processor = this.elementProcessors.get(cropNodeName(token.type, openSuffix, ''));
+        if (!processor || !processor.processNodeAttrs || processor.processNodeAttrs.length === 0) {
+            return attrs;
+        }
+        return processor.processNodeAttrs.reduce((currentAttrs, process) => {
+            return process(token, currentAttrs);
+        }, attrs);
+    }
+    processNodes(node) {
+        const processor = this.elementProcessors.get(node.type.name);
+        if (!processor || !processor.processNode || processor.processNode.length === 0) {
+            return node;
+        }
+        return processor.processNode.reduce((currentNode, process) => {
+            return process(currentNode);
+        }, node);
+    }
+}
+exports.MarkdownParserDynamicModifier = MarkdownParserDynamicModifier;

package/build/cjs/core/markdown/MarkdownSerializer.d.ts

@@ -1,13 +1,14 @@
 export class MarkdownSerializer {
-    constructor(nodes: any, marks: any);
+    constructor(nodes: any, marks: any, dynamicModifier: any);
     nodes: any;
     marks: any;
+    dynamicModifier: any;
     serialize(content: any, options: any): string;
     containsNode(nodeName: any): boolean;
     containsMark(markName: any): boolean;
 }
 export class MarkdownSerializerState {
-    constructor(nodes: any, marks: any, options: any);
+    constructor(nodes: any, marks: any, options: any, dynamicModifier: any);
     nodes: any;
     marks: any;
     delim: string;
@@ -20,6 +21,7 @@ export class MarkdownSerializerState {
     /** @type {Boolean} */
     escapeWhitespace: boolean;
     options: any;
+    dynamicModifier: any;
     setNoAutoBlank(): void;
     unsetNoAutoBlank(): void;
     flushClose(size: any): void;

package/build/cjs/core/markdown/MarkdownSerializer.js

@@ -39,18 +39,19 @@ class MarkdownSerializer {
     // outside the marks. This is necessary for emphasis marks as
     // CommonMark does not permit enclosing whitespace inside emphasis
     // marks, see: http://spec.commonmark.org/0.26/#example-330
-    constructor(nodes, marks) {
+    constructor(nodes, marks, dynamicModifier) {
         // :: Object<(MarkdownSerializerState, Node)> The node serializer
         // functions for this serializer.
         this.nodes = nodes;
         // :: Object The mark serializer info.
         this.marks = marks;
+        this.dynamicModifier = dynamicModifier;
     }
     // :: (Node, ?Object) → string
     // Serialize the content of the given node to
     // [CommonMark](http://commonmark.org/).
     serialize(content, options) {
-        const state = new MarkdownSerializerState(this.nodes, this.marks, options);
+        const state = new MarkdownSerializerState(this.nodes, this.marks, options, this.dynamicModifier);
         state.renderContent(content);
         return state.out;
     }
@@ -69,7 +70,7 @@ exports.MarkdownSerializer = MarkdownSerializer;
 // node and mark serialization methods (see `toMarkdown`).
 // prettier-ignore
 class MarkdownSerializerState {
-    constructor(nodes, marks, options) {
+    constructor(nodes, marks, options, dynamicModifier) {
         this.nodes = nodes;
         this.marks = marks;
         this.delim = this.out = '';
@@ -87,6 +88,7 @@ class MarkdownSerializerState {
         //   on a node level by specifying a tight attribute on the node.
         //   Defaults to false.
         this.options = options || {};
+        this.dynamicModifier = dynamicModifier;
         if (typeof this.options.tightLists === 'undefined') {
             this.options.tightLists = false;
         }
@@ -177,11 +179,19 @@ class MarkdownSerializerState {
     // :: (Node)
     // Render the given node as a block.
     render(node, parent, index) {
-        if (typeof parent === 'number')
+        if (typeof parent === 'number') {
             throw new Error('!');
-        if (!this.nodes[node.type.name])
+        }
+        if (!this.nodes[node.type.name]) {
             throw new Error('Token type `' + node.type.name + '` not supported by Markdown renderer');
-        this.nodes[node.type.name](this, node, parent, index);
+        }
+        const callback = this.nodes[node.type.name];
+        if (this.dynamicModifier) {
+            this.dynamicModifier.processNode(this, node, parent, index, callback);
+        }
+        else {
+            callback(this, node, parent, index);
+        }
     }
     // :: (Node)
     // Render the contents of `parent` as block nodes.

package/build/cjs/core/markdown/MarkdownSerializerDynamicModifier.d.ts

@@ -0,0 +1 @@
+export {};

package/build/cjs/core/markdown/MarkdownSerializerDynamicModifier.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownSerializerDynamicModifier = void 0;
+/**
+ * Class MarkdownSerializerDynamicModifier
+ *
+ * Provides a mechanism for dynamic modification of node serialization during conversion of ProseMirror nodes
+ * to a markdown-like format. It allows sequential processing of nodes by applying a series of custom handlers:
+ *
+ *    - `processNode`: An array of handlers that process nodes sequentially, each modifying the output.
+ *
+ * Example:
+ * ```ts
+ * const serializerModifier = new MarkdownSerializerDynamicModifier({
+ *     paragraph: {
+ *         processNode: [
+ *             (state, node, parent, index, callback) => {
+ *                 // Custom modifications can be performed here.
+ *                 callback(state, node, parent, index);
+ *             },
+ *         ],
+ *     },
+ * });
+ * ```
+ *
+ * This class extends the functionality of a MarkdownSerializer for scenarios such as:
+ * - Customizing the serialization output.
+ * - Logging or modifying node content during serialization.
+ */
+/** @internal */
+class MarkdownSerializerDynamicModifier {
+    constructor(config) {
+        this.nodeProcessors = new Map(Object.entries(config));
+    }
+    processNode(state, node, parent, index, callback) {
+        const nodeType = this.nodeProcessors.get(node.type.name);
+        if (!nodeType || !nodeType.processNode || nodeType.processNode.length === 0) {
+            callback(state, node, parent, index);
+        }
+        else {
+            nodeType.processNode.forEach((process) => {
+                process(state, node, parent, index, callback);
+            });
+        }
+    }
+}
+exports.MarkdownSerializerDynamicModifier = MarkdownSerializerDynamicModifier;

package/build/cjs/core/types/dynamicModifiers.d.ts

@@ -0,0 +1 @@
+export {};

package/build/cjs/core/types/dynamicModifiers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/core/utils/dynamicModifiers.d.ts

@@ -0,0 +1,9 @@
+import { SchemaDynamicModifierConfig } from '../SchemaDynamicModifier';
+import { MarkdownParserDynamicModifierConfig } from '../markdown/MarkdownParser';
+import { MarkdownSerializerDynamicModifierConfig } from '../markdown/MarkdownSerializerDynamicModifier';
+import { DynamicModifiers } from '../types/dynamicModifiers';
+export declare function convertDynamicModifiersConfigs(modifiers: DynamicModifiers[]): {
+    parser: MarkdownParserDynamicModifierConfig;
+    schema: SchemaDynamicModifierConfig;
+    serializer: MarkdownSerializerDynamicModifierConfig;
+};

package/build/cjs/core/utils/dynamicModifiers.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertDynamicModifiersConfigs = void 0;
+function convertDynamicModifiersConfigs(modifiers) {
+    const parser = {};
+    const schema = {};
+    const serializer = {};
+    modifiers.forEach((modifier) => {
+        var _a, _b, _c, _d;
+        switch (modifier.type) {
+            case 'parserToken': {
+                const { tokenName, process } = modifier;
+                parser[tokenName] = parser[tokenName] || {};
+                parser[tokenName].processToken = parser[tokenName].processToken || [];
+                (_a = parser[tokenName].processToken) === null || _a === void 0 ? void 0 : _a.push(process);
+                break;
+            }
+            case 'parserNodeAttrs': {
+                const { tokenName, process } = modifier;
+                parser[tokenName] = parser[tokenName] || {};
+                parser[tokenName].processNodeAttrs = parser[tokenName].processNodeAttrs || [];
+                (_b = parser[tokenName].processNodeAttrs) === null || _b === void 0 ? void 0 : _b.push(process);
+                break;
+            }
+            case 'parserNode': {
+                const { nodeName, process } = modifier;
+                parser[nodeName] = parser[nodeName] || {};
+                parser[nodeName].processNode = parser[nodeName].processNode || [];
+                (_c = parser[nodeName].processNode) === null || _c === void 0 ? void 0 : _c.push(process);
+                break;
+            }
+            case 'serializerNode': {
+                const { nodeName, process } = modifier;
+                serializer[nodeName] = serializer[nodeName] || {};
+                serializer[nodeName].processNode = serializer[nodeName].processNode || [];
+                (_d = serializer[nodeName].processNode) === null || _d === void 0 ? void 0 : _d.push(process);
+                break;
+            }
+            case 'schemaNodeSpec': {
+                const { nodeName, allowedAttrs } = modifier;
+                schema[nodeName] = { allowedAttrs };
+                break;
+            }
+        }
+    });
+    return { parser, schema, serializer };
+}
+exports.convertDynamicModifiersConfigs = convertDynamicModifiersConfigs;

package/build/cjs/extensions/behavior/CommandMenu/component.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { AutocompletePopupProps } from '../../../utils/autocomplete-popup';
 import type { CommandAction } from './types';
-export declare type CommandMenuItem = Pick<CommandAction, 'id' | 'title' | 'icon' | 'hotkey' | 'hint'>;
+export declare type CommandMenuItem = Pick<CommandAction, 'id' | 'title' | 'icon' | 'hotkey' | 'hint' | 'preview'>;
 export declare type CommandMenuComponentProps = AutocompletePopupProps & {
     currentIndex?: number;
     items: readonly CommandMenuItem[];