@gravity-ui/markdown-editor 13.0.0

package/build/cjs/core/ExtensionBuilder.js

@@ -0,0 +1,141 @@
+"use strict";
+var _ExtensionBuilder_confMdCbs, _ExtensionBuilder_nodeSpecs, _ExtensionBuilder_markSpecs, _ExtensionBuilder_plugins, _ExtensionBuilder_actions;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionBuilder = void 0;
+const tslib_1 = require("tslib");
+const orderedmap_1 = tslib_1.__importDefault(require("orderedmap")); // eslint-disable-line import/no-extraneous-dependencies
+const prosemirror_inputrules_1 = require("prosemirror-inputrules");
+const prosemirror_keymap_1 = require("prosemirror-keymap");
+var Priority;
+(function (Priority) {
+    Priority[Priority["Highest"] = 1000000] = "Highest";
+    Priority[Priority["VeryHigh"] = 100000] = "VeryHigh";
+    Priority[Priority["High"] = 10000] = "High";
+    Priority[Priority["Medium"] = 1000] = "Medium";
+    Priority[Priority["Low"] = 100] = "Low";
+    Priority[Priority["VeryLow"] = 10] = "VeryLow";
+    Priority[Priority["Lowest"] = 0] = "Lowest";
+})(Priority || (Priority = {}));
+const DEFAULT_PRIORITY = Priority.Medium;
+class ExtensionBuilder {
+    constructor(context) {
+        this.Priority = ExtensionBuilder.Priority;
+        /** @deprecated use `builder.Priority` instead */
+        this.PluginPriority = ExtensionBuilder.PluginPriority;
+        /* eslint-enable @typescript-eslint/member-ordering */
+        _ExtensionBuilder_confMdCbs.set(this, []);
+        _ExtensionBuilder_nodeSpecs.set(this, {});
+        _ExtensionBuilder_markSpecs.set(this, {});
+        _ExtensionBuilder_plugins.set(this, []);
+        _ExtensionBuilder_actions.set(this, []);
+        this.context = context !== null && context !== void 0 ? context : ExtensionBuilder.createContext();
+    }
+    static createContext() {
+        return new Map();
+    }
+    use(extension, ...params) {
+        extension(this, ...params);
+        return this;
+    }
+    configureMd(cb, params = {}) {
+        var _a, _b;
+        tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_confMdCbs, "f").push({
+            cb,
+            params: {
+                text: (_a = params.text) !== null && _a !== void 0 ? _a : true,
+                markup: (_b = params.markup) !== null && _b !== void 0 ? _b : true,
+            },
+        });
+        return this;
+    }
+    addNode(name, cb) {
+        if (tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_nodeSpecs, "f")[name]) {
+            throw new Error(`ProseMirror node with this name "${name}" already exist`);
+        }
+        tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_nodeSpecs, "f")[name] = { name, cb };
+        return this;
+    }
+    addMark(name, cb, priority = DEFAULT_PRIORITY) {
+        if (tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_markSpecs, "f")[name]) {
+            throw new Error(`ProseMirror mark with this name "${name}" already exist`);
+        }
+        tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_markSpecs, "f")[name] = { name, cb, priority };
+        return this;
+    }
+    addPlugin(cb, priority = DEFAULT_PRIORITY) {
+        tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").push({ cb, priority });
+        return this;
+    }
+    addKeymap(cb, priority = DEFAULT_PRIORITY) {
+        tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").push({ cb: (...args) => (0, prosemirror_keymap_1.keymap)(cb(...args)), priority });
+        return this;
+    }
+    addInputRules(cb, priority = DEFAULT_PRIORITY) {
+        tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").push({ cb: (...args) => (0, prosemirror_inputrules_1.inputRules)(cb(...args)), priority });
+        return this;
+    }
+    addAction(name, cb) {
+        if (tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_actions, "f").some(([actionName]) => actionName === name)) {
+            throw new Error(`[Markdown Wysiwyg Editor] action with this name "${name}" already exist`);
+        }
+        tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_actions, "f").push([name, cb]);
+        return this;
+    }
+    build() {
+        const confMd = tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_confMdCbs, "f").slice();
+        const nodes = Object.assign({}, tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_nodeSpecs, "f"));
+        const marks = Object.assign({}, tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_markSpecs, "f"));
+        const plugins = tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").slice();
+        const actions = tslib_1.__classPrivateFieldGet(this, _ExtensionBuilder_actions, "f").slice();
+        return {
+            configureMd: (md, parserType) => confMd.reduce((pMd, { cb, params }) => {
+                if (parserType === 'text' && params.text) {
+                    return cb(pMd);
+                }
+                if (parserType === 'markup' && params.markup) {
+                    return cb(pMd);
+                }
+                return pMd;
+            }, md),
+            nodes: () => {
+                let map = orderedmap_1.default.from({});
+                for (const { name, cb } of Object.values(nodes)) {
+                    map = map.addToEnd(name, cb());
+                }
+                return map;
+            },
+            marks: () => {
+                // The order of marks in schema is important when serializing pm-document to DOM or markup
+                // https://discuss.prosemirror.net/t/marks-priority/4463
+                const sortedMarks = Object.values(marks).sort((a, b) => b.priority - a.priority);
+                let map = orderedmap_1.default.from({});
+                for (const { name, cb } of sortedMarks) {
+                    map = map.addToEnd(name, cb());
+                }
+                return map;
+            },
+            plugins: (deps) => {
+                return plugins
+                    .sort((a, b) => b.priority - a.priority)
+                    .reduce((acc, { cb }) => {
+                    const res = cb(deps);
+                    if (Array.isArray(res))
+                        acc.push(...res);
+                    else
+                        acc.push(res);
+                    return acc;
+                }, []);
+            },
+            actions: (deps) => actions.reduce((obj, [name, cb]) => {
+                obj[name] = cb(deps);
+                return obj;
+            }, {}),
+        };
+    }
+}
+exports.ExtensionBuilder = ExtensionBuilder;
+_ExtensionBuilder_confMdCbs = new WeakMap(), _ExtensionBuilder_nodeSpecs = new WeakMap(), _ExtensionBuilder_markSpecs = new WeakMap(), _ExtensionBuilder_plugins = new WeakMap(), _ExtensionBuilder_actions = new WeakMap();
+/* eslint-disable @typescript-eslint/member-ordering */
+ExtensionBuilder.Priority = Priority;
+/** @deprecated use `ExtensionBuilder.Priority` instead */
+ExtensionBuilder.PluginPriority = ExtensionBuilder.Priority;

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

