@gravity-ui/markdown-editor 13.0.0

package/build/esm/core/ExtensionsManager.js

@@ -0,0 +1,96 @@
+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;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import MarkdownIt from 'markdown-it';
+import { ActionsManager } from './ActionsManager';
+import { ExtensionBuilder } from './ExtensionBuilder';
+import { ParserTokensRegistry } from './ParserTokensRegistry';
+import { SchemaSpecRegistry } from './SchemaSpecRegistry';
+import { SerializerTokensRegistry } from './SerializerTokensRegistry';
+export class ExtensionsManager {
+    constructor({ extensions, options = {} }) {
+        var _a, _b, _c, _d;
+        _ExtensionsManager_schemaRegistry.set(this, new SchemaSpecRegistry());
+        _ExtensionsManager_parserRegistry.set(this, new ParserTokensRegistry());
+        _ExtensionsManager_serializerRegistry.set(this, new 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 }) => {
+            __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_extensions, extensions, "f");
+        const mdPreset = (_b = (_a = options.mdOpts) === null || _a === void 0 ? void 0 : _a.preset) !== null && _b !== void 0 ? _b : 'default';
+        __classPrivateFieldSet(this, _ExtensionsManager_mdForMarkup, new MarkdownIt(mdPreset, (_c = options.mdOpts) !== null && _c !== void 0 ? _c : {}), "f");
+        __classPrivateFieldSet(this, _ExtensionsManager_mdForText, new MarkdownIt(mdPreset, (_d = options.mdOpts) !== null && _d !== void 0 ? _d : {}), "f");
+        if (options.linkifyTlds) {
+            __classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f").linkify.tlds(options.linkifyTlds, true);
+            __classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f").linkify.tlds(options.linkifyTlds, true);
+        }
+        // TODO: add prefilled context
+        __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 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 __classPrivateFieldGet(this, _ExtensionsManager_deps, "f");
+    }
+    processExtensions() {
+        __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);
+    }
+    createDeps() {
+        const schema = __classPrivateFieldGet(this, _ExtensionsManager_schemaRegistry, "f").createSchema();
+        __classPrivateFieldSet(this, _ExtensionsManager_deps, {
+            schema,
+            actions: new ActionsManager(),
+            markupParser: __classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").createParser(schema, __classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f")),
+            textParser: __classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").createParser(schema, __classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f")),
+            serializer: __classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").createSerializer(),
+        }, "f");
+    }
+    createDerived() {
+        __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 __classPrivateFieldGet(this, _ExtensionsManager_markViewCreators, "f")) {
+            __classPrivateFieldGet(this, _ExtensionsManager_markViews, "f")[name] = view(__classPrivateFieldGet(this, _ExtensionsManager_deps, "f"));
+        }
+    }
+}
+_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/esm/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/esm/core/ParserTokensRegistry.js

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

package/build/esm/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/esm/core/SchemaSpecRegistry.js

