@thi.ng/hiccup-markdown 2.1.10 → 2.1.13

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2022-04-07T14:17:30Z
+- **Last updated**: 2022-06-09T16:14:01Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/hiccup-markdown",
-  "version": "2.1.10",
+  "version": "2.1.13",
   "description": "Markdown parser & serializer from/to Hiccup format",
   "type": "module",
   "module": "./index.js",
@@ -34,24 +34,24 @@
     "test": "testament test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.3.5",
-    "@thi.ng/arrays": "^2.2.1",
-    "@thi.ng/checks": "^3.1.5",
-    "@thi.ng/defmulti": "^2.1.5",
-    "@thi.ng/errors": "^2.1.5",
-    "@thi.ng/fsm": "^3.1.7",
-    "@thi.ng/hiccup": "^4.2.6",
-    "@thi.ng/strings": "^3.3.3",
-    "@thi.ng/text-canvas": "^2.3.1",
-    "@thi.ng/transducers": "^8.3.1"
+    "@thi.ng/api": "^8.3.7",
+    "@thi.ng/arrays": "^2.2.4",
+    "@thi.ng/checks": "^3.2.0",
+    "@thi.ng/defmulti": "^2.1.7",
+    "@thi.ng/errors": "^2.1.7",
+    "@thi.ng/fsm": "^3.1.10",
+    "@thi.ng/hiccup": "^4.2.8",
+    "@thi.ng/strings": "^3.3.5",
+    "@thi.ng/text-canvas": "^2.3.4",
+    "@thi.ng/transducers": "^8.3.4"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.19.4",
-    "@thi.ng/testament": "^0.2.5",
+    "@microsoft/api-extractor": "^7.25.0",
+    "@thi.ng/testament": "^0.2.8",
     "rimraf": "^3.0.2",
     "tools": "^0.0.1",
-    "typedoc": "^0.22.13",
-    "typescript": "^4.6.2"
+    "typedoc": "^0.22.17",
+    "typescript": "^4.7.3"
   },
   "keywords": [
     "ast",
@@ -95,5 +95,5 @@
     "status": "alpha",
     "year": 2018
   },
-  "gitHead": "542bf14bd0c7a56b4e6297718189eea772a824b7\n"
+  "gitHead": "9e516d30a1a537e027a6b3d78bf9121bc5831d31\n"
 }

package/parse.d.ts

@@ -4,5 +4,5 @@ import type { TagFactories } from "./api.js";
  * syntax matchers and state transition handlers. The returned parser
  * itself is only used in `index.ts`.
  */
-export declare const parse: (_tags?: Partial<TagFactories> | undefined) => import("@thi.ng/transducers").Transducer<string, any[]>;
+export declare const parse: (_tags?: Partial<TagFactories>) => import("@thi.ng/transducers").Transducer<string, any[]>;
 //# sourceMappingURL=parse.d.ts.map

package/parse.js

@@ -94,42 +94,42 @@ const collect = (id) => (ctx, buf) => {
     ctx.body += buf.join("");
     return [id];
 };
-const collectHeading = (tag) => (ctx) => [14 /* START */, [tag(ctx.hd, collectChildren(ctx))]];
-const collectAndRestart = (tag) => (ctx) => [14 /* START */, [tag(collectChildren(ctx))]];
+const collectHeading = (tag) => (ctx) => [14 /* State.START */, [tag(ctx.hd, collectChildren(ctx))]];
+const collectAndRestart = (tag) => (ctx) => [14 /* State.START */, [tag(collectChildren(ctx))]];
 const collectBlockQuote = (ctx) => (ctx.children.push(ctx.body, ["br", {}]),
     (ctx.body = ""),
-    [0 /* BLOCKQUOTE */]);
-const collectCodeBlock = (tag) => (ctx, body) => [14 /* START */, [tag(ctx.lang, body)]];
+    [0 /* State.BLOCKQUOTE */]);
+const collectCodeBlock = (tag) => (ctx, body) => [14 /* State.START */, [tag(ctx.lang, body)]];
 const collectLi = (ctx, tag) => ctx.container.push(tag(collectChildren(ctx)));
 const collectList = (type, list, item) => (ctx) => {
     collectLi(ctx, item);
-    return [14 /* START */, [list(type, ctx.container)]];
+    return [14 /* State.START */, [list(type, ctx.container)]];
 };
 const collectTD = (tag) => (ctx) => {
     ctx.children.push(ctx.body);
     ctx.container.push(tag(peek(ctx.stack).container.length, ctx.children));
-    return transition(ctx, 18 /* TABLE */);
+    return transition(ctx, 18 /* State.TABLE */);
 };
 const collectTR = (tag) => (ctx) => {
     const rows = peek(ctx.stack).container;
     rows.push(tag(rows.length, ctx.container));
     ctx.container = [];
-    return transition(ctx, 8 /* END_TABLE */);
+    return transition(ctx, 8 /* State.END_TABLE */);
 };
 const collectTable = (tag) => (ctx) => {
     const rows = ctx.stack.pop().container;
     rows.splice(1, 1);
-    return [14 /* START */, [tag(rows)]];
+    return [14 /* State.START */, [tag(rows)]];
 };
 const collectInline = (fn) => pop((ctx, body) => fn(ctx.body + body.trim()));