@@ -0,0 +1,49 @@
+import MarkdownIt, { PresetName } from 'markdown-it';
+import type { Plugin } from 'prosemirror-state';
+import { ActionsManager } from './ActionsManager';
+import type { ActionSpec } from './types/actions';
+import type { Extension, ExtensionDeps } from './types/extension';
+import type { MarkViewConstructor, NodeViewConstructor } from './types/node-views';
+declare type ExtensionsManagerParams = {
+    extensions: Extension;
+    options?: ExtensionsManagerOptions;
+};
+declare type ExtensionsManagerOptions = {
+    mdOpts?: MarkdownIt.Options & {
+        preset?: PresetName;
+    };
+    linkifyTlds?: string | string[];
+};
+export declare class ExtensionsManager {
+    #private;
+    static process(extensions: Extension, options: ExtensionsManagerOptions): {
+        actions: ActionsManager;
+        rawActions: Record<string, ActionSpec>;
+        plugins: Plugin<any>[];
+        nodeViews: Record<string, NodeViewConstructor>;
+        markViews: Record<string, MarkViewConstructor>;
+        schema: import("prosemirror-model").Schema<any, any>;
+        textParser: import(".").Parser;
+        markupParser: import(".").Parser;
+        serializer: import(".").Serializer;
+    };
+    constructor({ extensions, options }: ExtensionsManagerParams);
+    build(): {
+        actions: ActionsManager;
+        rawActions: Record<string, ActionSpec>;
+        plugins: Plugin<any>[];
+        nodeViews: Record<string, NodeViewConstructor>;
+        markViews: Record<string, MarkViewConstructor>;
+        schema: import("prosemirror-model").Schema<any, any>;
+        textParser: import(".").Parser;
+        markupParser: import(".").Parser;
+        serializer: import(".").Serializer;
+    };
+    buildDeps(): ExtensionDeps;
+    private processExtensions;
+    private processNode;
+    private processMark;
+    private createDeps;
+    private createDerived;
+}
+export {};

