@podlite/markdown 0.0.31 → 0.0.33

package/lib/index.esm.js

@@ -25644,7 +25644,7 @@ var require_package = __commonJS({
   "../podlite-schema/package.json"(exports, module) {
     module.exports = {
       name: "@podlite/schema",
-      version: "0.0.38",
+      version: "0.0.40",
       description: "AST tools and schema for Podlite markup language \u2014 validate, traverse, and transform document trees",
       main: "./src/index.ts",
       homepage: "https://podlite.org",
@@ -27026,6 +27026,245 @@ var plugin_defn_fill_term_default = () => (tree) => {
 function flattenDeep3(arr) {
   return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep3(val)) : acc.concat(val), []);
 }
+function parseCsv(text4) {
+  const rows = [];
+  let field = "";
+  let row = [];
+  let inQuote = false;
+  let i = 0;
+  while (i < text4.length) {
+    const c = text4[i];
+    if (inQuote) {
+      if (c === '"' && text4[i + 1] === '"') {
+        field += '"';
+        i += 2;
+        continue;
+      }
+      if (c === '"') {
+        inQuote = false;
+        i++;
+        continue;
+      }
+      field += c;
+      i++;
+      continue;
+    }
+    if (c === '"' && field === "") {
+      inQuote = true;
+      i++;
+      continue;
+    }
+    if (c === ",") {
+      row.push(field);
+      field = "";
+      i++;
+      continue;
+    }
+    if (c === "\r") {
+      i++;
+      continue;
+    }
+    if (c === "\n") {
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+      i++;
+      continue;
+    }
+    field += c;
+    i++;
+  }
+  if (field !== "" || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows.filter((r) => !(r.length === 1 && r[0].trim() === ""));
+}
+function parseTsv(text4) {
+  const lines = text4.split(/\r?\n/);
+  const rows = lines.map((line) => line.split("	"));
+  return rows.filter((r) => !(r.length === 1 && r[0].trim() === ""));
+}
+function parseMimeType(raw) {
+  if (!raw || typeof raw !== "string")
+    return { type: "", params: {} };
+  const parts = raw.split(";").map((s) => s.trim());
+  const type = (parts.shift() || "").toLowerCase();
+  const params = {};
+  for (const p of parts) {
+    if (!p)
+      continue;
+    const eq = p.indexOf("=");
+    if (eq < 0)
+      continue;
+    const key = p.slice(0, eq).trim().toLowerCase();
+    let value = p.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key)
+      params[key] = value;
+  }
+  return { type, params };
+}
+function findDataBlockByKey(tree, key) {
+  let found = null;
+  const walk = (node) => {
+    if (found)
+      return;
+    if (Array.isArray(node)) {
+      node.forEach(walk);
+      return;
+    }
+    if (!node || typeof node !== "object")
+      return;
+    if (node.type === "block" && node.name === "data") {
+      const attrs = config_default(node, {});
+      if (attrs.getFirstValue("key") === key) {
+        found = node;
+        return;
+      }
+    }
+    if (Array.isArray(node.content))
+      node.content.forEach(walk);
+  };
+  walk(tree);
+  return found;
+}
+function extractDataText(dataNode) {
+  if (!dataNode || !Array.isArray(dataNode.content))
+    return "";
+  const verbatim = dataNode.content.find((c) => c && c.type === "verbatim");
+  return verbatim && typeof verbatim.value === "string" ? verbatim.value : "";
+}
+function detectSourceReference(tableNode) {
+  const texts = [];
+  const walker = makeTransformer_default({
+    "row:text": (r) => {
+      texts.push(r.value);
+      return r;
+    },
+    "head:text": (h) => {
+      texts.push(h.value);
+      return h;
+    }
+  });
+  walker(tableNode, {});
+  const joined = texts.join("\n").trim();
+  const lines = joined.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+  if (lines.length !== 1)
+    return null;
+  const m = lines[0].match(/^(data|file):(\S+)$/);
+  if (!m)
+    return null;
+  return { scheme: m[1], target: m[2] };
+}
+function buildCellBlock(text4) {
+  return {
+    name: "cell",
+    type: "block",
+    margin: "",
+    content: [{ type: "text", value: text4 }]
+  };
+}
+function buildRowBlock(cells, isHeader) {
+  const block = {
+    name: "row",
+    type: "block",
+    margin: "",
+    content: cells
+  };
+  if (isHeader) {
+    block.config = [{ name: "header", value: true, type: "boolean" }];
+  }
+  return block;
+}
+function csvToTableContent(csvRows, hasHeader = false) {
+  return csvRows.map((row, i) => {
+    const cells = row.map((v) => buildCellBlock(v.trim()));
+    return buildRowBlock(cells, hasHeader && i === 0);
+  });
+}
+function normalizeCellCounts(tableNode, source = "table") {
+  if (!tableNode || !Array.isArray(tableNode.content))
+    return tableNode;
+  const rows = tableNode.content.filter((c) => c && c.type === "block" && c.name === "row");
+  if (rows.length === 0)
+    return tableNode;
+  const cellsOf = (row) => Array.isArray(row.content) ? row.content.filter((c) => c && c.name === "cell") : [];
+  const isHeaderRow = (row) => Array.isArray(row.config) && row.config.some((a) => a.name === "header" && a.value === true);
+  const cellHasSpan = (cell) => Array.isArray(cell.config) && cell.config.some((a) => a.name === "colspan" || a.name === "rowspan");
+  const rowHasSpan = (row) => cellsOf(row).some(cellHasSpan);
+  if (rows.some(rowHasSpan))
+    return tableNode;
+  const headerRow = rows.find(isHeaderRow);
+  const expected = headerRow ? cellsOf(headerRow).length : Math.max(...rows.map((r) => cellsOf(r).length));
+  if (expected === 0)
+    return tableNode;
+  let mutated = false;
+  const newContent = tableNode.content.map((child) => {
+    if (!child || child.type !== "block" || child.name !== "row")
+      return child;
+    const cells = cellsOf(child);
+    if (cells.length === expected)
+      return child;
+    if (cells.length < expected) {
+      const padding = [];
+      for (let i = cells.length; i < expected; i++)
+        padding.push(buildCellBlock(""));
+      console.warn(
+        `[${source}] row has ${cells.length} cells, expected ${expected} \u2014 padded with ${padding.length} empty`
+      );
+      mutated = true;
+      return { ...child, content: [...child.content, ...padding] };
+    }
+    const dropped = cells.length - expected;
+    console.warn(`[${source}] row has ${cells.length} cells, expected ${expected} \u2014 truncated ${dropped}`);
+    mutated = true;
+    let keepCells = expected;
+    const trimmed = [];
+    for (const c of child.content || []) {
+      if (c && c.type === "block" && c.name === "cell") {
+        if (keepCells > 0) {
+          trimmed.push(c);
+          keepCells--;
+        }
+      } else {
+        trimmed.push(c);
+      }
+    }
+    return { ...child, content: trimmed };
+  });
+  return mutated ? { ...tableNode, content: newContent } : tableNode;
+}
+function detectMixedSeparators(lines) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    if (!line || typeof line !== "string")
+      continue;
+    if (/\s\|\s/.test(line))
+      seen.add("pipe");
+    else if (/\s\+\s/.test(line))
+      seen.add("plus");
+    else if (line.trim().length > 0)
+      seen.add("whitespace");
+    if (seen.size > 1)
+      break;
+  }
+  if (seen.size > 1) {
+    console.warn(`[table] mixed separator types detected: ${Array.from(seen).join(", ")} \u2014 recommend a single style`);
+  }
+}
+function buildCodeFromDataBlock(tableNode, dataBlock) {
+  return {
+    type: "block",
+    name: "code",
+    margin: tableNode.margin || "",
+    content: Array.isArray(dataBlock.content) ? dataBlock.content : [],
+    config: Array.isArray(tableNode.config) ? tableNode.config : []
+  };
+}
 var strbin = (str1, str2, cb) => {
   let res = [];
   for (let i = 0; str1.length > i; i++) {
@@ -27036,49 +27275,91 @@ var strbin = (str1, str2, cb) => {
 var makeMask = (lines, separators) => {
   const tmplLength = Math.max(...[...lines, ...separators].map((s) => s.length));
   const masks = lines.map((str) => {
-    let tstr = str + " ".repeat(tmplLength - str.length);
-    let mask = [];
+    const tstr = str + " ".repeat(tmplLength - str.length);
+    const mask = [];
     const re = /\s+[+|\s]\s/g;
     let match;
     while ((match = re.exec(tstr)) != null) {
       const tmpMask = "1".repeat(match.index) + "0".repeat(match[0].length);
       mask.push(tmpMask + "1".repeat(tmplLength - tmpMask.length));
     }
-    return mask.reduce((a, b) => {
-      return strbin(a, b, (i1, i2) => i1 & i2);
-    }, "1".repeat(tmplLength));
+    return mask.reduce((a, b) => strbin(a, b, (i1, i2) => i1 & i2), "1".repeat(tmplLength));
   });
   const inverted = masks.map((m) => strbin(m, "", (i1) => i1 == 0 ? 1 : 0));
-  const columnTemplate = inverted.reduce((a, b) => {
-    return strbin(a, b, (i1, i2) => i1 & i2);
-  }, "1".repeat(tmplLength));
-  return columnTemplate;
+  return inverted.reduce((a, b) => strbin(a, b, (i1, i2) => i1 & i2), "1".repeat(tmplLength));
 };
 var extractColumnsByTemplate = (text4, template) => {
-  const lines = flattenDeep3(
-    text4.split(/\n/).filter((str) => str.length > 0)
-  );
+  const lines = flattenDeep3(text4.split(/\n/).filter((s) => s.length > 0));
   const cols = lines.map((line) => {
     const re = /((1+|0+))/g;
-    let columns = [];
+    const columns = [];
     let match;
     while ((match = re.exec(template)) != null) {
-      if (match[0][0] == 1)
+      if (match[0][0] == "1")
         continue;
-      const s = line.substring(match.index, match.index + match[0].length);
-      columns.push(s);
+      columns.push(line.substring(match.index, match.index + match[0].length));
     }
     return columns;
   });
-  let result = [];
-  result = cols.reduce((a, b) => {
+  const result = [];
+  cols.reduce((a, b) => {
     for (let i = 0; i < b.length; i++) {
       a[i] = (a[i] === void 0 ? "" : a[i]) + " " + b[i];
     }
     return a;
-  }, []);
+  }, result);
   return result;
 };
+var detectLineSeparator = (line) => {
+  if (/(?:^|\s)\|(?:\s|$)/.test(line))
+    return "pipe";
+  if (/(?:^|\s)\+(?:\s|$)/.test(line))
+    return "plus";
+  return "whitespace";
+};
+var trimEdgeEmpty = (cells) => {
+  let start = 0;
+  let end = cells.length;
+  if (cells[start] === "")
+    start++;
+  if (end > start && cells[end - 1] === "")
+    end--;
+  return cells.slice(start, end);
+};
+var splitLineByPipe = (line) => trimEdgeEmpty(line.split(/\s*\|\s*/).map((c) => c.trim()));
+var splitLineByPlus = (line) => trimEdgeEmpty(line.split(/\s*\+\s*/).map((c) => c.trim()));
+var splitLineByWhitespace = (line) => line.trim().split(/\s{2,}/).filter((c) => c !== "");
+var splitLineCells = (line) => {
+  const trimmed = line.trim();
+  if (trimmed === "")
+    return [];
+  const kind = detectLineSeparator(line);
+  if (kind === "pipe")
+    return splitLineByPipe(line);
+  if (kind === "plus")
+    return splitLineByPlus(line);
+  return splitLineByWhitespace(line);
+};
+var rowToCells = (rowValue) => {
+  const lines = rowValue.split(/\r?\n/).filter((l) => l.trim() !== "");
+  if (lines.length === 0)
+    return [];
+  if (lines.length === 1)
+    return splitLineCells(lines[0]);
+  const kind = detectLineSeparator(lines[0]);
+  const splitFn = kind === "pipe" ? splitLineByPipe : kind === "plus" ? splitLineByPlus : splitLineByWhitespace;
+  const lineCells = lines.map(splitFn);
+  const maxCols = Math.max(...lineCells.map((c) => c.length));
+  const merged = [];
+  for (let i = 0; i < maxCols; i++) {
+    const parts = lineCells.map((line) => {
+      var _a;
+      return (_a = line[i]) != null ? _a : "";
+    }).filter((p) => p !== "");
+    merged.push(parts.join(" "));
+  }
+  return merged;
+};
 var wrapImplicitCells = (rowNode) => {
   if (!Array.isArray(rowNode.content) || rowNode.content.length === 0)
     return rowNode;
@@ -27098,13 +27379,42 @@ var isStructured = (tableNode) => Array.isArray(tableNode.content) && tableNode.
 var plugin_tables_default = () => (tree) => {
   const transformer = makeTransformer_default({
     table: (node) => {
+      const ref = detectSourceReference(node);
+      if (ref && ref.scheme === "data") {
+        const dataBlock = findDataBlockByKey(tree, ref.target);
+        if (!dataBlock) {
+          console.warn(`[table] no =data block found for data:${ref.target} \u2014 rendered as empty`);
+          return { ...node, content: [] };
+        }
+        const rawMime = config_default(dataBlock, {}).getFirstValue("mime-type");
+        const { type: mimeType, params: mimeParams } = parseMimeType(rawMime);
+        const isCsv = mimeType === "text/csv";
+        const isTsv = mimeType === "text/tab-separated-values";
+        if (isCsv || isTsv) {
+          const text4 = extractDataText(dataBlock);
+          const rows2 = isCsv ? parseCsv(text4) : parseTsv(text4);
+          if (rows2.length === 0) {
+            console.warn(
+              `[table] ${isCsv ? "CSV" : "TSV"} parse produced no rows for data:${ref.target} \u2014 rendered as empty`
+            );
+            return { ...node, content: [] };
+          }
+          const hasHeader = mimeParams.header === "present";
+          const filledNode = { ...node, content: csvToTableContent(rows2, hasHeader) };
+          return normalizeCellCounts(filledNode, `table data:${ref.target}`);
+        }
+        console.warn(
+          `[table] =data :key<${ref.target}> has non-tabular mime-type ${rawMime || "(none)"} \u2014 rendered as =code`
+        );
+        return buildCodeFromDataBlock(node, dataBlock);
+      }
       if (isStructured(node)) {
         const transformedContent = (node.content || []).map((c) => {
           if (c && c.name === "row")
             return wrapImplicitCells(c);
           return c;
         });
-        return { ...node, content: transformedContent };
+        return normalizeCellCounts({ ...node, content: transformedContent }, "table");
       }
       let rows = [];
       const collectValues = (row) => {
@@ -27123,37 +27433,46 @@ var plugin_tables_default = () => (tree) => {
       const splitToLines = (row) => row.split(/\n/).filter((str) => str.length > 0);
       const lines = flattenDeep3(rows.map(splitToLines));
       const separators = flattenDeep3(seps.map(splitToLines));
+      detectMixedSeparators(lines);
       let textRows = [];
       makeTransformer_default({
         "row:text": (row) => {
           textRows.push(row.value);
         }
       })(node);
-      const columnTemplate = makeMask(lines, separators);
       const makeBlock = (name, content4, extra = {}) => {
         return { ...extra, name, type: "block", content: Array.isArray(content4) ? content4 : [content4] };
       };
       const makeRow = (cells) => makeBlock("row", cells);
       const makeHeaderRow = (cells) => makeBlock("row", cells, { config: [{ name: "header", value: true, type: "boolean" }] });
       const makeCell = (text4) => makeBlock("cell", { type: "text", value: text4 });
+      const columnTemplate = makeMask(lines, separators);
+      const seenSeparatorKinds = new Set(lines.map(detectLineSeparator));
+      const hasVisible = seenSeparatorKinds.has("pipe") || seenSeparatorKinds.has("plus");
+      const hasWhitespace = seenSeparatorKinds.has("whitespace");
+      const useMixedSplitting = hasVisible && hasWhitespace;
+      const splitToCells = (rowValue) => {
+        if (useMixedSplitting) {
+          const rowLines = rowValue.split(/\r?\n/).filter((l) => l.trim() !== "");
+          if (rowLines.length <= 1)
+            return rowToCells(rowValue);
+        }
+        return extractColumnsByTemplate(rowValue, columnTemplate);
+      };
       const res = makeTransformer_default({
         "row:text": (row) => {
           if (textRows.length == 1) {
             const textRowsLines = flattenDeep3([row.value].map(splitToLines));
-            return textRowsLines.map((rowValue) => {
-              const cols2 = extractColumnsByTemplate(rowValue, columnTemplate);
-              return makeRow(cols2.map(makeCell));
-            });
+            if (useMixedSplitting) {
+              return textRowsLines.map((line) => makeRow(splitLineCells(line).map(makeCell)));
+            }
+            return textRowsLines.map((line) => makeRow(extractColumnsByTemplate(line, columnTemplate).map(makeCell)));
           }
-          const cols = extractColumnsByTemplate(row.value, columnTemplate);
-          return makeRow(cols.map(makeCell));
+          return makeRow(splitToCells(row.value).map(makeCell));
         },
-        "head:text": (head) => {
-          const cols = extractColumnsByTemplate(head.value, columnTemplate);
-          return makeHeaderRow(cols.map(makeCell));
-        }
+        "head:text": (head) => makeHeaderRow(splitToCells(head.value).map(makeCell))
       })(node);
-      return res;
+      return normalizeCellCounts(res, "table");
     }
   });
   return transformer(tree, {});