@gravity-ui/markdown-editor 14.12.1 → 14.12.2

package/build/esm/core/SchemaDynamicModifier.js

@@ -1,6 +1,5 @@
 /** @internal */
 export class SchemaDynamicModifier {
-    nodeSpecsProcessors;
     constructor(config) {
         this.nodeSpecsProcessors = new Map(Object.entries(config));
     }
@@ -11,19 +10,12 @@ export class SchemaDynamicModifier {
                 processor.allowedAttrs &&
                 processor.allowedAttrs.length > 0 &&
                 nodeSpec) {
-                updatedSpec = {
-                    ...nodeSpec,
-                    attrs: {
-                        ...nodeSpec.attrs,
-                        ...processor.allowedAttrs.reduce((acc, key) => {
-                            acc[key] = { default: null };
-                            return acc;
-                        }, {}),
-                    },
-                };
+                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;
     }
 }
-//# sourceMappingURL=SchemaDynamicModifier.js.map

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

@@ -1,5 +1,5 @@
 import { MarkSpec, NodeSpec, Schema } from 'prosemirror-model';
-import { SchemaDynamicModifier } from "./SchemaDynamicModifier.js";
+import { SchemaDynamicModifier } from './SchemaDynamicModifier';
 export declare class SchemaSpecRegistry {
     #private;
     constructor(topNode?: string, dynamicModifier?: SchemaDynamicModifier);

package/build/esm/core/SchemaSpecRegistry.js

@@ -1,24 +1,26 @@
+var _SchemaSpecRegistry_spec, _SchemaSpecRegistry_dynamicModifier;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { Schema } from 'prosemirror-model';
 export class SchemaSpecRegistry {
-    #spec;
-    #dynamicModifier;
     constructor(topNode, dynamicModifier) {
-        this.#spec = { topNode, nodes: {}, marks: {} };
-        this.#dynamicModifier = dynamicModifier;
+        _SchemaSpecRegistry_spec.set(this, void 0);
+        _SchemaSpecRegistry_dynamicModifier.set(this, void 0);
+        __classPrivateFieldSet(this, _SchemaSpecRegistry_spec, { topNode, nodes: {}, marks: {} }, "f");
+        __classPrivateFieldSet(this, _SchemaSpecRegistry_dynamicModifier, dynamicModifier, "f");
     }
     addNode(name, spec) {
-        const modifiedSpec = this.#dynamicModifier
-            ? this.#dynamicModifier.processNodeSpec(name, spec)
+        const modifiedSpec = __classPrivateFieldGet(this, _SchemaSpecRegistry_dynamicModifier, "f")
+            ? __classPrivateFieldGet(this, _SchemaSpecRegistry_dynamicModifier, "f").processNodeSpec(name, spec)
             : spec;
-        this.#spec.nodes[name] = modifiedSpec;
+        __classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f").nodes[name] = modifiedSpec;
         return this;
     }
     addMark(name, spec) {
-        this.#spec.marks[name] = spec;
+        __classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f").marks[name] = spec;
         return this;
     }
     createSchema() {
-        return new Schema(this.#spec);
+        return new Schema(__classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f"));
     }
 }
-//# sourceMappingURL=SchemaSpecRegistry.js.map
+_SchemaSpecRegistry_spec = new WeakMap(), _SchemaSpecRegistry_dynamicModifier = new WeakMap();

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

@@ -1,5 +1,5 @@
-import { MarkdownSerializerDynamicModifier } from "./markdown/MarkdownSerializerDynamicModifier.js";
-import type { Serializer, SerializerMarkToken, SerializerNodeToken } from "./types/serializer.js";
+import { MarkdownSerializerDynamicModifier } from './markdown/MarkdownSerializerDynamicModifier';
+import type { Serializer, SerializerMarkToken, SerializerNodeToken } from './types/serializer';
 export declare class SerializerTokensRegistry {
     #private;
     addNode(name: string, node: SerializerNodeToken): this;

package/build/esm/core/SerializerTokensRegistry.js

@@ -1,17 +1,21 @@
-import { MarkdownSerializer } from "./markdown/MarkdownSerializer.js";
+var _SerializerTokensRegistry_nodes, _SerializerTokensRegistry_marks;
+import { __classPrivateFieldGet } from "tslib";
+import { MarkdownSerializer } from './markdown/MarkdownSerializer';
 export class SerializerTokensRegistry {
-    #nodes = {};
-    #marks = {};
+    constructor() {
+        _SerializerTokensRegistry_nodes.set(this, {});
+        _SerializerTokensRegistry_marks.set(this, {});
+    }
     addNode(name, node) {
-        this.#nodes[name] = node;
+        __classPrivateFieldGet(this, _SerializerTokensRegistry_nodes, "f")[name] = node;
         return this;
     }
     addMark(name, mark) {
-        this.#marks[name] = mark;
+        __classPrivateFieldGet(this, _SerializerTokensRegistry_marks, "f")[name] = mark;
         return this;
     }
     createSerializer(dynamicModifier) {
-        return new MarkdownSerializer(this.#nodes, this.#marks, dynamicModifier);
+        return new MarkdownSerializer(__classPrivateFieldGet(this, _SerializerTokensRegistry_nodes, "f"), __classPrivateFieldGet(this, _SerializerTokensRegistry_marks, "f"), dynamicModifier);
     }
 }
-//# sourceMappingURL=SerializerTokensRegistry.js.map
+_SerializerTokensRegistry_nodes = new WeakMap(), _SerializerTokensRegistry_marks = new WeakMap();

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

@@ -1,13 +1,13 @@
-export * from "./Editor.js";
-export * from "./ExtensionBuilder.js";
-export * from "./ExtensionsManager.js";
-export { bindActions } from "./utils/actions.js";
-export { trackTransactionMetrics } from "./utils/metrics.js";
-export type { Keymap } from "./types/keymap.js";
-export type { ActionSpec, Action, ActionStorage, CommandWithAttrs } from "./types/actions.js";
-export type { Extension, ExtensionAuto, ExtensionWithOptions, ExtensionDeps, ExtensionNodeSpec, ExtensionMarkSpec, } from "./types/extension.js";
-export type { Parser, ParserToken } from "./types/parser.js";
-export type { Serializer, SerializerState, SerializerNodeToken, SerializerMarkToken, } from "./types/serializer.js";
-export type { NodeViewConstructor, MarkViewConstructor } from "./types/node-views.js";
-export type { MarkdownParserDynamicModifierConfig } from "./markdown/MarkdownParser.js";
-export type { MarkdownSerializerDynamicModifierConfig } from "./markdown/MarkdownSerializerDynamicModifier.js";
+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';
+export type { MarkdownParserDynamicModifierConfig } from './markdown/MarkdownParser';
+export type { MarkdownSerializerDynamicModifierConfig } from './markdown/MarkdownSerializerDynamicModifier';

package/build/esm/core/index.js

@@ -1,6 +1,5 @@
-export * from "./Editor.js";
-export * from "./ExtensionBuilder.js";
-export * from "./ExtensionsManager.js";
-export { bindActions } from "./utils/actions.js";
-export { trackTransactionMetrics } from "./utils/metrics.js";
-//# sourceMappingURL=index.js.map
+export * from './Editor';
+export * from './ExtensionBuilder';
+export * from './ExtensionsManager';
+export { bindActions } from './utils/actions';
+export { trackTransactionMetrics } from './utils/metrics';

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

@@ -2,9 +2,9 @@ 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.js";
-import { TransformFn } from "./ProseMirrorTransformer/index.js";
-export type TokenAttrs = {
+import type { Parser, ParserToken } from '../types/parser';
+import { TransformFn } from './ProseMirrorTransformer';
+export declare type TokenAttrs = {
     [name: string]: unknown;
 };
 export declare class MarkdownParser implements Parser {
@@ -44,5 +44,5 @@ export declare class MarkdownParser implements Parser {
     private closeMark;
     private parseTokens;
 }
-export type ProcessNodeAttrs = (token: Token, attrs: TokenAttrs, allowedAttrs?: string[]) => TokenAttrs;
-export type ProcessNode = (node: Node) => Node;
+export declare type ProcessNodeAttrs = (token: Token, attrs: TokenAttrs, allowedAttrs?: string[]) => TokenAttrs;
+export declare type ProcessNode = (node: Node) => Node;

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

@@ -1,6 +1,6 @@
 import { Mark } from 'prosemirror-model';
-import { logger } from "../../logger.js";
-import { ProseMirrorTransformer } from "./ProseMirrorTransformer/index.js";
+import { logger } from '../../logger';
+import { ProseMirrorTransformer } from './ProseMirrorTransformer';
 const openSuffix = '_open';
 const closeSuffix = '_close';
 var TokenType;
@@ -18,20 +18,14 @@ function cropNodeName(tokName, openSuffix, closeSuffix) {
     return tokName.replace(regex, '');
 }
 export class MarkdownParser {
-    schema;
-    stack = [];
-    marks;
-    tokens;
-    tokenizer;
-    pmTransformers;
-    dynamicModifier;
     constructor(schema, tokenizer, tokens, pmTransformers, dynamicModifier) {
+        this.stack = [];
         this.schema = schema;
         this.marks = Mark.none;
         this.tokens = tokens;
         this.tokenizer = tokenizer;
         this.pmTransformers = pmTransformers;
-        this.dynamicModifier = dynamicModifier ?? null;
+        this.dynamicModifier = dynamicModifier !== null && dynamicModifier !== void 0 ? dynamicModifier : null;
     }
     validateLink(url) {
         return this.tokenizer.validateLink(url);
@@ -94,13 +88,14 @@ export class MarkdownParser {
             attrs = tokenSpec.attrs;
         }
         if (this.dynamicModifier) {
-            attrs = this.dynamicModifier.processAttrs(token, attrs ?? {});
+            attrs = this.dynamicModifier.processAttrs(token, attrs !== null && attrs !== void 0 ? attrs : {});
         }
         return attrs;
     }
     getTokenSpec(token) {
+        var _a;
         // Matching the pm-node meta-attribute which is set in the plugin for markdown-it
-        let tokName = token.meta?.['pm-node'] || token.type;
+        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 = cropNodeName(tokName, openSuffix, closeSuffix);
@@ -174,10 +169,11 @@ export class MarkdownParser {
         this.addNode(schemaSpec, attrs);
     }
     handleBlock(token, tokenSpec, attrs) {
+        var _a;
         const schemaSpec = this.getNodeSchema(tokenSpec);
         if (tokenSpec.noCloseToken) {
             this.openNode(schemaSpec, attrs);
-            if (tokenSpec.contentField === 'children' && token.children?.length) {
+            if (tokenSpec.contentField === 'children' && ((_a = token.children) === null || _a === void 0 ? void 0 : _a.length)) {
                 this.parseTokens(token.children);
             }
             else {
@@ -287,7 +283,6 @@ function withoutTrailingNewline(str) {
 }
 /** @internal */
 export class MarkdownParserDynamicModifier {
-    elementProcessors;
     constructor(config) {
         this.elementProcessors = new Map(Object.entries(config));
     }
@@ -321,4 +316,3 @@ export class MarkdownParserDynamicModifier {
         }, node);
     }
 }
-//# sourceMappingURL=MarkdownParser.js.map

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

@@ -1,72 +1,47 @@
-import type { Mark, Node } from "prosemirror-model";
-import type { MarkdownSerializerDynamicModifier } from "./MarkdownSerializerDynamicModifier.js";
-export interface SerializerNodeToken {
-    (state: MarkdownSerializerState, node: Node, parent: Node, index: number): void;
+export class MarkdownSerializer {
+    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 interface SerializerMarkToken {
-    open: string | ((state: MarkdownSerializerState, mark: Mark, parent: Node, index: number) => string);
-    close: string | ((state: MarkdownSerializerState, mark: Mark, parent: Node, index: number) => string);
-    mixable?: boolean;
-    expelEnclosingWhitespace?: boolean;
-    escape?: boolean;
-}
-interface SerializerOptions {
-    tightLists?: boolean;
-    escapeExtraCharacters?: RegExp;
-    hardBreakNodeName?: string;
-    strict?: boolean;
-    commonEscape?: RegExp;
-    startOfLineEscape?: RegExp;
-    escape?: boolean;
-}
-interface MarkMap {
-    [markName: string]: SerializerMarkToken;
-}
-interface NodeMap {
-    [nodeName: string]: SerializerNodeToken;
-}
-export declare class MarkdownSerializer {
-    private readonly nodes;
-    private readonly marks;
-    private readonly dynamicModifier?;
-    constructor(nodes: NodeMap, marks: MarkMap, dynamicModifier?: MarkdownSerializerDynamicModifier);
-    serialize(content: Node, options?: Partial<SerializerOptions>): string;
-    containsNode(nodeName: string): boolean;
-    containsMark(markName: string): boolean;
-}
-export declare class MarkdownSerializerState {
+export class MarkdownSerializerState {
+    constructor(nodes: any, marks: any, options: any, dynamicModifier: any);
+    nodes: any;
+    marks: any;
+    delim: string;
     out: string;
+    closed: boolean;
     inTightList: boolean;
     noAutoBlank: boolean;
+    /** @type {Boolean|undefined} */
     isAutolink: boolean | undefined;
+    /** @type {Boolean} */
     escapeWhitespace: boolean;
-    private readonly nodes;
-    private readonly marks;
-    private readonly options;
-    private delim;
-    private closed;
-    private readonly dynamicModifier?;
-    constructor(nodes: NodeMap, marks: MarkMap, options?: Partial<SerializerOptions>, dynamicModifier?: MarkdownSerializerDynamicModifier);
+    options: any;
+    dynamicModifier: any;
     setNoAutoBlank(): void;
     unsetNoAutoBlank(): void;
-    flushClose(size?: number | null): void;
-    wrapBlock(delim: string, firstDelim: string | null, node: Node, f: () => void): void;
+    flushClose(size: any): void;
+    wrapBlock(delim: any, firstDelim: any, node: any, f: any): void;
     atBlank(): boolean;
     ensureNewLine(): void;
-    write(content?: string | null): void;
-    closeBlock(node?: Node): void;
-    text(text: string, escape?: boolean): void;
-    render(node: Node, parent: Node, index: number): void;
-    renderContent(parent: Node): void;
-    renderInline(parent: Node): void;
-    renderList(node: Node, delim: string, firstDelim: (index: number, firstDelimNode: Node) => string): void;
-    esc(str: string, startOfLine?: boolean): string;
-    escWhitespace(str: string): string;
-    repeat(str: string, n: number): string;
-    markString(mark: Mark, open: boolean, parent: Node, index: number): string;
-    getEnclosingWhitespace(text: string): {
-        leading: string | undefined;
-        trailing: string | undefined;
+    write(content: any): void;
+    closeBlock(node: any): void;
+    text(text: any, escape: any): void;
+    render(node: any, parent: any, index: any): void;
+    renderContent(parent: any): void;
+    renderInline(parent: any): void;
+    renderList(node: any, delim: any, firstDelim: any): void;
+    esc(str: any, startOfLine: any): any;
+    escWhitespace(str: any): any;
+    quote(str: any): string;
+    repeat(str: any, n: any): string;
+    markString(mark: any, open: any, parent: any, index: any): any;
+    getEnclosingWhitespace(text: any): {
+        leading: any;
+        trailing: any;
     };
 }
-export {};

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

@@ -1,7 +1,8 @@
+/* eslint-disable */
+// ::- A specification for serializing a ProseMirror document as
+// Markdown/CommonMark text.
+// prettier-ignore
 export class MarkdownSerializer {
-    nodes;
-    marks;
-    dynamicModifier;
     // :: (Object<(state: MarkdownSerializerState, node: Node, parent: Node, index: number)>, Object)
     // Construct a serializer with the given configuration. The `nodes`
     // object should map node names in a given schema to function that
@@ -46,7 +47,7 @@ export class MarkdownSerializer {
     // :: (Node, ?Object) → string
     // Serialize the content of the given node to
     // [CommonMark](http://commonmark.org/).
-    serialize(content, options = {}) {
+    serialize(content, options) {
         const state = new MarkdownSerializerState(this.nodes, this.marks, options, this.dynamicModifier);
         state.renderContent(content);
         return state.out;
@@ -65,25 +66,16 @@ export class MarkdownSerializer {
 // node and mark serialization methods (see `toMarkdown`).
 // prettier-ignore
 export class MarkdownSerializerState {
-    out;
-    inTightList;
-    noAutoBlank;
-    isAutolink;
-    escapeWhitespace;
-    nodes;
-    marks;
-    options;
-    delim;
-    closed;
-    dynamicModifier;
-    constructor(nodes, marks, options = {}, dynamicModifier) {
+    constructor(nodes, marks, options, dynamicModifier) {
         this.nodes = nodes;
         this.marks = marks;
         this.delim = this.out = '';
         this.closed = false;
         this.inTightList = false;
         this.noAutoBlank = false;
+        /** @type {Boolean|undefined} */
         this.isAutolink = undefined;
+        /** @type {Boolean} */
         this.escapeWhitespace = false;
         // :: Object
         // The options passed to the serializer.
@@ -107,7 +99,7 @@ export class MarkdownSerializerState {
         if (this.closed) {
             if (!this.atBlank() && !this.noAutoBlank)
                 this.out += '\n';
-            if (size === null || size === undefined)
+            if (size == null)
                 size = 2;
             if (size > 1) {
                 let delimMin = this.delim;
@@ -160,7 +152,7 @@ export class MarkdownSerializerState {
     // :: (Node)
     // Close the block for the given node.
     closeBlock(node) {
-        this.closed = node ?? false;
+        this.closed = node;
     }
     // :: (string, ?bool)
     // Add the given text to the document. When escape is not `false`,
@@ -213,26 +205,26 @@ export class MarkdownSerializerState {
             // that mark to prevent parser edge cases with new lines just
             // before closing or after opening marks.
             if (node && node.type.spec.isBreak) {
-                marks = marks.filter((m) => {
+                marks = marks.filter(m => {
                     if (index === 0)
                         return false;
                     if (index + 1 == parent.childCount)
                         return false;
                     const prev = parent.child(index - 1);
                     const next = parent.child(index + 1);
-                    return ((m.isInSet(prev.marks) && (!prev.isText || /\S/.test(prev.text ?? ''))) &&
-                        (m.isInSet(next.marks) && (!next.isText || /\S/.test(next.text ?? ''))));
+                    return ((m.isInSet(prev.marks) && (!prev.isText || /\S/.test(prev.text))) &&
+                        (m.isInSet(next.marks) && (!next.isText || /\S/.test(next.text))));
                 });
             }
             let leading = trailing;
             trailing = '';
             // If whitespace has to be expelled from the node, adjust
             // leading and trailing accordingly.
-            if (node && node.isText && marks.some((mark) => {
+            if (node && node.isText && marks.some(mark => {
                 const info = this.marks[mark.type.name];
                 return info && info.expelEnclosingWhitespace;
             })) {
-                const [_, lead, inner, trail] = /^(\s*)(.*?)(\s*)$/m.exec(node.text ?? '');
+                const [_, lead, inner, trail] = /^(\s*)(.*?)(\s*)$/m.exec(node.text);
                 leading += lead;
                 trailing = trail;
                 if (lead || trail) {
@@ -248,7 +240,6 @@ export class MarkdownSerializerState {
             // in Markdown may be opened and closed in different order, so
             // that order of the marks for the token matches the order in
             // active.
-            // eslint-disable-next-line  no-labels
             outer: for (let i = 0; i < len; i++) {
                 const mark = marks[i];
                 if (!this.marks[mark.type.name].mixable)
@@ -264,7 +255,6 @@ export class MarkdownSerializerState {
                         else if (j > i) {
                             marks = marks.slice(0, i).concat(marks.slice(i + 1, j)).concat(mark).concat(marks.slice(j, len));
                         }
-                        // eslint-disable-next-line no-labels
                         continue outer;
                     }
                 }
@@ -274,8 +264,9 @@ export class MarkdownSerializerState {
             while (keep < Math.min(active.length, len) && marks[keep].eq(active[keep]))
                 ++keep;
             // Close the marks that need to be closed
-            while (keep < active.length)
+            while (keep < active.length) {
                 this.text(this.markString(active.pop(), false, parent, index), false);
+            }
             // Output any previously expelled trailing whitespace outside the marks
             if (leading)
                 this.text(leading);
@@ -326,10 +317,10 @@ export class MarkdownSerializerState {
     // Escape the given string so that it can safely appear in Markdown
     // content. If `startOfLine` is true, also escape characters that
     // have special meaning only at the start of the line.
-    esc(str, startOfLine = false) {
-        // eslint-disable-next-line no-useless-escape
-        const escRegexp = this.options?.commonEscape || /[`\^+*\\\|~\[\]\{\}<>\$_]/g;
-        const startOfLineEscRegexp = this.options?.startOfLineEscape || /^[:#\-*+>]/;
+    esc(str, startOfLine) {
+        var _a, _b;
+        const escRegexp = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.commonEscape) || /[`\^+*\\\|~\[\]\{\}<>\$_]/g;
+        const startOfLineEscRegexp = ((_b = this.options) === null || _b === void 0 ? void 0 : _b.startOfLineEscape) || /^[:#\-*+>]/;
         str = str.replace(escRegexp, '\\$&');
         if (startOfLine)
             str = str.replace(startOfLineEscRegexp, '\\$&').replace(/^(\s*\d+)\./, '$1\\.');
@@ -338,7 +329,6 @@ export class MarkdownSerializerState {
     escWhitespace(str) {
         return str.replace(/ /g, '\\ ');
     }
-    /// @internal
     quote(str) {
         const wrap = str.indexOf('"') == -1 ? '""' : str.indexOf("'") == -1 ? "''" : '()';
         return wrap[0] + str + wrap[1];
@@ -351,7 +341,7 @@ export class MarkdownSerializerState {
             out += str;
         return out;
     }
-    // :: (Mark, bool, string?) → string
+    // : (Mark, bool, string?) → string
     // Get the markdown string for a given opening or closing mark.
     markString(mark, open, parent, index) {
         const info = this.marks[mark.type.name];
@@ -369,4 +359,3 @@ export class MarkdownSerializerState {
         };
     }
 }
-//# sourceMappingURL=MarkdownSerializer.js.map

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

@@ -26,7 +26,6 @@
  */
 /** @internal */
 export class MarkdownSerializerDynamicModifier {
-    nodeProcessors;
     constructor(config) {
         this.nodeProcessors = new Map(Object.entries(config));
     }
@@ -42,4 +41,3 @@ export class MarkdownSerializerDynamicModifier {
         }
     }
 }
-//# sourceMappingURL=MarkdownSerializerDynamicModifier.js.map

package/build/esm/core/markdown/ProseMirrorTransformer/emptyRowTransformer.d.ts

@@ -1,2 +1,2 @@
-import { TransformFn } from "./index.js";
+import { TransformFn } from './index';
 export declare const transformEmptyParagraph: TransformFn;

package/build/esm/core/markdown/ProseMirrorTransformer/emptyRowTransformer.js

@@ -1,11 +1,11 @@
 export const transformEmptyParagraph = (node) => {
+    var _a, _b;
     if (node.type !== 'paragraph')
         return;
-    if (node.content?.length !== 1)
+    if (((_a = node.content) === null || _a === void 0 ? void 0 : _a.length) !== 1)
         return;
-    if (node.content[0]?.type !== 'text')
+    if (((_b = node.content[0]) === null || _b === void 0 ? void 0 : _b.type) !== 'text')
         return;
     if (node.content[0].text === String.fromCharCode(160))
         delete node.content;
 };
-//# sourceMappingURL=emptyRowTransformer.js.map

package/build/esm/core/markdown/ProseMirrorTransformer/getTransformers.d.ts

@@ -1,7 +1,7 @@
-import { TransformFn } from "./index.js";
-type GetTransformersProps = {
+import { TransformFn } from '.';
+declare type GetTransformersProps = {
     emptyRowTransformer?: boolean;
 };
-type GetPMTransformersType = (config: GetTransformersProps) => TransformFn[];
+declare type GetPMTransformersType = (config: GetTransformersProps) => TransformFn[];
 export declare const getPMTransformers: GetPMTransformersType;
 export {};

package/build/esm/core/markdown/ProseMirrorTransformer/getTransformers.js

@@ -1,5 +1,5 @@
 // TODO: add a new method to the ExtensionBuilder
-import { transformEmptyParagraph } from "./emptyRowTransformer.js";
+import { transformEmptyParagraph } from './emptyRowTransformer';
 export const getPMTransformers = ({ emptyRowTransformer }) => {
     const transformers = [];
     if (emptyRowTransformer) {
@@ -7,4 +7,3 @@ export const getPMTransformers = ({ emptyRowTransformer }) => {
     }
     return transformers;
 };
-//# sourceMappingURL=getTransformers.js.map

package/build/esm/core/markdown/ProseMirrorTransformer/index.d.ts

@@ -1,11 +1,11 @@
 import { Node } from 'prosemirror-model';
-type PMNodeJSON = {
+declare type PMNodeJSON = {
     type: string;
     attrs?: Record<string, any>;
     content?: PMNodeJSON[];
     text?: string;
 };
-export type TransformFn = (node: PMNodeJSON) => void;
+export declare type TransformFn = (node: PMNodeJSON) => void;
 export declare class ProseMirrorTransformer {
     private readonly _transformers;
     constructor(fns: TransformFn[]);

package/build/esm/core/markdown/ProseMirrorTransformer/index.js

@@ -1,6 +1,5 @@
 import { Node } from 'prosemirror-model';
 export class ProseMirrorTransformer {
-    _transformers;
     constructor(fns) {
         this._transformers = fns;
     }
@@ -20,4 +19,3 @@ export class ProseMirrorTransformer {
         }
     }
 }
-//# sourceMappingURL=index.js.map

package/build/esm/core/types/actions.d.ts

@@ -1,6 +1,6 @@
 import type { EditorState, Transaction } from 'prosemirror-state';
 import type { EditorView } from 'prosemirror-view';
-export type CommandWithAttrs<T = Record<string, string>> = (state: EditorState, dispatch?: (tr: Transaction) => void, view?: EditorView, attrs?: T) => boolean;
+export declare type CommandWithAttrs<T = Record<string, string>> = (state: EditorState, dispatch?: (tr: Transaction) => void, view?: EditorView, attrs?: T) => boolean;
 export interface ActionSpec {
     /** @default () => false */
     isActive?(state: EditorState): boolean;
@@ -9,11 +9,11 @@ export interface ActionSpec {
     /** @default () => {} */
     meta?(state: EditorState): any;
 }
-export interface Action<A extends {} | unknown = unknown, M = unknown> {
-    isActive: () => boolean;
-    isEnable: (args?: Record<string, unknown>) => boolean;
-    run: A extends {} ? (arg: A) => void : () => void;
-    meta: () => M;
+export interface Action<A extends {} = never, M = unknown> {
+    isActive(): boolean;
+    isEnable(args?: Record<string, unknown>): boolean;
+    run(...args: A extends never ? [] : [A]): void;
+    meta(): M;
 }
 export interface ActionStorage {
     actions: WysiwygEditor.Actions;

package/build/esm/core/types/actions.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=actions.js.map

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=dynamicModifiers.js.map