@doist/typist 1.0.0

package/dist/serializers/html/extensions/html.js

@@ -0,0 +1,15 @@
+import { escape } from 'lodash-es';
+/**
+ * A Marked extension which tweaks the `html` renderer to escape special characters (i.e. `&`, `<`,
+ * `>`, `"`, and `'`) for unsupported tokens. This custom rule is required because the escaping must
+ * be performed at the token level to avoid escaping the full input, which would result in unwanted
+ * escaped output (i.e. valid HTML would be escaped).
+ */
+const html = {
+    renderer: {
+        html(html) {
+            return escape(html);
+        },
+    },
+};
+export { html };

package/dist/serializers/html/extensions/link.d.ts

@@ -0,0 +1,11 @@
+import { marked } from 'marked';
+import type { NodeType } from 'prosemirror-model';
+/**
+ * A Marked extension which tweaks the `link` renderer to add support for suggestion nodes, while
+ * preserving the original renderer for standard links.
+ *
+ * @param suggestionNodes An array of the suggestion nodes to serialize.
+ */
+declare function link(suggestionNodes: NodeType[]): marked.MarkedExtension;
+export { link };
+//# sourceMappingURL=link.d.ts.map

package/dist/serializers/html/extensions/link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../../src/serializers/html/extensions/link.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAIjD;;;;;GAKG;AACH,iBAAS,IAAI,CAAC,eAAe,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,eAAe,CAsBjE;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/serializers/html/extensions/link.js

@@ -0,0 +1,28 @@
+import { kebabCase } from 'lodash-es';
+import { marked } from 'marked';
+const markedRenderer = new marked.Renderer();
+/**
+ * A Marked extension which tweaks the `link` renderer to add support for suggestion nodes, while
+ * preserving the original renderer for standard links.
+ *
+ * @param suggestionNodes An array of the suggestion nodes to serialize.
+ */
+function link(suggestionNodes) {
+    const linkSchemaRegex = new RegExp(`^(?:${suggestionNodes
+        .map((suggestionNode) => kebabCase(suggestionNode.name.replace(/Suggestion$/, '')))
+        .join('|')})://`);
+    return {
+        renderer: {
+            link(href, title, text) {
+                if (href && linkSchemaRegex.test(href)) {
+                    const [, schema, id] = /^([a-z-]+):\/\/(\d+)$/i.exec(href) || [];
+                    if (schema && id && text) {
+                        return `<span data-${schema} data-id="${id}" data-label="${text}"></span>`;
+                    }
+                }
+                return markedRenderer.link.apply(this, [href, title, text]);
+            },
+        },
+    };
+}
+export { link };

package/dist/serializers/html/extensions/paragraph.d.ts

@@ -0,0 +1,12 @@
+import { marked } from 'marked';
+import type { NodeType } from 'prosemirror-model';
+/**
+ * A Marked extension which tweaks the `paragraph` renderer to remove the surrounding `<p></p>` tag
+ * when it's wrapping an image element as a single child, or to remove all inline images if the
+ * editor was configured without inline image support (default).
+ *
+ * @param imageNode The node object for the schema image node.
+ */
+declare function paragraph(imageNode?: NodeType): marked.MarkedExtension;
+export { paragraph };
+//# sourceMappingURL=paragraph.d.ts.map

