@kernhq/module-quire 0.13.0 → 0.14.0

package/dist/server/export/html.d.ts

@@ -0,0 +1,67 @@
+/**
+ * What an exported page is dressed in.
+ *
+ * Deliberately not a copy of `prose.css`: the same shapes, in the values a standalone file can rely
+ * on. Every colour pair here was chosen against the surface it sits on — body ink on paper is
+ * #2c2a26 on #fdfcfa in light and #e8e4dc on #171614 in dark, and the muted ink is a colour rather
+ * than an opacity, because `opacity` fades text against whatever is behind it and a "muted" row at
+ * 0.5 is a row nobody can read.
+ *
+ * The contrast is arithmetic and was computed rather than judged: every foreground below was
+ * measured against the surface it actually sits on — including each callout tint, the highlight and
+ * the code ground, in both themes — and the worst pair is the muted trail at **5.33:1**, which
+ * clears AA for body text. Re-measure before changing a value rather than adjusting it by eye.
+ */
+export declare const EXPORT_STYLES: string;
+/**
+ * A stand-in for an address `renderPageDoc` would otherwise refuse, swapped back afterwards.
+ *
+ * This exists because of a rule in `render.ts` that is right and inconvenient. `safeHref` accepts a
+ * fragment, a root-relative path, and `http`/`https`/`mailto` — and **nothing else**, deliberately:
+ * a bare relative path is something it cannot resolve, and `data:` is a document that can carry
+ * script. An exported file needs exactly the two it refuses. `media/diagram.png` and
+ * `../getting-started/index.html` are what makes an archive open on a laptop with nothing running,
+ * and a `data:` URI is what puts a picture into a PDF without handing Chromium a URL into our
+ * storage.
+ *
+ * The wrong fix would be to loosen `safeHref`, which is consulted by the published-site renderer on
+ * behalf of anonymous readers. So the renderer is given an `https` URL it accepts, and the exporter
+ * swaps it for the real one after the HTML is drawn. Two things make that safe rather than clever:
+ * the token is exact and unique, so the replacement is a string swap and not a regular expression
+ * over markup; and the host is under `.invalid`, the TLD RFC 2606 reserves as permanently
+ * unresolvable — so a token that somehow escaped the swap is a picture that cannot load rather than
+ * a request to somebody's server.
+ */
+export interface ExportLinks {
+    /** A token `safeHref` accepts, standing for `target`. The same target always gets the same token. */
+    to(target: string): string;
+    /** The drawn HTML with every token swapped back. */
+    resolve(html: string): string;
+}
+export declare function exportLinks(): ExportLinks;
+export interface ExportedPage {
+    /** the page's own id, so a mention of it inside this export can be an anchor */
+    id: string;
+    title: string;
+    /** the titles above it, outermost first — drawn as a trail so a loose file says where it came from */
+    trail: string[];
+    /** already rendered and escaped by `renderPageDoc`; never raw prose */
+    html: string;
+}
+/**
+ * One HTML file holding one page or many.
+ *
+ * `pages` is a list rather than a page because the PDF path needs every page of a subtree in one
+ * document — Chromium is handed a document and produces a PDF, so one round trip per page would be
+ * one PDF per page and nothing to join them with. The zip path passes a list of one.
+ *
+ * `dir` is the writing direction of the *content*, not of the reader's locale: an exported Persian
+ * handbook is right-to-left wherever it is opened.
+ */
+export declare function exportedHtmlDocument(opts: {
+    title: string;
+    pages: ExportedPage[];
+    dir?: 'ltr' | 'rtl' | 'auto';
+    lang?: string;
+}): string;
+//# sourceMappingURL=html.d.ts.map

package/dist/server/export/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../../src/server/export/html.ts"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,QAwGlB,CAAA;AAER;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,WAAW;IAC1B,qGAAqG;IACrG,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1B,oDAAoD;IACpD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAC9B;AAED,wBAAgB,WAAW,IAAI,WAAW,CAkBzC;AAED,MAAM,WAAW,YAAY;IAC3B,gFAAgF;IAChF,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,sGAAsG;IACtG,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAA;CACb;AAaD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACzC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,YAAY,EAAE,CAAA;IACrB,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAA;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,MAAM,CAoBT"}

package/dist/server/export/html.js