package/build/cjs/core/ExtensionsManager.js

@@ -0,0 +1,100 @@
+"use strict";
+var _ExtensionsManager_schemaRegistry, _ExtensionsManager_parserRegistry, _ExtensionsManager_serializerRegistry, _ExtensionsManager_nodeViewCreators, _ExtensionsManager_markViewCreators, _ExtensionsManager_mdForMarkup, _ExtensionsManager_mdForText, _ExtensionsManager_extensions, _ExtensionsManager_builder, _ExtensionsManager_spec, _ExtensionsManager_deps, _ExtensionsManager_plugins, _ExtensionsManager_actions, _ExtensionsManager_nodeViews, _ExtensionsManager_markViews;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionsManager = void 0;
+const tslib_1 = require("tslib");
+const markdown_it_1 = tslib_1.__importDefault(require("markdown-it"));
+const ActionsManager_1 = require("./ActionsManager");
+const ExtensionBuilder_1 = require("./ExtensionBuilder");
+const ParserTokensRegistry_1 = require("./ParserTokensRegistry");
+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());
+        _ExtensionsManager_nodeViewCreators.set(this, new Map());
+        _ExtensionsManager_markViewCreators.set(this, new Map());
+        _ExtensionsManager_mdForMarkup.set(this, void 0);
+        _ExtensionsManager_mdForText.set(this, void 0);
+        _ExtensionsManager_extensions.set(this, void 0);
+        _ExtensionsManager_builder.set(this, void 0);
+        _ExtensionsManager_spec.set(this, void 0);
+        _ExtensionsManager_deps.set(this, void 0);
+        _ExtensionsManager_plugins.set(this, []);
+        _ExtensionsManager_actions.set(this, {});
+        _ExtensionsManager_nodeViews.set(this, {});
+        _ExtensionsManager_markViews.set(this, {});
+        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);
+            tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").addNode(name, toMd);
+            if (view) {
+                tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_nodeViewCreators, "f").set(name, view);
+            }
+        };
+        this.processMark = (name, { spec, fromMd, toMd, view }) => {
+            tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_schemaRegistry, "f").addMark(name, spec);
+            tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").addToken(fromMd.tokenName || name, fromMd.tokenSpec);
+            tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").addMark(name, toMd);
+            if (view) {
+                tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_markViewCreators, "f").set(name, view);
+            }
+        };
+        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");
+        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);
+        }
+        // TODO: add prefilled context
+        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_builder, new ExtensionBuilder_1.ExtensionBuilder(), "f");
+    }
+    static process(extensions, options) {
+        return new this({ extensions, options }).build();
+    }
+    build() {
+        this.processExtensions();
+        this.createDeps();
+        this.createDerived();
+        return Object.assign(Object.assign({}, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_deps, "f")), { actions: tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_deps, "f").actions, rawActions: tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_actions, "f"), plugins: tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_plugins, "f"), nodeViews: tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_nodeViews, "f"), markViews: tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_markViews, "f") });
+    }
+    buildDeps() {
+        this.processExtensions();
+        this.createDeps();
+        return tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_deps, "f");
+    }
+    processExtensions() {
+        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_spec, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_builder, "f").use(tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_extensions, "f")).build(), "f");
+        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_mdForMarkup, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_spec, "f").configureMd(tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f"), 'markup'), "f");
+        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_mdForText, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_spec, "f").configureMd(tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f"), 'text'), "f");
+        tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_spec, "f").nodes().forEach(this.processNode);
+        tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_spec, "f").marks().forEach(this.processMark);
+    }
+    createDeps() {
+        const schema = tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_schemaRegistry, "f").createSchema();
+        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")),
+            textParser: tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").createParser(schema, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f")),
+            serializer: tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").createSerializer(),
+        }, "f");
+    }
+    createDerived() {
+        tslib_1.__classPrivateFieldSet(this, _ExtensionsManager_plugins, tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_spec, "f").plugins(tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_deps, "f")), "f");
+        Object.assign(tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_actions, "f"), tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_spec, "f").actions(tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_deps, "f")));
+        for (const [name, view] of tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_nodeViewCreators, "f")) {
+            tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_nodeViews, "f")[name] = view(tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_deps, "f"));
+        }
+        for (const [name, view] of tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_markViewCreators, "f")) {
+            tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_markViews, "f")[name] = view(tslib_1.__classPrivateFieldGet(this, _ExtensionsManager_deps, "f"));
+        }
+    }
+}
+exports.ExtensionsManager = ExtensionsManager;
+_ExtensionsManager_schemaRegistry = new WeakMap(), _ExtensionsManager_parserRegistry = new WeakMap(), _ExtensionsManager_serializerRegistry = new WeakMap(), _ExtensionsManager_nodeViewCreators = new WeakMap(), _ExtensionsManager_markViewCreators = 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();

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

