@teleporthq/teleport-shared 0.43.71 → 0.43.75

package/dist/cjs/utils/rich-text-content.js

@@ -0,0 +1,649 @@
+"use strict";
+/**
+ * The stored form of rich-text content (a blog post body, a product
+ * description) and its editor form.
+ *
+ * STORED: plain HTML — `<p>`, `<h1>`–`<h6>`, nested `<ul>`/`<ol>`, `<blockquote>`
+ * holding paragraphs, `<pre><code class="language-x">`, `<table>` with its
+ * `<thead>`/`<th>`, `<aside class="tq-callout" data-kind="note">`, the image and
+ * embed figures, and inline marks. What a published page renders and what an
+ * import writes.
+ *
+ * EDITOR: what a Quill editor can hold without rewriting it. Lists become one
+ * flat `<ol>` of `<li data-list>` lines with `ql-indent-N` for nesting, a
+ * blockquote becomes one `<blockquote>` line per paragraph, and everything Quill
+ * has no blot for — a table, a code block, a callout, a list whose items hold
+ * blocks, anything unknown — is wrapped in a PROTECTED block:
+ * `<div class="tq-protected" data-tq-protected="table" contenteditable="false">`
+ * holding the stored markup untouched. The editors register that wrapper as a
+ * block embed, so Quill treats it as one atomic unit and never looks inside.
+ *
+ * Both editors (the studio post form on the `quill` fork, the generated admin
+ * panel on react-quill-new) run `toEditorHtml` on the way in and
+ * `fromEditorHtml` on the way out. `normalizeLegacyRichTextHtml` additionally
+ * understands what the two editors wrote BEFORE this contract existed, so an
+ * older post is cleaned on its next save and renders right meanwhile — it is
+ * string-only, so the generated project can run it where there is no DOM.
+ *
+ * Emission rules (see `__tests__/_helpers/rich-text-content-runtime-emitter.ts`):
+ * the generated admin editor receives these very functions printed as a module,
+ * so an exported function may call only other exported functions and the
+ * constants below — never an import or a module-private helper.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeBlockquoteLines = exports.rebuildQuillCodeBlockHtml = exports.rebuildQuillListHtml = exports.normalizeLegacyRichTextHtml = exports.trimEmptyEdgeParagraphs = exports.toCanonicalRichTextHtml = exports.fromEditorHtml = exports.toEditorHtml = exports.protectedKindForElement = exports.blockquoteLinesForQuill = exports.isQuillSimpleBlockquote = exports.flattenListForQuill = exports.isQuillSimpleList = exports.readInlineHtml = exports.serializeRichTextNode = exports.wrapBareBlockquoteContent = exports.normalizeLinkTargets = exports.isExternalWebLink = exports.unwrapSingleParagraphListItems = exports.stripInterBlockWhitespace = exports.isRichTextBlockElement = exports.isBlankTextNode = exports.isRichTextInlineNode = exports.hasClass = exports.buildCodeBlockHtml = exports.buildCalloutHtml = exports.isCalloutKind = exports.readProtectedBlockValue = exports.buildProtectedBlockHtml = exports.isProtectedBlockKind = exports.escapeRichTextAttribute = exports.escapeRichTextText = exports.parseRichTextFragment = exports.RICH_TEXT_BLOCK_TAGS = exports.RICH_TEXT_INLINE_TAGS = exports.QUILL_INDENT_CLASS_PREFIX = exports.QUILL_LIST_ITEM_ATTR = exports.RICH_TEXT_IMAGE_CLASS = exports.RICH_TEXT_EMBED_CLASS = exports.CALLOUT_KINDS = exports.CALLOUT_KIND_ATTR = exports.CALLOUT_CLASS = exports.PROTECTED_BLOCK_KINDS = exports.PROTECTED_BLOCK_BLOT_NAME = exports.PROTECTED_BLOCK_ATTR = exports.PROTECTED_BLOCK_CLASS = void 0;
+exports.PROTECTED_BLOCK_CLASS = 'tq-protected';
+exports.PROTECTED_BLOCK_ATTR = 'data-tq-protected';
+exports.PROTECTED_BLOCK_BLOT_NAME = 'tq-protected-block';
+exports.PROTECTED_BLOCK_KINDS = ['table', 'code', 'callout', 'list', 'quote', 'html'];
+exports.CALLOUT_CLASS = 'tq-callout';
+exports.CALLOUT_KIND_ATTR = 'data-kind';
+exports.CALLOUT_KINDS = ['note', 'tip', 'important', 'warning', 'caution'];
+/** ⛔ PAIRED with `EMBED_CLASS_NAME` in `rich-text-embeds.ts` (a test keeps them equal). */
+exports.RICH_TEXT_EMBED_CLASS = 'tq-embed';
+/** ⛔ PAIRED with the image blot in teleport-gui `features/blog/components/content-image-blot.ts`. */
+exports.RICH_TEXT_IMAGE_CLASS = 'ql-content-image';
+exports.QUILL_LIST_ITEM_ATTR = 'data-list';
+exports.QUILL_INDENT_CLASS_PREFIX = 'ql-indent-';
+/** Marks that can sit inside a line; anything else is a block to Quill. */
+exports.RICH_TEXT_INLINE_TAGS = [
+    'A',
+    'ABBR',
+    'B',
+    'BR',
+    'CODE',
+    'DEL',
+    'EM',
+    'I',
+    'IMG',
+    'INS',
+    'KBD',
+    'MARK',
+    'S',
+    'SMALL',
+    'SPAN',
+    'STRIKE',
+    'STRONG',
+    'SUB',
+    'SUP',
+    'U',
+];
+/** Elements that stand on their own line; white space between two of them carries nothing. */
+exports.RICH_TEXT_BLOCK_TAGS = [
+    'ARTICLE',
+    'ASIDE',
+    'BLOCKQUOTE',
+    'DD',
+    'DETAILS',
+    'DIV',
+    'DL',
+    'DT',
+    'FIGCAPTION',
+    'FIGURE',
+    'FOOTER',
+    'FORM',
+    'H1',
+    'H2',
+    'H3',
+    'H4',
+    'H5',
+    'H6',
+    'HEADER',
+    'HR',
+    'LI',
+    'MAIN',
+    'NAV',
+    'OL',
+    'P',
+    'PRE',
+    'SECTION',
+    'SUMMARY',
+    'TABLE',
+    'TBODY',
+    'TD',
+    'TFOOT',
+    'TH',
+    'THEAD',
+    'TR',
+    'UL',
+];
+/** Parses an HTML fragment into a detached body the way a browser would. */
+function parseRichTextFragment(html) {
+    var doc = new DOMParser().parseFromString('<!doctype html><html><body>' + html, 'text/html');
+    return doc.body;
+}
+exports.parseRichTextFragment = parseRichTextFragment;
+function escapeRichTextText(value) {
+    return String(value).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+exports.escapeRichTextText = escapeRichTextText;
+function escapeRichTextAttribute(value) {
+    return escapeRichTextText(value).replace(/"/g, '&quot;');
+}
+exports.escapeRichTextAttribute = escapeRichTextAttribute;
+function isProtectedBlockKind(value) {
+    return exports.PROTECTED_BLOCK_KINDS.indexOf(String(value)) !== -1;
+}
+exports.isProtectedBlockKind = isProtectedBlockKind;
+/** The editor-side wrapper for one stored block. */
+function buildProtectedBlockHtml(kind, html) {
+    return ("<div class=\"".concat(exports.PROTECTED_BLOCK_CLASS, "\" ").concat(exports.PROTECTED_BLOCK_ATTR, "=\"").concat(kind, "\" contenteditable=\"false\">") +
+        html +
+        '</div>');
+}
+exports.buildProtectedBlockHtml = buildProtectedBlockHtml;
+function readProtectedBlockValue(element) {
+    var kind = element.getAttribute(exports.PROTECTED_BLOCK_ATTR);
+    return {
+        kind: isProtectedBlockKind(kind) ? kind : 'html',
+        html: element.innerHTML,
+    };
+}
+exports.readProtectedBlockValue = readProtectedBlockValue;
+function isCalloutKind(value) {
+    return exports.CALLOUT_KINDS.indexOf(String(value)) !== -1;
+}
+exports.isCalloutKind = isCalloutKind;
+/** The stored markup of a callout: a kind and the blocks it holds. */
+function buildCalloutHtml(kind, innerHtml) {
+    return "<aside class=\"".concat(exports.CALLOUT_CLASS, "\" ").concat(exports.CALLOUT_KIND_ATTR, "=\"").concat(kind, "\">").concat(innerHtml, "</aside>");
+}
+exports.buildCalloutHtml = buildCalloutHtml;
+/** The stored markup of a code block; `code` is already HTML-escaped when `escaped` is set. */
+function buildCodeBlockHtml(language, code, escaped) {
+    var text = escaped ? code : escapeRichTextText(code || '');
+    var lang = String(language || '').replace(/[^\w.+#-]/g, '');
+    var classAttr = lang && lang !== 'plain' ? " class=\"language-".concat(lang, "\"") : '';
+    return "<pre><code".concat(classAttr, ">").concat(text, "</code></pre>");
+}
+exports.buildCodeBlockHtml = buildCodeBlockHtml;
+function hasClass(element, className) {
+    var classes = (element.getAttribute('class') || '').split(/\s+/);
+    return classes.indexOf(className) !== -1;
+}
+exports.hasClass = hasClass;
+function isRichTextInlineNode(node) {
+    if (node.nodeType === 3 || node.nodeType === 8) {
+        return true;
+    }
+    if (node.nodeType !== 1) {
+        return false;
+    }
+    return exports.RICH_TEXT_INLINE_TAGS.indexOf(node.tagName) !== -1;
+}
+exports.isRichTextInlineNode = isRichTextInlineNode;
+function isBlankTextNode(node) {
+    return node.nodeType === 3 && !/\S/.test(node.nodeValue || '');
+}
+exports.isBlankTextNode = isBlankTextNode;
+function isRichTextBlockElement(node) {
+    return (!!node && node.nodeType === 1 && exports.RICH_TEXT_BLOCK_TAGS.indexOf(node.tagName) !== -1);
+}
+exports.isRichTextBlockElement = isRichTextBlockElement;
+/**
+ * Drops the white space that only separates blocks (the newlines a Markdown
+ * renderer puts between `<li>`s, after `</p>`) and collapses runs of it inside
+ * text to the one space they render as, so stored HTML has one spelling
+ * whatever wrote it. Everything inside `<pre>` stays.
+ */
+function stripInterBlockWhitespace(root) {
+    if (root.nodeType === 1 && root.tagName === 'PRE') {
+        return;
+    }
+    var rootIsBlock = root.nodeType !== 1 || isRichTextBlockElement(root);
+    var children = Array.prototype.slice.call(root.childNodes);
+    children.forEach(function (child) {
+        if (child.nodeType === 3) {
+            var afterBlock = isRichTextBlockElement(child.previousSibling) || (rootIsBlock && !child.previousSibling);
+            var beforeBlock = isRichTextBlockElement(child.nextSibling) || (rootIsBlock && !child.nextSibling);
+            // A run of white space renders as one space; stored HTML keeps it that way
+            // (a no-break space is not white space here).
+            var text = (child.nodeValue || '').replace(/[ \t\r\n\f]+/g, ' ');
+            if (afterBlock) {
+                text = text.replace(/^\s+/, '');
+            }
+            if (beforeBlock) {
+                text = text.replace(/\s+$/, '');
+            }
+            if (!text && (afterBlock || beforeBlock)) {
+                root.removeChild(child);
+            }
+            else if (text !== child.nodeValue) {
+                child.nodeValue = text;
+            }
+            return;
+        }
+        if (child.nodeType === 1) {
+            stripInterBlockWhitespace(child);
+        }
+    });
+}
+exports.stripInterBlockWhitespace = stripInterBlockWhitespace;
+/** `<li><p>one paragraph</p></li>` means the same as `<li>one paragraph</li>`; stored HTML uses the short form. */
+function unwrapSingleParagraphListItems(root) {
+    Array.prototype.slice.call(root.querySelectorAll('li')).forEach(function (item) {
+        var paragraphs = Array.prototype.slice
+            .call(item.children)
+            .filter(function (child) { return child.tagName === 'P'; });
+        var blocks = Array.prototype.slice
+            .call(item.children)
+            .filter(function (child) { return !isRichTextInlineNode(child); });
+        var nested = blocks.filter(function (child) { return child.tagName === 'UL' || child.tagName === 'OL'; });
+        if (paragraphs.length !== 1 || blocks.length !== 1 + nested.length) {
+            return;
+        }
+        var paragraph = paragraphs[0];
+        while (paragraph.firstChild) {
+            item.insertBefore(paragraph.firstChild, paragraph);
+        }
+        item.removeChild(paragraph);
+    });
+}
+exports.unwrapSingleParagraphListItems = unwrapSingleParagraphListItems;
+/** A link to another web page: an absolute http(s) address. Everything else stays in the tab. */
+function isExternalWebLink(href) {
+    return /^https?:\/\//i.test(String(href || '').trim());
+}
+exports.isExternalWebLink = isExternalWebLink;
+/**
+ * Quill creates every link with `target="_blank"`. Stored HTML decides for
+ * itself: a link to another web page opens in a new tab, a link to a page of
+ * the same site (or a mail or phone link) opens in this one.
+ */
+function normalizeLinkTargets(root) {
+    Array.prototype.slice.call(root.querySelectorAll('a[href]')).forEach(function (link) {
+        if (isExternalWebLink(link.getAttribute('href') || '')) {
+            if (!link.getAttribute('target')) {
+                link.setAttribute('rel', 'noopener noreferrer');
+                link.setAttribute('target', '_blank');
+            }
+            return;
+        }
+        link.removeAttribute('target');
+        link.removeAttribute('rel');
+    });
+}
+exports.normalizeLinkTargets = normalizeLinkTargets;
+/** A quote holds paragraphs; bare inline content inside one becomes its single paragraph. */
+function wrapBareBlockquoteContent(root) {
+    Array.prototype.slice.call(root.querySelectorAll('blockquote')).forEach(function (quote) {
+        var children = Array.prototype.slice.call(quote.childNodes);
+        var bare = children.filter(function (child) { return !isBlankTextNode(child); });
+        if (!bare.length || !bare.every(function (child) { return isRichTextInlineNode(child); })) {
+            return;
+        }
+        var paragraph = quote.ownerDocument.createElement('p');
+        children.forEach(function (child) { return paragraph.appendChild(child); });
+        quote.appendChild(paragraph);
+    });
+}
+exports.wrapBareBlockquoteContent = wrapBareBlockquoteContent;
+/** The markup of one node as it sits in its parent: text escaped, elements whole. */
+function serializeRichTextNode(node) {
+    if (node.nodeType === 1) {
+        return node.outerHTML;
+    }
+    if (node.nodeType === 3) {
+        return escapeRichTextText(node.nodeValue || '');
+    }
+    return '';
+}
+exports.serializeRichTextNode = serializeRichTextNode;
+/**
+ * The inline markup of a list item: text and marks, a single wrapping `<p>`
+ * unwrapped, nested lists left out.
+ */
+function readInlineHtml(element) {
+    var html = '';
+    Array.prototype.slice.call(element.childNodes).forEach(function (node) {
+        if (node.nodeType === 1) {
+            var child = node;
+            if (child.tagName === 'UL' || child.tagName === 'OL') {
+                return;
+            }
+            if (child.tagName === 'P') {
+                html += child.innerHTML;
+                return;
+            }
+        }
+        html += serializeRichTextNode(node);
+    });
+    return html.replace(/^\s+|\s+$/g, '');
+}
+exports.readInlineHtml = readInlineHtml;
+/**
+ * A list Quill can hold as lines: every item is inline content (at most one
+ * `<p>` around it) followed, at most, by one nested list that is itself simple,
+ * and no `start` offset on a numbered list.
+ */
+function isQuillSimpleList(list) {
+    if (list.hasAttribute('start')) {
+        return false;
+    }
+    var items = Array.prototype.slice.call(list.children);
+    for (var i = 0; i < items.length; i += 1) {
+        var item = items[i];
+        if (item.tagName !== 'LI') {
+            return false;
+        }
+        var children = Array.prototype.slice.call(item.childNodes);
+        var paragraphs = 0;
+        var nested = null;
+        for (var j = 0; j < children.length; j += 1) {
+            var child = children[j];
+            if (isRichTextInlineNode(child)) {
+                if (nested && !isBlankTextNode(child)) {
+                    return false;
+                }
+                continue;
+            }
+            var tag = child.tagName;
+            if (tag === 'P') {
+                paragraphs += 1;
+                if (paragraphs > 1 || nested) {
+                    return false;
+                }
+                continue;
+            }
+            if ((tag === 'UL' || tag === 'OL') && !nested) {
+                nested = child;
+                continue;
+            }
+            return false;
+        }
+        if (nested && !isQuillSimpleList(nested)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isQuillSimpleList = isQuillSimpleList;
+/** One flat `<ol>` of `<li data-list>` lines, the shape Quill keeps a list in. */
+function flattenListForQuill(list) {
+    var html = '<ol>';
+    var walk = function (node, indent) {
+        var type = node.tagName === 'OL' ? 'ordered' : 'bullet';
+        Array.prototype.slice.call(node.children).forEach(function (item) {
+            if (item.tagName !== 'LI') {
+                return;
+            }
+            var indentClass = indent > 0 ? " class=\"".concat(exports.QUILL_INDENT_CLASS_PREFIX).concat(indent, "\"") : '';
+            html += "<li ".concat(exports.QUILL_LIST_ITEM_ATTR, "=\"").concat(type, "\"").concat(indentClass, ">").concat(readInlineHtml(item), "</li>");
+            Array.prototype.slice.call(item.children).forEach(function (child) {
+                if (child.tagName === 'UL' || child.tagName === 'OL') {
+                    walk(child, indent + 1);
+                }
+            });
+        });
+    };
+    walk(list, 0);
+    return html + '</ol>';
+}
+exports.flattenListForQuill = flattenListForQuill;
+/** A blockquote Quill can hold: paragraphs (or bare inline content) only. */
+function isQuillSimpleBlockquote(quote) {
+    var children = Array.prototype.slice.call(quote.childNodes);
+    for (var i = 0; i < children.length; i += 1) {
+        var child = children[i];
+        if (isRichTextInlineNode(child)) {
+            continue;
+        }
+        if (child.tagName !== 'P') {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isQuillSimpleBlockquote = isQuillSimpleBlockquote;
+/** One `<blockquote>` line per paragraph, the shape Quill keeps a quote in. */
+function blockquoteLinesForQuill(quote) {
+    var lines = [];
+    var pending = '';
+    var flush = function () {
+        if (/\S/.test(pending)) {
+            lines.push(pending.replace(/^\s+|\s+$/g, ''));
+        }
+        pending = '';
+    };
+    Array.prototype.slice.call(quote.childNodes).forEach(function (node) {
+        if (node.nodeType === 1 && node.tagName === 'P') {
+            flush();
+            lines.push(node.innerHTML);
+            return;
+        }
+        pending += serializeRichTextNode(node);
+    });
+    flush();
+    return lines.map(function (line) { return "<blockquote>".concat(line, "</blockquote>"); }).join('');
+}
+exports.blockquoteLinesForQuill = blockquoteLinesForQuill;
+/** Which protected kind a stored block that Quill cannot hold gets. */
+function protectedKindForElement(element) {
+    var tag = element.tagName;
+    if (tag === 'TABLE') {
+        return 'table';
+    }
+    if (tag === 'PRE') {
+        return 'code';
+    }
+    if (tag === 'ASIDE' && hasClass(element, exports.CALLOUT_CLASS)) {
+        return 'callout';
+    }
+    if (tag === 'UL' || tag === 'OL') {
+        return 'list';
+    }
+    if (tag === 'BLOCKQUOTE') {
+        return 'quote';
+    }
+    return 'html';
+}
+exports.protectedKindForElement = protectedKindForElement;
+/**
+ * Stored HTML → what the editor is given. Every block Quill holds natively is
+ * handed over in Quill's own shape; every other block is protected.
+ */
+function toEditorHtml(storedHtml) {
+    var body = parseRichTextFragment(normalizeLegacyRichTextHtml(storedHtml));
+    var html = '';
+    Array.prototype.slice.call(body.childNodes).forEach(function (node) {
+        if (node.nodeType === 3) {
+            if (/\S/.test(node.nodeValue || '')) {
+                html += '<p>' + escapeRichTextText(node.nodeValue || '') + '</p>';
+            }
+            return;
+        }
+        if (node.nodeType !== 1) {
+            return;
+        }
+        var element = node;
+        var tag = element.tagName;
+        if (tag === 'P' || /^H[1-6]$/.test(tag)) {
+            html += element.outerHTML;
+            return;
+        }
+        if (isRichTextInlineNode(element)) {
+            html += '<p>' + element.outerHTML + '</p>';
+            return;
+        }
+        if (tag === 'DIV' && hasClass(element, exports.PROTECTED_BLOCK_CLASS)) {
+            html += element.outerHTML;
+            return;
+        }
+        if (tag === 'FIGURE' &&
+            (hasClass(element, exports.RICH_TEXT_IMAGE_CLASS) || hasClass(element, exports.RICH_TEXT_EMBED_CLASS))) {
+            html += element.outerHTML;
+            return;
+        }
+        if ((tag === 'UL' || tag === 'OL') && isQuillSimpleList(element)) {
+            html += flattenListForQuill(element);
+            return;
+        }
+        if (tag === 'BLOCKQUOTE' && isQuillSimpleBlockquote(element)) {
+            html += blockquoteLinesForQuill(element);
+            return;
+        }
+        html += buildProtectedBlockHtml(protectedKindForElement(element), element.outerHTML);
+    });
+    return html;
+}
+exports.toEditorHtml = toEditorHtml;
+/**
+ * What the editor holds → stored HTML. Protected blocks are unwrapped, Quill's
+ * flat lists and blockquote lines are rebuilt, and Quill's own helpers are
+ * stripped. Idempotent on stored HTML.
+ */
+function fromEditorHtml(editorHtml) {
+    var body = parseRichTextFragment(editorHtml);
+    Array.prototype.slice
+        .call(body.querySelectorAll('.' + exports.PROTECTED_BLOCK_CLASS))
+        .forEach(function (wrapper) {
+        var parent = wrapper.parentNode;
+        if (!parent) {
+            return;
+        }
+        while (wrapper.firstChild) {
+            parent.insertBefore(wrapper.firstChild, wrapper);
+        }
+        parent.removeChild(wrapper);
+    });
+    var normalized = parseRichTextFragment(normalizeLegacyRichTextHtml(body.innerHTML));
+    unwrapSingleParagraphListItems(normalized);
+    wrapBareBlockquoteContent(normalized);
+    normalizeLinkTargets(normalized);
+    stripInterBlockWhitespace(normalized);
+    return trimEmptyEdgeParagraphs(normalized.innerHTML);
+}
+exports.fromEditorHtml = fromEditorHtml;
+/** Stored HTML in its one canonical spelling, whatever dialect it arrived in. */
+function toCanonicalRichTextHtml(html) {
+    return fromEditorHtml(html);
+}
+exports.toCanonicalRichTextHtml = toCanonicalRichTextHtml;
+/** Quill keeps an empty line as `<p><br></p>`; one at either end carries nothing. */
+function trimEmptyEdgeParagraphs(html) {
+    return html
+        .replace(/^(?:\s*<p>(?:<br\s*\/?>|\s|&nbsp;)*<\/p>)+/, '')
+        .replace(/(?:<p>(?:<br\s*\/?>|\s|&nbsp;)*<\/p>\s*)+$/, '');
+}
+exports.trimEmptyEdgeParagraphs = trimEmptyEdgeParagraphs;
+/**
+ * What the editors wrote before this contract, turned into stored HTML. String
+ * only, so a generated page can run it in `getStaticProps`:
+ * - the studio's lists: one `<ol>` of `<li data-list="bullet|ordered">` with
+ *   `ql-indent-N` and an empty `<span class="ql-ui">` per line;
+ * - the studio's code blocks: `div.ql-code-block-container` of line divs;
+ * - the studio's quotes: one `<blockquote>` element per line;
+ * - the admin panel's text: every space a no-break space;
+ * - the admin panel's code blocks: `<pre data-language>` with no `<code>`.
+ * Leaves stored HTML as it is.
+ */
+function normalizeLegacyRichTextHtml(html) {
+    var out = String(html || '');
+    out = out.replace(/<span class="ql-ui"[^>]*>(?:<\/span>)?/g, '');
+    out = out.replace(/<(ol|ul)(\s[^>]*)?>((?:(?!<\/?(?:ol|ul)\b)[\s\S])*)<\/\1>/g, function (match, _tag, _attrs, inner) {
+        return inner.indexOf(exports.QUILL_LIST_ITEM_ATTR + '=') === -1 ? match : rebuildQuillListHtml(inner);
+    });
+    out = out.replace(/<div class="ql-code-block-container"[^>]*>((?:\s*<div class="ql-code-block"[^>]*>[\s\S]*?<\/div>)*)\s*<\/div>/g, function (_match, inner) { return rebuildQuillCodeBlockHtml(inner); });
+    out = out.replace(/<pre data-language="([^"]*)">\n?([\s\S]*?)\n?<\/pre>/g, function (_match, language, code) { return buildCodeBlockHtml(language, code, true); });
+    out = out.replace(/((?:<blockquote>(?:(?!<\/?blockquote\b)[\s\S])*<\/blockquote>\s*)+)/g, function (run) {
+        return mergeBlockquoteLines(run);
+    });
+    out = out.replace(/(\S)(?:&nbsp;| )(?=\S)/g, '$1 ');
+    return out;
+}
+exports.normalizeLegacyRichTextHtml = normalizeLegacyRichTextHtml;
+/** The nested `<ul>`/`<ol>` that a flat run of Quill list lines means. */
+function rebuildQuillListHtml(innerHtml) {
+    var items = [];
+    var pattern = /<li\b([^>]*)>([\s\S]*?)<\/li>/g;
+    var match = pattern.exec(innerHtml);
+    while (match) {
+        var attrs = match[1];
+        var typeMatch = /data-list="([^"]*)"/.exec(attrs);
+        var indentMatch = /ql-indent-(\d+)/.exec(attrs);
+        items.push({
+            type: typeMatch && typeMatch[1] === 'ordered' ? 'ordered' : 'bullet',
+            indent: indentMatch ? parseInt(indentMatch[1], 10) : 0,
+            html: match[2].replace(/^\s+|\s+$/g, ''),
+        });
+        match = pattern.exec(innerHtml);
+    }
+    if (!items.length) {
+        return '';
+    }
+    var render = function (from, level) {
+        var html = '';
+        var i = from;
+        var openType = '';
+        var close = function () {
+            if (openType) {
+                html += openType === 'ordered' ? '</ol>' : '</ul>';
+                openType = '';
+            }
+        };
+        while (i < items.length) {
+            var item = items[i];
+            if (item.indent < level) {
+                break;
+            }
+            if (item.indent > level) {
+                // A deeper line with nothing above it reads as this level.
+                item.indent = level;
+            }
+            if (openType !== item.type) {
+                close();
+                openType = item.type;
+                html += openType === 'ordered' ? '<ol>' : '<ul>';
+            }
+            html += '<li>' + item.html;
+            i += 1;
+            if (i < items.length && items[i].indent > level) {
+                var nested = render(i, level + 1);
+                html += nested.html;
+                i = nested.next;
+            }
+            html += '</li>';
+        }
+        close();
+        return { html: html, next: i };
+    };
+    return render(0, 0).html;
+}
+exports.rebuildQuillListHtml = rebuildQuillListHtml;
+/** The `<pre><code>` that a run of the studio's code-block line divs means. */
+function rebuildQuillCodeBlockHtml(innerHtml) {
+    var lines = [];
+    var language = '';
+    var pattern = /<div class="ql-code-block"([^>]*)>([\s\S]*?)<\/div>/g;
+    var match = pattern.exec(innerHtml);
+    while (match) {
+        var languageMatch = /data-language="([^"]*)"/.exec(match[1]);
+        if (languageMatch && !language) {
+            language = languageMatch[1];
+        }
+        lines.push(match[2] === '<br>' ? '' : match[2]);
+        match = pattern.exec(innerHtml);
+    }
+    return buildCodeBlockHtml(language, lines.join('\n'), true);
+}
+exports.rebuildQuillCodeBlockHtml = rebuildQuillCodeBlockHtml;
+/**
+ * One `<blockquote>` of paragraphs out of a run of single-line quotes (one line
+ * is a run too). A run whose lines already hold blocks is stored HTML and is
+ * left alone.
+ */
+function mergeBlockquoteLines(run) {
+    var lines = [];
+    var pattern = /<blockquote>([\s\S]*?)<\/blockquote>/g;
+    var match = pattern.exec(run);
+    while (match) {
+        if (/<(?:p|ul|ol|div|pre|table|aside|figure|h[1-6])\b/.test(match[1])) {
+            return run;
+        }
+        lines.push(match[1]);
+        match = pattern.exec(run);
+    }
+    return '<blockquote>' + lines.map(function (line) { return '<p>' + line + '</p>'; }).join('') + '</blockquote>';
+}
+exports.mergeBlockquoteLines = mergeBlockquoteLines;
+//# sourceMappingURL=rich-text-content.js.map