@@ -0,0 +1,206 @@
+/**
+ * A page as an HTML file somebody can open with no Kern behind it.
+ *
+ * The body comes from `renderPageDoc` — the same static renderer the public site uses — so an export
+ * and a published page are the same drawing of the same stored version. What this file adds is
+ * everything a *file* needs and a page inside an application does not: a document element, a
+ * character set, a title, and the styles, inlined.
+ *
+ * **The stylesheet is written here rather than taken from `@kernhq/ui`, and that is deliberate.**
+ * `prose.css` in that package is 480 lines referencing 31 `--kern-*` tokens defined in a second
+ * stylesheet that itself references a palette — so "inline the prose styles" is really "inline the
+ * whole design system", and an exported file would carry a copy of it that goes stale the moment the
+ * palette moves. What a reader of an exported page needs is smaller and does not change: the ink and
+ * paper colours, a measure they can read, and a rule for every block the renderer can emit. It is
+ * written flat, with no custom properties to resolve, because a file that is opened in a mail client
+ * or pasted into a wiki is not guaranteed a cascade.
+ *
+ * It has to answer for the same things a Kern screen answers for. Dark mode is `prefers-color-scheme`
+ * rather than a class, because a file has no shell to set one. `dir` comes from the document element
+ * so a Persian or Arabic page reads right-to-left, and every rule that could have been `left` or
+ * `right` is a logical property — `margin-inline-start`, `border-inline-start`, `text-align: start` —
+ * so nothing has to be mirrored. A table is the one block that cannot be made narrower, so it keeps
+ * the same `overflow-x` scroller the application gives it rather than pushing the page sideways.
+ */
+import { escapeHtml } from '../render.js';
+/**
+ * What an exported page is dressed in.
+ *
+ * Deliberately not a copy of `prose.css`: the same shapes, in the values a standalone file can rely
+ * on. Every colour pair here was chosen against the surface it sits on — body ink on paper is
+ * #2c2a26 on #fdfcfa in light and #e8e4dc on #171614 in dark, and the muted ink is a colour rather
+ * than an opacity, because `opacity` fades text against whatever is behind it and a "muted" row at
+ * 0.5 is a row nobody can read.
+ *
+ * The contrast is arithmetic and was computed rather than judged: every foreground below was
+ * measured against the surface it actually sits on — including each callout tint, the highlight and
+ * the code ground, in both themes — and the worst pair is the muted trail at **5.33:1**, which
+ * clears AA for body text. Re-measure before changing a value rather than adjusting it by eye.
+ */
+export const EXPORT_STYLES = `
+:root { color-scheme: light dark; }
+* { box-sizing: border-box; }
+html { -webkit-text-size-adjust: 100%; }
+body {
+  margin: 0;
+  padding: 40px 24px 96px;
+  background: #fdfcfa;
+  color: #2c2a26;
+  font: 16px/1.7 ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Noto Sans", sans-serif;
+}
+main { margin: 0 auto; max-width: 74ch; }
+.kern-page + .kern-page { margin-top: 72px; border-top: 1px solid #e5e0d6; padding-top: 40px; }
+.kern-page-title { margin: 0 0 4px; font-size: 32px; line-height: 1.25; font-weight: 650; }
+.kern-page-trail { margin: 0 0 28px; font-size: 13px; color: #6f6959; }
+.kern-prose > :first-child { margin-top: 0; }
+.kern-prose > :last-child { margin-bottom: 0; }
+.kern-prose p { margin: 0 0 16px; }
+.kern-prose h1, .kern-prose h2, .kern-prose h3,
+.kern-prose h4, .kern-prose h5, .kern-prose h6 {
+  margin: 32px 0 12px; line-height: 1.3; font-weight: 650; scroll-margin-top: 16px;
+}
+.kern-prose h1 { font-size: 28px; }
+.kern-prose h2 { font-size: 23px; }
+.kern-prose h3 { font-size: 19px; }
+.kern-prose h4 { font-size: 17px; }
+.kern-prose h5 { font-size: 15px; }
+.kern-prose h6 { font-size: 14px; color: #6f6959; text-transform: uppercase; letter-spacing: 0.04em; }
+.kern-prose a { color: #1c5f7a; text-underline-offset: 2px; }
+.kern-prose ul, .kern-prose ol { margin: 0 0 16px; padding-inline-start: 26px; }
+.kern-prose li { margin: 4px 0; }
+.kern-prose li > p { margin: 0; }
+.kern-prose blockquote {
+  margin: 0 0 16px; padding-block: 2px; padding-inline: 16px 0;
+  border-inline-start: 3px solid #d8d2c4; color: #4a463d;
+}
+.kern-prose code {
+  font: 0.9em/1.5 ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;
+  background: #f1eee6; border: 1px solid #e5e0d6; border-radius: 4px; padding: 1px 4px;
+}
+.kern-prose pre {
+  margin: 0 0 16px; padding: 14px 16px; overflow-x: auto;
+  background: #f6f3ec; border: 1px solid #e5e0d6; border-radius: 8px;
+}
+.kern-prose pre code { background: none; border: 0; padding: 0; font-size: 13px; }
+.kern-prose hr { margin: 28px 0; border: 0; border-top: 1px solid #e5e0d6; }
+.kern-prose img { max-width: 100%; height: auto; border-radius: 6px; }
+.kern-prose mark.kern-highlight { background: #fbeaa8; color: inherit; padding: 0 2px; border-radius: 3px; }
+.kern-table-wrap { margin: 0 0 16px; overflow-x: auto; }
+.kern-prose table.kern-table { border-collapse: collapse; width: 100%; font-size: 15px; }
+.kern-prose table.kern-table td, .kern-prose table.kern-table th {
+  border: 1px solid #e5e0d6; padding: 7px 10px; text-align: start; vertical-align: top;
+}
+.kern-prose table.kern-table th { background: #f6f3ec; font-weight: 620; }
+.kern-prose table.kern-table [data-align="center"] { text-align: center; }
+.kern-prose table.kern-table [data-align="end"] { text-align: end; }
+.kern-prose ul.kern-tasks { list-style: none; padding-inline-start: 2px; }
+.kern-prose ul.kern-tasks li { display: flex; gap: 8px; align-items: baseline; }
+.kern-prose ul.kern-tasks li > div { flex: 1; min-width: 0; }
+.kern-prose ul.kern-tasks li > div > p { margin: 0; }
+.kern-prose aside.kern-callout {
+  margin: 0 0 16px; padding: 12px 16px; border-radius: 8px;
+  border: 1px solid #d8d2c4; border-inline-start-width: 3px; background: #f6f3ec;
+}
+.kern-prose aside.kern-callout > :last-child { margin-bottom: 0; }
+.kern-prose aside.kern-callout[data-callout="info"] { border-color: #a9cbd8; background: #eef6f9; }
+.kern-prose aside.kern-callout[data-callout="success"] { border-color: #a9d3b4; background: #eef8f1; }
+.kern-prose aside.kern-callout[data-callout="warning"] { border-color: #e0cb96; background: #fbf5e6; }
+.kern-prose aside.kern-callout[data-callout="danger"] { border-color: #e0aaa4; background: #fbefee; }
+.kern-prose details.kern-toggle {
+  margin: 0 0 16px; padding: 10px 14px; border: 1px solid #e5e0d6; border-radius: 8px;
+}
+.kern-prose details.kern-toggle > summary { cursor: pointer; font-weight: 600; }
+.kern-prose .kern-mention, .kern-prose .kern-page-mention {
+  border-radius: 4px; padding: 0 3px; background: #eef2f7; color: #2b4a63;
+}
+@media print {
+  body { padding: 0; background: #fff; color: #000; }
+  .kern-page { break-after: page; }
+  .kern-page:last-child { break-after: auto; }
+  .kern-page + .kern-page { margin-top: 0; border-top: 0; padding-top: 0; }
+  .kern-prose a { color: inherit; }
+  .kern-table-wrap { overflow-x: visible; }
+}
+@media (prefers-color-scheme: dark) {
+  body { background: #171614; color: #e8e4dc; }
+  .kern-page + .kern-page { border-top-color: #35322c; }
+  .kern-page-trail, .kern-prose h6 { color: #9a9384; }
+  .kern-prose a { color: #7fc2dd; }
+  .kern-prose blockquote { border-inline-start-color: #3f3b33; color: #c6c1b6; }
+  .kern-prose code { background: #23211d; border-color: #35322c; }
+  .kern-prose pre { background: #1e1d1a; border-color: #35322c; }
+  .kern-prose hr { border-top-color: #35322c; }
+  .kern-prose mark.kern-highlight { background: #6a5a1e; color: #f4efdd; }
+  .kern-prose table.kern-table td, .kern-prose table.kern-table th { border-color: #35322c; }
+  .kern-prose table.kern-table th { background: #1e1d1a; }
+  .kern-prose aside.kern-callout { border-color: #3f3b33; background: #1e1d1a; }
+  .kern-prose aside.kern-callout[data-callout="info"] { border-color: #2d5a6d; background: #16232a; }
+  .kern-prose aside.kern-callout[data-callout="success"] { border-color: #2f5c3d; background: #16241b; }
+  .kern-prose aside.kern-callout[data-callout="warning"] { border-color: #6a5622; background: #241f13; }
+  .kern-prose aside.kern-callout[data-callout="danger"] { border-color: #6d3a34; background: #261917; }
+  .kern-prose details.kern-toggle { border-color: #35322c; }
+  .kern-prose .kern-mention, .kern-prose .kern-page-mention { background: #22303a; color: #b7d4e4; }
+}
+`.trim();
+export function exportLinks() {
+    const byTarget = new Map();
+    const byToken = new Map();
+    return {
+        to(target) {
+            const existing = byTarget.get(target);
+            if (existing)
+                return existing;
+            const token = `https://asset.invalid/${byToken.size}`;
+            byTarget.set(target, token);
+            byToken.set(token, target);
+            return token;
+        },
+        resolve(html) {
+            let out = html;
+            for (const [token, target] of byToken)
+                out = out.replaceAll(token, target);
+            return out;
+        },
+    };
+}
+const section = (page) => [
+    `<article class="kern-page" id="p-${escapeHtml(page.id)}">`,
+    `<h1 class="kern-page-title">${escapeHtml(page.title || 'Untitled')}</h1>`,
+    page.trail.length > 0
+        ? `<p class="kern-page-trail">${page.trail.map((part) => escapeHtml(part)).join(' / ')}</p>`
+        : '',
+    `<div class="kern-prose">${page.html}</div>`,
+    '</article>',
+].join('\n');
+/**
+ * One HTML file holding one page or many.
+ *
+ * `pages` is a list rather than a page because the PDF path needs every page of a subtree in one
+ * document — Chromium is handed a document and produces a PDF, so one round trip per page would be
+ * one PDF per page and nothing to join them with. The zip path passes a list of one.
+ *
+ * `dir` is the writing direction of the *content*, not of the reader's locale: an exported Persian
+ * handbook is right-to-left wherever it is opened.
+ */
+export function exportedHtmlDocument(opts) {
+    const dir = opts.dir ?? 'auto';
+    return `<!doctype html>
+<html lang="${escapeHtml(opts.lang ?? 'en')}" dir="${dir}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="generator" content="Kern Quire">
+<title>${escapeHtml(opts.title || 'Untitled')}</title>
+<style>
+${EXPORT_STYLES}
+</style>
+</head>
+<body>
+<main>
+${opts.pages.map(section).join('\n')}
+</main>
+</body>
+</html>
+`;
+}
+//# sourceMappingURL=html.js.map