@@ -0,0 +1,8 @@
+import type MarkdownIt from 'markdown-it';
+import type { Schema } from 'prosemirror-model';
+import type { Parser, ParserToken } from './types/parser';
+export declare class ParserTokensRegistry {
+    #private;
+    addToken(name: string, token: ParserToken): this;
+    createParser(schema: Schema, tokenizer: MarkdownIt): Parser;
+}

package/build/cjs/core/ParserTokensRegistry.js

@@ -0,0 +1,20 @@
+"use strict";
+var _ParserTokensRegistry_tokens;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserTokensRegistry = void 0;
+const tslib_1 = require("tslib");
+const MarkdownParser_1 = require("./markdown/MarkdownParser");
+class ParserTokensRegistry {
+    constructor() {
+        _ParserTokensRegistry_tokens.set(this, {});
+    }
+    addToken(name, token) {
+        tslib_1.__classPrivateFieldGet(this, _ParserTokensRegistry_tokens, "f")[name] = token;
+        return this;
+    }
+    createParser(schema, tokenizer) {
+        return new MarkdownParser_1.MarkdownParser(schema, tokenizer, tslib_1.__classPrivateFieldGet(this, _ParserTokensRegistry_tokens, "f"));
+    }
+}
+exports.ParserTokensRegistry = ParserTokensRegistry;
+_ParserTokensRegistry_tokens = new WeakMap();

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

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

package/build/cjs/core/SchemaSpecRegistry.js

@@ -0,0 +1,25 @@
+"use strict";
+var _SchemaSpecRegistry_spec;
+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) {
+        _SchemaSpecRegistry_spec.set(this, void 0);
+        tslib_1.__classPrivateFieldSet(this, _SchemaSpecRegistry_spec, { topNode, nodes: {}, marks: {} }, "f");
+    }
+    addNode(name, spec) {
+        tslib_1.__classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f").nodes[name] = spec;
+        return this;
+    }
+    addMark(name, spec) {
+        tslib_1.__classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f").marks[name] = spec;
+        return this;
+    }
+    createSchema() {
+        return new prosemirror_model_1.Schema(tslib_1.__classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f"));
+    }
+}
+exports.SchemaSpecRegistry = SchemaSpecRegistry;
+_SchemaSpecRegistry_spec = new WeakMap();

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