package/dist/serializers/html/extensions/paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["../../../../src/serializers/html/extensions/paragraph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAI/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAOjD;;;;;;GAMG;AACH,iBAAS,SAAS,CAAC,SAAS,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC,eAAe,CA6C/D;AAED,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/dist/serializers/html/extensions/paragraph.js

@@ -0,0 +1,51 @@
+import { marked } from 'marked';
+import { parseHtmlToElement } from '../../../helpers/dom';
+/**
+ * Initialize a new instance of the original renderer to be used by the extension.
+ */
+const markedRenderer = new marked.Renderer();
+/**
+ * A Marked extension which tweaks the `paragraph` renderer to remove the surrounding `<p></p>` tag
+ * when it's wrapping an image element as a single child, or to remove all inline images if the
+ * editor was configured without inline image support (default).
+ *
+ * @param imageNode The node object for the schema image node.
+ */
+function paragraph(imageNode) {
+    const isInlineImageSupported = imageNode ? imageNode.spec.inline : false;
+    return {
+        renderer: {
+            paragraph(text) {
+                const renderedHTML = markedRenderer.paragraph.apply(this, [text]);
+                const { firstElementChild: renderedElement } = parseHtmlToElement(renderedHTML);
+                // Return the rendered HTML as a safeguard in the event that the rendered element
+                // does not exist (just in case, but highly unlikely to happen)
+                if (!renderedElement) {
+                    return renderedHTML;
+                }
+                // Return the rendered element HTML if inline images are supported
+                if (isInlineImageSupported) {
+                    return renderedElement.outerHTML;
+                }
+                const imageChildNodes = Array.from(renderedElement.childNodes).filter((childNode) => childNode.nodeName === 'IMG');
+                // Return the HTML contained in the rendered element if it only contains images
+                // (i.e. removes the surrounding `<p></p>` tag from image child elements)
+                if (renderedElement.childNodes.length === imageChildNodes.length) {
+                    return renderedElement.innerHTML;
+                }
+                // Remove all image elements contained in the rendered element since at this point
+                // we know that the editor does not support inline images
+                if (renderedElement.childNodes.length > 1) {
+                    renderedElement.childNodes.forEach((childNode) => {
+                        if (childNode.nodeName === 'IMG') {
+                            renderedElement.removeChild(childNode);
+                        }
+                    });
+                }
+                // Return the rendered element HTML (stripped of inline images)
+                return renderedElement.outerHTML;
+            },
+        },
+    };
+}
+export { paragraph };

package/dist/serializers/html/extensions/task-list.d.ts

@@ -0,0 +1,9 @@
+import { marked } from 'marked';
+/**
+ * A Marked extension which tweaks the `checkbox`, `list`, and `listitem` renderers to add support
+ * for task lists (i.e., `* [ ] Task`), while preserving the original renderers for standard bullet
+ * and ordered lists.
+ */
+declare const taskList: marked.MarkedExtension;
+export { taskList };
+//# sourceMappingURL=task-list.d.ts.map

package/dist/serializers/html/extensions/task-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-list.d.ts","sourceRoot":"","sources":["../../../../src/serializers/html/extensions/task-list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAO/B;;;;GAIG;AACH,QAAA,MAAM,QAAQ,EAAE,MAAM,CAAC,eAwBtB,CAAA;AAED,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/serializers/html/extensions/task-list.js

@@ -0,0 +1,31 @@
+import { marked } from 'marked';
+/**
+ * Initialize a new instance of the original renderer to be used by the extension.
+ */
+const markedRenderer = new marked.Renderer();
+/**
+ * A Marked extension which tweaks the `checkbox`, `list`, and `listitem` renderers to add support
+ * for task lists (i.e., `* [ ] Task`), while preserving the original renderers for standard bullet
+ * and ordered lists.
+ */
+const taskList = {
+    renderer: {
+        checkbox(checked) {
+            return `[${checked ? 'x' : ' '}] `;
+        },
+        list(body, ordered, start) {
+            if (body.includes('data-type="taskItem"')) {
+                return `<ul data-type="taskList">\n${body}</ul>\n`;
+            }
+            return markedRenderer.list.apply(this, [body, ordered, start]);
+        },
+        listitem(text) {
+            const taskItem = /^(\[[ x]\])( [\s\S]*)?/i.exec(text);
+            if (taskItem) {
+                return `<li data-type="taskItem" data-checked="${String(taskItem[1] !== '[ ]')}">${taskItem[2].trim() || ''}</li>\n`;
+            }
+            return markedRenderer.listitem.apply(this, [text, false, false]);
+        },
+    },
+};
+export { taskList };

package/dist/serializers/html/html.d.ts

@@ -0,0 +1,27 @@
+import type { Schema } from 'prosemirror-model';
+/**
+ * The return type for the `createHTMLSerializer` function.
+ */
+declare type HTMLSerializerReturnType = {
+    /**
+     * Serializes an input Markdown string to an output HTML string.
+     *
+     * @param markdown The Markdown string to serialize.
+     *
+     * @returns The serialized HTML.
+     */
+    serialize: (markdown: string) => string;
+};
+/**
+ * Create a Markdown to HTML serializer with the Marked library for a rich-text editor, or use a
+ * custom serializer for a plain-text editor. The editor schema is used to detect which nodes and
+ * marks are available in the editor, and only parses the input with the minimal required rules.
+ *
+ * @param schema The editor schema to be used for nodes and marks detection.
+ *
+ * @returns A normalized `serialize` function.
+ */
+declare function createHTMLSerializer(schema: Schema): HTMLSerializerReturnType;
+export { createHTMLSerializer };
+export type { HTMLSerializerReturnType };
+//# sourceMappingURL=html.d.ts.map

package/dist/serializers/html/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../../src/serializers/html/html.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;GAEG;AACH,aAAK,wBAAwB,GAAG;IAC5B;;;;;;OAMG;IACH,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;CAC1C,CAAA;AA0HD;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,wBAAwB,CAQtE;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAA;AAE/B,YAAY,EAAE,wBAAwB,EAAE,CAAA"}

package/dist/serializers/html/html.js

@@ -0,0 +1,129 @@
+import { escape, kebabCase } from 'lodash-es';
+import { marked } from 'marked';
+import { REGEX_LINE_BREAKS } from '../../constants/regular-expressions';
+import { isPlainTextDocument } from '../../helpers/schema';
+import { checkbox } from './extensions/checkbox';
+import { code } from './extensions/code';
+import { html } from './extensions/html';
+import { link } from './extensions/link';
+import { paragraph } from './extensions/paragraph';
+import { taskList } from './extensions/task-list';
+/**
+ * Sensible default options to initialize the Marked parser with.
+ *
+ * @see https://marked.js.org/using_advanced#options
+ */
+const INITIAL_MARKED_OPTIONS = {
+    breaks: true,
+    gfm: true,
+    headerIds: false,
+    silent: true,
+};
+/**
+ * Serialize the Markdown input to HTML with a custom serializer, ready for a plain-text editor.
+ *
+ * @param schema The editor schema to be used for nodes and marks detection.
+ *
+ * @returns The serialized HTML output.
+ */
+function serializeForPlainTextEditor(markdown, schema) {
+    // Converts special characters (i.e. `&`, `<`, `>`, `"`, and `'`) to their corresponding HTML
+    // entities. Unlike the `sanitize` option that is used by the rich-text serializer, it's safe
+    // for the plain-text serializer to escape the full input considering we need to output the full
+    // content as valid HTML (i.e. the editor should not drop invalid HTML).
+    let htmlResult = escape(markdown);
+    // Serialize all suggestion links if any suggestion node exists in the schema
+    Object.values(schema.nodes)
+        .filter((node) => node.name.endsWith('Suggestion'))
+        .forEach((suggestionNode) => {
+        const linkSchema = kebabCase(suggestionNode.name.replace(/Suggestion$/, ''));
+        htmlResult = htmlResult.replace(new RegExp(`\\[([^\\[]+)\\]\\((?:${linkSchema}):\\/\\/(\\d+)\\)`, 'gm'), `<span data-${linkSchema} data-id="$2" data-label="$1"></span>`);
+    });
+    // Return the serialized HTML with every line wrapped in a paragraph element
+    return htmlResult.replace(/^([^\n]+)\n?|\n+/gm, `<p>$1</p>`);
+}
+/**
+ * Serialize the Markdown input to HTML with Marked, ready for a rich-text editor.
+ *
+ * @param markdown The input Markdown to be serialized to HTML.
+ * @param schema The editor schema to be used for nodes and marks detection.
+ *
+ * @returns The serialized HTML output.
+ */
+function serializeForRichTextEditor(markdown, schema) {
+    // Reset Marked to the defaults and set custom options
+    marked.setOptions({
+        ...marked.getDefaults(),
+        ...INITIAL_MARKED_OPTIONS,
+    });
+    // Disable built-in rules that the editor does not yet support
+    marked.use({
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore: Returning `undefined` is acceptable to disable tokens
+        tokenizer: {
+            ...(!schema.marks.strike
+                ? {
+                    del() {
+                        /* noop: disables tokenizer */
+                    },
+                }
+                : {}),
+            ...(!schema.nodes.heading
+                ? {
+                    heading() {
+                        /* noop: disables tokenizer */
+                    },
+                }
+                : {}),
+            ...(!schema.nodes.table
+                ? {
+                    table() {
+                        /* noop: disables tokenizer */
+                    },
+                }
+                : {}),
+        },
+    });
+    // Overwrite some built-in rules for handling of special behaviours
+    // (see documentation for each extension for more details)
+    marked.use(checkbox, html, paragraph(schema.nodes.image));
+    // Overwrite the built-in `code` rule if the corresponding node exists in the schema
+    if (schema.nodes.codeBlock) {
+        marked.use(code);
+    }
+    // Add a rule for a task list if the corresponding nodes exists in the schema
+    if (schema.nodes.taskList && schema.nodes.taskItem) {
+        marked.use(taskList);
+    }
+    // Get all the available suggestion nodes from the schema
+    const suggestionNodes = Object.values(schema.nodes).filter((node) => node.name.endsWith('Suggestion'));
+    // Overwrite the built-in link rule if any suggestion node exists in the schema
+    if (suggestionNodes.length > 0) {
+        marked.use(link(suggestionNodes));
+    }
+    // Return the serialized HTML parsed with Marked
+    return (marked
+        .parse(markdown)
+        // Removes newlines after tags from the HTML output with a specially crafted RegExp
+        // (needed to prevent the editor from converting newlines to blank paragraphs)
+        .replace(new RegExp(`>${REGEX_LINE_BREAKS.source}`, REGEX_LINE_BREAKS.flags), '>'));
+}
+/**
+ * Create a Markdown to HTML serializer with the Marked library for a rich-text editor, or use a
+ * custom serializer for a plain-text editor. The editor schema is used to detect which nodes and
+ * marks are available in the editor, and only parses the input with the minimal required rules.
+ *
+ * @param schema The editor schema to be used for nodes and marks detection.
+ *
+ * @returns A normalized `serialize` function.
+ */
+function createHTMLSerializer(schema) {
+    return {
+        serialize(markdown) {
+            return isPlainTextDocument(schema)
+                ? serializeForPlainTextEditor(markdown, schema)
+                : serializeForRichTextEditor(markdown, schema);
+        },
+    };
+}
+export { createHTMLSerializer };

package/dist/serializers/markdown/markdown.d.ts

@@ -0,0 +1,40 @@
+import type { Schema } from 'prosemirror-model';
+/**
+ * The options that the `createMarkdownSerializer` function accepts.
+ */
+declare type MarkdownSerializerOptions = {
+    /**
+     * Disables markdown escaping.
+     */
+    escape?: false;
+};
+/**
+ * The return type for the `createMarkdownSerializer` function.
+ */
+declare type MarkdownSerializerReturnType = {
+    /**
+     * Serializes an input HTML string to an output Markdown string.
+     *
+     * @param html The HTML string to serialize.
+     *
+     * @returns The serialized Markdown.
+     */
+    serialize: (html: string) => string;
+};
+/**
+ * The bullet list marker for both standard and task list items.
+ */
+declare const BULLET_LIST_MARKER = "-";
+/**
+ * Create an HTML to Markdown serializer with the Turndown library for both a rich-text editor, and
+ * a plain-text editor. The editor schema is used to detect which nodes and marks are available in
+ * the editor, and only parses the input with the minimal required rules.
+ *
+ * @param schema The editor schema to be used for nodes and marks detection.
+ *
+ * @returns A normalized `serialize` function.
+ */
+declare function createMarkdownSerializer(schema: Schema, options?: MarkdownSerializerOptions): MarkdownSerializerReturnType;
+export { BULLET_LIST_MARKER, createMarkdownSerializer };
+export type { MarkdownSerializerReturnType };
+//# sourceMappingURL=markdown.d.ts.map

package/dist/serializers/markdown/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/serializers/markdown/markdown.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;GAEG;AACH,aAAK,yBAAyB,GAAG;IAC7B;;OAEG;IACH,MAAM,CAAC,EAAE,KAAK,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,aAAK,4BAA4B,GAAG;IAChC;;;;;;OAMG;IACH,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;CACtC,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,kBAAkB,MAAM,CAAA;AA8C9B;;;;;;;;GAQG;AACH,iBAAS,wBAAwB,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,yBAAyB,GACpC,4BAA4B,CA6E9B;AAED,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,CAAA;AAEvD,YAAY,EAAE,4BAA4B,EAAE,CAAA"}

package/dist/serializers/markdown/markdown.js

@@ -0,0 +1,126 @@
+import Turndown from 'turndown';
+import { isPlainTextDocument } from '../../helpers/schema';
+import { image } from './plugins/image';
+import { listItem } from './plugins/list-item';
+import { paragraph } from './plugins/paragraph';
+import { strikethrough } from './plugins/strikethrough';
+import { suggestion } from './plugins/suggestion';
+import { taskItem } from './plugins/task-item';
+/**
+ * The bullet list marker for both standard and task list items.
+ */
+const BULLET_LIST_MARKER = '-';
+/**
+ * Sensible default options to initialize the Turndown with.
+ *
+ * @see https://github.com/mixmark-io/turndown#options
+ */
+const INITIAL_TURNDOWN_OPTIONS = {
+    headingStyle: 'atx',
+    hr: '---',
+    bulletListMarker: BULLET_LIST_MARKER,
+    codeBlockStyle: 'fenced',
+    fence: '```',
+    emDelimiter: '_',
+    strongDelimiter: '**',
+    linkStyle: 'inlined',
+    /**
+     * Special rule to handle blank elements (overrides EVERY rule).
+     *
+     * @see https://github.com/mixmark-io/turndown#special-rules
+     */
+    blankReplacement(_, node) {
+        const parentNode = node.parentNode;
+        // Return the list marker for empty bullet list items
+        if (node.nodeName === 'UL' || (parentNode?.nodeName === 'UL' && node.nodeName === 'LI')) {
+            return `${BULLET_LIST_MARKER} `;
+        }
+        // Return the list marker for empty ordered list items
+        if (node.nodeName === 'OL' || (parentNode?.nodeName === 'OL' && node.nodeName === 'LI')) {
+            const start = node.nodeName === 'LI'
+                ? parentNode.getAttribute('start')
+                : node.getAttribute('start');
+            const index = Array.prototype.indexOf.call(parentNode.children, node);
+            return `${start ? Number(start) + index : index + 1}. `;
+        }
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore: The `Turndown.Node` type does not include `isBlock`
+        return node.isBlock ? '\n\n' : '';
+    },
+};
+/**
+ * Create an HTML to Markdown serializer with the Turndown library for both a rich-text editor, and
+ * a plain-text editor. The editor schema is used to detect which nodes and marks are available in
+ * the editor, and only parses the input with the minimal required rules.
+ *
+ * @param schema The editor schema to be used for nodes and marks detection.
+ *
+ * @returns A normalized `serialize` function.
+ */
+function createMarkdownSerializer(schema, options) {
+    // Initialize Turndown with custom options
+    const turndown = new Turndown(INITIAL_TURNDOWN_OPTIONS);
+    // Turndown ensures Markdown characters are escaped (i.e. `\`) by default, so they are not
+    // interpreted as Markdown when the output is compiled back to HTML. For example, the contents
+    // of `<h1>1. Hello world</h1>` need to be escaped to `1\. Hello world`, otherwise it will be
+    // interpreted as a list item rather than a heading. However, if the schema represents a
+    // plain-text document, we need to override the escape function to return the input as-is, so
+    // that Markdown characters are interpreted as Markdown.
+    // ref: https://github.com/mixmark-io/turndown#escaping-markdown-characters
+    if (isPlainTextDocument(schema) || options?.escape === false) {
+        turndown.escape = (str) => str;
+    }
+    // Overwrite the built-in `image` rule if the corresponding node exists in the schema
+    if (schema.nodes.image) {
+        turndown.use(image(schema.nodes.image));
+    }
+    // Overwrite the built-in `listItem` rule if the corresponding node exists in the schema
+    if (schema.nodes.listItem) {
+        turndown.use(listItem(schema.nodes.listItem));
+    }
+    // Overwrite the built-in `paragraph` rule if the corresponding node exists in the schema
+    if (schema.nodes.paragraph) {
+        turndown.use(paragraph(schema.nodes.paragraph, isPlainTextDocument(schema)));
+    }
+    // Add a rule for `strikethrough` if the corresponding node exists in the schema
+    if (schema.marks.strike) {
+        turndown.use(strikethrough(schema.marks.strike));
+    }
+    // Add a rule for `taskItem` if the corresponding nodes exists in the schema
+    if (schema.nodes.taskList && schema.nodes.taskItem) {
+        turndown.use(taskItem(schema.nodes.taskItem));
+    }
+    // Add a custom rule for all suggestion nodes available in the schema
+    Object.values(schema.nodes)
+        .filter((node) => node.name.endsWith('Suggestion'))
+        .forEach((suggestionNode) => {
+        turndown.use(suggestion(suggestionNode));
+    });
+    // Return a normalized `serialize` function
+    return {
+        serialize(html) {
+            let markdownResult = html;
+            // Turndown was built to convert HTML into Markdown, expecting the input to be
+            // standard-compliant HTML. As such, it collapses all whitespace by default, and there's
+            // currently no way to opt-out of this behavior. However, for plain-text editors, we
+            // need to preserve Markdown whitespace (otherwise we lose syntax like nested lists) by
+            // replacing all instances of the space character (but only if it's preceded by another
+            // space character) by the non-breaking space character, and after processing the input
+            // with Turndown, we restore the original space character.
+            if (isPlainTextDocument(schema)) {
+                markdownResult = markdownResult.replace(/ {2,}/g, (m) => m.replace(/ /g, '\u00a0'));
+            }
+            // Get the serialized Markdown parsed with Turndown
+            markdownResult = turndown.turndown(markdownResult);
+            // Restore the original space character for plain-text editors (as mentioned above),
+            // after Markdown serialization has been performed
+            if (isPlainTextDocument(schema)) {
+                markdownResult = markdownResult.replace(/\u00a0/g, ' ');
+            }
+            // Return the serialized Markdown parsed with Turndown, and with trailing space
+            // characters removed
+            return markdownResult.replace(/ +$/gm, '');
+        },
+    };
+}
+export { BULLET_LIST_MARKER, createMarkdownSerializer };

package/dist/serializers/markdown/plugins/image.d.ts

@@ -0,0 +1,12 @@
+import type { NodeType } from 'prosemirror-model';
+import type Turndown from 'turndown';
+/**
+ * A Turndown plugin which adds a custom rule for images. This custom rule is required to disable
+ * support for Data URLs (URLs prefixed with the `data: scheme`), while displaying an explicit
+ * message in the Markdown output (for debugging and testing).
+ *
+ * @param nodeType The node object that matches this rule.
+ */
+declare function image(nodeType: NodeType): Turndown.Plugin;
+export { image };
+//# sourceMappingURL=image.d.ts.map

package/dist/serializers/markdown/plugins/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../../src/serializers/markdown/plugins/image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAA;AAWpC;;;;;;GAMG;AACH,iBAAS,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAiBlD;AAED,OAAO,EAAE,KAAK,EAAE,CAAA"}

package/dist/serializers/markdown/plugins/image.js

@@ -0,0 +1,31 @@
+/**
+ * Cleans an attribute value by replacing multiple newlines with a single one.
+ *
+ * @param attribute The attribute value to clean.
+ */
+function cleanAttribute(attribute) {
+    return attribute ? attribute.replace(/(\n+\s*)+/g, '\n') : '';
+}
+/**
+ * A Turndown plugin which adds a custom rule for images. This custom rule is required to disable
+ * support for Data URLs (URLs prefixed with the `data: scheme`), while displaying an explicit
+ * message in the Markdown output (for debugging and testing).
+ *
+ * @param nodeType The node object that matches this rule.
+ */
+function image(nodeType) {
+    return (turndown) => {
+        turndown.addRule(nodeType.name, {
+            filter: 'img',
+            replacement: function (_, node) {
+                const src = String(node.getAttribute('src'));
+                // Preserve Data URL image prefix with message about base64 being unsupported
+                const link = src.startsWith('data:') ? `${src.split(',')[0]},NOT_SUPPORTED` : src;
+                const alt = cleanAttribute(node.getAttribute('alt'));
+                const title = cleanAttribute(node.getAttribute('title'));
+                return src ? `![${alt}](${link}${title.length > 0 ? ` "${title}"` : ''})` : '';
+            },
+        });
+    };
+}
+export { image };

package/dist/serializers/markdown/plugins/list-item.d.ts

@@ -0,0 +1,14 @@
+import type { NodeType } from 'prosemirror-model';
+import type Turndown from 'turndown';
+/**
+ * A Turndown plugin which adds a custom rule for standard list items (i.e., not task list items),
+ * based on the original list item rule. This custom rule is required to avoid conflicts with task
+ * list items, and to normalize the Markdown output.
+ *
+ * @see https://github.com/mixmark-io/turndown/blob/v7.1.1/src/commonmark-rules.js#L61
+ *
+ * @param nodeType The node object that matches this rule.
+ */
+declare function listItem(nodeType: NodeType): Turndown.Plugin;
+export { listItem };
+//# sourceMappingURL=list-item.d.ts.map

package/dist/serializers/markdown/plugins/list-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-item.d.ts","sourceRoot":"","sources":["../../../../src/serializers/markdown/plugins/list-item.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAA;AAEpC;;;;;;;;GAQG;AACH,iBAAS,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAqCrD;AAED,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/serializers/markdown/plugins/list-item.js

@@ -0,0 +1,41 @@
+import { extractTagsFromParseRules } from '../../../helpers/serializer';
+import { BULLET_LIST_MARKER } from '../markdown';
+/**
+ * A Turndown plugin which adds a custom rule for standard list items (i.e., not task list items),
+ * based on the original list item rule. This custom rule is required to avoid conflicts with task
+ * list items, and to normalize the Markdown output.
+ *
+ * @see https://github.com/mixmark-io/turndown/blob/v7.1.1/src/commonmark-rules.js#L61
+ *
+ * @param nodeType The node object that matches this rule.
+ */
+function listItem(nodeType) {
+    const tags = extractTagsFromParseRules(nodeType.spec.parseDOM);
+    return (turndown) => {
+        turndown.addRule(nodeType.name, {
+            filter: (node) => {
+                return (tags.some((tag) => tag.toUpperCase() === node.nodeName) &&
+                    node.getAttribute('data-type') !== 'taskItem');
+            },
+            replacement: function (content, node) {
+                const parentNode = node.parentNode;
+                let listItemMarker = `${BULLET_LIST_MARKER} `;
+                // Use a sequence of 1–9 digits for the ordered list marker (CommonMark specification)
+                if (parentNode?.nodeName === 'OL') {
+                    const start = parentNode.getAttribute('start');
+                    const index = Array.prototype.indexOf.call(parentNode.children, node);
+                    listItemMarker = `${start ? Number(start) + index : index + 1}. `;
+                }
+                const newContent = content
+                    // Remove leading newlines
+                    .replace(/^\n+/, '')
+                    // Replace trailing newlines with a single one
+                    .replace(/\n+$/, '\n')
+                    // Indent list items with 4 spaces
+                    .replace(/\n/gm, '\n    ');
+                return `${listItemMarker}${newContent.trim()}${node.nextSibling && !newContent.endsWith('\n') ? '\n' : ''}`;
+            },
+        });
+    };
+}
+export { listItem };

package/dist/serializers/markdown/plugins/paragraph.d.ts

@@ -0,0 +1,12 @@
+import type { NodeType } from 'prosemirror-model';
+import type Turndown from 'turndown';
+/**
+ * A Turndown plugin which adds a custom rule for paragraphs. This custom rule is required to avoid
+ * adding unnecessary blank lines between paragraphs to plain-text documents.
+ *
+ * @param nodeType The node object that matches this rule.
+ * @param isPlainText Specifies if the schema represents a plain-text document.
+ */
+declare function paragraph(nodeType: NodeType, isPlainText: boolean): Turndown.Plugin;
+export { paragraph };
+//# sourceMappingURL=paragraph.d.ts.map

package/dist/serializers/markdown/plugins/paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["../../../../src/serializers/markdown/plugins/paragraph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAA;AAEpC;;;;;;GAMG;AACH,iBAAS,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,GAAG,QAAQ,CAAC,MAAM,CAS5E;AAED,OAAO,EAAE,SAAS,EAAE,CAAA"}