@gravity-ui/markdown-editor 14.12.1 → 14.12.2

package/build/esm/core/Editor.js

@@ -1,37 +1,23 @@
+var _WysiwygEditor_view, _WysiwygEditor_serializer, _WysiwygEditor_parser, _WysiwygEditor_actions, _WysiwygEditor_contentHandler, _WysiwygEditor_escapeConfig;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { EditorState } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
-import { WysiwygContentHandler } from "./ContentHandler.js";
-import { ExtensionsManager } from "./ExtensionsManager.js";
-import { SchemaDynamicModifier } from "./SchemaDynamicModifier.js";
-import { MarkdownParserDynamicModifier } from "./markdown/MarkdownParser.js";
-import { MarkdownSerializerDynamicModifier } from "./markdown/MarkdownSerializerDynamicModifier.js";
-import { bindActions } from "./utils/actions.js";
-import { convertDynamicModifiersConfigs } from "./utils/dynamicModifiers.js";
-import { logTransactionMetrics } from "./utils/metrics.js";
+import { WysiwygContentHandler } from './ContentHandler';
+import { ExtensionsManager } from './ExtensionsManager';
+import { SchemaDynamicModifier } from './SchemaDynamicModifier';
+import { MarkdownParserDynamicModifier } from './markdown/MarkdownParser';
+import { MarkdownSerializerDynamicModifier } from './markdown/MarkdownSerializerDynamicModifier';
+import { bindActions } from './utils/actions';
+import { convertDynamicModifiersConfigs } from './utils/dynamicModifiers';
+import { logTransactionMetrics } from './utils/metrics';
 export class WysiwygEditor {
-    #view;
-    #serializer;
-    #parser;
-    #actions;
-    #contentHandler;
-    #escapeConfig;
-    get dom() {
-        return this.#view.dom;
-    }
-    get serializer() {
-        return this.#serializer;
-    }
-    get parser() {
-        return this.#parser;
-    }
-    get actions() {
-        return this.#actions.actions;
-    }
-    /** @internal used for prosemirror-dev-tools in demo */
-    get view() {
-        return this.#view;
-    }
     constructor({ domElem, initialContent = '', extensions = () => { }, allowHTML, mdPreset, linkify, pmTransformers, linkifyTlds, escapeConfig, onChange, onDocChange, modifiers, }) {
+        _WysiwygEditor_view.set(this, void 0);
+        _WysiwygEditor_serializer.set(this, void 0);
+        _WysiwygEditor_parser.set(this, void 0);
+        _WysiwygEditor_actions.set(this, void 0);
+        _WysiwygEditor_contentHandler.set(this, void 0);
+        _WysiwygEditor_escapeConfig.set(this, void 0);
         const dynamicModifiersConfig = modifiers
             ? convertDynamicModifiersConfigs(modifiers)
             : undefined;
@@ -56,7 +42,7 @@ export class WysiwygEditor {
         });
         const thisOnChange = () => this.tryOnChange(onChange);
         const thisOnDocChange = () => this.tryOnChange(onDocChange);
-        this.#view = new EditorView(domElem ?? null, {
+        __classPrivateFieldSet(this, _WysiwygEditor_view, new EditorView(domElem !== null && domElem !== void 0 ? domElem : null, {
             state,
             nodeViews,
             markViews,
@@ -70,48 +56,65 @@ export class WysiwygEditor {
                 }
                 logTransactionMetrics(tr);
             },
-        });
-        this.#actions = actions.setActions(bindActions(rawActions)(this.#view));
-        this.#serializer = serializer;
-        this.#parser = parser;
-        this.#contentHandler = new WysiwygContentHandler(this.#view, parser);
-        this.#escapeConfig = escapeConfig;
+        }), "f");
+        __classPrivateFieldSet(this, _WysiwygEditor_actions, actions.setActions(bindActions(rawActions)(__classPrivateFieldGet(this, _WysiwygEditor_view, "f"))), "f");
+        __classPrivateFieldSet(this, _WysiwygEditor_serializer, serializer, "f");
+        __classPrivateFieldSet(this, _WysiwygEditor_parser, parser, "f");
+        __classPrivateFieldSet(this, _WysiwygEditor_contentHandler, new WysiwygContentHandler(__classPrivateFieldGet(this, _WysiwygEditor_view, "f"), parser), "f");
+        __classPrivateFieldSet(this, _WysiwygEditor_escapeConfig, escapeConfig, "f");
+    }
+    get dom() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_view, "f").dom;
+    }
+    get serializer() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_serializer, "f");
+    }
+    get parser() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_parser, "f");
+    }
+    get actions() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_actions, "f").actions;
+    }
+    /** @internal used for prosemirror-dev-tools in demo */
+    get view() {
+        return __classPrivateFieldGet(this, _WysiwygEditor_view, "f");
     }
     action(actionName) {
-        return this.#actions.action(actionName);
+        return __classPrivateFieldGet(this, _WysiwygEditor_actions, "f").action(actionName);
     }
     focus() {
-        return this.#view.focus();
+        return __classPrivateFieldGet(this, _WysiwygEditor_view, "f").focus();
     }
     hasFocus() {
-        return this.#view.hasFocus();
+        return __classPrivateFieldGet(this, _WysiwygEditor_view, "f").hasFocus();
     }
     getValue() {
-        return this.#serializer.serialize(this.#view.state.doc, this.#escapeConfig);
+        return __classPrivateFieldGet(this, _WysiwygEditor_serializer, "f").serialize(__classPrivateFieldGet(this, _WysiwygEditor_view, "f").state.doc, __classPrivateFieldGet(this, _WysiwygEditor_escapeConfig, "f"));
     }
     isEmpty() {
-        const { doc } = this.#view.state;
+        var _a;
+        const { doc } = __classPrivateFieldGet(this, _WysiwygEditor_view, "f").state;
         return (doc.childCount === 1 &&
-            doc.firstChild?.type.name === 'paragraph' &&
+            ((_a = doc.firstChild) === null || _a === void 0 ? void 0 : _a.type.name) === 'paragraph' &&
             doc.firstChild.childCount === 0);
     }
     clear() {
-        return this.#contentHandler.clear();
+        return __classPrivateFieldGet(this, _WysiwygEditor_contentHandler, "f").clear();
     }
     replace(newMarkup) {
-        return this.#contentHandler.replace(newMarkup);
+        return __classPrivateFieldGet(this, _WysiwygEditor_contentHandler, "f").replace(newMarkup);
     }
     prepend(markup) {
-        return this.#contentHandler.prepend(markup);
+        return __classPrivateFieldGet(this, _WysiwygEditor_contentHandler, "f").prepend(markup);
     }
     append(markup) {
-        return this.#contentHandler.append(markup);
+        return __classPrivateFieldGet(this, _WysiwygEditor_contentHandler, "f").append(markup);
     }
     moveCursor(position) {
-        return this.#contentHandler.moveCursor(position);
+        return __classPrivateFieldGet(this, _WysiwygEditor_contentHandler, "f").moveCursor(position);
     }
     destroy() {
-        this.#view.destroy();
+        __classPrivateFieldGet(this, _WysiwygEditor_view, "f").destroy();
     }
     tryOnChange(cb) {
         if (cb) {
@@ -124,4 +127,4 @@ export class WysiwygEditor {
         }
     }
 }