package/dist/server/export/html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.js","sourceRoot":"","sources":["../../../src/server/export/html.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwG5B,CAAC,IAAI,EAAE,CAAA;AA4BR,MAAM,UAAU,WAAW;IACzB,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAA;IAC1C,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAA;IACzC,OAAO;QACL,EAAE,CAAC,MAAM;YACP,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;YACrC,IAAI,QAAQ;gBAAE,OAAO,QAAQ,CAAA;YAC7B,MAAM,KAAK,GAAG,yBAAyB,OAAO,CAAC,IAAI,EAAE,CAAA;YACrD,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;YAC3B,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;YAC1B,OAAO,KAAK,CAAA;QACd,CAAC;QACD,OAAO,CAAC,IAAI;YACV,IAAI,GAAG,GAAG,IAAI,CAAA;YACd,KAAK,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,OAAO;gBAAE,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;YAC1E,OAAO,GAAG,CAAA;QACZ,CAAC;KACF,CAAA;AACH,CAAC;AAYD,MAAM,OAAO,GAAG,CAAC,IAAkB,EAAU,EAAE,CAC7C;IACE,oCAAoC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI;IAC3D,+BAA+B,UAAU,CAAC,IAAI,CAAC,KAAK,IAAI,UAAU,CAAC,OAAO;IAC1E,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;QACnB,CAAC,CAAC,8BAA8B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM;QAC5F,CAAC,CAAC,EAAE;IACN,2BAA2B,IAAI,CAAC,IAAI,QAAQ;IAC5C,YAAY;CACb,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAEd;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAKpC;IACC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,MAAM,CAAA;IAC9B,OAAO;cACK,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,GAAG;;;;;SAK/C,UAAU,CAAC,IAAI,CAAC,KAAK,IAAI,UAAU,CAAC;;EAE3C,aAAa;;;;;EAKb,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;CAInC,CAAA;AACD,CAAC"}