@@ -0,0 +1,21 @@
+var _SchemaSpecRegistry_spec;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { Schema } from 'prosemirror-model';
+export class SchemaSpecRegistry {
+    constructor(topNode) {
+        _SchemaSpecRegistry_spec.set(this, void 0);
+        __classPrivateFieldSet(this, _SchemaSpecRegistry_spec, { topNode, nodes: {}, marks: {} }, "f");
+    }
+    addNode(name, spec) {
+        __classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f").nodes[name] = spec;
+        return this;
+    }
+    addMark(name, spec) {
+        __classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f").marks[name] = spec;
+        return this;
+    }
+    createSchema() {
+        return new Schema(__classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f"));
+    }
+}
+_SchemaSpecRegistry_spec = new WeakMap();

package/build/esm/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/esm/core/SerializerTokensRegistry.js

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

package/build/esm/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/esm/core/index.js

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

@@ -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 {};

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

@@ -0,0 +1,247 @@
+import { Mark } from 'prosemirror-model';
+import { logger } from '../../logger';
+const openSuffix = '_open';
+const closeSuffix = '_close';
+var TokenType;
+(function (TokenType) {
+    TokenType["open"] = "open";
+    TokenType["close"] = "close";
+    TokenType["default"] = "default";
+})(TokenType || (TokenType = {}));
+export class MarkdownParser {
+    constructor(schema, tokenizer, tokens) {
+        this.stack = [];
+        this.schema = schema;
+        this.marks = Mark.none;
+        this.tokens = tokens;
+        this.tokenizer = tokenizer;
+    }
+    validateLink(url) {
+        return this.tokenizer.validateLink(url);
+    }
+    normalizeLink(url) {
+        return this.tokenizer.normalizeLink(url);
+    }
+    normalizeLinkText(url) {
+        return this.tokenizer.normalizeLinkText(url);
+    }
+    matchLinks(text) {
+        return this.tokenizer.linkify.match(text);
+    }
+    parse(text) {
+        const time = Date.now();
+        try {
+            this.stack = [{ type: this.schema.topNodeType, content: [] }];
+            let mdItTokens;
+            try {
+                mdItTokens = this.tokenizer.parse(text, {});
+            }
+            catch (err) {
+                const e = err;
+                e.message = 'Unable to parse your markup. Please check for errors. ' + e.message;
+                throw e;
+            }
+            this.parseTokens(mdItTokens);
+            let doc;
+            // If after parsing there are still unclosed nodes, close them by removing them from the stack.
+            do {
+                doc = this.closeNode();
+            } while (this.stack.length);
+            return (doc || this.schema.topNodeType.createAndFill());
+        }
+        finally {
+            logger.metrics({ component: 'parser', event: 'parse', duration: Date.now() - time });
+        }
+    }
+    top() {
+        return this.stack[this.stack.length - 1];
+    }
+    push(elt) {
+        if (this.stack.length)
+            this.top().content.push(elt);
+    }
+    //#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;
+    }
+    getTokenSpec(token) {
+        var _a;
+        // Matching the pm-node meta-attribute which is set in the plugin for markdown-it
+        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})$`), '');
+        let tokenSpec;
+        if (tokName in this.tokens)
+            tokenSpec = this.tokens[tokName];
+        if (!tokenSpec)
+            throw new RangeError(`No token spec for token: ${JSON.stringify(token)}`);
+        return tokenSpec;
+    }
+    // Getting token type from its name
+    // e.g. "paragraph_open" - is opening token for paragraph
+    getTokenType({ type }) {
+        if (type.endsWith(openSuffix))
+            return TokenType.open;
+        if (type.endsWith(closeSuffix))
+            return TokenType.close;
+        return TokenType.default;
+    }
+    //#endregion
+    //#region token handlers
+    // Self-explanatory
+    handlePrimitiveToken(token) {
+        switch (token.type) {
+            case 'text':
+                this.addText(withoutTrailingNewline(token.content));
+                return true;
+            case 'inline':
+                this.parseTokens(token.children || []);
+                return true;
+            case 'softbreak':
+                // TODO: move all primitive token's handlers to extensions
+                if (this.tokens.softbreak)
+                    return false;
+                this.addText('\n');
+                return true;
+        }
+        return false;
+    }
+    handleMark(token, tokenSpec, attrs) {
+        const schemaSpec = this.schema.marks[tokenSpec.name];
+        if (tokenSpec.noCloseToken) {
+            this.openMark(schemaSpec.create(attrs));
+            let { content } = token;
+            if (!tokenSpec.code)
+                content = withoutTrailingNewline(content);
+            this.addText(content);
+            this.closeMark(schemaSpec);
+            return;
+        }
+        switch (this.getTokenType(token)) {
+            case 'open': {
+                this.openMark(schemaSpec.create(attrs));
+                break;
+            }
+            case 'close': {
+                this.closeMark(schemaSpec);
+                break;
+            }
+        }
+    }
+    handleNode(_token, tokenSpec, attrs) {
+        const schemaSpec = this.schema.nodes[tokenSpec.name];
+        // 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];
+        if (tokenSpec.noCloseToken) {
+            this.openNode(schemaSpec, attrs);
+            if (tokenSpec.contentField === 'children' && ((_a = token.children) === null || _a === void 0 ? void 0 : _a.length)) {
+                this.parseTokens(token.children);
+            }
+            else {
+                let { content } = token;
+                if (tokenSpec.prepareContent) {
+                    content = tokenSpec.prepareContent(content);
+                }
+                this.addText(content);
+            }
+            this.closeNode();
+            return;
+        }
+        switch (this.getTokenType(token)) {
+            case 'open': {
+                this.openNode(schemaSpec, attrs);
+                break;
+            }
+            case 'close': {
+                this.closeNode();
+                break;
+            }
+        }
+    }
+    handleToken(token, tokenSpec, attrs) {
+        switch (tokenSpec.type) {
+            case 'mark':
+                this.handleMark(token, tokenSpec, attrs);
+                break;
+            case 'node':
+                this.handleNode(token, tokenSpec, attrs);
+                break;
+            case 'block':
+                this.handleBlock(token, tokenSpec, attrs);
+                break;
+        }
+    }
+    //#endregion
+    //#region state methods
+    addNode(type, attrs, content) {
+        const node = type.createAndFill(attrs, content, this.marks);
+        if (!node)
+            return null;
+        this.push(node);
+        return node;
+    }
+    openNode(type, attrs) {
+        this.stack.push({ type: type, attrs, content: [] });
+    }
+    closeNode() {
+        // Marks operate within a node. Therefore, when we close the node, we reset the existing marks.
+        if (this.marks.length)
+            this.marks = Mark.none;
+        const info = this.stack.pop();
+        if (info)
+            return this.addNode(info.type, info.attrs, info.content);
+        return null;
+    }
+    addText(text) {
+        if (!text)
+            return;
+        const nodes = this.top().content;
+        const last = nodes[nodes.length - 1];
+        const node = this.schema.text(text, this.marks);
+        let merged;
+        if (last && (merged = maybeMerge(last, node)))
+            nodes[nodes.length - 1] = merged;
+        else
+            nodes.push(node);
+    }
+    // Adding mark to a set of open marks
+    openMark(mark) {
+        this.marks = mark.addToSet(this.marks);
+    }
+    closeMark(mark) {
+        this.marks = mark.removeFromSet(this.marks);
+    }
+    //#endregion
+    parseTokens(tokens) {
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (this.handlePrimitiveToken(token))
+                continue;
+            const tokenSpec = this.getTokenSpec(token);
+            if (tokenSpec.ignore)
+                continue;
+            const attrs = this.getTokenAttrs(token, tokenSpec, tokens, i);
+            this.handleToken(token, tokenSpec, attrs);
+        }
+    }
+}
+// Checking if these are two text nodes and they have the same marks, then it merges them into one.
+function maybeMerge(a, b) {
+    if (a.isText && b.isText && Mark.sameSet(a.marks, b.marks)) {
+        // Somehow this method is not in typings but it exists.
+        // @ts-expect-error
+        return a.withText(a.text + b.text);
+    }
+}
+function withoutTrailingNewline(str) {
+    return str[str.length - 1] === '\n' || str.endsWith('\\n') ? str.slice(0, str.length - 1) : str;
+}

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

@@ -0,0 +1,45 @@
+export class MarkdownSerializer {
+    constructor(nodes: any, marks: any);
+    nodes: any;
+    marks: 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);
+    nodes: any;
+    marks: any;
+    delim: string;
+    out: string;
+    closed: boolean;
+    inTightList: boolean;
+    noAutoBlank: boolean;
+    /** @type {Boolean|undefined} */
+    isAutolink: boolean | undefined;
+    /** @type {Boolean} */
+    escapeWhitespace: boolean;
+    options: any;
+    setNoAutoBlank(): void;
+    unsetNoAutoBlank(): void;
+    flushClose(size: any): void;
+    wrapBlock(delim: any, firstDelim: any, node: any, f: any): void;
+    atBlank(): boolean;
+    ensureNewLine(): void;
+    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;
+    };
+}