-//# sourceMappingURL=Editor.js.map
+_WysiwygEditor_view = new WeakMap(), _WysiwygEditor_serializer = new WeakMap(), _WysiwygEditor_parser = new WeakMap(), _WysiwygEditor_actions = new WeakMap(), _WysiwygEditor_contentHandler = new WeakMap(), _WysiwygEditor_escapeConfig = new WeakMap();

package/build/esm/core/ExtensionBuilder.d.ts

@@ -1,11 +1,11 @@
 import type MarkdownIt from 'markdown-it';
 import { inputRules } from 'prosemirror-inputrules';
 import type { Plugin } from 'prosemirror-state';
-import type { ActionSpec } from "./types/actions.js";
-import type { Extension, ExtensionDeps, ExtensionMarkSpec, ExtensionNodeSpec, ExtensionSpec, ExtensionWithOptions } from "./types/extension.js";
-import type { Keymap } from "./types/keymap.js";
-type InputRulesConfig = Parameters<typeof inputRules>[0];
-type ConfigureMdParams = {
+import type { ActionSpec } from './types/actions';
+import type { Extension, ExtensionDeps, ExtensionMarkSpec, ExtensionNodeSpec, ExtensionSpec, ExtensionWithOptions } from './types/extension';
+import type { Keymap } from './types/keymap';
+declare type InputRulesConfig = Parameters<typeof inputRules>[0];
+declare type ConfigureMdParams = {
     /**
      * Apply this configurtion to text parser
      *
@@ -19,13 +19,13 @@ type ConfigureMdParams = {
      */
     markup?: boolean;
 };
-type ConfigureMdCallback = (md: MarkdownIt) => MarkdownIt;
-type AddPmNodeCallback = () => ExtensionNodeSpec;
-type AddPmMarkCallback = () => ExtensionMarkSpec;
-type AddPmPluginCallback = (deps: ExtensionDeps) => Plugin | Plugin[];
-type AddPmKeymapCallback = (deps: ExtensionDeps) => Keymap;
-type AddPmInputRulesCallback = (deps: ExtensionDeps) => InputRulesConfig;
-type AddActionCallback = (deps: ExtensionDeps) => ActionSpec;
+declare type ConfigureMdCallback = (md: MarkdownIt) => MarkdownIt;
+declare type AddPmNodeCallback = () => ExtensionNodeSpec;
+declare type AddPmMarkCallback = () => ExtensionMarkSpec;
+declare type AddPmPluginCallback = (deps: ExtensionDeps) => Plugin | Plugin[];
+declare type AddPmKeymapCallback = (deps: ExtensionDeps) => Keymap;
+declare type AddPmInputRulesCallback = (deps: ExtensionDeps) => InputRulesConfig;
+declare type AddActionCallback = (deps: ExtensionDeps) => ActionSpec;
 declare enum Priority {
     Highest = 1000000,
     VeryHigh = 100000,
@@ -35,7 +35,7 @@ declare enum Priority {
     VeryLow = 10,
     Lowest = 0
 }
-type BuilderContext<T extends object> = {
+declare type BuilderContext<T extends object> = {
     has(key: keyof T): boolean;
     get<K extends keyof T>(key: K): T[K] | undefined;
     set<K extends keyof T>(key: K, value: T[K]): BuilderContext<T>;
@@ -51,6 +51,10 @@ export declare class ExtensionBuilder {
     static createContext(): BuilderContext<WysiwygEditor.Context>;
     static readonly Priority: typeof Priority;
     readonly Priority: typeof Priority;
+    /** @deprecated use `ExtensionBuilder.Priority` instead */
+    static readonly PluginPriority: typeof Priority;
+    /** @deprecated use `builder.Priority` instead */
+    readonly PluginPriority: typeof Priority;
     readonly context: BuilderContext<WysiwygEditor.Context>;
     constructor(context?: BuilderContext<WysiwygEditor.Context>);
     use(extension: Extension): this;

package/build/esm/core/ExtensionBuilder.js

@@ -1,3 +1,5 @@
+var _ExtensionBuilder_confMdCbs, _ExtensionBuilder_nodeSpecs, _ExtensionBuilder_markSpecs, _ExtensionBuilder_plugins, _ExtensionBuilder_actions;
+import { __classPrivateFieldGet } from "tslib";
 import OrderedMap from 'orderedmap'; // eslint-disable-line import/no-extraneous-dependencies
 import { inputRules } from 'prosemirror-inputrules';
 import { keymap } from 'prosemirror-keymap';
@@ -13,75 +15,75 @@ var Priority;
 })(Priority || (Priority = {}));
 const DEFAULT_PRIORITY = Priority.Medium;
 export 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();
     }
-    /* eslint-disable @typescript-eslint/member-ordering */
-    static Priority = Priority;
-    Priority = ExtensionBuilder.Priority;
-    /* eslint-enable @typescript-eslint/member-ordering */
-    #confMdCbs = [];
-    #nodeSpecs = {};
-    #markSpecs = {};
-    #plugins = [];
-    #actions = [];
-    context;
-    constructor(context) {
-        this.context = context ?? ExtensionBuilder.createContext();
-    }
     use(extension, ...params) {
         extension(this, ...params);
         return this;
     }
     configureMd(cb, params = {}) {
-        this.#confMdCbs.push({
+        var _a, _b;
+        __classPrivateFieldGet(this, _ExtensionBuilder_confMdCbs, "f").push({
             cb,
             params: {
-                text: params.text ?? true,
-                markup: params.markup ?? true,
+                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 (this.#nodeSpecs[name]) {
+        if (__classPrivateFieldGet(this, _ExtensionBuilder_nodeSpecs, "f")[name]) {
             throw new Error(`ProseMirror node with this name "${name}" already exist`);
         }
-        this.#nodeSpecs[name] = { name, cb };
+        __classPrivateFieldGet(this, _ExtensionBuilder_nodeSpecs, "f")[name] = { name, cb };
         return this;
     }
     addMark(name, cb, priority = DEFAULT_PRIORITY) {
-        if (this.#markSpecs[name]) {
+        if (__classPrivateFieldGet(this, _ExtensionBuilder_markSpecs, "f")[name]) {
             throw new Error(`ProseMirror mark with this name "${name}" already exist`);
         }
-        this.#markSpecs[name] = { name, cb, priority };
+        __classPrivateFieldGet(this, _ExtensionBuilder_markSpecs, "f")[name] = { name, cb, priority };
         return this;
     }
     addPlugin(cb, priority = DEFAULT_PRIORITY) {
-        this.#plugins.push({ cb, priority });
+        __classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").push({ cb, priority });
         return this;
     }
     addKeymap(cb, priority = DEFAULT_PRIORITY) {
-        this.#plugins.push({ cb: (...args) => keymap(cb(...args)), priority });
+        __classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").push({ cb: (...args) => keymap(cb(...args)), priority });
         return this;
     }
     addInputRules(cb, priority = DEFAULT_PRIORITY) {
-        this.#plugins.push({ cb: (...args) => inputRules(cb(...args)), priority });
+        __classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").push({ cb: (...args) => inputRules(cb(...args)), priority });
         return this;
     }
     addAction(name, cb) {
-        if (this.#actions.some(([actionName]) => actionName === name)) {
+        if (__classPrivateFieldGet(this, _ExtensionBuilder_actions, "f").some(([actionName]) => actionName === name)) {
             throw new Error(`[Markdown Wysiwyg Editor] action with this name "${name}" already exist`);
         }
-        this.#actions.push([name, cb]);
+        __classPrivateFieldGet(this, _ExtensionBuilder_actions, "f").push([name, cb]);
         return this;
     }
     build() {
-        const confMd = this.#confMdCbs.slice();
-        const nodes = { ...this.#nodeSpecs };
-        const marks = { ...this.#markSpecs };
-        const plugins = this.#plugins.slice();
-        const actions = this.#actions.slice();
+        const confMd = __classPrivateFieldGet(this, _ExtensionBuilder_confMdCbs, "f").slice();
+        const nodes = Object.assign({}, __classPrivateFieldGet(this, _ExtensionBuilder_nodeSpecs, "f"));
+        const marks = Object.assign({}, __classPrivateFieldGet(this, _ExtensionBuilder_markSpecs, "f"));
+        const plugins = __classPrivateFieldGet(this, _ExtensionBuilder_plugins, "f").slice();
+        const actions = __classPrivateFieldGet(this, _ExtensionBuilder_actions, "f").slice();
         return {
             configureMd: (md, parserType) => confMd.reduce((pMd, { cb, params }) => {
                 if (parserType === 'text' && params.text) {
@@ -128,4 +130,8 @@ export class ExtensionBuilder {
         };
     }
 }
-//# sourceMappingURL=ExtensionBuilder.js.map
+_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/esm/core/ExtensionsManager.d.ts

@@ -1,19 +1,19 @@
 import MarkdownIt, { PresetName } from 'markdown-it';
 import { Schema } from 'prosemirror-model';
 import type { Plugin } from 'prosemirror-state';
-import { ActionsManager } from "./ActionsManager.js";
-import { SchemaDynamicModifier } from "./SchemaDynamicModifier.js";
-import { MarkdownParserDynamicModifier } from "./markdown/MarkdownParser.js";
-import { MarkdownSerializerDynamicModifier } from "./markdown/MarkdownSerializerDynamicModifier.js";
-import { TransformFn } from "./markdown/ProseMirrorTransformer/index.js";
-import type { ActionSpec } from "./types/actions.js";
-import type { Extension, ExtensionDeps } from "./types/extension.js";
-import type { MarkViewConstructor, NodeViewConstructor } from "./types/node-views.js";
-type ExtensionsManagerParams = {
+import { ActionsManager } from './ActionsManager';
+import { SchemaDynamicModifier } from './SchemaDynamicModifier';
+import { MarkdownParserDynamicModifier } from './markdown/MarkdownParser';
+import { MarkdownSerializerDynamicModifier } from './markdown/MarkdownSerializerDynamicModifier';
+import { TransformFn } from './markdown/ProseMirrorTransformer';
+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;
 };
-type ExtensionsManagerOptions = {
+declare type ExtensionsManagerOptions = {
     mdOpts?: MarkdownIt.Options & {
         preset?: PresetName;
     };
@@ -33,10 +33,10 @@ export declare class ExtensionsManager {
         plugins: Plugin<any>[];
         nodeViews: Record<string, NodeViewConstructor>;
         markViews: Record<string, MarkViewConstructor>;
-        schema: Schema;
-        textParser: import("./index.js").Parser;
-        markupParser: import("./index.js").Parser;
-        serializer: import("./index.js").Serializer;
+        schema: Schema<any, any>;
+        textParser: import(".").Parser;
+        markupParser: import(".").Parser;
+        serializer: import(".").Serializer;
     };
     constructor({ extensions, options }: ExtensionsManagerParams);
     build(): {
@@ -45,10 +45,10 @@ export declare class ExtensionsManager {
         plugins: Plugin<any>[];
         nodeViews: Record<string, NodeViewConstructor>;
         markViews: Record<string, MarkViewConstructor>;
-        schema: Schema;
-        textParser: import("./index.js").Parser;
-        markupParser: import("./index.js").Parser;
-        serializer: import("./index.js").Serializer;
+        schema: Schema<any, any>;
+        textParser: import(".").Parser;
+        markupParser: import(".").Parser;
+        serializer: import(".").Serializer;
     };
     buildDeps(): ExtensionDeps;
     private processExtensions;

package/build/esm/core/ExtensionsManager.js

@@ -1,120 +1,116 @@
+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;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import MarkdownIt from 'markdown-it';
-import { ActionsManager } from "./ActionsManager.js";
-import { ExtensionBuilder } from "./ExtensionBuilder.js";
-import { ParserTokensRegistry } from "./ParserTokensRegistry.js";
-import { SchemaSpecRegistry } from "./SchemaSpecRegistry.js";
-import { SerializerTokensRegistry } from "./SerializerTokensRegistry.js";
+import { ActionsManager } from './ActionsManager';
+import { ExtensionBuilder } from './ExtensionBuilder';
+import { ParserTokensRegistry } from './ParserTokensRegistry';
+import { SchemaSpecRegistry } from './SchemaSpecRegistry';
+import { SerializerTokensRegistry } from './SerializerTokensRegistry';
 export class ExtensionsManager {
-    static process(extensions, options) {
-        return new this({ extensions, options }).build();
-    }
-    #schemaRegistry;
-    #parserRegistry;
-    #serializerRegistry;
-    #nodeViewCreators = new Map();
-    #markViewCreators = new Map();
-    #pmTransformers = [];
-    #mdForMarkup;
-    #mdForText;
-    #extensions;
-    #builder;
-    #spec;
-    #deps;
-    #plugins = [];
-    #actions = {};
-    #nodeViews = {};
-    #markViews = {};
-    #serializerDynamicModifier;
-    #parserDynamicModifier;
     constructor({ extensions, options = {} }) {
-        this.#schemaRegistry = new SchemaSpecRegistry(undefined, options.dynamicModifiers?.schema);
-        this.#parserRegistry = new ParserTokensRegistry();
-        this.#serializerRegistry = new 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, []);
+        _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, {});
+        _ExtensionsManager_serializerDynamicModifier.set(this, void 0);
+        _ExtensionsManager_parserDynamicModifier.set(this, void 0);
+        this.processNode = (name, { spec, fromMd, toMd: toMd, view }) => {
+            __classPrivateFieldGet(this, _ExtensionsManager_schemaRegistry, "f").addNode(name, spec);
+            __classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").addToken(fromMd.tokenName || name, fromMd.tokenSpec);
+            __classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").addNode(name, toMd);
+            if (view) {
+                __classPrivateFieldGet(this, _ExtensionsManager_nodeViewCreators, "f").set(name, view);
+            }
+        };
+        this.processMark = (name, { spec, fromMd, toMd, view }) => {
+            __classPrivateFieldGet(this, _ExtensionsManager_schemaRegistry, "f").addMark(name, spec);
+            __classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").addToken(fromMd.tokenName || name, fromMd.tokenSpec);
+            __classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").addMark(name, toMd);
+            if (view) {
+                __classPrivateFieldGet(this, _ExtensionsManager_markViewCreators, "f").set(name, view);
+            }
+        };
+        __classPrivateFieldSet(this, _ExtensionsManager_schemaRegistry, new SchemaSpecRegistry(undefined, (_a = options.dynamicModifiers) === null || _a === void 0 ? void 0 : _a.schema), "f");
+        __classPrivateFieldSet(this, _ExtensionsManager_parserRegistry, new ParserTokensRegistry(), "f");
+        __classPrivateFieldSet(this, _ExtensionsManager_serializerRegistry, new SerializerTokensRegistry(), "f");
         if (options.dynamicModifiers) {
-            this.#parserDynamicModifier = options.dynamicModifiers?.parser;
-            this.#serializerDynamicModifier = options.dynamicModifiers?.serializer;
+            __classPrivateFieldSet(this, _ExtensionsManager_parserDynamicModifier, (_b = options.dynamicModifiers) === null || _b === void 0 ? void 0 : _b.parser, "f");
+            __classPrivateFieldSet(this, _ExtensionsManager_serializerDynamicModifier, (_c = options.dynamicModifiers) === null || _c === void 0 ? void 0 : _c.serializer, "f");
         }
-        this.#extensions = extensions;
-        const mdPreset = options.mdOpts?.preset ?? 'default';
-        this.#mdForMarkup = new MarkdownIt(mdPreset, options.mdOpts ?? {});
-        this.#mdForText = new MarkdownIt(mdPreset, options.mdOpts ?? {});
+        __classPrivateFieldSet(this, _ExtensionsManager_extensions, extensions, "f");
+        const mdPreset = (_e = (_d = options.mdOpts) === null || _d === void 0 ? void 0 : _d.preset) !== null && _e !== void 0 ? _e : 'default';
+        __classPrivateFieldSet(this, _ExtensionsManager_mdForMarkup, new MarkdownIt(mdPreset, (_f = options.mdOpts) !== null && _f !== void 0 ? _f : {}), "f");
+        __classPrivateFieldSet(this, _ExtensionsManager_mdForText, new MarkdownIt(mdPreset, (_g = options.mdOpts) !== null && _g !== void 0 ? _g : {}), "f");
         if (options.linkifyTlds) {
-            this.#mdForMarkup.linkify.tlds(options.linkifyTlds, true);
-            this.#mdForText.linkify.tlds(options.linkifyTlds, true);
+            __classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f").linkify.tlds(options.linkifyTlds, true);
+            __classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f").linkify.tlds(options.linkifyTlds, true);
         }
         if (options.pmTransformers) {
-            this.#pmTransformers = options.pmTransformers;
+            __classPrivateFieldSet(this, _ExtensionsManager_pmTransformers, options.pmTransformers, "f");
         }
         // TODO: add prefilled context
-        this.#builder = new ExtensionBuilder();
+        __classPrivateFieldSet(this, _ExtensionsManager_builder, new ExtensionBuilder(), "f");
+    }
+    static process(extensions, options) {
+        return new this({ extensions, options }).build();
     }
     build() {
         this.processExtensions();
         this.createDeps();
         this.createDerived();
-        return {
-            ...this.#deps,
-            actions: this.#deps.actions,
-            rawActions: this.#actions,
-            plugins: this.#plugins,
-            nodeViews: this.#nodeViews,
-            markViews: this.#markViews,
-        };
+        return Object.assign(Object.assign({}, __classPrivateFieldGet(this, _ExtensionsManager_deps, "f")), { actions: __classPrivateFieldGet(this, _ExtensionsManager_deps, "f").actions, rawActions: __classPrivateFieldGet(this, _ExtensionsManager_actions, "f"), plugins: __classPrivateFieldGet(this, _ExtensionsManager_plugins, "f"), nodeViews: __classPrivateFieldGet(this, _ExtensionsManager_nodeViews, "f"), markViews: __classPrivateFieldGet(this, _ExtensionsManager_markViews, "f") });
     }
     buildDeps() {
         this.processExtensions();
         this.createDeps();
-        return this.#deps;
+        return __classPrivateFieldGet(this, _ExtensionsManager_deps, "f");
     }
     processExtensions() {
-        this.#spec = this.#builder.use(this.#extensions).build();
-        this.#mdForMarkup = this.#spec.configureMd(this.#mdForMarkup, 'markup');
-        this.#mdForText = this.#spec.configureMd(this.#mdForText, 'text');
-        this.#spec.nodes().forEach(this.processNode);
-        this.#spec.marks().forEach(this.processMark);
+        __classPrivateFieldSet(this, _ExtensionsManager_spec, __classPrivateFieldGet(this, _ExtensionsManager_builder, "f").use(__classPrivateFieldGet(this, _ExtensionsManager_extensions, "f")).build(), "f");
+        __classPrivateFieldSet(this, _ExtensionsManager_mdForMarkup, __classPrivateFieldGet(this, _ExtensionsManager_spec, "f").configureMd(__classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f"), 'markup'), "f");
+        __classPrivateFieldSet(this, _ExtensionsManager_mdForText, __classPrivateFieldGet(this, _ExtensionsManager_spec, "f").configureMd(__classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f"), 'text'), "f");
+        __classPrivateFieldGet(this, _ExtensionsManager_spec, "f").nodes().forEach(this.processNode);
+        __classPrivateFieldGet(this, _ExtensionsManager_spec, "f").marks().forEach(this.processMark);
     }
-    processNode = (name, { spec, fromMd, toMd: toMd, view }) => {
-        this.#schemaRegistry.addNode(name, spec);
-        this.#parserRegistry.addToken(fromMd.tokenName || name, fromMd.tokenSpec);
-        this.#serializerRegistry.addNode(name, toMd);
-        if (view) {
-            this.#nodeViewCreators.set(name, view);
-        }
-    };
-    processMark = (name, { spec, fromMd, toMd, view }) => {
-        this.#schemaRegistry.addMark(name, spec);
-        this.#parserRegistry.addToken(fromMd.tokenName || name, fromMd.tokenSpec);
-        this.#serializerRegistry.addMark(name, toMd);
-        if (view) {
-            this.#markViewCreators.set(name, view);
-        }
-    };
     createParser(schema, mdInstance) {
-        return this.#parserRegistry.createParser(schema, mdInstance, this.#pmTransformers, this.#parserDynamicModifier);
+        return __classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").createParser(schema, mdInstance, __classPrivateFieldGet(this, _ExtensionsManager_pmTransformers, "f"), __classPrivateFieldGet(this, _ExtensionsManager_parserDynamicModifier, "f"));
     }
     createDeps() {
         const actions = new ActionsManager();
-        const schema = this.#schemaRegistry.createSchema();
-        const markupParser = this.createParser(schema, this.#mdForMarkup);
-        const textParser = this.createParser(schema, this.#mdForText);
-        const serializer = this.#serializerRegistry.createSerializer(this.#serializerDynamicModifier);
-        this.#deps = {
+        const schema = __classPrivateFieldGet(this, _ExtensionsManager_schemaRegistry, "f").createSchema();
+        const markupParser = this.createParser(schema, __classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f"));
+        const textParser = this.createParser(schema, __classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f"));
+        const serializer = __classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").createSerializer(__classPrivateFieldGet(this, _ExtensionsManager_serializerDynamicModifier, "f"));
+        __classPrivateFieldSet(this, _ExtensionsManager_deps, {
             schema,
             actions,
             markupParser,
             textParser,
             serializer,
-        };
+        }, "f");
     }
     createDerived() {
-        this.#plugins = this.#spec.plugins(this.#deps);
-        Object.assign(this.#actions, this.#spec.actions(this.#deps));
-        for (const [name, view] of this.#nodeViewCreators) {
-            this.#nodeViews[name] = view(this.#deps);
+        __classPrivateFieldSet(this, _ExtensionsManager_plugins, __classPrivateFieldGet(this, _ExtensionsManager_spec, "f").plugins(__classPrivateFieldGet(this, _ExtensionsManager_deps, "f")), "f");
+        Object.assign(__classPrivateFieldGet(this, _ExtensionsManager_actions, "f"), __classPrivateFieldGet(this, _ExtensionsManager_spec, "f").actions(__classPrivateFieldGet(this, _ExtensionsManager_deps, "f")));
+        for (const [name, view] of __classPrivateFieldGet(this, _ExtensionsManager_nodeViewCreators, "f")) {
+            __classPrivateFieldGet(this, _ExtensionsManager_nodeViews, "f")[name] = view(__classPrivateFieldGet(this, _ExtensionsManager_deps, "f"));
         }
-        for (const [name, view] of this.#markViewCreators) {
-            this.#markViews[name] = view(this.#deps);
+        for (const [name, view] of __classPrivateFieldGet(this, _ExtensionsManager_markViewCreators, "f")) {
+            __classPrivateFieldGet(this, _ExtensionsManager_markViews, "f")[name] = view(__classPrivateFieldGet(this, _ExtensionsManager_deps, "f"));
         }
     }
 }
-//# sourceMappingURL=ExtensionsManager.js.map
+_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/esm/core/ParserTokensRegistry.d.ts

@@ -1,8 +1,8 @@
 import type MarkdownIt from 'markdown-it';
 import type { Schema } from 'prosemirror-model';
-import { MarkdownParserDynamicModifier } from "./markdown/MarkdownParser.js";
-import { TransformFn } from "./markdown/ProseMirrorTransformer/index.js";
-import type { Parser, ParserToken } from "./types/parser.js";
+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;

package/build/esm/core/ParserTokensRegistry.js

@@ -1,12 +1,16 @@
-import { MarkdownParser } from "./markdown/MarkdownParser.js";
+var _ParserTokensRegistry_tokens;
+import { __classPrivateFieldGet } from "tslib";
+import { MarkdownParser } from './markdown/MarkdownParser';
 export class ParserTokensRegistry {
-    #tokens = {};
+    constructor() {
+        _ParserTokensRegistry_tokens.set(this, {});
+    }
     addToken(name, token) {
-        this.#tokens[name] = token;
+        __classPrivateFieldGet(this, _ParserTokensRegistry_tokens, "f")[name] = token;
         return this;
     }
     createParser(schema, tokenizer, pmTransformers, dynamicModifier) {
-        return new MarkdownParser(schema, tokenizer, this.#tokens, pmTransformers, dynamicModifier);
+        return new MarkdownParser(schema, tokenizer, __classPrivateFieldGet(this, _ParserTokensRegistry_tokens, "f"), pmTransformers, dynamicModifier);
     }
 }
-//# sourceMappingURL=ParserTokensRegistry.js.map
+_ParserTokensRegistry_tokens = new WeakMap();

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

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