tarsec 0.4.6 → 0.5.0

package/dist/parsers/markdown/references.js

@@ -16,27 +16,44 @@ export const linkDefinitionParser = seqC(set("type", "link-definition"), char("[
 export const footnoteDefinitionParser = seqC(set("type", "footnote-definition"), str("[^"), capture(many1WithJoin(noneOf("] \n\t")), "id"), str("]:"), spaces, capture(many1WithJoin(noneOf("\n")), "content"));
 /* Resolution pass.
  *
- * Walk the AST. Collect link-definitions, then rewrite ref nodes to inline
- * links/images and strip the definitions. Id matching is case-insensitive. */
+ * Walk the AST. Collect link/footnote definitions (deeply — they can now
+ * appear nested inside list-item block children), then rewrite ref nodes to
+ * inline links/images and strip the definitions everywhere they appear. Id
+ * matching is case-insensitive. */
+const CHILD_KEYS = ["content", "items", "rows"];
+const isDef = (n) => isObj(n) &&
+    (n.type === "link-definition" ||
+        n.type === "footnote-definition");
 export function resolveReferences(ast) {
     const linkDefs = new Map();
     const footnoteDefs = new Map();
-    for (const node of ast) {
+    function collect(node) {
+        if (Array.isArray(node)) {
+            node.forEach(collect);
+            return;
+        }
         if (!isObj(node))
-            continue;
-        const t = node.type;
+            return;
+        const obj = node;
+        const t = obj.type;
         if (t === "link-definition") {
-            const def = node;
+            const def = obj;
             linkDefs.set(def.id.toLowerCase(), def);
         }
         else if (t === "footnote-definition") {
-            const def = node;
+            const def = obj;
             footnoteDefs.set(def.id.toLowerCase(), def);
         }
+        for (const key of CHILD_KEYS) {
+            if (Array.isArray(obj[key]))
+                obj[key].forEach(collect);
+        }
     }
+    collect(ast);
     function walk(node) {
-        if (Array.isArray(node))
-            return node.map(walk);
+        if (Array.isArray(node)) {
+            return node.filter((n) => !isDef(n)).map(walk);
+        }
         if (!isObj(node))
             return node;
         const obj = node;
@@ -75,21 +92,17 @@ export function resolveReferences(ast) {
             }
             return { type: "inline-text", content: `[^${obj.id}]` };
         }
-        // recurse into known child-bearing fields
+        // Recurse into known child-bearing fields. The array path through `walk`
+        // also strips nested link/footnote definitions, so list items, blockquotes,
+        // etc. all get the same treatment as the top-level array.
         const out = Object.assign({}, obj);
-        for (const key of ["content", "items", "rows"]) {
+        for (const key of CHILD_KEYS) {
             if (Array.isArray(obj[key]))
-                out[key] = obj[key].map(walk);
+                out[key] = walk(obj[key]);
         }
-        if (obj.sublist)
-            out.sublist = walk(obj.sublist);
         return out;
     }
-    return ast
-        .filter((n) => !(isObj(n) &&
-        (n.type === "link-definition" ||
-            n.type === "footnote-definition")))
-        .map(walk);
+    return walk(ast);
 }
 function isObj(v) {
     return typeof v === "object" && v !== null;

package/dist/parsers/markdown/types.d.ts

@@ -76,11 +76,13 @@ export type InlineRefImage = {
     id: string;
 };
 export type ListItem = {
-    content: InlineMarkdown[];
-    sublist?: List;
+    content: Block[];
     /** GFM task-list state: `true` for `[x]`/`[X]`, `false` for `[ ]`, absent for plain items. */
     checked?: boolean;
 };
+export type Block = Paragraph | Heading | CodeBlock | List | BlockQuote | HorizontalRule | Table | HTMLBlock | Image | LinkDef | FootnoteDef;
+/** Top-level node in the markdown AST (optionally prefixed by frontmatter). */
+export type MarkdownNode = Block | Frontmatter;
 export type List = {
     type: "list";
     ordered: boolean;

package/dist/parsers.d.ts

@@ -47,6 +47,18 @@ export declare function noneOf(chars: string): Parser<string>;
  * ```
  */
 export type CharPredicate = (code: number) => boolean;
+/**
+ * Compile a string of allowed characters or a user-supplied predicate
+ * into a fast `CharPredicate`. For string inputs whose characters are
+ * all ASCII (code points < 128), the result is a single 128-byte
+ * `Uint8Array` lookup — one array read per character test. Non-ASCII
+ * characters in the string fall back to a `Set<number>` check.
+ * Predicates pass through unchanged.
+ *
+ * @param charsOrPred - a string of allowed characters or a predicate function
+ * @returns - a `CharPredicate` suitable for use in tight scanning loops
+ */
+export declare function compileCharPredicate(charsOrPred: string | CharPredicate): CharPredicate;
 /**
  * A faster version of many/ manyWithJoin for character-class scanning.
  *

package/dist/parsers.js

@@ -104,7 +104,7 @@ export function noneOf(chars) {
  * @param charsOrPred - a string of allowed characters or a predicate function
  * @returns - a `CharPredicate` suitable for use in tight scanning loops
  */
-function compileCharPredicate(charsOrPred) {
+export function compileCharPredicate(charsOrPred) {
     if (typeof charsOrPred === "function")
         return charsOrPred;
     const chars = charsOrPred;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tarsec",
-  "version": "0.4.6",
+  "version": "0.5.0",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
   "scripts": {
@@ -24,6 +24,11 @@
       "import": "./dist/parsers/markdown/index.js",
       "require": "./dist/parsers/markdown/index.js",
       "types": "./dist/parsers/markdown/index.d.ts"
+    },
+    "./parsers/bash": {
+      "import": "./dist/parsers/bash/index.js",
+      "require": "./dist/parsers/bash/index.js",
+      "types": "./dist/parsers/bash/index.d.ts"
     }
   },
   "type": "module",