package/dist/server/export/markdown.d.ts

@@ -0,0 +1,51 @@
+/**
+ * A page as Markdown, written from the page document rather than from HTML.
+ *
+ * Two writers, one source. `renderPageDoc` next door draws the same document as HTML; this one draws
+ * it as Markdown, and both read the stored `PageDoc`. Converting the HTML instead would have been
+ * less code and would have thrown away everything a heading, a task and a table know about
+ * themselves — an `<h2>` is a heading, but a `<ul class="kern-tasks">` full of disabled checkboxes is
+ * not a task list to anything that reads it back.
+ *
+ * **Round-tripping is the requirement, not prettiness.** A heading, a list, a table, a code block, a
+ * callout and a task list have to come back as themselves when the file is imported again, so every
+ * one of them is written in the dialect an importer can recognise without guessing:
+ *
+ *   - tables and task lists are GitHub-flavoured Markdown, because that is what every reader
+ *     implements and what an import will parse;
+ *   - a callout is a blockquote with a GitHub alert marker — `> [!WARNING]` — carrying Quire's own
+ *     tone name, so it re-reads as the same callout here and degrades to an ordinary blockquote
+ *     anywhere else. A `<div data-callout>` would round-trip too and would be a raw HTML block in
+ *     every other reader;
+ *   - underline and highlight have no Markdown at all and are written as `<u>` and `<mark>`, which
+ *     is inline HTML a Markdown parser passes through rather than a syntax it will mangle.
+ *
+ * `PAGE_DOC_NODES` is the list this has to cover, the same list `render.ts` is held to, and
+ * `export.int.test.ts` compares this file's table against it in both directions. A node with no
+ * writer here does not degrade quietly — it would lose somebody's table.
+ */
+import type { PageDoc } from '@kernhq/ui/editor/page-doc';
+export interface MarkdownOptions {
+    /**
+     * Where the picture with this id sits *relative to the file being written* — `media/diagram.png`.
+     *
+     * Never a signed storage URL. A presigned GET is the object's key, so it carries the tenant's
+     * workspace uuid and the file's uuid, and it stops working an hour after it is minted: writing one
+     * into a file somebody keeps is both a leak and a broken picture. A picture with no answer here is
+     * dropped, exactly as the HTML renderer drops it.
+     */
+    fileSrc?: (fileId: string) => string | null;
+    /** Where another exported page sits relative to this one. Without one, a mention stays as text. */
+    pageHref?: (pageId: string) => string | null;
+}
+/** Every node type this file can write, for the test that compares it against `PAGE_DOC_NODES`. */
+export declare const MARKDOWN_NODES: readonly string[];
+/**
+ * A stored page as Markdown. An empty or unreadable document is an empty string, never a throw.
+ *
+ * The title is not written here. A page's title is a column, not a node in its document, so whether
+ * it becomes an `# H1` at the top is a decision about the file — and the file writer next door makes
+ * it, once, for both formats.
+ */
+export declare function pageDocToMarkdown(doc: PageDoc | null | undefined, options?: MarkdownOptions): string;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/server/export/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/server/export/markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,OAAO,EAA4B,MAAM,4BAA4B,CAAA;AAEnF,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IAC3C,mGAAmG;IACnG,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;CAC7C;AAsUD,mGAAmG;AACnG,eAAO,MAAM,cAAc,EAAE,SAAS,MAAM,EAE3C,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,GAAE,eAAoB,GAAG,MAAM,CAKxG"}

