ngwr 14.7.0 → 14.9.0

package/fesm2022/ngwr-markdown.mjs

@@ -495,6 +495,32 @@ const MAX_LABEL_LENGTH = 999;
 const MAX_DESTINATION_NESTING = 32;
 const BARE_URL_RE = /^https?:\/\/[^\s<>[\]()]*(?:\([^\s<>()]*\)[^\s<>[\]()]*)*/i;
 const EMAIL_AUTOLINK_RE = /^<([^\s@<>]+@[^\s@<>.]+\.[^\s@<>]+)>/;
+/**
+ * Whitespace and control characters only: a hyphen has no business being
+ * stripped out of a host name. Written as escapes rather than literal bytes — a
+ * raw NUL inside a regex literal makes the file binary to every text tool.
+ * Stripping control characters is the entire point: a browser ignores them before
+ * resolving the scheme, so a check that reads the raw string sees a relative path
+ * and waves `java\u0000script:` straight through.
+ */
+// eslint-disable-next-line no-control-regex
+const URL_IGNORED_RE = /[\s\u0000-\u001f\u007f]/g;
+/**
+ * The character references a CommonMark renderer decodes in a link destination
+ * that can spell a scheme: every numeric one, and the named ones for the colon
+ * and for the whitespace a browser strips (`&colon;`, `&Tab;`, `&NewLine;`).
+ * Matched without regard to case and with the semicolon optional, which is wider
+ * than any renderer decodes — the net only ever catches a URL nobody writes.
+ */
+const SCHEME_REFERENCE_RE = /&(?:#x([0-9a-f]+)|#(\d+)|(colon|tab|newline));?/gi;
+function decodeSchemeReferences(url) {
+    return url.replace(SCHEME_REFERENCE_RE, (_reference, hex, decimal, name) => {
+        if (name)
+            return name.toLowerCase() === 'colon' ? ':' : '\n';
+        const code = hex ? Number.parseInt(hex, 16) : Number(decimal);
+        return code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : '\ufffd';
+    });
+}
 /**
  * A URL safe to put in `href` / `src`, or `null` to render the link as plain text.
  *
@@ -505,19 +531,16 @@ const EMAIL_AUTOLINK_RE = /^<([^\s@<>]+@[^\s@<>.]+\.[^\s@<>]+)>/;
  *
  * Whitespace and control characters are stripped before the scheme is read,
  * because `java\nscript:` and `java script:` are the same URL to a browser and
- * different strings to a naive check.
+ * different strings to a naive check. So are character references:
+ * `javascript&colon;` has no scheme to this check, but a CommonMark renderer
+ * decodes it in a destination, so any markdown the URL is written into — an
+ * editor's output, say — hands a browser `javascript:`. The scheme is read from
+ * the decoded form; what comes back is still the URL as written.
  */
 function safeMarkdownUrl(raw, kind) {
     const url = raw.trim();
-    // Whitespace and control characters only: a hyphen has no business being
-    // stripped out of a host name. Written as escapes rather than literal bytes —
-    // a raw NUL inside a regex literal makes the file binary to every text tool.
-    // Stripping control characters is the entire point here: a browser ignores them
-    // before resolving the scheme, so a check that reads the raw string sees a
-    // relative path and waves `java\u0000script:` straight through.
-    // eslint-disable-next-line no-control-regex
-    const bare = url.replace(/[\s\u0000-\u001f\u007f]/g, '');
-    const scheme = SCHEME_RE.exec(bare);
+    const bare = url.replace(URL_IGNORED_RE, '');
+    const scheme = SCHEME_RE.exec(decodeSchemeReferences(bare).replace(URL_IGNORED_RE, ''));
     // No scheme at all: relative path, `#anchor`, `//host` — nothing executable.
     if (!scheme)
         return url;
@@ -1295,10 +1318,10 @@ class WrMarkdownHighlight {
             this.cache.delete(oldest.value);
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrMarkdownHighlight, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrMarkdownHighlight, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: WrMarkdownHighlight, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: WrMarkdownHighlight, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrMarkdownHighlight, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: WrMarkdownHighlight, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -1539,10 +1562,10 @@ class WrMarkdown {
     asCells(value) {
         return value;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrMarkdown, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.6", type: WrMarkdown, isStandalone: true, selector: "wr-markdown", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, streaming: { classPropertyName: "streaming", publicName: "streaming", isSignal: true, isRequired: false, transformFunction: null }, copyable: { classPropertyName: "copyable", publicName: "copyable", isSignal: true, isRequired: false, transformFunction: null }, linkTarget: { classPropertyName: "linkTarget", publicName: "linkTarget", isSignal: true, isRequired: false, transformFunction: null }, headingIds: { classPropertyName: "headingIds", publicName: "headingIds", isSignal: true, isRequired: false, transformFunction: null }, headingIdPrefix: { classPropertyName: "headingIdPrefix", publicName: "headingIdPrefix", isSignal: true, isRequired: false, transformFunction: null }, copyLabel: { classPropertyName: "copyLabel", publicName: "copyLabel", isSignal: true, isRequired: false, transformFunction: null }, copiedLabel: { classPropertyName: "copiedLabel", publicName: "copiedLabel", isSignal: true, isRequired: false, transformFunction: null }, taskDoneLabel: { classPropertyName: "taskDoneLabel", publicName: "taskDoneLabel", isSignal: true, isRequired: false, transformFunction: null }, taskTodoLabel: { classPropertyName: "taskTodoLabel", publicName: "taskTodoLabel", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class.wr-markdown--streaming": "streaming()" }, classAttribute: "wr-markdown" }, ngImport: i0, template: "<!--\n  Recursion runs through `ngTemplateOutlet` into these templates rather than\n  through a child component, so the rendered DOM is exactly the document \u2014 no\n  wrapper element between a `<ul>` and its `<li>`. See `asBlocks` for the whole\n  reasoning.\n-->\n<ng-template #inlineList let-raw>\n  @let nodes = asInlines(raw);\n\n  @for (node of nodes; track $index) {\n    @switch (node.kind) {\n      @case ('text') {\n        <!-- Wrapped, and not for tidiness: a bare interpolation on its own line is\n             ONE text node that includes the indentation around it, so `a **b** c`\n             rendered with a space inside every `<strong>`. Inside an element the\n             whitespace becomes separate whitespace-only nodes, which Angular\n             removes, and `<ng-container>` itself renders nothing. Prettier\n             reformats the bare form back, so this also has to survive `--fix`. -->\n        <ng-container>{{ node.value }}</ng-container>\n      }\n      @case ('code') {\n        <!-- `dir=\"ltr\"` because code is not prose: under RTL the browser\n             reorders `foo();` to `;foo()`. -->\n        <code class=\"wr-markdown__code-inline\" dir=\"ltr\">{{ node.value }}</code>\n      }\n      @case ('strong') {\n        <strong class=\"wr-markdown__strong\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></strong>\n      }\n      @case ('em') {\n        <em class=\"wr-markdown__em\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></em>\n      }\n      @case ('del') {\n        <del class=\"wr-markdown__del\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></del>\n      }\n      @case ('link') {\n        <a\n          class=\"wr-markdown__link\"\n          [href]=\"hrefOf(node.href)\"\n          [attr.title]=\"node.title\"\n          [attr.target]=\"resolvedLinkTarget()\"\n          [attr.rel]=\"linkRel()\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></a>\n      }\n      @case ('image') {\n        <img\n          class=\"wr-markdown__image\"\n          [src]=\"node.src\"\n          [alt]=\"node.alt\"\n          [attr.title]=\"node.title\"\n          loading=\"lazy\"\n          decoding=\"async\"\n        />\n      }\n      @case ('break') {\n        <br />\n      }\n    }\n  }\n</ng-template>\n\n<ng-template #itemList let-raw let-tight=\"tight\">\n  @let items = asItems(raw);\n\n  @for (item of items; track $index) {\n    <li class=\"wr-markdown__item\" [class.wr-markdown__item--task]=\"item.checked !== null\">\n      @if (item.checked !== null) {\n        <!-- Presentational, with the state as text beside it: a real\n             `<input type=\"checkbox\">` here would be an unlabelled form control,\n             which is a serious axe violation, and making it operable would\n             promise an interaction a renderer cannot honour. -->\n        <span class=\"wr-markdown__task\" [class.wr-markdown__task--checked]=\"item.checked\" aria-hidden=\"true\"></span>\n        <span class=\"wr-markdown__sr-only\">{{ item.checked ? resolvedTaskDoneLabel() : resolvedTaskTodoLabel() }}</span>\n      }\n      <ng-container\n        [ngTemplateOutlet]=\"blockList\"\n        [ngTemplateOutletContext]=\"{ $implicit: item.children, tight: tight }\"\n      />\n    </li>\n  }\n</ng-template>\n\n<ng-template #blockList let-raw let-tight=\"tight\">\n  @let list = asBlocks(raw);\n\n  @for (block of list; track $index) {\n    @switch (block.kind) {\n      @case ('paragraph') {\n        <!-- A tight list drops the `<p>`, which is what CommonMark specifies and\n             what keeps a one-line list from being double-spaced. -->\n        @if (tight) {\n          <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n        } @else {\n          <p class=\"wr-markdown__paragraph\">\n            <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n          </p>\n        }\n      }\n      @case ('heading') {\n        @switch (block.level) {\n          @case (1) {\n            <h1 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h1>\n          }\n          @case (2) {\n            <h2 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h2>\n          }\n          @case (3) {\n            <h3 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h3>\n          }\n          @case (4) {\n            <h4 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h4>\n          }\n          @case (5) {\n            <h5 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h5>\n          }\n          @default {\n            <h6 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h6>\n          }\n        }\n      }\n      @case ('code') {\n        @let highlighted = linesOf(block.code, block.language);\n\n        <div class=\"wr-markdown__code-block\">\n          <pre\n            class=\"wr-markdown__pre\"\n            dir=\"ltr\"\n            tabindex=\"0\"\n          ><code class=\"wr-markdown__code\" [attr.data-language]=\"block.language\">@if (highlighted) {@for (row of highlighted; track $index) {<span class=\"wr-markdown__line\">@for (span of row; track $index) {<span\n            [style.color]=\"span.color\"\n            [style.font-style]=\"span.fontStyle === 'italic' ? 'italic' : null\"\n            [style.font-weight]=\"span.fontStyle === 'bold' ? 'bold' : null\"\n            [style.text-decoration]=\"span.fontStyle === 'underline' ? 'underline' : null\"\n          >{{ span.text }}</span>}</span>@if (!$last) {{{ newline }}}}} @else {{{ block.code }}}</code></pre>\n\n          @if (resolvedCopyable() && block.closed) {\n            <button\n              type=\"button\"\n              class=\"wr-markdown__copy\"\n              [wrCopyToClipboard]=\"block.code\"\n              [attr.aria-label]=\"isCopied(block) ? resolvedCopiedLabel() : resolvedCopyLabel()\"\n              (copied)=\"onCopied(block)\"\n            >\n              <svg\n                class=\"wr-markdown__copy-icon\"\n                xmlns=\"http://www.w3.org/2000/svg\"\n                viewBox=\"0 0 24 24\"\n                fill=\"none\"\n                stroke=\"currentColor\"\n                stroke-width=\"2\"\n                stroke-linecap=\"round\"\n                stroke-linejoin=\"round\"\n                aria-hidden=\"true\"\n              >\n                @if (isCopied(block)) {\n                  <path d=\"M20 6 9 17l-5-5\" />\n                } @else {\n                  <rect width=\"14\" height=\"14\" x=\"8\" y=\"8\" rx=\"2\" ry=\"2\" />\n                  <path d=\"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2\" />\n                }\n              </svg>\n            </button>\n          }\n        </div>\n      }\n      @case ('quote') {\n        <blockquote class=\"wr-markdown__quote\">\n          <ng-container\n            [ngTemplateOutlet]=\"blockList\"\n            [ngTemplateOutletContext]=\"{ $implicit: block.children, tight: false }\"\n          />\n        </blockquote>\n      }\n      @case ('list') {\n        @if (block.ordered) {\n          <ol\n            class=\"wr-markdown__list wr-markdown__list--ordered\"\n            [attr.start]=\"block.start === 1 ? null : block.start\"\n          >\n            <ng-container\n              [ngTemplateOutlet]=\"itemList\"\n              [ngTemplateOutletContext]=\"{ $implicit: block.items, tight: block.tight }\"\n            />\n          </ol>\n        } @else {\n          <ul class=\"wr-markdown__list\">\n            <ng-container\n              [ngTemplateOutlet]=\"itemList\"\n              [ngTemplateOutletContext]=\"{ $implicit: block.items, tight: block.tight }\"\n            />\n          </ul>\n        }\n      }\n      @case ('table') {\n        <!-- Its own scroller: a wide table must not push the page sideways, which\n             is also what keeps the RTL layout gate quiet about it. -->\n        <div class=\"wr-markdown__table-scroll\" tabindex=\"0\">\n          <table class=\"wr-markdown__table\">\n            <thead>\n              <tr>\n                @for (cell of block.head; track column; let column = $index) {\n                  <th class=\"wr-markdown__th\" scope=\"col\" [style.text-align]=\"block.align[column]\">\n                    <ng-container\n                      [ngTemplateOutlet]=\"inlineList\"\n                      [ngTemplateOutletContext]=\"{ $implicit: cell.inlines }\"\n                    />\n                  </th>\n                }\n              </tr>\n            </thead>\n            <tbody>\n              @for (row of block.rows; track $index) {\n                <tr>\n                  @for (cell of asCells(row); track column; let column = $index) {\n                    <td class=\"wr-markdown__td\" [style.text-align]=\"block.align[column]\">\n                      <ng-container\n                        [ngTemplateOutlet]=\"inlineList\"\n                        [ngTemplateOutletContext]=\"{ $implicit: cell.inlines }\"\n                      />\n                    </td>\n                  }\n                </tr>\n              }\n            </tbody>\n          </table>\n        </div>\n      }\n      @case ('rule') {\n        <hr class=\"wr-markdown__rule\" />\n      }\n    }\n  }\n</ng-template>\n\n<ng-container [ngTemplateOutlet]=\"blockList\" [ngTemplateOutletContext]=\"{ $implicit: blocks(), tight: false }\" />\n", dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: WrCopyToClipboard, selector: "[wrCopyToClipboard]", inputs: ["wrCopyToClipboard"], outputs: ["copied", "copyFailed"] }], encapsulation: i0.ViewEncapsulation.None });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: WrMarkdown, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.7", type: WrMarkdown, isStandalone: true, selector: "wr-markdown", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, streaming: { classPropertyName: "streaming", publicName: "streaming", isSignal: true, isRequired: false, transformFunction: null }, copyable: { classPropertyName: "copyable", publicName: "copyable", isSignal: true, isRequired: false, transformFunction: null }, linkTarget: { classPropertyName: "linkTarget", publicName: "linkTarget", isSignal: true, isRequired: false, transformFunction: null }, headingIds: { classPropertyName: "headingIds", publicName: "headingIds", isSignal: true, isRequired: false, transformFunction: null }, headingIdPrefix: { classPropertyName: "headingIdPrefix", publicName: "headingIdPrefix", isSignal: true, isRequired: false, transformFunction: null }, copyLabel: { classPropertyName: "copyLabel", publicName: "copyLabel", isSignal: true, isRequired: false, transformFunction: null }, copiedLabel: { classPropertyName: "copiedLabel", publicName: "copiedLabel", isSignal: true, isRequired: false, transformFunction: null }, taskDoneLabel: { classPropertyName: "taskDoneLabel", publicName: "taskDoneLabel", isSignal: true, isRequired: false, transformFunction: null }, taskTodoLabel: { classPropertyName: "taskTodoLabel", publicName: "taskTodoLabel", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class.wr-markdown--streaming": "streaming()" }, classAttribute: "wr-markdown" }, ngImport: i0, template: "<!--\n  Recursion runs through `ngTemplateOutlet` into these templates rather than\n  through a child component, so the rendered DOM is exactly the document \u2014 no\n  wrapper element between a `<ul>` and its `<li>`. See `asBlocks` for the whole\n  reasoning.\n-->\n<ng-template #inlineList let-raw>\n  @let nodes = asInlines(raw);\n\n  @for (node of nodes; track $index) {\n    @switch (node.kind) {\n      @case ('text') {\n        <!-- Wrapped, and not for tidiness: a bare interpolation on its own line is\n             ONE text node that includes the indentation around it, so `a **b** c`\n             rendered with a space inside every `<strong>`. Inside an element the\n             whitespace becomes separate whitespace-only nodes, which Angular\n             removes, and `<ng-container>` itself renders nothing. Prettier\n             reformats the bare form back, so this also has to survive `--fix`. -->\n        <ng-container>{{ node.value }}</ng-container>\n      }\n      @case ('code') {\n        <!-- `dir=\"ltr\"` because code is not prose: under RTL the browser\n             reorders `foo();` to `;foo()`. -->\n        <code class=\"wr-markdown__code-inline\" dir=\"ltr\">{{ node.value }}</code>\n      }\n      @case ('strong') {\n        <strong class=\"wr-markdown__strong\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></strong>\n      }\n      @case ('em') {\n        <em class=\"wr-markdown__em\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></em>\n      }\n      @case ('del') {\n        <del class=\"wr-markdown__del\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></del>\n      }\n      @case ('link') {\n        <a\n          class=\"wr-markdown__link\"\n          [href]=\"hrefOf(node.href)\"\n          [attr.title]=\"node.title\"\n          [attr.target]=\"resolvedLinkTarget()\"\n          [attr.rel]=\"linkRel()\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></a>\n      }\n      @case ('image') {\n        <img\n          class=\"wr-markdown__image\"\n          [src]=\"node.src\"\n          [alt]=\"node.alt\"\n          [attr.title]=\"node.title\"\n          loading=\"lazy\"\n          decoding=\"async\"\n        />\n      }\n      @case ('break') {\n        <br />\n      }\n    }\n  }\n</ng-template>\n\n<ng-template #itemList let-raw let-tight=\"tight\">\n  @let items = asItems(raw);\n\n  @for (item of items; track $index) {\n    <li class=\"wr-markdown__item\" [class.wr-markdown__item--task]=\"item.checked !== null\">\n      @if (item.checked !== null) {\n        <!-- Presentational, with the state as text beside it: a real\n             `<input type=\"checkbox\">` here would be an unlabelled form control,\n             which is a serious axe violation, and making it operable would\n             promise an interaction a renderer cannot honour. -->\n        <span class=\"wr-markdown__task\" [class.wr-markdown__task--checked]=\"item.checked\" aria-hidden=\"true\"></span>\n        <span class=\"wr-markdown__sr-only\">{{ item.checked ? resolvedTaskDoneLabel() : resolvedTaskTodoLabel() }}</span>\n      }\n      <ng-container\n        [ngTemplateOutlet]=\"blockList\"\n        [ngTemplateOutletContext]=\"{ $implicit: item.children, tight: tight }\"\n      />\n    </li>\n  }\n</ng-template>\n\n<ng-template #blockList let-raw let-tight=\"tight\">\n  @let list = asBlocks(raw);\n\n  @for (block of list; track $index) {\n    @switch (block.kind) {\n      @case ('paragraph') {\n        <!-- A tight list drops the `<p>`, which is what CommonMark specifies and\n             what keeps a one-line list from being double-spaced. -->\n        @if (tight) {\n          <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n        } @else {\n          <p class=\"wr-markdown__paragraph\">\n            <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n          </p>\n        }\n      }\n      @case ('heading') {\n        @switch (block.level) {\n          @case (1) {\n            <h1 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h1>\n          }\n          @case (2) {\n            <h2 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h2>\n          }\n          @case (3) {\n            <h3 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h3>\n          }\n          @case (4) {\n            <h4 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h4>\n          }\n          @case (5) {\n            <h5 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h5>\n          }\n          @default {\n            <h6 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h6>\n          }\n        }\n      }\n      @case ('code') {\n        @let highlighted = linesOf(block.code, block.language);\n\n        <div class=\"wr-markdown__code-block\">\n          <pre\n            class=\"wr-markdown__pre\"\n            dir=\"ltr\"\n            tabindex=\"0\"\n          ><code class=\"wr-markdown__code\" [attr.data-language]=\"block.language\">@if (highlighted) {@for (row of highlighted; track $index) {<span class=\"wr-markdown__line\">@for (span of row; track $index) {<span\n            [style.color]=\"span.color\"\n            [style.font-style]=\"span.fontStyle === 'italic' ? 'italic' : null\"\n            [style.font-weight]=\"span.fontStyle === 'bold' ? 'bold' : null\"\n            [style.text-decoration]=\"span.fontStyle === 'underline' ? 'underline' : null\"\n          >{{ span.text }}</span>}</span>@if (!$last) {{{ newline }}}}} @else {{{ block.code }}}</code></pre>\n\n          @if (resolvedCopyable() && block.closed) {\n            <button\n              type=\"button\"\n              class=\"wr-markdown__copy\"\n              [wrCopyToClipboard]=\"block.code\"\n              [attr.aria-label]=\"isCopied(block) ? resolvedCopiedLabel() : resolvedCopyLabel()\"\n              (copied)=\"onCopied(block)\"\n            >\n              <svg\n                class=\"wr-markdown__copy-icon\"\n                xmlns=\"http://www.w3.org/2000/svg\"\n                viewBox=\"0 0 24 24\"\n                fill=\"none\"\n                stroke=\"currentColor\"\n                stroke-width=\"2\"\n                stroke-linecap=\"round\"\n                stroke-linejoin=\"round\"\n                aria-hidden=\"true\"\n              >\n                @if (isCopied(block)) {\n                  <path d=\"M20 6 9 17l-5-5\" />\n                } @else {\n                  <rect width=\"14\" height=\"14\" x=\"8\" y=\"8\" rx=\"2\" ry=\"2\" />\n                  <path d=\"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2\" />\n                }\n              </svg>\n            </button>\n          }\n        </div>\n      }\n      @case ('quote') {\n        <blockquote class=\"wr-markdown__quote\">\n          <ng-container\n            [ngTemplateOutlet]=\"blockList\"\n            [ngTemplateOutletContext]=\"{ $implicit: block.children, tight: false }\"\n          />\n        </blockquote>\n      }\n      @case ('list') {\n        @if (block.ordered) {\n          <ol\n            class=\"wr-markdown__list wr-markdown__list--ordered\"\n            [attr.start]=\"block.start === 1 ? null : block.start\"\n          >\n            <ng-container\n              [ngTemplateOutlet]=\"itemList\"\n              [ngTemplateOutletContext]=\"{ $implicit: block.items, tight: block.tight }\"\n            />\n          </ol>\n        } @else {\n          <ul class=\"wr-markdown__list\">\n            <ng-container\n              [ngTemplateOutlet]=\"itemList\"\n              [ngTemplateOutletContext]=\"{ $implicit: block.items, tight: block.tight }\"\n            />\n          </ul>\n        }\n      }\n      @case ('table') {\n        <!-- Its own scroller: a wide table must not push the page sideways, which\n             is also what keeps the RTL layout gate quiet about it. -->\n        <div class=\"wr-markdown__table-scroll\" tabindex=\"0\">\n          <table class=\"wr-markdown__table\">\n            <thead>\n              <tr>\n                @for (cell of block.head; track column; let column = $index) {\n                  <th class=\"wr-markdown__th\" scope=\"col\" [style.text-align]=\"block.align[column]\">\n                    <ng-container\n                      [ngTemplateOutlet]=\"inlineList\"\n                      [ngTemplateOutletContext]=\"{ $implicit: cell.inlines }\"\n                    />\n                  </th>\n                }\n              </tr>\n            </thead>\n            <tbody>\n              @for (row of block.rows; track $index) {\n                <tr>\n                  @for (cell of asCells(row); track column; let column = $index) {\n                    <td class=\"wr-markdown__td\" [style.text-align]=\"block.align[column]\">\n                      <ng-container\n                        [ngTemplateOutlet]=\"inlineList\"\n                        [ngTemplateOutletContext]=\"{ $implicit: cell.inlines }\"\n                      />\n                    </td>\n                  }\n                </tr>\n              }\n            </tbody>\n          </table>\n        </div>\n      }\n      @case ('rule') {\n        <hr class=\"wr-markdown__rule\" />\n      }\n    }\n  }\n</ng-template>\n\n<ng-container [ngTemplateOutlet]=\"blockList\" [ngTemplateOutletContext]=\"{ $implicit: blocks(), tight: false }\" />\n", dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: WrCopyToClipboard, selector: "[wrCopyToClipboard]", inputs: ["wrCopyToClipboard"], outputs: ["copied", "copyFailed"] }], encapsulation: i0.ViewEncapsulation.None });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrMarkdown, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: WrMarkdown, decorators: [{
             type: Component,
             args: [{ selector: 'wr-markdown', imports: [NgTemplateOutlet, WrCopyToClipboard], encapsulation: ViewEncapsulation.None, host: {
                         class: 'wr-markdown',
@@ -1550,6 +1573,764 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImpor
                     }, template: "<!--\n  Recursion runs through `ngTemplateOutlet` into these templates rather than\n  through a child component, so the rendered DOM is exactly the document \u2014 no\n  wrapper element between a `<ul>` and its `<li>`. See `asBlocks` for the whole\n  reasoning.\n-->\n<ng-template #inlineList let-raw>\n  @let nodes = asInlines(raw);\n\n  @for (node of nodes; track $index) {\n    @switch (node.kind) {\n      @case ('text') {\n        <!-- Wrapped, and not for tidiness: a bare interpolation on its own line is\n             ONE text node that includes the indentation around it, so `a **b** c`\n             rendered with a space inside every `<strong>`. Inside an element the\n             whitespace becomes separate whitespace-only nodes, which Angular\n             removes, and `<ng-container>` itself renders nothing. Prettier\n             reformats the bare form back, so this also has to survive `--fix`. -->\n        <ng-container>{{ node.value }}</ng-container>\n      }\n      @case ('code') {\n        <!-- `dir=\"ltr\"` because code is not prose: under RTL the browser\n             reorders `foo();` to `;foo()`. -->\n        <code class=\"wr-markdown__code-inline\" dir=\"ltr\">{{ node.value }}</code>\n      }\n      @case ('strong') {\n        <strong class=\"wr-markdown__strong\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></strong>\n      }\n      @case ('em') {\n        <em class=\"wr-markdown__em\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></em>\n      }\n      @case ('del') {\n        <del class=\"wr-markdown__del\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></del>\n      }\n      @case ('link') {\n        <a\n          class=\"wr-markdown__link\"\n          [href]=\"hrefOf(node.href)\"\n          [attr.title]=\"node.title\"\n          [attr.target]=\"resolvedLinkTarget()\"\n          [attr.rel]=\"linkRel()\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></a>\n      }\n      @case ('image') {\n        <img\n          class=\"wr-markdown__image\"\n          [src]=\"node.src\"\n          [alt]=\"node.alt\"\n          [attr.title]=\"node.title\"\n          loading=\"lazy\"\n          decoding=\"async\"\n        />\n      }\n      @case ('break') {\n        <br />\n      }\n    }\n  }\n</ng-template>\n\n<ng-template #itemList let-raw let-tight=\"tight\">\n  @let items = asItems(raw);\n\n  @for (item of items; track $index) {\n    <li class=\"wr-markdown__item\" [class.wr-markdown__item--task]=\"item.checked !== null\">\n      @if (item.checked !== null) {\n        <!-- Presentational, with the state as text beside it: a real\n             `<input type=\"checkbox\">` here would be an unlabelled form control,\n             which is a serious axe violation, and making it operable would\n             promise an interaction a renderer cannot honour. -->\n        <span class=\"wr-markdown__task\" [class.wr-markdown__task--checked]=\"item.checked\" aria-hidden=\"true\"></span>\n        <span class=\"wr-markdown__sr-only\">{{ item.checked ? resolvedTaskDoneLabel() : resolvedTaskTodoLabel() }}</span>\n      }\n      <ng-container\n        [ngTemplateOutlet]=\"blockList\"\n        [ngTemplateOutletContext]=\"{ $implicit: item.children, tight: tight }\"\n      />\n    </li>\n  }\n</ng-template>\n\n<ng-template #blockList let-raw let-tight=\"tight\">\n  @let list = asBlocks(raw);\n\n  @for (block of list; track $index) {\n    @switch (block.kind) {\n      @case ('paragraph') {\n        <!-- A tight list drops the `<p>`, which is what CommonMark specifies and\n             what keeps a one-line list from being double-spaced. -->\n        @if (tight) {\n          <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n        } @else {\n          <p class=\"wr-markdown__paragraph\">\n            <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n          </p>\n        }\n      }\n      @case ('heading') {\n        @switch (block.level) {\n          @case (1) {\n            <h1 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h1>\n          }\n          @case (2) {\n            <h2 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h2>\n          }\n          @case (3) {\n            <h3 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h3>\n          }\n          @case (4) {\n            <h4 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h4>\n          }\n          @case (5) {\n            <h5 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h5>\n          }\n          @default {\n            <h6 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h6>\n          }\n        }\n      }\n      @case ('code') {\n        @let highlighted = linesOf(block.code, block.language);\n\n        <div class=\"wr-markdown__code-block\">\n          <pre\n            class=\"wr-markdown__pre\"\n            dir=\"ltr\"\n            tabindex=\"0\"\n          ><code class=\"wr-markdown__code\" [attr.data-language]=\"block.language\">@if (highlighted) {@for (row of highlighted; track $index) {<span class=\"wr-markdown__line\">@for (span of row; track $index) {<span\n            [style.color]=\"span.color\"\n            [style.font-style]=\"span.fontStyle === 'italic' ? 'italic' : null\"\n            [style.font-weight]=\"span.fontStyle === 'bold' ? 'bold' : null\"\n            [style.text-decoration]=\"span.fontStyle === 'underline' ? 'underline' : null\"\n          >{{ span.text }}</span>}</span>@if (!$last) {{{ newline }}}}} @else {{{ block.code }}}</code></pre>\n\n          @if (resolvedCopyable() && block.closed) {\n            <button\n              type=\"button\"\n              class=\"wr-markdown__copy\"\n              [wrCopyToClipboard]=\"block.code\"\n              [attr.aria-label]=\"isCopied(block) ? resolvedCopiedLabel() : resolvedCopyLabel()\"\n              (copied)=\"onCopied(block)\"\n            >\n              <svg\n                class=\"wr-markdown__copy-icon\"\n                xmlns=\"http://www.w3.org/2000/svg\"\n                viewBox=\"0 0 24 24\"\n                fill=\"none\"\n                stroke=\"currentColor\"\n                stroke-width=\"2\"\n                stroke-linecap=\"round\"\n                stroke-linejoin=\"round\"\n                aria-hidden=\"true\"\n              >\n                @if (isCopied(block)) {\n                  <path d=\"M20 6 9 17l-5-5\" />\n                } @else {\n                  <rect width=\"14\" height=\"14\" x=\"8\" y=\"8\" rx=\"2\" ry=\"2\" />\n                  <path d=\"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2\" />\n                }\n              </svg>\n            </button>\n          }\n        </div>\n      }\n      @case ('quote') {\n        <blockquote class=\"wr-markdown__quote\">\n          <ng-container\n            [ngTemplateOutlet]=\"blockList\"\n            [ngTemplateOutletContext]=\"{ $implicit: block.children, tight: false }\"\n          />\n        </blockquote>\n      }\n      @case ('list') {\n        @if (block.ordered) {\n          <ol\n            class=\"wr-markdown__list wr-markdown__list--ordered\"\n            [attr.start]=\"block.start === 1 ? null : block.start\"\n          >\n            <ng-container\n              [ngTemplateOutlet]=\"itemList\"\n              [ngTemplateOutletContext]=\"{ $implicit: block.items, tight: block.tight }\"\n            />\n          </ol>\n        } @else {\n          <ul class=\"wr-markdown__list\">\n            <ng-container\n              [ngTemplateOutlet]=\"itemList\"\n              [ngTemplateOutletContext]=\"{ $implicit: block.items, tight: block.tight }\"\n            />\n          </ul>\n        }\n      }\n      @case ('table') {\n        <!-- Its own scroller: a wide table must not push the page sideways, which\n             is also what keeps the RTL layout gate quiet about it. -->\n        <div class=\"wr-markdown__table-scroll\" tabindex=\"0\">\n          <table class=\"wr-markdown__table\">\n            <thead>\n              <tr>\n                @for (cell of block.head; track column; let column = $index) {\n                  <th class=\"wr-markdown__th\" scope=\"col\" [style.text-align]=\"block.align[column]\">\n                    <ng-container\n                      [ngTemplateOutlet]=\"inlineList\"\n                      [ngTemplateOutletContext]=\"{ $implicit: cell.inlines }\"\n                    />\n                  </th>\n                }\n              </tr>\n            </thead>\n            <tbody>\n              @for (row of block.rows; track $index) {\n                <tr>\n                  @for (cell of asCells(row); track column; let column = $index) {\n                    <td class=\"wr-markdown__td\" [style.text-align]=\"block.align[column]\">\n                      <ng-container\n                        [ngTemplateOutlet]=\"inlineList\"\n                        [ngTemplateOutletContext]=\"{ $implicit: cell.inlines }\"\n                      />\n                    </td>\n                  }\n                </tr>\n              }\n            </tbody>\n          </table>\n        </div>\n      }\n      @case ('rule') {\n        <hr class=\"wr-markdown__rule\" />\n      }\n    }\n  }\n</ng-template>\n\n<ng-container [ngTemplateOutlet]=\"blockList\" [ngTemplateOutletContext]=\"{ $implicit: blocks(), tight: false }\" />\n" }]
         }], ctorParameters: () => [], propDecorators: { value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }], streaming: [{ type: i0.Input, args: [{ isSignal: true, alias: "streaming", required: false }] }], copyable: [{ type: i0.Input, args: [{ isSignal: true, alias: "copyable", required: false }] }], linkTarget: [{ type: i0.Input, args: [{ isSignal: true, alias: "linkTarget", required: false }] }], headingIds: [{ type: i0.Input, args: [{ isSignal: true, alias: "headingIds", required: false }] }], headingIdPrefix: [{ type: i0.Input, args: [{ isSignal: true, alias: "headingIdPrefix", required: false }] }], copyLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "copyLabel", required: false }] }], copiedLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "copiedLabel", required: false }] }], taskDoneLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "taskDoneLabel", required: false }] }], taskTodoLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "taskTodoLabel", required: false }] }] } });
 
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * A block tree back to markdown — the inverse of {@link parseMarkdown}.
+ *
+ * **Written against this library's parser, not against CommonMark.** The two
+ * disagree in places (no setext headings, no indented code, no entities, a
+ * simplified reading of emphasis), and a serializer that escapes for the wrong
+ * dialect writes text that comes back as something else. So every escape here is
+ * derived from a question `parseMarkdown` actually asks — several of them by
+ * calling the parser's own predicates — and the spec holds the pair to one
+ * property: `parseMarkdown(serializeMarkdown(tree))` returns `tree`.
+ *
+ * **What markdown cannot say is normalised, never guessed at.** The output is the
+ * nearest document this dialect can express, and reading it back gives a tree
+ * that serializes to the same string. The losses, all of them structural:
+ *
+ * - Whitespace at the edges of a paragraph, heading or cell is dropped, and so is
+ *   whitespace just inside `**` / `*` / `~~` — a delimiter next to a space is not
+ *   a delimiter. A soft line break inside a text node becomes a space, and a hard
+ *   break at the very end of a block (a trailing `\` stays literal) is dropped;
+ *   inside a heading or a table cell every hard break becomes a space.
+ * - An empty paragraph, an empty list and a table with no header cell vanish.
+ * - Two adjacent lists of the same kind merge on the way back — there is no
+ *   raw-HTML comment to put between them. A single-item list with one block
+ *   cannot be loose, and a loose list nested in a tight one loosens it. Nesting
+ *   deeper than the parser's twelve levels reads back as text.
+ * - Inline marks are rewritten in one canonical nesting — link outside strong
+ *   outside strikethrough outside emphasis — which is also how a mark SET, the
+ *   shape an editor holds, becomes a tree. An image carries no emphasis (none of
+ *   it paints on an image); where an emphasis run touches a strong one and
+ *   neither can switch to `_`, the emphasis is dropped rather than written as
+ *   markup that reads back as literal asterisks.
+ * - A link or image whose URL `safeMarkdownUrl` refuses is written as its text,
+ *   exactly as the renderer would show it. A destination is percent-encoded
+ *   where this parser cannot carry a character (`<`, `>`, an unbalanced
+ *   parenthesis, a `\` it would read as an escape — and `[`, `]`, a backtick for
+ *   an image inside a link label), loses a tab or line break the way a browser's
+ *   URL parser does, a title that cannot be delimited is dropped, and a link
+ *   whose label is too long for the parser's label cap is written as plain text.
+ * - A fence's info string keeps its first word, lowercased, and `closed` is not
+ *   written: a serialized fence is always closed. A tab that indents a line reads
+ *   back as four spaces, as the parser expands it. Heading ids are the parser's,
+ *   recomputed on the way back.
+ *
+ * @param blocks a block tree, typically from {@link parseMarkdown} or an editor
+ * @returns markdown, with no trailing newline; `''` for an empty tree
+ */
+function serializeMarkdown(blocks) {
+    return joinBlocks(blocks.map(renderBlock), false);
+}
+/** The largest number `LIST_RE` reads as an ordinal: `\d{1,9}`. */
+const MAX_ORDINAL = 999999999;
+const DELIMITER_ROW = {
+    start: ':--',
+    center: ':-:',
+    end: '--:',
+    none: '---',
+};
+function renderBlock(block) {
+    const text = blockText(block);
+    return text ? { block, text } : null;
+}
+function blockText(block) {
+    switch (block.kind) {
+        case 'paragraph':
+            return inlineMarkdown(block.inlines, 'paragraph').split('\n').map(escapeLineStart).join('\n');
+        case 'heading':
+            return headingText(block.level, block.inlines);
+        case 'code':
+            return codeBlock(block.language, block.code);
+        case 'quote': {
+            const body = joinBlocks(block.children.map(renderBlock), false);
+            // A lone `>` is how an empty quote is written, and it reads back as one.
+            return body
+                .split('\n')
+                .map(line => (line ? `> ${line}` : '>'))
+                .join('\n');
+        }
+        case 'list':
+            return listText(block.ordered, block.start, block.tight, block.items);
+        case 'table':
+            return tableText(block.head, block.rows, block.align);
+        case 'rule':
+            return '---';
+    }
+}
+/**
+ * Blocks joined the way the parser will split them again.
+ *
+ * A blank line is the safe separator, and between two siblings at one level it is
+ * always correct but for one case: a blank line followed by ANY list marker marks
+ * the list before it loose, even when the marker starts a list of the other kind.
+ * So a tight list that is followed by a list is joined by a single newline. Inside
+ * a tight list item a single newline is wanted everywhere, and is used wherever
+ * the parser would still end the first block there.
+ */
+function joinBlocks(parts, tight) {
+    let out = '';
+    let previous = null;
+    for (const part of parts) {
+        if (!part)
+            continue;
+        if (previous)
+            out += separator(previous, part, tight);
+        out += part.text;
+        previous = part;
+    }
+    return out;
+}
+function separator(previous, next, tight) {
+    const tightList = previous.block.kind === 'list' && !previous.text.includes('\n\n');
+    if (tightList && next.block.kind === 'list')
+        return '\n';
+    return tight && endsBefore(previous, next) ? '\n' : '\n\n';
+}
+/**
+ * Does `previous` end where `next` begins, with no blank line between them?
+ *
+ * Each case is the parser's own stopping rule, asked through its own predicates: a
+ * paragraph runs until a line interrupts it, a quote swallows any line that does
+ * not start a block (lazy continuation), a list swallows the same and continues on
+ * a marker of its own kind, and a table runs while a line has a pipe. A heading, a
+ * rule and a closed fence end themselves.
+ */
+function endsBefore(previous, next) {
+    const lines = next.text.split('\n');
+    const first = lines[0];
+    switch (previous.block.kind) {
+        case 'paragraph': {
+            // A last line holding a pipe, over a `---`, is a table header and its
+            // delimiter row — which is the parser's answer before it asks anything else.
+            const last = previous.text.slice(previous.text.lastIndexOf('\n') + 1);
+            return (interruptsParagraph(first) || isTableStart(lines, 0)) && !isTableStart([last, first], 0);
+        }
+        case 'quote':
+            return startsBlock(first) && !QUOTE_RE.test(first);
+        case 'list': {
+            const start = matchListStart(first);
+            return startsBlock(first) && (!start || RULE_RE.test(first) || start.ordered !== previous.block.ordered);
+        }
+        case 'table':
+            return !first.includes('|') || startsBlock(first);
+        default:
+            return true;
+    }
+}
+function headingText(level, inlines) {
+    const hashes = '#'.repeat(Math.min(Math.max(Math.trunc(level) || 1, 1), 6));
+    // A `#` run at the end, after whitespace, is a closing sequence and the parser
+    // strips it — `# Issue #` would come back as "Issue". `# C#` keeps its sharp.
+    const text = inlineMarkdown(inlines, 'heading').replace(/(^|[ \t])(#*)#$/, '$1$2\\#');
+    return text ? `${hashes} ${text}` : hashes;
+}
+function codeBlock(language, raw) {
+    const info = (language ?? '').trim().split(/\s+/)[0].toLowerCase();
+    // A backtick fence absorbs an info string that starts with a backtick into its
+    // own run, so that one info string takes a tilde fence instead.
+    const char = info.startsWith('`') ? '~' : '`';
+    const code = raw.replace(/\r\n?/g, '\n');
+    // Longer than any run of the fence character anywhere in the code, so no line
+    // of it can close the fence early.
+    const longest = (code.match(char === '`' ? /`+/g : /~+/g) ?? []).reduce((max, run) => Math.max(max, run.length), 0);
+    const fence = char.repeat(Math.max(3, longest + 1));
+    return code ? `${fence}${info}\n${code}\n${fence}` : `${fence}${info}\n${fence}`;
+}
+function listText(ordered, start, tight, items) {
+    const first = Math.min(Math.max(Math.trunc(start) || 0, 0), MAX_ORDINAL);
+    return items
+        .map((item, index) => listItem(item, ordered ? `${Math.min(first + index, MAX_ORDINAL)}. ` : '- ', tight))
+        .join(tight ? '\n' : '\n\n');
+}
+function listItem(item, marker, tight) {
+    const task = item.checked === null ? '' : item.checked ? '[x] ' : '[ ] ';
+    const bare = (marker + task).trimEnd();
+    const body = joinBlocks(item.children.map(renderBlock), tight);
+    if (!body)
+        return bare;
+    // Continuation lines sit at the item's content column, which for `- ` is 2 and
+    // for `10. ` is 4 — the parser dedents by exactly the marker's width.
+    const pad = ' '.repeat(marker.length);
+    const lines = body.split('\n');
+    const head = marker + task + lines[0];
+    const indented = (rest) => rest.map(line => (line ? pad + line : line));
+    // `- ---` is a thematic break, not an item holding one, so a first line that
+    // would read that way moves under a bare marker.
+    return RULE_RE.test(head) ? [bare, ...indented(lines)].join('\n') : [head, ...indented(lines.slice(1))].join('\n');
+}
+function tableText(head, rows, align) {
+    const width = Math.min(head.length, MAX_TABLE_COLUMNS);
+    if (!width)
+        return '';
+    const columns = Array.from({ length: width }, (_, index) => index);
+    const row = (cells) => `| ${columns.map(index => cellText(cells[index]?.inlines ?? [])).join(' | ')} |`;
+    const delimiter = `| ${columns.map(index => DELIMITER_ROW[align[index] ?? 'none']).join(' | ')} |`;
+    return [row(head), delimiter, ...rows.map(row)].join('\n');
+}
+/**
+ * A cell's inline markdown with every pipe escaped — inside code spans, URLs and
+ * titles too. The row is split on pipes BEFORE any inline parsing, and the split
+ * turns `\|` into `|` and touches nothing else, so escaping every pipe is its
+ * exact inverse.
+ */
+function cellText(inlines) {
+    return inlineMarkdown(inlines, 'cell').replace(/\|/g, '\\|');
+}
+/**
+ * A backslash before the first character of a line that would otherwise start a
+ * block, or turn the line above it into a table header.
+ *
+ * Every such character is ASCII punctuation, which the parser unescapes, except
+ * the digits of an ordered marker — there the delimiter is escaped instead,
+ * `1986\.`. The test runs on the line as the parser will see it, with indent tabs
+ * expanded, because the parser expands them before it looks.
+ */
+function escapeLineStart(line) {
+    const indent = /^[ \t]*/.exec(line)[0];
+    const probe = indent.replace(/\t/g, '    ') + line.slice(indent.length);
+    if (!startsBlock(probe) && !TABLE_DELIM_RE.test(probe))
+        return line;
+    const ordinal = /^\d{1,9}(?=[.)])/.exec(line.slice(indent.length));
+    const at = indent.length + (ordinal ? ordinal[0].length : 0);
+    return `${line.slice(0, at)}\\${line.slice(at)}`;
+}
+/** Outermost first. Emphasis never contains strong, which is the nesting `*x **y** z*` breaks on. */
+const LEVELS = ['link', 'strong', 'del', 'em'];
+const EMPHASIS = ['strong', 'del', 'em'];
+const NO_MARKS = { link: null, strong: false, del: false, em: false };
+/** The parser's own "word character" for `_` flanking. */
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+/** A soft break and the indentation around it: whitespace once rendered. */
+const SOFT_BREAK_RE = /\s*[\r\n]\s*/g;
+/** What another renderer would decode as an entity; this one does not, so `\&` keeps it literal everywhere. */
+const ENTITY_RE = /^&(?:#\d+|#x[\da-f]+|[a-z][a-z\d]*);/i;
+function inlineMarkdown(nodes, context) {
+    let leaves = settle(flatten(nodes, NO_MARKS, context, []), context);
+    // A link whose label is past the parser's cap is not a link on the way back.
+    // Its leaves lose the mark and the run is laid out again, since unwrapping it
+    // can put two emphasis runs next to each other.
+    for (;;) {
+        const state = { tooLong: null };
+        const out = renderNodes(group(leaves, 0, 0), state);
+        if (!state.tooLong)
+            return out;
+        const [from, to] = state.tooLong;
+        leaves = settle(leaves.map((leaf, index) => index >= from && index < to ? { ...leaf, marks: { ...leaf.marks, link: null } } : leaf), context);
+    }
+}
+function flatten(nodes, marks, context, out) {
+    for (const node of nodes) {
+        switch (node.kind) {
+            case 'text':
+                out.push({ kind: 'text', value: node.value.replace(SOFT_BREAK_RE, ' '), marks });
+                break;
+            case 'code':
+                // The parser reads a newline inside a code span as a space.
+                out.push({ kind: 'code', value: node.value.replace(/\r\n?|\n/g, ' '), marks });
+                break;
+            case 'break':
+                out.push(context === 'paragraph' ? { kind: 'break', marks } : { kind: 'text', value: ' ', marks });
+                break;
+            case 'image': {
+                const src = safeMarkdownUrl(node.src, 'image');
+                const alt = node.alt.replace(SOFT_BREAK_RE, ' ');
+                const inLabel = marks.link !== null;
+                // A refused source renders its alt as text, so that is what is written.
+                out.push(src
+                    ? {
+                        kind: 'image',
+                        src: encodeUrl(src, inLabel),
+                        alt,
+                        title: writableTitle(node.title, inLabel),
+                        marks: { ...NO_MARKS, link: marks.link },
+                    }
+                    : { kind: 'text', value: alt, marks });
+                break;
+            }
+            case 'link': {
+                // No link inside a link, and no link the reader would refuse anyway. The
+                // attributes are stored as they will be WRITTEN, so two links that differ
+                // only in what cannot be written are one link here, as they will be on the
+                // way back.
+                const href = marks.link ? null : safeMarkdownUrl(node.href, 'link');
+                const next = href
+                    ? { ...marks, link: { href: encodeUrl(href, false), title: writableTitle(node.title, false) } }
+                    : marks;
+                flatten(node.children, next, context, out);
+                break;
+            }
+            default:
+                flatten(node.children, { ...marks, [node.kind]: true }, context, out);
+        }
+    }
+    return out;
+}
+/**
+ * The leaves in canonical form: merged, with whitespace outside emphasis, trimmed
+ * at the block's edges, and no code span that would open a line as a fence.
+ */
+function settle(leaves, context) {
+    let current = leaves;
+    // A code span turned into text can bring a space to the edge of a node, so the
+    // pass runs again until nothing more is unfenced.
+    for (;;) {
+        const out = trimBlock(merge(moveEdgesOut(merge(current))));
+        if (context !== 'paragraph')
+            return out;
+        const unfenced = unfence(out);
+        if (unfenced.every((leaf, index) => leaf === out[index]))
+            return out;
+        current = unfenced;
+    }
+}
+function sameLink(a, b) {
+    return a === b || (!!a && !!b && a.href === b.href && a.title === b.title);
+}
+function sameMarks(a, b) {
+    return a.strong === b.strong && a.del === b.del && a.em === b.em && sameLink(a.link, b.link);
+}
+/** Adjacent text (or code) with the same marks is one node; an empty one is none. */
+function merge(leaves) {
+    const out = [];
+    for (const leaf of leaves) {
+        if ((leaf.kind === 'text' || leaf.kind === 'code') && !leaf.value)
+            continue;
+        const last = out[out.length - 1];
+        if (last &&
+            (last.kind === 'text' || last.kind === 'code') &&
+            last.kind === leaf.kind &&
+            sameMarks(last.marks, leaf.marks)) {
+            out[out.length - 1] = { ...last, value: last.value + leaf.value };
+        }
+        else {
+            out.push(leaf);
+        }
+    }
+    return out;
+}
+/**
+ * Whitespace and hard breaks at the edge of an emphasis run lose that mark.
+ *
+ * The parser refuses an opener followed by whitespace and a closer preceded by it,
+ * so `** bold **` is literal asterisks; the same text written `**bold**` with the
+ * spaces outside is what was meant. A link keeps its edges — `[` and `]` have no
+ * flanking rule.
+ *
+ * The unit is the NODE the mark will become, not the run of leaves carrying it:
+ * the canonical nesting cuts a strong run wherever a link begins or ends, and an
+ * emphasis run wherever strong or strikethrough changes, and each piece gets
+ * delimiters of its own. Outer marks go first, so an inner node is measured
+ * against leaves that are already final.
+ */
+function moveEdgesOut(leaves) {
+    let out = [...leaves];
+    for (const mark of EMPHASIS) {
+        const outer = EMPHASIS.slice(0, EMPHASIS.indexOf(mark));
+        const sameNode = (a, b) => b.marks[mark] && sameLink(a.marks.link, b.marks.link) && outer.every(name => a.marks[name] === b.marks[name]);
+        const next = [];
+        let i = 0;
+        while (i < out.length) {
+            if (!out[i].marks[mark]) {
+                next.push(out[i]);
+                i++;
+                continue;
+            }
+            let j = i;
+            while (j < out.length && sameNode(out[i], out[j]))
+                j++;
+            next.push(...trimRun(out.slice(i, j), mark));
+            i = j;
+        }
+        out = next;
+    }
+    return out;
+}
+function trimRun(run, mark) {
+    const body = [...run];
+    const head = [];
+    const tail = [];
+    const unmark = (leaf) => ({ ...leaf, marks: { ...leaf.marks, [mark]: false } });
+    while (body.length) {
+        const leaf = body[0];
+        if (leaf.kind === 'break') {
+            head.push(unmark(leaf));
+            body.shift();
+            continue;
+        }
+        if (leaf.kind !== 'text')
+            break;
+        const space = /^\s*/.exec(leaf.value)[0];
+        if (!space)
+            break;
+        head.push(unmark({ ...leaf, value: space }));
+        if (space.length < leaf.value.length) {
+            body[0] = { ...leaf, value: leaf.value.slice(space.length) };
+            break;
+        }
+        body.shift();
+    }
+    while (body.length) {
+        const leaf = body[body.length - 1];
+        if (leaf.kind === 'break') {
+            tail.unshift(unmark(leaf));
+            body.pop();
+            continue;
+        }
+        if (leaf.kind !== 'text')
+            break;
+        const space = /\s*$/.exec(leaf.value)[0];
+        if (!space)
+            break;
+        tail.unshift(unmark({ ...leaf, value: space }));
+        if (space.length < leaf.value.length) {
+            body[body.length - 1] = { ...leaf, value: leaf.value.slice(0, -space.length) };
+            break;
+        }
+        body.pop();
+    }
+    return [...head, ...body, ...tail];
+}
+/**
+ * What the parser's trim would take anyway: leading whitespace, and trailing
+ * whitespace and hard breaks (a `\` at the end of a block stays a literal
+ * backslash). Content inside a link label is past its reach and stays.
+ */
+function trimBlock(leaves) {
+    const out = [...leaves];
+    let start = 0;
+    let end = out.length;
+    while (start < end) {
+        const leaf = out[start];
+        if (leaf.kind !== 'text' || leaf.marks.link)
+            break;
+        const value = leaf.value.replace(/^\s+/, '');
+        if (value) {
+            out[start] = { ...leaf, value };
+            break;
+        }
+        start++;
+    }
+    while (end > start) {
+        const leaf = out[end - 1];
+        if (leaf.marks.link || (leaf.kind !== 'text' && leaf.kind !== 'break'))
+            break;
+        if (leaf.kind === 'break') {
+            end--;
+            continue;
+        }
+        const value = leaf.value.replace(/\s+$/, '');
+        if (value) {
+            out[end - 1] = { ...leaf, value };
+            break;
+        }
+        end--;
+    }
+    return out.slice(start, end);
+}
+/**
+ * A code span that opens a paragraph line and needs three or more backticks would
+ * read back as a fence. Nothing can be put in front of it, so it keeps its text
+ * and loses the code mark. It takes a value holding both a single and a double
+ * backtick run to get here.
+ */
+function unfence(leaves) {
+    const blank = (leaf) => leaf.kind === 'text' && !leaf.value.trim();
+    return leaves.map((leaf, index) => {
+        if (leaf.kind !== 'code' || ticks(leaf.value) < 3)
+            return leaf;
+        let k = index - 1;
+        while (k >= 0 && blank(leaves[k])) {
+            if (!sameMarks(leaves[k].marks, leaf.marks))
+                return leaf;
+            k--;
+        }
+        const opensLine = k < 0 ? sameMarks(leaf.marks, NO_MARKS) : leaves[k].kind === 'break' && sameMarks(leaves[k].marks, leaf.marks);
+        return opensLine ? { kind: 'text', value: leaf.value, marks: leaf.marks } : leaf;
+    });
+}
+/**
+ * Leaves to a tree, one mark level at a time in {@link LEVELS} order: a maximal
+ * run sharing the mark becomes one node, and what is inside it is grouped by the
+ * next level. Two leaves painted the same way always land in the same shape.
+ */
+function group(leaves, level, offset) {
+    if (level === LEVELS.length)
+        return [...leaves];
+    const mark = LEVELS[level];
+    const key = (leaf) => (mark === 'link' ? leaf.marks.link : leaf.marks[mark]);
+    const same = (a, b) => mark === 'link' ? sameLink(a.marks.link, b.marks.link) : a.marks[mark] === b.marks[mark];
+    const out = [];
+    let i = 0;
+    while (i < leaves.length) {
+        let j = i + 1;
+        while (j < leaves.length && same(leaves[i], leaves[j]))
+            j++;
+        const children = group(leaves.slice(i, j), level + 1, offset + i);
+        const on = key(leaves[i]);
+        if (!on) {
+            out.push(...children);
+        }
+        else if (mark === 'link') {
+            out.push({ kind: 'link', link: on, from: offset + i, to: offset + j, children });
+        }
+        else {
+            out.push({ kind: mark, children });
+        }
+        i = j;
+    }
+    return out;
+}
+function renderNodes(nodes, state) {
+    const [list, chars] = delimiters(nodes);
+    let out = '';
+    list.forEach((node, index) => {
+        out += renderNode(node, chars[index], list[index + 1], state);
+    });
+    return out;
+}
+function renderNode(node, char, next, state) {
+    switch (node.kind) {
+        case 'text':
+            return escapeText(node.value, next?.kind === 'link');
+        case 'code':
+            return codeSpan(node.value);
+        case 'break':
+            return '\\\n';
+        case 'image':
+            return `![${escapeText(node.alt, false)}](${destination(node.src, node.title)})`;
+        case 'link': {
+            const auto = autolink(node.link, node.children);
+            if (auto)
+                return auto;
+            const label = renderNodes(node.children, state);
+            if (label.length >= MAX_LABEL_LENGTH) {
+                state.tooLong ??= [node.from, node.to];
+                return label;
+            }
+            return `[${label}](${destination(node.link.href, node.link.title)})`;
+        }
+        case 'del':
+            return `~~${renderNodes(node.children, state)}~~`;
+        default: {
+            const delimiter = node.kind === 'strong' ? char.repeat(2) : char;
+            return delimiter + renderNodes(node.children, state) + delimiter;
+        }
+    }
+}
+/**
+ * The delimiter character of every strong and emphasis node in a sibling list.
+ *
+ * `*` unless it would touch another `*` run: `*a***b**` reads as one run of three
+ * and parses wrong. The canonical nesting means the only neighbours that can clash
+ * are an emphasis and a strong, so one of them switches to `_` — the emphasis
+ * first — where `_` flanking allows it: no letter or digit against it from
+ * outside, and no `_` neighbour to clash with in turn. Where neither can switch,
+ * the emphasis is dropped and the list is laid out again; its children are
+ * leaves, so the drop cannot create a clash of its own.
+ */
+function delimiters(nodes) {
+    let list = nodes;
+    for (;;) {
+        const chars = list.map(node => (node.kind === 'strong' || node.kind === 'em' ? '*' : null));
+        const drop = settleClashes(list, chars);
+        if (drop < 0)
+            return [list, chars];
+        const dropped = list[drop];
+        list = [...list.slice(0, drop), ...dropped.children, ...list.slice(drop + 1)];
+    }
+}
+/** Index of an emphasis node to drop, or -1 once every clash is settled. */
+function settleClashes(list, chars) {
+    for (let i = 0; i + 1 < list.length; i++) {
+        if (!chars[i] || chars[i] !== chars[i + 1])
+            continue;
+        const emFirst = list[i].kind === 'em';
+        const switched = (emFirst ? [i, i + 1] : [i + 1, i]).find(k => canUnderscore(list, chars, k));
+        if (switched === undefined)
+            return emFirst ? i : i + 1;
+        chars[switched] = '_';
+    }
+    return -1;
+}
+function canUnderscore(list, chars, k) {
+    const before = k > 0 ? edgeChar(list[k - 1], chars[k - 1], 'end') : '';
+    const after = k + 1 < list.length ? edgeChar(list[k + 1], chars[k + 1], 'start') : '';
+    return chars[k - 1] !== '_' && chars[k + 1] !== '_' && !WORD_CHAR.test(before) && !WORD_CHAR.test(after);
+}
+/**
+ * The character a node puts next to its neighbour — only ever asked whether it is
+ * a letter or a digit. Escaping inserts a backslash before punctuation and never
+ * before a word character, so the raw text answers that question for text.
+ */
+function edgeChar(node, char, side) {
+    switch (node.kind) {
+        case 'text':
+            return side === 'start' ? node.value[0] : node.value[node.value.length - 1];
+        case 'strong':
+        case 'em':
+            return char ?? '';
+        default:
+            return '';
+    }
+}
+/**
+ * Text with every character the parser would read as syntax escaped — and no
+ * more, so prose stays prose. `snake_case` keeps its underscores, `2 * 3` its
+ * star, `a < b` its bracket: in those positions the parser can never read them as
+ * markup. The ends of the string are treated as the worst case, since whatever is
+ * written next to it is not known here.
+ */
+function escapeText(value, beforeLink) {
+    let out = '';
+    for (let i = 0; i < value.length; i++) {
+        const char = value[i];
+        if (mustEscape(value, i, beforeLink))
+            out += '\\';
+        out += char;
+    }
+    // A bare URL in plain text would come back as a link. The escaped colon is
+    // invisible once parsed, and it stops `BARE_URL_RE` from matching.
+    return out.replace(/(https?):(?=\/\/)/gi, '$1\\:');
+}
+function mustEscape(value, i, beforeLink) {
+    const prev = value[i - 1];
+    const next = value[i + 1];
+    const space = (c) => c !== undefined && /\s/.test(c);
+    const word = (c) => c !== undefined && WORD_CHAR.test(c);
+    switch (value[i]) {
+        case '\\':
+        case '`':
+        case '[':
+        case ']':
+            return true;
+        // Between two spaces a star can neither open (followed by whitespace) nor
+        // close (preceded by it).
+        case '*':
+            return !(space(prev) && space(next));
+        // Between two word characters an underscore is never a delimiter.
+        case '_':
+            return !(word(prev) && word(next));
+        // Strikethrough needs a pair; a single tilde between other characters is text.
+        case '~':
+            return prev === undefined || prev === '~' || next === undefined || next === '~';
+        // An autolink needs a scheme or an address right after the bracket.
+        case '<':
+            return !space(next);
+        // `!` followed by a link's `[` would turn the link into an image.
+        case '!':
+            return beforeLink && next === undefined;
+        case '&':
+            return ENTITY_RE.test(value.slice(i));
+        default:
+            return false;
+    }
+}
+/** The shortest backtick run that does not occur inside the value. */
+function ticks(value) {
+    const runs = new Set((value.match(/`+/g) ?? []).map(run => run.length));
+    let length = 1;
+    while (runs.has(length))
+        length++;
+    return length;
+}
+/**
+ * A code span, padded where the parser would otherwise eat a character: it strips
+ * one space from each end when both are present, and a backtick at either end
+ * would merge into the fence.
+ */
+function codeSpan(value) {
+    const fence = '`'.repeat(ticks(value));
+    const pad = codeSpanValue(value) !== value || value.startsWith('`') || value.endsWith('`');
+    return pad ? `${fence} ${value} ${fence}` : `${fence}${value}${fence}`;
+}
+/** `<https://…>` or `<name@host>` when the label IS the address — the form the parser reads back identically. */
+function autolink(link, children) {
+    const only = children.length === 1 ? children[0] : null;
+    if (link.title !== null || only?.kind !== 'text')
+        return null;
+    const whole = (re, value) => re.exec(`<${value}>`)?.[0].length === value.length + 2;
+    if (only.value === link.href && whole(AUTOLINK_RE, link.href))
+        return `<${link.href}>`;
+    if (`mailto:${only.value}` === link.href && whole(EMAIL_AUTOLINK_RE, only.value))
+        return `<${only.value}>`;
+    return null;
+}
+/**
+ * A URL as this parser will read it back, and as a browser resolves it.
+ *
+ * The destination scan counts parentheses and ends at a line break, so an angle
+ * bracket and an unbalanced parenthesis are percent-encoded — to a browser the
+ * same address. A tab or a line break is removed rather than encoded: the URL
+ * parser strips them, so the address never had them, and `%0A` would be a
+ * different one. A backslash is kept as it is — the parser keeps it, and in an
+ * http(s) URL a browser reads it as `/`, which `%5C` is not — except where the
+ * scan would take it for an escape and skip what follows: before a parenthesis,
+ * and at the very end, where it would swallow the closing one. Inside a link label
+ * the label scan also runs over an image's destination, so its brackets and
+ * backticks are encoded too. Spaces are not encoded: {@link destination} carries
+ * them in the `<…>` form.
+ */
+function encodeUrl(url, inLabel) {
+    const out = url
+        .replace(/[\t\r\n]/g, '')
+        .replace(/\\(?=[()]|$)/g, percent)
+        .replace(inLabel ? /[<>[\]`]/g : /[<>]/g, percent);
+    return balanced(out) ? out : out.replace(/[()]/g, percent);
+}
+function percent(char) {
+    return `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`;
+}
+/** Parentheses the destination scan accepts: balanced, never closing early, and under its nesting cap. */
+function balanced(url) {
+    let depth = 0;
+    for (const char of url) {
+        if (char === '(' && ++depth >= MAX_DESTINATION_NESTING)
+            return false;
+        if (char === ')' && --depth < 0)
+            return false;
+    }
+    return depth === 0;
+}
+/**
+ * The title as it can be written, or `null` when it cannot: a line break becomes a
+ * space, and the destination scan runs through the title counting parentheses (a
+ * backslash skipping the next character), so one that would close the scan early
+ * or leave it open is dropped. Inside a link label the label scan runs through it
+ * as well, so a bracket, a backtick or a backslash drops it there.
+ */
+function writableTitle(raw, inLabel) {
+    if (raw === null)
+        return null;
+    const title = raw.replace(SOFT_BREAK_RE, ' ');
+    if (inLabel && /[[\]`\\]/.test(title))
+        return null;
+    let depth = 1;
+    for (let i = 0; i < title.length; i++) {
+        const char = title[i];
+        if (char === '\\') {
+            i++;
+            continue;
+        }
+        if (char === '(' && ++depth > MAX_DESTINATION_NESTING)
+            return null;
+        if (char === ')' && --depth === 0)
+            return null;
+    }
+    return depth === 1 ? title : null;
+}
+/** An encoded URL and a writable title, inside the parentheses. */
+function destination(url, title) {
+    const target = /\s/.test(url) ? `<${url}>` : url;
+    return title === null ? target : `${target} "${title}"`;
+}
+
 /**
  * @license
  *
@@ -1598,5 +2379,5 @@ function provideWrMarkdownHighlighter(highlighter) {
  * Generated bundle index. Do not edit.
  */
 
-export { WR_MARKDOWN_HIGHLIGHTER, WrMarkdown, WrMarkdownHighlight, parseInlines, parseMarkdown, plainText, provideWrMarkdownHighlighter, safeMarkdownUrl };
+export { WR_MARKDOWN_HIGHLIGHTER, WrMarkdown, WrMarkdownHighlight, parseInlines, parseMarkdown, plainText, provideWrMarkdownHighlighter, safeMarkdownUrl, serializeMarkdown };
 //# sourceMappingURL=ngwr-markdown.mjs.map