-const heading = (ctx, body) => ((ctx.hd = body.length), transition(ctx, 9 /* HEADING */));
+const heading = (ctx, body) => ((ctx.hd = body.length), transition(ctx, 9 /* State.HEADING */));
 const matchInline = (id) => [
-    str("![", push(id, 10 /* IMG */)),
-    str(LINK_LABEL, push(id, 11 /* LINK */)),
-    str(STRIKE, push(id, 16 /* STRIKE */)),
-    str(STRONG, push(id, 17 /* STRONG */)),
-    str(EM, push(id, 3 /* EMPHASIS */)),
-    str(CODE, push(id, 1 /* CODE */)),
+    str("![", push(id, 10 /* State.IMG */)),
+    str(LINK_LABEL, push(id, 11 /* State.LINK */)),
+    str(STRIKE, push(id, 16 /* State.STRIKE */)),
+    str(STRONG, push(id, 17 /* State.STRONG */)),
+    str(EM, push(id, 3 /* State.EMPHASIS */)),
+    str(CODE, push(id, 1 /* State.CODE */)),
 ];
 const matchLink = (result) => seq([
     untilStr(LINK_LABEL_END, (ctx, body) => ((ctx.title = body), undefined)),
@@ -140,18 +140,18 @@ const matchPara = (id, next) => alts([
     ...matchInline(id),
     str(NL, (ctx) => ((ctx.body += " "), [next])),
 ], collect(id));
-const newPara = (ctx, buf) => ((ctx.body = buf.join("")), (ctx.children = []), [13 /* PARA */]);
+const newPara = (ctx, buf) => ((ctx.body = buf.join("")), (ctx.children = []), [13 /* State.PARA */]);
 const newParaInline = (next) => (ctx) => {
-    ctx.stack.push({ id: 13 /* PARA */, children: [] });
+    ctx.stack.push({ id: 13 /* State.PARA */, children: [] });
     return transition(ctx, next);
 };
 const newParaCode = (ctx, x) => ((ctx.body = x[1]),
-    ctx.stack.push({ id: 13 /* PARA */, children: [] }),
-    [1 /* CODE */]);
-const newList = (ctx) => ((ctx.container = []), transition(ctx, 12 /* LI */));
-const newTable = (ctx) => (ctx.stack.push({ id: 18 /* TABLE */, container: [] }),
+    ctx.stack.push({ id: 13 /* State.PARA */, children: [] }),
+    [1 /* State.CODE */]);
+const newList = (ctx) => ((ctx.container = []), transition(ctx, 12 /* State.LI */));
+const newTable = (ctx) => (ctx.stack.push({ id: 18 /* State.TABLE */, container: [] }),
     (ctx.container = []),
-    transition(ctx, 18 /* TABLE */));
+    transition(ctx, 18 /* State.TABLE */));
 /**
  * Main parser / transducer. Defines state map with the various Markdown
  * syntax matchers and state transition handlers. The returned parser
@@ -160,64 +160,64 @@ const newTable = (ctx) => (ctx.stack.push({ id: 18 /* TABLE */, container: [] })
 export const parse = (_tags) => {
     const tags = { ...DEFAULT_TAGS, ..._tags };
     return comp(filter((x) => x !== "\r"), fsm({
-        [14 /* START */]: alts([
-            whitespace(() => [14 /* START */]),
+        [14 /* State.START */]: alts([
+            whitespace(() => [14 /* State.START */]),
             repeat(str(HD), 1, Infinity, heading),
-            str(BQUOTE, (ctx) => transition(ctx, 0 /* BLOCKQUOTE */)),
+            str(BQUOTE, (ctx) => transition(ctx, 0 /* State.BLOCKQUOTE */)),
             str(LI, newList),
             alts([
                 seq([str(CODE), not(str(CODE))], newParaCode),
-                str(CODEBLOCK, () => [15 /* START_CODEBLOCK */]),
+                str(CODEBLOCK, () => [15 /* State.START_CODEBLOCK */]),
             ], undefined, (_, next) => next),
             seq([repeat(str(HR), 3, Infinity), str(NL)], () => [
-                14 /* START */,
+                14 /* State.START */,
                 [tags.hr()],
             ]),
-            str(IMG, newParaInline(10 /* IMG */)),
-            str(LINK_LABEL, newParaInline(11 /* LINK */)),
-            str(STRONG, newParaInline(17 /* STRONG */)),
-            str(STRIKE, newParaInline(16 /* STRIKE */)),
-            str(EM, newParaInline(3 /* EMPHASIS */)),
+            str(IMG, newParaInline(10 /* State.IMG */)),
+            str(LINK_LABEL, newParaInline(11 /* State.LINK */)),
+            str(STRONG, newParaInline(17 /* State.STRONG */)),
+            str(STRIKE, newParaInline(16 /* State.STRIKE */)),
+            str(EM, newParaInline(3 /* State.EMPHASIS */)),
             str(TD, newTable),
         ], newPara),
-        [13 /* PARA */]: matchPara(13 /* PARA */, 6 /* END_PARA */),
-        [6 /* END_PARA */]: alts([
-            ...matchInline(13 /* PARA */),
+        [13 /* State.PARA */]: matchPara(13 /* State.PARA */, 6 /* State.END_PARA */),
+        [6 /* State.END_PARA */]: alts([
+            ...matchInline(13 /* State.PARA */),
             str(NL, collectAndRestart(tags.paragraph)),
-        ], collect(13 /* PARA */)),
-        [0 /* BLOCKQUOTE */]: matchPara(0 /* BLOCKQUOTE */, 4 /* END_BLOCKQUOTE */),
-        [4 /* END_BLOCKQUOTE */]: alts([
-            ...matchInline(0 /* BLOCKQUOTE */),
+        ], collect(13 /* State.PARA */)),
+        [0 /* State.BLOCKQUOTE */]: matchPara(0 /* State.BLOCKQUOTE */, 4 /* State.END_BLOCKQUOTE */),
+        [4 /* State.END_BLOCKQUOTE */]: alts([
+            ...matchInline(0 /* State.BLOCKQUOTE */),
             str(BQUOTE, collectBlockQuote),
             str(NL, collectAndRestart(tags.blockquote)),
-        ], collect(0 /* BLOCKQUOTE */)),
-        [9 /* HEADING */]: matchPara(9 /* HEADING */, 7 /* END_HEADING */),
-        [7 /* END_HEADING */]: alts([
-            ...matchInline(9 /* HEADING */),
+        ], collect(0 /* State.BLOCKQUOTE */)),
+        [9 /* State.HEADING */]: matchPara(9 /* State.HEADING */, 7 /* State.END_HEADING */),
+        [7 /* State.END_HEADING */]: alts([
+            ...matchInline(9 /* State.HEADING */),
             str(NL, collectHeading(tags.heading)),
-        ], collect(9 /* HEADING */)),
-        [15 /* START_CODEBLOCK */]: untilStr(NL, (ctx, lang) => ((ctx.lang = lang), [2 /* CODEBLOCK */])),
-        [2 /* CODEBLOCK */]: untilStr(CODEBLOCK_END, collectCodeBlock(tags.codeblock)),
-        [12 /* LI */]: matchPara(12 /* LI */, 5 /* END_LI */),
-        [5 /* END_LI */]: alts([
+        ], collect(9 /* State.HEADING */)),
+        [15 /* State.START_CODEBLOCK */]: untilStr(NL, (ctx, lang) => ((ctx.lang = lang), [2 /* State.CODEBLOCK */])),
+        [2 /* State.CODEBLOCK */]: untilStr(CODEBLOCK_END, collectCodeBlock(tags.codeblock)),
+        [12 /* State.LI */]: matchPara(12 /* State.LI */, 5 /* State.END_LI */),
+        [5 /* State.END_LI */]: alts([
             str(NL, collectList("ul", tags.list, tags.li)),
             str(LI, (ctx) => (collectLi(ctx, tags.li),
-                transition(ctx, 12 /* LI */))),
-        ], collect(12 /* LI */)),
-        [11 /* LINK */]: matchLink(tags.link),
-        [10 /* IMG */]: matchLink(tags.img),
-        [17 /* STRONG */]: untilStr(STRONG, collectInline(tags.strong)),
-        [16 /* STRIKE */]: untilStr(STRIKE, collectInline(tags.strike)),
-        [3 /* EMPHASIS */]: untilStr(EM, collectInline(tags.em)),
-        [1 /* CODE */]: untilStr(CODE, collectInline(tags.code)),
-        [18 /* TABLE */]: alts([
-            ...matchInline(18 /* TABLE */),
+                transition(ctx, 12 /* State.LI */))),
+        ], collect(12 /* State.LI */)),
+        [11 /* State.LINK */]: matchLink(tags.link),
+        [10 /* State.IMG */]: matchLink(tags.img),
+        [17 /* State.STRONG */]: untilStr(STRONG, collectInline(tags.strong)),
+        [16 /* State.STRIKE */]: untilStr(STRIKE, collectInline(tags.strike)),
+        [3 /* State.EMPHASIS */]: untilStr(EM, collectInline(tags.em)),
+        [1 /* State.CODE */]: untilStr(CODE, collectInline(tags.code)),
+        [18 /* State.TABLE */]: alts([
+            ...matchInline(18 /* State.TABLE */),
             str(TD, collectTD(tags.td)),
             str(NL, collectTR(tags.tr)),
-        ], collect(18 /* TABLE */)),
-        [8 /* END_TABLE */]: alts([
+        ], collect(18 /* State.TABLE */)),
+        [8 /* State.END_TABLE */]: alts([
             str(NL, collectTable(tags.table)),
-            str(TD, () => [18 /* TABLE */]),
+            str(TD, () => [18 /* State.TABLE */]),
         ]),
-    }, { stack: [] }, 14 /* START */));
+    }, { stack: [] }, 14 /* State.START */));
 };