@@ -0,0 +1,7 @@
+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;
+}

package/build/cjs/core/SerializerTokensRegistry.js

@@ -0,0 +1,25 @@
+"use strict";
+var _SerializerTokensRegistry_nodes, _SerializerTokensRegistry_marks;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializerTokensRegistry = void 0;
+const tslib_1 = require("tslib");
+const MarkdownSerializer_1 = require("./markdown/MarkdownSerializer");
+class SerializerTokensRegistry {
+    constructor() {
+        _SerializerTokensRegistry_nodes.set(this, {});
+        _SerializerTokensRegistry_marks.set(this, {});
+    }
+    addNode(name, node) {
+        tslib_1.__classPrivateFieldGet(this, _SerializerTokensRegistry_nodes, "f")[name] = node;
+        return this;
+    }
+    addMark(name, mark) {
+        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"));
+    }
+}
+exports.SerializerTokensRegistry = SerializerTokensRegistry;
+_SerializerTokensRegistry_nodes = new WeakMap(), _SerializerTokensRegistry_marks = new WeakMap();

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

@@ -0,0 +1,11 @@
+export * from './Editor';
+export * from './ExtensionBuilder';
+export * from './ExtensionsManager';
+export { bindActions } from './utils/actions';
+export { trackTransactionMetrics } from './utils/metrics';
+export type { Keymap } from './types/keymap';
+export type { ActionSpec, Action, ActionStorage, CommandWithAttrs } from './types/actions';
+export type { Extension, ExtensionAuto, ExtensionWithOptions, ExtensionDeps, ExtensionNodeSpec, ExtensionMarkSpec, } from './types/extension';
+export type { Parser, ParserToken } from './types/parser';
+export type { Serializer, SerializerState, SerializerNodeToken, SerializerMarkToken, } from './types/serializer';
+export type { NodeViewConstructor, MarkViewConstructor } from './types/node-views';

package/build/cjs/core/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackTransactionMetrics = exports.bindActions = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Editor"), exports);
+tslib_1.__exportStar(require("./ExtensionBuilder"), exports);
+tslib_1.__exportStar(require("./ExtensionsManager"), exports);
+var actions_1 = require("./utils/actions");
+Object.defineProperty(exports, "bindActions", { enumerable: true, get: function () { return actions_1.bindActions; } });
+var metrics_1 = require("./utils/metrics");
+Object.defineProperty(exports, "trackTransactionMetrics", { enumerable: true, get: function () { return metrics_1.trackTransactionMetrics; } });

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

@@ -0,0 +1,42 @@
+import type { Match } from 'linkify-it';
+import type MarkdownIt from 'markdown-it';
+import { Mark, Node, NodeType, Schema } from 'prosemirror-model';
+import type { Parser, ParserToken } from '../types/parser';
+declare type TokenAttrs = {
+    [name: string]: unknown;
+};
+export declare class MarkdownParser implements Parser {
+    schema: Schema;
+    stack: Array<{
+        type: NodeType;
+        attrs?: TokenAttrs;
+        content: Array<Node>;
+    }>;
+    marks: readonly Mark[];
+    tokens: Record<string, ParserToken>;
+    tokenizer: MarkdownIt;
+    constructor(schema: Schema, tokenizer: MarkdownIt, tokens: Record<string, ParserToken>);
+    validateLink(url: string): boolean;
+    normalizeLink(url: string): string;
+    normalizeLinkText(url: string): string;
+    matchLinks(text: string): Readonly<Match>[] | null;
+    parse(text: string): Node;
+    private top;
+    private push;
+    private getTokenAttrs;
+    private getTokenSpec;
+    private getTokenType;
+    private handlePrimitiveToken;
+    private handleMark;
+    private handleNode;
+    private handleBlock;
+    private handleToken;
+    private addNode;
+    private openNode;
+    private closeNode;
+    private addText;
+    private openMark;
+    private closeMark;
+    private parseTokens;
+}
+export {};