@tabnas/markdown 0.7.6 → 0.7.7

package/dist/markdown.d.ts

@@ -24,4 +24,6 @@ export type { DocumentNode, Block, HeadingNode, ParagraphNode, BlockquoteNode, L
 export { MdNode } from './node.ts';
 export type { ParserOptions } from './options.ts';
 export { renderHTML } from './html.ts';
-declare const VERSION = "0.7.6";
+export { translate } from './translate';
+export type { TranslationPart, TranslationParts } from './translate';
+declare const VERSION = "0.7.7";

package/dist/markdown.js

@@ -1,7 +1,7 @@
 "use strict";
 /* Copyright (c) 2021-2026 Richard Rodger, MIT License */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderHTML = exports.MdNode = exports.Markdown = exports.VERSION = void 0;
+exports.translate = exports.renderHTML = exports.MdNode = exports.Markdown = exports.VERSION = void 0;
 exports.parseDocument = parseDocument;
 exports.parseInline = parseInline;
 exports.toHtml = toHtml;
@@ -156,9 +156,11 @@ Object.defineProperty(exports, "MdNode", { enumerable: true, get: function () {
 // and the two runtimes' public surfaces did not match.
 var html_ts_2 = require("./html.js");
 Object.defineProperty(exports, "renderHTML", { enumerable: true, get: function () { return html_ts_2.renderHTML; } });
+var translate_1 = require("./translate");
+Object.defineProperty(exports, "translate", { enumerable: true, get: function () { return translate_1.translate; } });
 // VERSION is this package's version. It MUST equal package.json "version":
 // the release orchestrator rewrites both, and the version test fails the
 // build if they drift. Mirrors `const VERSION` in go/markdown.go.
-const VERSION = '0.7.6';
+const VERSION = '0.7.7';
 exports.VERSION = VERSION;
 //# sourceMappingURL=markdown.js.map

package/dist/markdown.js.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"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"}

package/dist/translate.d.ts

@@ -0,0 +1,12 @@
+type TranslationPart = Readonly<{
+    entry: string;
+    source?: string;
+}>;
+type TranslationParts = Readonly<{
+    manifest: string;
+    lift?: TranslationPart;
+    render?: TranslationPart;
+}>;
+declare function translate(): TranslationParts | undefined;
+export { translate, };
+export type { TranslationPart, TranslationParts, };

package/dist/translate.js

@@ -0,0 +1,335 @@
+"use strict";
+/* Copyright (c) 2021-2026 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translate = translate;
+const TRANSLATION = Object.freeze({
+    manifest: `{
+  "$schema": "https://tabnas.dev/schema/plugin.schema.json",
+  "name": "@tabnas/markdown",
+  "go": "github.com/tabnas/markdown/go",
+  "description": "CommonMark and GFM Markdown parsing for the tabnas engine.",
+  "engine": "@tabnas/parser",
+  "extensions": [
+    ".md",
+    ".markdown"
+  ],
+  "mediaTypes": [
+    "text/markdown"
+  ],
+  "languageId": "markdown",
+  "pluginKind": "grammar",
+  "specDir": "test/spec",
+  "clib": {
+    "dir": "go/clib",
+    "library": "libtabnasmarkdown",
+    "abi": "v1",
+    "errorCodes": [
+      "usage",
+      "grammar",
+      "handle",
+      "internal"
+    ]
+  },
+  "errorCodes": [],
+  "docs": "https://tabnas.dev/docs/packages",
+  "repository": "https://github.com/tabnas/markdown",
+  "versionSource": "ts/package.json",
+  "translate": {
+    "reads": [
+      "records",
+      "tree"
+    ],
+    "writes": "records",
+    "lift": "alchemy/lift.alc",
+    "render": "alchemy/render.alc",
+    "loss": [
+      "Only a document holding one table is read as records: a document with no table, or with more than one, is refused.",
+      "Inline markup in a cell is flattened to its text when it is read, an image to its alt text, and a written cell is plain text, so text that spells inline markup reads back as that markup.",
+      "Column alignment is not kept.",
+      "A line break in a cell is written as a space.",
+      "Leading and trailing spaces in a cell are not kept.",
+      "A U+0000 in a cell is written as it is, and the reader replaces it with U+FFFD when the table is read back."
+    ]
+  }
+}
+`,
+    lift: Object.freeze({ entry: "markdown-lift", source: `; Markdown's lift: a document's events, as the reader builds them, read
+; as a table's records: the TableRows protocol the standard library's
+; \`table-from-json\` answers, one \`schema\`, a \`row\` per record and
+; \`table-end\`. This is a library of definitions, each named
+; \`markdown-...\`, which a host links with its own program (alchemy's
+; \`compile_sources\`); its entry point is \`markdown-lift\`, and nothing
+; else here is the host's to call.
+;
+; The reader's tree is mdast's shape: a \`document\` whose \`children\` are
+; blocks, a \`table\` among them whose \`children\` are \`tableRow\`s of
+; \`tableCell\`s, and each cell's \`children\` the inline nodes of its text:
+; \`text\`, \`inlineCode\` and \`html\` with a \`value\`, \`image\` with an \`alt\`,
+; and \`emphasis\`, \`strong\`, \`link\` and the rest with \`children\` of their
+; own. \`type\` is each node's first member. The lift takes the first
+; row's cells as the column labels and every later row as a record, and
+; reads nothing else of the document: not the blocks around the table,
+; and not the table's \`align\`. A cell is the text under it, every
+; \`value\` and every image's \`alt\` in order, joined into one string
+; (\`string-join\`, which alchemy has for this lift: \`concat\` and \`join\`
+; answer a text, which a cell may not be), so inline markup is
+; flattened to its text and an image to its alt text, and every cell is
+; a string, as the CSV reader's records are: an empty cell is "", and a
+; cell of text beside emphasis, a link, an image, inline HTML or an
+; autolink is their texts run together, \`Bob *b*\` as \`Bob b\`.
+;
+; The document must hold exactly one table: a second table, or none by
+; the end, is a failure (INPUT_INVALID) that says so, since a Markdown
+; document is read as records through its table and nothing else.
+;
+; The state is one vector, [stack phase seen in-cell runs cells]:
+;   stack    the open containers, one marker each: \`:array\`, \`:node\` for
+;            an object whose type is not known yet or is any other node,
+;            and \`:table\`, \`:row\` or \`:cell\` once its \`type\` has named
+;            one, so that its end is known when its object ends;
+;   phase    \`:before\` the table, \`:header\` inside it until its first
+;            row ends, \`:body\` once the schema is written, \`:after\` it;
+;   seen     what the last key was, \`:type\`, \`:text\` (a \`value\` or an
+;            \`alt\`) or \`:other\`, so that the scalar after it is classified;
+;   in-cell  whether a cell is open, so that text under it is the cell's;
+;   runs     the open cell's runs of text, in order;
+;   cells    the open row's cells, as wide as one row.
+; It grows with the document's nesting and with one row's width, never
+; with the table's length: a row is emitted when its object ends and
+; dropped. Events no tree has (a key outside an object, an end with
+; nothing open) fail with INPUT_INVALID, saying so.
+
+; A column record of the TableRows protocol, as the standard library's
+; \`public-column\` makes one.
+def markdown-column [label]
+  record
+    entry :label label
+
+; A cell's text: its runs, in order, as one string.
+def markdown-cell-text [runs]
+  string-join "" runs
+
+; A \`value\` or an image's \`alt\` under a cell, which the reader's tree
+; makes a string.
+def markdown-run [value]
+  match (kind value)
+    case :string value
+    case _ (fail "a node's value or alt under a table cell is not a string, which the reader's tree never has")
+
+; What the scalar after a key is: the one after \`type\` names the node,
+; the one after \`value\` (a text, code or HTML node's text) or \`alt\` (an
+; image's alt text) is a run of text, any other is neither.
+def markdown-seen [name]
+  match name
+    case "type" :type
+    case "value" :text
+    case "alt" :text
+    case _ :other
+
+; The top marker, or \`:none\` with nothing open.
+def markdown-top [stack]
+  match (count stack)
+    case 0 :none
+    case _ (top stack)
+
+; The open object's marker, once its \`type\` has named it.
+def markdown-mark [marker stack]
+  push marker (pop stack)
+
+; The scalar after \`type\`: the three nodes the lift reads leave their
+; marker on the stack and move the phase; any other node is \`:node\`.
+def markdown-node [name stack phase in-cell runs cells]
+  match name
+    case "table"
+      match phase
+        case :before (transition [(markdown-mark :table stack) :header :other in-cell runs cells] [])
+        case :after (fail "the document holds a second table, and only a document of one table is read as records")
+        case _ (fail "the events hold a table inside a table, which the reader's tree never has")
+    case "tableRow"
+      match phase
+        case :before (fail "the events hold a table row outside a table, which the reader's tree never has")
+        case :after (fail "the events hold a table row outside a table, which the reader's tree never has")
+        case _ (transition [(markdown-mark :row stack) phase :other in-cell runs []] [])
+    case "tableCell"
+      match phase
+        case :before (fail "the events hold a table cell outside a table, which the reader's tree never has")
+        case :after (fail "the events hold a table cell outside a table, which the reader's tree never has")
+        case _
+          if in-cell
+            fail "the events hold a table cell inside a cell, which the reader's tree never has"
+            transition [(markdown-mark :cell stack) phase :other true [] cells] []
+    case _ (transition [stack phase :other in-cell runs cells] [])
+
+; An object's end: a cell joins its row, a row is the schema or a
+; record, the table is done, and any other node is dropped.
+def markdown-close [stack phase in-cell runs cells]
+  match (markdown-top stack)
+    case :cell
+      transition [(pop stack) phase :other false [] (push (markdown-cell-text runs) cells)] []
+    case :row
+      match phase
+        case :header
+          transition [(pop stack) :body :other in-cell runs []] [(schema (map markdown-column cells))]
+        case _
+          transition [(pop stack) phase :other in-cell runs []] [(row cells)]
+    case :table
+      transition [(pop stack) :after :other in-cell runs cells] []
+    case :node
+      transition [(pop stack) phase :other in-cell runs cells] []
+    case _ (fail "the events end an object that is not open, which a tree's never do")
+
+def markdown-event [stack phase seen in-cell runs cells event]
+  match event
+    case object-start
+      transition [(push :node stack) phase :other in-cell runs cells] []
+    case array-start
+      transition [(push :array stack) phase :other in-cell runs cells] []
+    case (key name)
+      match (markdown-top stack)
+        case :none (fail "the events hold a key outside an object, which a tree's never do")
+        case :array (fail "the events hold a key inside an array, which a tree's never do")
+        case _ (transition [stack phase (markdown-seen name) in-cell runs cells] [])
+    case (scalar value)
+      match seen
+        case :type (markdown-node value stack phase in-cell runs cells)
+        case :text
+          if in-cell
+            transition [stack phase :other in-cell (push (markdown-run value) runs) cells] []
+            transition [stack phase :other in-cell runs cells] []
+        case _ (transition [stack phase :other in-cell runs cells] [])
+    case object-end (markdown-close stack phase in-cell runs cells)
+    case array-end
+      match (markdown-top stack)
+        case :array (transition [(pop stack) phase :other in-cell runs cells] [])
+        case _ (fail "the events end an array that is not open, which a tree's never do")
+
+def markdown-lift-step [s event]
+  match s
+    case [stack phase seen in-cell runs cells]
+      markdown-event stack phase seen in-cell runs cells event
+
+def markdown-lift-finish [s]
+  match s
+    case [stack phase seen in-cell runs cells]
+      match phase
+        case :after
+          match (count stack)
+            case 0 [table-end]
+            case _ (fail "the events ended inside a container, which a tree's never do")
+        case :before (fail "the document holds no table, and only a document of one table is read as records")
+        case _ (fail "the events ended inside the table, which a tree's never do")
+
+; The lift: the document's events in, the table's records out.
+def markdown-lift [input]
+  scan-emit [[] :before :other false [] []] markdown-lift-step markdown-lift-finish (events input)
+` }),
+    render: Object.freeze({ entry: "markdown-render", source: `; Markdown's render: a table's records, the TableRows protocol (one
+; \`schema\`, a \`row\` per record and \`table-end\`), written as one GFM pipe
+; table. This is a library of definitions, each named \`markdown-...\`,
+; which a host links with its own program (alchemy's \`compile_sources\`);
+; its entry point is \`markdown-render\`, and nothing else here is the
+; host's to call.
+;
+; The table is the header row, \`| Name | Age |\`, the delimiter row,
+; \`| --- | --- |\`, and a row per record, each line ended by a line feed
+; and every cell between \`| \` and \` |\`. A cell is its value's text as
+; the CSV renderer writes it (\`scalar-text\`: a string as it is, a number
+; by its lexeme, a boolean by its name, null and a missing cell as
+; nothing, a vector or a record as its compact JSON text), with every
+; backslash doubled and every pipe escaped as \`\\|\`, which the reader
+; turns back into the characters (the reader's split skips the byte
+; after a backslash, so the pipe's escape holds only when a backslash
+; before it is itself escaped), and every line break replaced by a
+; space, since a row is one line. No other character is escaped: the
+; render cannot look at one (alchemy has no character test), so a cell
+; is plain text, and text that spells inline markup reads back as that
+; markup. A U+0000 in a cell is written as it is for the same reason,
+; and the reader replaces it with U+FFFD, as CommonMark asks of every
+; reader; the loss declaration says so. Alignment is not written: every
+; column's delimiter is \`---\`.
+;
+; The state is one marker: \`:start\` before the schema, the schema's
+; width (a number) while rows may follow, and \`:ended\` after
+; \`table-end\`, so that a stream which breaks the protocol (a row before
+; the schema, a second schema, a row of another width, anything after
+; the end, no end) fails with INPUT_INVALID, saying so, rather than
+; being written. The check is this file's rather than \`csv-table\`'s,
+; whose refusals speak of CSV. A schema of no columns fails too: a row
+; needs at least one cell, so such a table has no Markdown form.
+
+; What \`scalar-text\` reads: null and a missing cell are written as
+; nothing, where the CSV renderer's \`csv-options\` map a missing cell to
+; an error.
+def markdown-options
+  record
+    entry :null-text ""
+    entry :missing ""
+
+; A cell's text, as it stands between the pipes.
+def markdown-cell [cell]
+  replace-text "\\r" " "
+    replace-text "\\n" " "
+      replace-text "\\r\\n" " "
+        replace-text "|" "\\\\|"
+          replace-text "\\\\" "\\\\\\\\"
+            scalar-text markdown-options cell
+
+def markdown-label [column]
+  markdown-cell (get :label column)
+
+; One row of the table, cells in order.
+def markdown-line [cells]
+  concat
+    "| "
+    join " | " cells
+    " |\\n"
+
+; The delimiter row under the header, one \`---\` per column.
+def markdown-delimiter [width]
+  concat
+    repeat width "| --- "
+    "|\\n"
+
+def markdown-render-step [s event]
+  match event
+    case (schema columns)
+      match s
+        case :start
+          match (count columns)
+            case 0 (fail "a table of no columns has no Markdown form: a row needs at least one cell")
+            case _
+              transition (count columns)
+                vector
+                  markdown-line (map markdown-label columns)
+                  markdown-delimiter (count columns)
+        case _ (fail "the events hold a second schema, where a table's hold one")
+    case (row cells)
+      match s
+        case :start (fail "the events hold a row before the schema, which a table's never do")
+        case :ended (fail "the events hold a row after table-end, which a table's never do")
+        case _
+          match (compare (count cells) s)
+            case :equal (transition s [(markdown-line (map markdown-cell cells))])
+            case _ (fail "the events hold a row that is not as wide as the schema, which a table's never do")
+    case table-end
+      match s
+        case :start (fail "the events end before the schema, which a table's never do")
+        case :ended (fail "the events hold a second table-end, which a table's never do")
+        case _ (transition :ended [])
+
+def markdown-render-finish [s]
+  match s
+    case :ended []
+    case :start (fail "the events hold no schema, where a table's hold one first")
+    case _ (fail "the events ended before table-end, which a table's never do")
+
+; The render: the table's records in, the pipe table's text out.
+def markdown-render [input]
+  join ""
+    scan-emit :start markdown-render-step markdown-render-finish input
+` })
+});
+function translate() {
+    return TRANSLATION;
+}
+//# sourceMappingURL=translate.js.map

package/dist/translate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"translate.js","sourceRoot":"","sources":["../src/translate.ts"],"names":[],"mappings":";AAAA,yDAAyD;;QA6VvD,SAAS;AA7UX,MAAM,WAAW,GAAqB,MAAM,CAAC,MAAM,CAAC;IAClD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDX;IACC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyKvD,EAAE,CAAC;IACF,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwG3D,EAAE,CAAC;CACH,CAAC,CAAA;AAEF,SAAS,SAAS;IAChB,OAAO,WAAW,CAAA;AACpB,CAAC"}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"version":"7.0.2","root":["../src/ast.ts","../src/block.ts","../src/common.ts","../src/commonmark.ts","../src/engine-block.ts","../src/engine-inline.ts","../src/entities.ts","../src/html.ts","../src/inline.ts","../src/markdown.ts","../src/node.ts","../src/options.ts"],"packageJsons":["../node_modules/@tabnas/parser/package.json","../package.json"],"missingPackageJsons":["../node_modules/@tabnas/parser/dist/package.json"]}
+{"version":"7.0.2","root":["../src/ast.ts","../src/block.ts","../src/common.ts","../src/commonmark.ts","../src/engine-block.ts","../src/engine-inline.ts","../src/entities.ts","../src/html.ts","../src/inline.ts","../src/markdown.ts","../src/node.ts","../src/options.ts","../src/translate.ts"],"packageJsons":["../node_modules/@tabnas/parser/package.json","../package.json"],"missingPackageJsons":["../node_modules/@tabnas/parser/dist/package.json"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tabnas/markdown",
-  "version": "0.7.6",
-  "description": "A Tabnas parser plugin for CommonMark/GFM Markdown \u2014 headings, lists, blockquotes, code, emphasis, links and more, into a JSON AST.",
+  "version": "0.7.7",
+  "description": "A Tabnas parser plugin for CommonMark/GFM Markdown — headings, lists, blockquotes, code, emphasis, links and more, into a JSON AST.",
   "main": "dist/markdown.js",
   "type": "commonjs",
   "types": "dist/markdown.d.ts",
@@ -30,7 +30,8 @@
     "pretest-watch": "npm run build",
     "test-watch": "node --test --watch dist-test/markdown.test.js",
     "watch": "tsc --build src test -w",
-    "build": "tsc --build src && tsc --build test",
+    "embed": "node embed-translate.js",
+    "build": "npm run embed && tsc --build src && tsc --build test",
     "clean": "rm -rf node_modules dist dist-test yarn.lock package-lock.json",
     "reset": "npm run clean && npm i && npm run build && npm test",
     "repo-tag": "REPO_VERSION=`node -e \"console.log(require('./package').version)\"` && echo TAG: ts/v$REPO_VERSION && git commit -a -m v$REPO_VERSION && git push && git tag ts/v$REPO_VERSION && git push origin ts/v$REPO_VERSION;",

package/src/markdown.ts

@@ -230,7 +230,10 @@ export type { ParserOptions } from './options.ts'
 // and the two runtimes' public surfaces did not match.
 export { renderHTML } from './html.ts'
 
+export { translate } from './translate'
+export type { TranslationPart, TranslationParts } from './translate'
+
 // VERSION is this package's version. It MUST equal package.json "version":
 // the release orchestrator rewrites both, and the version test fails the
 // build if they drift. Mirrors `const VERSION` in go/markdown.go.
-const VERSION = '0.7.6'
+const VERSION = '0.7.7'

package/src/translate.ts

@@ -0,0 +1,356 @@
+/* Copyright (c) 2021-2026 Richard Rodger, MIT License */
+
+// Generated by ../embed-translate.js. Edit tabnas.plugin.json or alchemy/*,
+// then run npm run embed.
+
+type TranslationPart = Readonly<{
+  entry: string
+  source?: string
+}>
+
+type TranslationParts = Readonly<{
+  manifest: string
+  lift?: TranslationPart
+  render?: TranslationPart
+}>
+
+const TRANSLATION: TranslationParts = Object.freeze({
+  manifest: `{
+  "$schema": "https://tabnas.dev/schema/plugin.schema.json",
+  "name": "@tabnas/markdown",
+  "go": "github.com/tabnas/markdown/go",
+  "description": "CommonMark and GFM Markdown parsing for the tabnas engine.",
+  "engine": "@tabnas/parser",
+  "extensions": [
+    ".md",
+    ".markdown"
+  ],
+  "mediaTypes": [
+    "text/markdown"
+  ],
+  "languageId": "markdown",
+  "pluginKind": "grammar",
+  "specDir": "test/spec",
+  "clib": {
+    "dir": "go/clib",
+    "library": "libtabnasmarkdown",
+    "abi": "v1",
+    "errorCodes": [
+      "usage",
+      "grammar",
+      "handle",
+      "internal"
+    ]
+  },
+  "errorCodes": [],
+  "docs": "https://tabnas.dev/docs/packages",
+  "repository": "https://github.com/tabnas/markdown",
+  "versionSource": "ts/package.json",
+  "translate": {
+    "reads": [
+      "records",
+      "tree"
+    ],
+    "writes": "records",
+    "lift": "alchemy/lift.alc",
+    "render": "alchemy/render.alc",
+    "loss": [
+      "Only a document holding one table is read as records: a document with no table, or with more than one, is refused.",
+      "Inline markup in a cell is flattened to its text when it is read, an image to its alt text, and a written cell is plain text, so text that spells inline markup reads back as that markup.",
+      "Column alignment is not kept.",
+      "A line break in a cell is written as a space.",
+      "Leading and trailing spaces in a cell are not kept.",
+      "A U+0000 in a cell is written as it is, and the reader replaces it with U+FFFD when the table is read back."
+    ]
+  }
+}
+`,
+  lift: Object.freeze({ entry: "markdown-lift", source: `; Markdown's lift: a document's events, as the reader builds them, read
+; as a table's records: the TableRows protocol the standard library's
+; \`table-from-json\` answers, one \`schema\`, a \`row\` per record and
+; \`table-end\`. This is a library of definitions, each named
+; \`markdown-...\`, which a host links with its own program (alchemy's
+; \`compile_sources\`); its entry point is \`markdown-lift\`, and nothing
+; else here is the host's to call.
+;
+; The reader's tree is mdast's shape: a \`document\` whose \`children\` are
+; blocks, a \`table\` among them whose \`children\` are \`tableRow\`s of
+; \`tableCell\`s, and each cell's \`children\` the inline nodes of its text:
+; \`text\`, \`inlineCode\` and \`html\` with a \`value\`, \`image\` with an \`alt\`,
+; and \`emphasis\`, \`strong\`, \`link\` and the rest with \`children\` of their
+; own. \`type\` is each node's first member. The lift takes the first
+; row's cells as the column labels and every later row as a record, and
+; reads nothing else of the document: not the blocks around the table,
+; and not the table's \`align\`. A cell is the text under it, every
+; \`value\` and every image's \`alt\` in order, joined into one string
+; (\`string-join\`, which alchemy has for this lift: \`concat\` and \`join\`
+; answer a text, which a cell may not be), so inline markup is
+; flattened to its text and an image to its alt text, and every cell is
+; a string, as the CSV reader's records are: an empty cell is "", and a
+; cell of text beside emphasis, a link, an image, inline HTML or an
+; autolink is their texts run together, \`Bob *b*\` as \`Bob b\`.
+;
+; The document must hold exactly one table: a second table, or none by
+; the end, is a failure (INPUT_INVALID) that says so, since a Markdown
+; document is read as records through its table and nothing else.
+;
+; The state is one vector, [stack phase seen in-cell runs cells]:
+;   stack    the open containers, one marker each: \`:array\`, \`:node\` for
+;            an object whose type is not known yet or is any other node,
+;            and \`:table\`, \`:row\` or \`:cell\` once its \`type\` has named
+;            one, so that its end is known when its object ends;
+;   phase    \`:before\` the table, \`:header\` inside it until its first
+;            row ends, \`:body\` once the schema is written, \`:after\` it;
+;   seen     what the last key was, \`:type\`, \`:text\` (a \`value\` or an
+;            \`alt\`) or \`:other\`, so that the scalar after it is classified;
+;   in-cell  whether a cell is open, so that text under it is the cell's;
+;   runs     the open cell's runs of text, in order;
+;   cells    the open row's cells, as wide as one row.
+; It grows with the document's nesting and with one row's width, never
+; with the table's length: a row is emitted when its object ends and
+; dropped. Events no tree has (a key outside an object, an end with
+; nothing open) fail with INPUT_INVALID, saying so.
+
+; A column record of the TableRows protocol, as the standard library's
+; \`public-column\` makes one.
+def markdown-column [label]
+  record
+    entry :label label
+
+; A cell's text: its runs, in order, as one string.
+def markdown-cell-text [runs]
+  string-join "" runs
+
+; A \`value\` or an image's \`alt\` under a cell, which the reader's tree
+; makes a string.
+def markdown-run [value]
+  match (kind value)
+    case :string value
+    case _ (fail "a node's value or alt under a table cell is not a string, which the reader's tree never has")
+
+; What the scalar after a key is: the one after \`type\` names the node,
+; the one after \`value\` (a text, code or HTML node's text) or \`alt\` (an
+; image's alt text) is a run of text, any other is neither.
+def markdown-seen [name]
+  match name
+    case "type" :type
+    case "value" :text
+    case "alt" :text
+    case _ :other
+
+; The top marker, or \`:none\` with nothing open.
+def markdown-top [stack]
+  match (count stack)
+    case 0 :none
+    case _ (top stack)
+
+; The open object's marker, once its \`type\` has named it.
+def markdown-mark [marker stack]
+  push marker (pop stack)
+
+; The scalar after \`type\`: the three nodes the lift reads leave their
+; marker on the stack and move the phase; any other node is \`:node\`.
+def markdown-node [name stack phase in-cell runs cells]
+  match name
+    case "table"
+      match phase
+        case :before (transition [(markdown-mark :table stack) :header :other in-cell runs cells] [])
+        case :after (fail "the document holds a second table, and only a document of one table is read as records")
+        case _ (fail "the events hold a table inside a table, which the reader's tree never has")
+    case "tableRow"
+      match phase
+        case :before (fail "the events hold a table row outside a table, which the reader's tree never has")
+        case :after (fail "the events hold a table row outside a table, which the reader's tree never has")
+        case _ (transition [(markdown-mark :row stack) phase :other in-cell runs []] [])
+    case "tableCell"
+      match phase
+        case :before (fail "the events hold a table cell outside a table, which the reader's tree never has")
+        case :after (fail "the events hold a table cell outside a table, which the reader's tree never has")
+        case _
+          if in-cell
+            fail "the events hold a table cell inside a cell, which the reader's tree never has"
+            transition [(markdown-mark :cell stack) phase :other true [] cells] []
+    case _ (transition [stack phase :other in-cell runs cells] [])
+
+; An object's end: a cell joins its row, a row is the schema or a
+; record, the table is done, and any other node is dropped.
+def markdown-close [stack phase in-cell runs cells]
+  match (markdown-top stack)
+    case :cell
+      transition [(pop stack) phase :other false [] (push (markdown-cell-text runs) cells)] []
+    case :row
+      match phase
+        case :header
+          transition [(pop stack) :body :other in-cell runs []] [(schema (map markdown-column cells))]
+        case _
+          transition [(pop stack) phase :other in-cell runs []] [(row cells)]
+    case :table
+      transition [(pop stack) :after :other in-cell runs cells] []
+    case :node
+      transition [(pop stack) phase :other in-cell runs cells] []
+    case _ (fail "the events end an object that is not open, which a tree's never do")
+
+def markdown-event [stack phase seen in-cell runs cells event]
+  match event
+    case object-start
+      transition [(push :node stack) phase :other in-cell runs cells] []
+    case array-start
+      transition [(push :array stack) phase :other in-cell runs cells] []
+    case (key name)
+      match (markdown-top stack)
+        case :none (fail "the events hold a key outside an object, which a tree's never do")
+        case :array (fail "the events hold a key inside an array, which a tree's never do")
+        case _ (transition [stack phase (markdown-seen name) in-cell runs cells] [])
+    case (scalar value)
+      match seen
+        case :type (markdown-node value stack phase in-cell runs cells)
+        case :text
+          if in-cell
+            transition [stack phase :other in-cell (push (markdown-run value) runs) cells] []
+            transition [stack phase :other in-cell runs cells] []
+        case _ (transition [stack phase :other in-cell runs cells] [])
+    case object-end (markdown-close stack phase in-cell runs cells)
+    case array-end
+      match (markdown-top stack)
+        case :array (transition [(pop stack) phase :other in-cell runs cells] [])
+        case _ (fail "the events end an array that is not open, which a tree's never do")
+
+def markdown-lift-step [s event]
+  match s
+    case [stack phase seen in-cell runs cells]
+      markdown-event stack phase seen in-cell runs cells event
+
+def markdown-lift-finish [s]
+  match s
+    case [stack phase seen in-cell runs cells]
+      match phase
+        case :after
+          match (count stack)
+            case 0 [table-end]
+            case _ (fail "the events ended inside a container, which a tree's never do")
+        case :before (fail "the document holds no table, and only a document of one table is read as records")
+        case _ (fail "the events ended inside the table, which a tree's never do")
+
+; The lift: the document's events in, the table's records out.
+def markdown-lift [input]
+  scan-emit [[] :before :other false [] []] markdown-lift-step markdown-lift-finish (events input)
+` }),
+  render: Object.freeze({ entry: "markdown-render", source: `; Markdown's render: a table's records, the TableRows protocol (one
+; \`schema\`, a \`row\` per record and \`table-end\`), written as one GFM pipe
+; table. This is a library of definitions, each named \`markdown-...\`,
+; which a host links with its own program (alchemy's \`compile_sources\`);
+; its entry point is \`markdown-render\`, and nothing else here is the
+; host's to call.
+;
+; The table is the header row, \`| Name | Age |\`, the delimiter row,
+; \`| --- | --- |\`, and a row per record, each line ended by a line feed
+; and every cell between \`| \` and \` |\`. A cell is its value's text as
+; the CSV renderer writes it (\`scalar-text\`: a string as it is, a number
+; by its lexeme, a boolean by its name, null and a missing cell as
+; nothing, a vector or a record as its compact JSON text), with every
+; backslash doubled and every pipe escaped as \`\\|\`, which the reader
+; turns back into the characters (the reader's split skips the byte
+; after a backslash, so the pipe's escape holds only when a backslash
+; before it is itself escaped), and every line break replaced by a
+; space, since a row is one line. No other character is escaped: the
+; render cannot look at one (alchemy has no character test), so a cell
+; is plain text, and text that spells inline markup reads back as that
+; markup. A U+0000 in a cell is written as it is for the same reason,
+; and the reader replaces it with U+FFFD, as CommonMark asks of every
+; reader; the loss declaration says so. Alignment is not written: every
+; column's delimiter is \`---\`.
+;
+; The state is one marker: \`:start\` before the schema, the schema's
+; width (a number) while rows may follow, and \`:ended\` after
+; \`table-end\`, so that a stream which breaks the protocol (a row before
+; the schema, a second schema, a row of another width, anything after
+; the end, no end) fails with INPUT_INVALID, saying so, rather than
+; being written. The check is this file's rather than \`csv-table\`'s,
+; whose refusals speak of CSV. A schema of no columns fails too: a row
+; needs at least one cell, so such a table has no Markdown form.
+
+; What \`scalar-text\` reads: null and a missing cell are written as
+; nothing, where the CSV renderer's \`csv-options\` map a missing cell to
+; an error.
+def markdown-options
+  record
+    entry :null-text ""
+    entry :missing ""
+
+; A cell's text, as it stands between the pipes.
+def markdown-cell [cell]
+  replace-text "\\r" " "
+    replace-text "\\n" " "
+      replace-text "\\r\\n" " "
+        replace-text "|" "\\\\|"
+          replace-text "\\\\" "\\\\\\\\"
+            scalar-text markdown-options cell
+
+def markdown-label [column]
+  markdown-cell (get :label column)
+
+; One row of the table, cells in order.
+def markdown-line [cells]
+  concat
+    "| "
+    join " | " cells
+    " |\\n"
+
+; The delimiter row under the header, one \`---\` per column.
+def markdown-delimiter [width]
+  concat
+    repeat width "| --- "
+    "|\\n"
+
+def markdown-render-step [s event]
+  match event
+    case (schema columns)
+      match s
+        case :start
+          match (count columns)
+            case 0 (fail "a table of no columns has no Markdown form: a row needs at least one cell")
+            case _
+              transition (count columns)
+                vector
+                  markdown-line (map markdown-label columns)
+                  markdown-delimiter (count columns)
+        case _ (fail "the events hold a second schema, where a table's hold one")
+    case (row cells)
+      match s
+        case :start (fail "the events hold a row before the schema, which a table's never do")
+        case :ended (fail "the events hold a row after table-end, which a table's never do")
+        case _
+          match (compare (count cells) s)
+            case :equal (transition s [(markdown-line (map markdown-cell cells))])
+            case _ (fail "the events hold a row that is not as wide as the schema, which a table's never do")
+    case table-end
+      match s
+        case :start (fail "the events end before the schema, which a table's never do")
+        case :ended (fail "the events hold a second table-end, which a table's never do")
+        case _ (transition :ended [])
+
+def markdown-render-finish [s]
+  match s
+    case :ended []
+    case :start (fail "the events hold no schema, where a table's hold one first")
+    case _ (fail "the events ended before table-end, which a table's never do")
+
+; The render: the table's records in, the pipe table's text out.
+def markdown-render [input]
+  join ""
+    scan-emit :start markdown-render-step markdown-render-finish input
+` })
+})
+
+function translate (): TranslationParts | undefined {
+  return TRANSLATION
+}
+
+export {
+  translate,
+}
+
+export type {
+  TranslationPart,
+  TranslationParts,
+}