package/dist/server/export/markdown.js

@@ -0,0 +1,312 @@
+/**
+ * What a Markdown reader would otherwise take as syntax.
+ *
+ * Deliberately not every character CommonMark lists. Escaping `.`, `+`, `(` and `)` everywhere turns
+ * an ordinary sentence into a thicket of backslashes, and they are only meaningful at the start of a
+ * line or inside a link — both of which are handled where they arise. What is escaped here is what
+ * changes the meaning of a sentence wherever it appears.
+ */
+const escapeInline = (text) => text.replace(/([\\`*_[\]<>|~])/g, '\\$1');
+/**
+ * A line that would start a block if it were left alone — a paragraph beginning `- ` or `# `.
+ *
+ * The ordered-list case is separate because the escape goes in a different place. `\1. ` is not an
+ * escape at all: a backslash before anything that is not punctuation is a literal backslash, so it
+ * would print one and still start a list. `1\. ` is the one that works.
+ */
+const escapeLineStart = (line) => line
+    .replace(/^(\s*)(>|#{1,6}(?=\s)|[-*+](?=\s))/, '$1\\$2')
+    .replace(/^(\s*)(\d{1,9})([.)])(?=\s)/, '$1$2\\$3');
+/** Every character in the node, ignoring marks. What a fence and a `<pre>` want. */
+function textOf(node) {
+    if (typeof node.text === 'string')
+        return node.text;
+    return (node.content ?? []).map(textOf).join('');
+}
+/**
+ * The marks, applied so the result parses.
+ *
+ * Order matters and is not alphabetical. `code` goes on first because a code span's content is
+ * literal — `**bold**` inside backticks is four asterisks and a word — and `link` goes on last
+ * because a link's label may hold everything else and nothing may hold a link.
+ */
+function applyMarks(text, marks) {
+    const has = (type) => (marks ?? []).some((m) => m?.type === type);
+    let out = has('code') ? codeSpan(text) : escapeInline(text);
+    if (has('highlight'))
+        out = `<mark>${out}</mark>`;
+    if (has('strike'))
+        out = `~~${out}~~`;
+    if (has('underline'))
+        out = `<u>${out}</u>`;
+    if (has('italic'))
+        out = `*${out}*`;
+    if (has('bold'))
+        out = `**${out}**`;
+    const link = (marks ?? []).find((m) => m?.type === 'link');
+    if (link) {
+        const href = typeof link.attrs?.href === 'string' ? link.attrs.href : '';
+        if (href)
+            out = `[${out}](${encodeLinkTarget(href)})`;
+    }
+    return out;
+}
+/** A code span whose fence is longer than any run of backticks inside it, so it closes where it should. */
+function codeSpan(text) {
+    const longest = Math.max(0, ...[...text.matchAll(/`+/g)].map((m) => m[0].length));
+    const fence = '`'.repeat(longest + 1);
+    const pad = text.startsWith('`') || text.endsWith('`') ? ' ' : '';
+    return `${fence}${pad}${text}${pad}${fence}`;
+}
+/** Parentheses and whitespace are what break an inline link target; angle brackets fix both. */
+const encodeLinkTarget = (href) => /[\s()<>]/.test(href) ? `<${href.replaceAll('>', '%3E')}>` : href;
+function inline(nodes, options) {
+    return (nodes ?? [])
+        .map((node) => {
+        if (typeof node.text === 'string')
+            return applyMarks(node.text, node.marks);
+        const writer = INLINE_WRITERS[node.type ?? ''];
+        if (writer)
+            return writer(node, options);
+        // An inline node with no writer keeps its text rather than vanishing mid-sentence.
+        return escapeInline(textOf(node));
+    })
+        .join('');
+}
+const INLINE_WRITERS = {
+    // Two trailing spaces is the line break every Markdown reader implements; a backslash is CommonMark
+    // only, and an importer that is not CommonMark would keep the backslash as a character.
+    hardBreak: () => '  \n',
+    text: (node) => escapeInline(node.text ?? ''),
+    /**
+     * A person, as `@Ada` — **and this one does not come back.**
+     *
+     * Stated here because it is the one construct in the writer that is knowingly lossy, and a reader
+     * of this table would otherwise assume the pairing with `import/markdown.ts` is total. A page
+     * mention resolves against a path in the same archive, so the reader can rebuild it; a person
+     * resolves against a *user id*, which is a fact about the instance the export came from. The two
+     * spellings that would carry it are both worse than the loss: putting the id in the file makes an
+     * export identify people, and importing it would mint a mention of a stranger's id in a workspace
+     * that never had that person. So this writes what a mention reads as — the name — and it re-imports
+     * as prose. There is no report row for it either, because by then it is a run of text and nothing
+     * can tell it from one somebody typed.
+     */
+    mention: (node) => `@${escapeInline(String(node.attrs?.label ?? ''))}`,
+    pageMention: (node, options) => {
+        const label = escapeInline(String(node.attrs?.label ?? '') || 'Untitled');
+        const id = typeof node.attrs?.id === 'string' ? node.attrs.id : '';
+        const href = id ? (options.pageHref?.(id) ?? null) : null;
+        // A page that is not in this export cannot be linked to, and a dead link is worse than a name.
+        return href ? `[${label}](${encodeLinkTarget(href)})` : label;
+    },
+    image: (node, options) => {
+        const fileId = typeof node.attrs?.fileId === 'string' ? node.attrs.fileId : null;
+        const resolved = fileId ? (options.fileSrc?.(fileId) ?? null) : null;
+        const src = resolved ?? (typeof node.attrs?.src === 'string' ? node.attrs.src : null);
+        if (!src)
+            return '';
+        const alt = escapeInline(typeof node.attrs?.alt === 'string' ? node.attrs.alt : '');
+        const title = typeof node.attrs?.title === 'string' && node.attrs.title ? node.attrs.title : null;
+        return `![${alt}](${encodeLinkTarget(src)}${title ? ` "${title.replaceAll('"', '\\"')}"` : ''})`;
+    },
+};
+/**
+ * Prefix every line, including the blank ones — which is what makes a nested blockquote hold.
+ *
+ * A blank line gets the prefix trimmed (`>` rather than `> `) and a line with content does not, so
+ * the two trailing spaces that mean "line break" survive. Trimming every line would delete them and
+ * silently join two lines of an address.
+ */
+const prefixLines = (text, first, rest = first) => text
+    .split('\n')
+    .map((line, i) => line.length === 0 ? (i === 0 ? first : rest).trimEnd() : `${i === 0 ? first : rest}${line}`)
+    .join('\n');
+/** Blocks, separated by the blank line that keeps them separate blocks. */
+function blocks(nodes, options) {
+    return (nodes ?? [])
+        .map((node) => block(node, options))
+        .filter((text) => text.length > 0)
+        .join('\n\n');
+}
+function block(node, options) {
+    const writer = BLOCK_WRITERS[node.type ?? ''];
+    if (writer)
+        return writer(node, options);
+    // Unreachable while the test below holds, and correct if a newer image writes a node this one has
+    // never heard of: keep the children rather than losing a paragraph to an unknown wrapper.
+    return blocks(node.content, options);
+}
+/**
+ * A list, whose marker depends on the list and whose continuation depends on the marker.
+ *
+ * Every line after the first is indented by the marker's own width, or the reader ends the item and
+ * starts a paragraph — which is how a two-paragraph bullet becomes a bullet and an orphan.
+ */
+function list(node, options, markerFor) {
+    return (node.content ?? [])
+        .map((item, index) => {
+        const marker = markerFor(index);
+        const body = blocks(item.content, options);
+        // An empty bullet is still a bullet somebody typed, so the marker survives on its own.
+        return body ? prefixLines(body, marker, ' '.repeat(marker.length)) : marker.trimEnd();
+    })
+        .join('\n');
+}
+/** `info` | `note` | `success` | `warning` | `danger`, upper-cased into a GitHub alert marker. */
+const CALLOUT_TONES = new Set(['info', 'note', 'success', 'warning', 'danger']);
+/**
+ * Escape the pipes a cell still has, and only those.
+ *
+ * `escapeInline` already escaped every pipe in ordinary prose, so a blind `replaceAll` would double
+ * them — `Pipe \| here` becomes `Pipe \\| here`, which renders as a backslash and *then* ends the
+ * cell. What is left unescaped is a pipe inside a code span, where escaping is deliberately not
+ * applied — and GFM says a table cell escapes those too, code span or not. So this walks the string,
+ * steps over anything already escaped, and escapes what remains.
+ */
+function escapePipes(text) {
+    let out = '';
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '\\' && i + 1 < text.length) {
+            out += ch + text[i + 1];
+            i++;
+            continue;
+        }
+        out += ch === '|' ? '\\|' : ch;
+    }
+    return out;
+}
+/**
+ * One cell of a GFM table.
+ *
+ * A cell is inline only — the format has no way to hold a second paragraph — so a paragraph break
+ * becomes `<br><br>`. Losing the block structure inside a cell is the format's limit, and saying so
+ * here is better than a table that stops being a table at the first newline.
+ *
+ * The whitespace before each newline goes with it, and that is not tidiness. A hard break is written
+ * `  \n` — two spaces are what makes it a break in prose — so leaving them in front of the `<br>`
+ * hands the importer a cell whose text ends in two spaces it never had. They are invisible in every
+ * rendering and they *accumulate*: three export-import cycles turned `a` into `a` and six spaces.
+ */
+const tableCell = (cell, options) => escapePipes((blocks(cell.content, options) || '')
+    .replace(/[ \t]*\n{2,}/g, '<br><br>')
+    .replace(/[ \t]*\n/g, '<br>')
+    .trim());
+function table(node, options) {
+    const rows = (node.content ?? []).filter((row) => (row.content ?? []).length > 0);
+    if (rows.length === 0)
+        return '';
+    const width = Math.max(...rows.map((row) => (row.content ?? []).length));
+    const cellsOf = (row) => {
+        const cells = (row.content ?? []).map((cell) => tableCell(cell, options));
+        while (cells.length < width)
+            cells.push('');
+        return cells;
+    };
+    /*
+     * GFM has no table without a header row, so a table whose first row is ordinary cells still
+     * contributes one — its own first row. Emitting an empty header instead would put a blank band at
+     * the top of every table Quire exports, and shift every row's meaning by one on the way back in.
+     */
+    const [head, ...body] = rows;
+    const line = (cells) => `| ${cells.join(' | ')} |`;
+    return [
+        line(cellsOf(head)),
+        line(Array.from({ length: width }, () => '---')),
+        ...body.map((row) => line(cellsOf(row))),
+    ].join('\n');
+}
+const BLOCK_WRITERS = {
+    paragraph: (node, options) => escapeLineStart(inline(node.content, options)),
+    heading: (node, options) => {
+        const raw = Number(node.attrs?.level);
+        const level = Number.isInteger(raw) && raw >= 1 && raw <= 6 ? raw : 1;
+        return `${'#'.repeat(level)} ${inline(node.content, options)}`.trimEnd();
+    },
+    bulletList: (node, options) => list(node, options, () => '- '),
+    orderedList: (node, options) => {
+        const raw = Number(node.attrs?.start);
+        const start = Number.isInteger(raw) && raw > 0 ? raw : 1;
+        return list(node, options, (index) => `${start + index}. `);
+    },
+    listItem: (node, options) => blocks(node.content, options),
+    taskList: (node, options) => (node.content ?? [])
+        .map((item) => {
+        const marker = `- [${item.attrs?.checked === true ? 'x' : ' '}] `;
+        const body = blocks(item.content, options);
+        return body ? prefixLines(body, marker, ' '.repeat(marker.length)) : marker.trimEnd();
+    })
+        .join('\n'),
+    taskItem: (node, options) => blocks(node.content, options),
+    blockquote: (node, options) => prefixLines(blocks(node.content, options), '> '),
+    /**
+     * A GitHub alert: a blockquote whose first line names the tone.
+     *
+     * The tone is Quire's own word rather than GitHub's nearest equivalent, because the round trip
+     * matters more than the rendering on one website. `[!SUCCESS]` is not one of GitHub's five, so it
+     * renders there as a plain blockquote with a line of text at the top — which is a smaller loss
+     * than mapping `success` onto `TIP` and importing it back as the wrong colour.
+     */
+    callout: (node, options) => {
+        const tone = String(node.attrs?.tone ?? 'info');
+        const marker = CALLOUT_TONES.has(tone) ? tone : 'info';
+        return prefixLines(`[!${marker.toUpperCase()}]\n${blocks(node.content, options)}`, '> ');
+    },
+    codeBlock: (node) => {
+        const language = typeof node.attrs?.language === 'string' && /^[a-z0-9#+.-]{1,24}$/i.test(node.attrs.language)
+            ? node.attrs.language
+            : '';
+        const body = textOf(node);
+        // Longer than any run of backticks in the body, or a snippet about Markdown closes its own fence.
+        const longest = Math.max(2, ...[...body.matchAll(/^`{3,}/gm)].map((m) => m[0].length));
+        const fence = '`'.repeat(longest + 1);
+        return `${fence}${language}\n${body}\n${fence}`;
+    },
+    horizontalRule: () => '---',
+    table,
+    // A row or a cell reached on its own is inside a table that has already written it; reaching one
+    // here would mean a malformed document, and its text is better kept than dropped.
+    tableRow: (node, options) => blocks(node.content, options),
+    tableCell: (node, options) => blocks(node.content, options),
+    tableHeader: (node, options) => blocks(node.content, options),
+    /**
+     * A toggle, as the HTML block Markdown has no syntax for.
+     *
+     * The blank lines around the body are load-bearing: without them a Markdown reader treats
+     * everything between the tags as raw HTML and stops parsing the prose inside, so a bulleted list
+     * inside a toggle arrives as literal hyphens.
+     */
+    details: (node, options) => {
+        const summary = (node.content ?? []).find((child) => child.type === 'detailsSummary');
+        const rest = (node.content ?? []).filter((child) => child.type !== 'detailsSummary');
+        const title = summary ? inline(summary.content, options) : '';
+        return `<details>\n<summary>${title}</summary>\n\n${blocks(rest, options)}\n\n</details>`;
+    },
+    detailsSummary: (node, options) => inline(node.content, options),
+    detailsContent: (node, options) => blocks(node.content, options),
+    // Blocks in name only: both are inline nodes that can also stand alone as a whole block.
+    image: (node, options) => INLINE_WRITERS.image(node, options),
+    hardBreak: () => '',
+    mention: (node, options) => INLINE_WRITERS.mention(node, options),
+    pageMention: (node, options) => INLINE_WRITERS.pageMention(node, options),
+    text: (node) => escapeInline(node.text ?? ''),
+};
+/** Every node type this file can write, for the test that compares it against `PAGE_DOC_NODES`. */
+export const MARKDOWN_NODES = [
+    ...new Set(['doc', ...Object.keys(BLOCK_WRITERS), ...Object.keys(INLINE_WRITERS)]),
+];
+/**
+ * A stored page as Markdown. An empty or unreadable document is an empty string, never a throw.
+ *
+ * The title is not written here. A page's title is a column, not a node in its document, so whether
+ * it becomes an `# H1` at the top is a decision about the file — and the file writer next door makes
+ * it, once, for both formats.
+ */
+export function pageDocToMarkdown(doc, options = {}) {
+    if (!doc || !Array.isArray(doc.content))
+        return '';
+    return `${blocks(doc.content, options)
+        .replace(/\n{3,}/g, '\n\n')
+        .trim()}\n`;
+}
+//# sourceMappingURL=markdown.js.map