flex-md 3.5.0 → 4.0.0

package/dist/ofs/validator.js

@@ -1,91 +0,0 @@
-import { buildOutline } from "../outline/builder.js";
-/**
- * Validate Markdown output against an OutputFormatSpec.
- */
-export function validateOutput(md, spec) {
-    const outline = buildOutline(md);
-    const errors = [];
-    const warnings = [];
-    // Index nodes by normalized title
-    const matches = collectMatches(outline.nodes);
-    // Validate each required section
-    for (const section of spec.sections) {
-        const key = normalizeTitle(section.name);
-        const nodes = matches.get(key) ?? [];
-        if (nodes.length === 0) {
-            errors.push(`missing_section:${section.name}`);
-            continue;
-        }
-        // Choose best node (highest level, i.e., smallest level number)
-        const chosen = chooseBestNode(nodes);
-        const body = chosen.content_md.trim();
-        // Check for empty sections
-        if (spec.emptySectionValue) {
-            if (body === "" && !normalizeNone(body, spec.emptySectionValue)) {
-                errors.push(`empty_section_without_none:${section.name}`);
-            }
-            // If it's "None", skip further validation
-            if (normalizeNone(body, spec.emptySectionValue)) {
-                continue;
-            }
-        }
-        // Validate section kind
-        if (section.kind === "list") {
-            if (!/^\s*-\s+/m.test(body)) {
-                errors.push(`section_not_bullets:${section.name}`);
-            }
-        }
-        if (section.kind === "ordered_list") {
-            if (!/^\s*\d+\.\s+/m.test(body)) {
-                errors.push(`section_not_numbered:${section.name}`);
-            }
-        }
-    }
-    // Validate tables (if any)
-    // Note: Full table validation would require parsing tables from the markdown
-    // For now, we just check if tables exist when required
-    // This is a simplified version; full implementation would use extractAllTables
-    return {
-        ok: errors.length === 0,
-        errors,
-        warnings
-    };
-}
-/**
- * Collect all nodes by normalized title.
- */
-function collectMatches(nodes) {
-    const map = new Map();
-    function visit(node) {
-        const key = normalizeTitle(node.title);
-        const existing = map.get(key) ?? [];
-        existing.push(node);
-        map.set(key, existing);
-        node.children.forEach(visit);
-    }
-    nodes.forEach(visit);
-    return map;
-}
-/**
- * Choose the best node from multiple matches.
- * Prefer highest-level heading (smallest level number).
- */
-function chooseBestNode(nodes) {
-    if (nodes.length === 1)
-        return nodes[0];
-    // Sort by level (ascending) and take first
-    const sorted = [...nodes].sort((a, b) => a.level - b.level);
-    return sorted[0];
-}
-/**
- * Normalize title for comparison: lowercase, remove trailing punctuation.
- */
-function normalizeTitle(t) {
-    return t.trim().replace(/[:\-–—]\s*$/, "").trim().toLowerCase();
-}
-/**
- * Check if body is the "None" value.
- */
-function normalizeNone(body, noneValue) {
-    return body.trim().toLowerCase() === noneValue.toLowerCase();
-}

package/dist/outline/builder.d.ts

@@ -1,10 +0,0 @@
-import type { MdOutline } from "../types.js";
-/**
- * Build a nested outline tree from Markdown headings.
- * Accepts any heading level (#..######) and builds parent/child relationships.
- */
-export declare function buildOutline(md: string): MdOutline;
-/**
- * Convert title to slug: lowercase, replace spaces with _, remove special chars
- */
-export declare function slugify(t: string): string;

package/dist/outline/builder.js

@@ -1,85 +0,0 @@
-/**
- * Build a nested outline tree from Markdown headings.
- * Accepts any heading level (#..######) and builds parent/child relationships.
- */
-export function buildOutline(md) {
-    const lines = md.split("\n");
-    const nodes = [];
-    const stack = [];
-    // Collect heading positions
-    const headings = [];
-    for (let i = 0; i < lines.length; i++) {
-        const m = lines[i].match(/^(#{1,6})\s+(.+)\s*$/);
-        if (m) {
-            headings.push({
-                idx: i,
-                level: m[1].length,
-                title: cleanTitle(m[2])
-            });
-        }
-    }
-    // If no headings, return empty outline
-    if (headings.length === 0) {
-        return { type: "md_outline", nodes: [] };
-    }
-    // Build tree using stack-based algorithm
-    for (let h = 0; h < headings.length; h++) {
-        const cur = headings[h];
-        const next = headings[h + 1];
-        const contentStart = cur.idx + 1;
-        const contentEnd = next ? next.idx : lines.length;
-        const content_md = lines.slice(contentStart, contentEnd).join("\n").trimEnd() + "\n";
-        const node = {
-            title: cur.title,
-            level: cur.level,
-            key: "", // filled later
-            content_md,
-            children: []
-        };
-        // Attach using stack: pop nodes with level >= current level
-        while (stack.length && stack[stack.length - 1].level >= node.level) {
-            stack.pop();
-        }
-        if (!stack.length) {
-            nodes.push(node);
-        }
-        else {
-            stack[stack.length - 1].children.push(node);
-        }
-        stack.push(node);
-    }
-    // Fill keys deterministically (slug + dedup)
-    assignKeys(nodes);
-    return { type: "md_outline", nodes };
-}
-/**
- * Clean heading title: remove trailing punctuation like :, -, –, —
- */
-function cleanTitle(t) {
-    return t.trim().replace(/[:\-–—]\s*$/, "").trim();
-}
-/**
- * Convert title to slug: lowercase, replace spaces with _, remove special chars
- */
-export function slugify(t) {
-    return t.toLowerCase()
-        .replace(/[:\-–—]+$/g, "")
-        .replace(/\s+/g, "_")
-        .replace(/[^a-z0-9_]/g, "")
-        .replace(/_+/g, "_")
-        .replace(/^_+|_+$/g, "");
-}
-/**
- * Assign unique keys to all nodes in the tree.
- * Uses slugified titles with deduplication (e.g., "section", "section__2", "section__3")
- */
-function assignKeys(nodes, seen = new Map()) {
-    const visit = (n) => {
-        const base = slugify(n.title) || "section";
-        const count = (seen.get(base) ?? 0) + 1;
-        seen.set(base, count);
-        n.key = count === 1 ? base : `${base}__${count}`;
-        n.children.forEach(visit);
-    };
-    nodes.forEach(visit);
-}

package/dist/outline/renderer.d.ts

@@ -1,6 +0,0 @@
-import type { MdOutline } from "../types.js";
-/**
- * Render an outline tree back to Markdown.
- * Never renders internal keys, ids, or dedup suffixes.
- */
-export declare function renderOutline(outline: MdOutline): string;

package/dist/outline/renderer.js

@@ -1,23 +0,0 @@
-/**
- * Render an outline tree back to Markdown.
- * Never renders internal keys, ids, or dedup suffixes.
- */
-export function renderOutline(outline) {
-    const parts = [];
-    function renderNode(node) {
-        // Render heading
-        const hashes = "#".repeat(node.level);
-        parts.push(`${hashes} ${node.title}\n`);
-        // Render content
-        if (node.content_md && node.content_md.trim()) {
-            parts.push(node.content_md);
-            if (!node.content_md.endsWith("\n")) {
-                parts.push("\n");
-            }
-        }
-        // Render children recursively
-        node.children.forEach(renderNode);
-    }
-    outline.nodes.forEach(renderNode);
-    return parts.join("");
-}

package/dist/parser.d.ts

@@ -1,2 +0,0 @@
-import type { FlexDocument, ParseOptions } from "./types.js";
-export declare function parseFlexMd(input: string, options?: ParseOptions): FlexDocument;

package/dist/parser.js

@@ -1,199 +0,0 @@
-import { splitTokensPreservingQuotes, unquote } from "./util.js";
-const HEADER_RE = /^\[\[(.+)\]\]\s*$/;
-const META_RE = /^@([^:]+):\s*(.*)$/;
-const PAYLOAD_DECL_RE = /^@payload:name:\s*(.+)\s*$/;
-function parseHeader(inner) {
-    // Supports:
-    // 1) [[message role=user id=m1 ts=...]]
-    // 2) shorthand: [[user m1]] => type=message role=user id=m1
-    const tokens = splitTokensPreservingQuotes(inner.trim()).map(unquote);
-    if (tokens.length === 0)
-        return { type: "message" };
-    // shorthand: [[user m1]] or [[assistant m2]]
-    if (tokens.length === 2 && !tokens[0].includes("=") && !tokens[1].includes("=")) {
-        return { type: "message", role: tokens[0], id: tokens[1] };
-    }
-    const type = tokens[0];
-    const out = { type };
-    for (const t of tokens.slice(1)) {
-        const idx = t.indexOf("=");
-        if (idx <= 0)
-            continue;
-        const key = t.slice(0, idx).trim();
-        const val = unquote(t.slice(idx + 1).trim());
-        out[key] = val;
-    }
-    return out;
-}
-function parseMetaValue(key, value, arrayKeys, options) {
-    const v = value.trim();
-    // Handle array keys first
-    if (arrayKeys.has(key)) {
-        const parts = v
-            .split(",")
-            .map((p) => p.trim())
-            .filter((p) => p.length > 0);
-        return parts;
-    }
-    // Apply type mode
-    const mode = options.metaTypeMode ?? "strings";
-    if (mode === "schema" && options.metaSchema?.[key]) {
-        return parseWithSchema(v, options.metaSchema[key]);
-    }
-    if (mode === "infer") {
-        return inferType(v);
-    }
-    // Default: strings mode
-    return v;
-}
-/**
- * Parse value according to schema type.
- */
-function parseWithSchema(value, type) {
-    switch (type) {
-        case "boolean":
-            return value.toLowerCase() === "true";
-        case "null":
-            return null;
-        case "number": {
-            const num = Number(value);
-            return isNaN(num) ? value : num;
-        }
-        default:
-            return value;
-    }
-}
-/**
- * Safely infer type from string value.
- */
-function inferType(value) {
-    const lower = value.toLowerCase();
-    // Boolean
-    if (lower === "true")
-        return true;
-    if (lower === "false")
-        return false;
-    // Null
-    if (lower === "null")
-        return null;
-    // Number (avoid leading zeros like "0012" unless it's just "0" or "0.xxx")
-    if (/^-?\d+(\.\d+)?$/.test(value) && !/^0\d/.test(value)) {
-        const num = Number(value);
-        if (!isNaN(num))
-            return num;
-    }
-    return value;
-}
-function tryParsePayload(lang, raw) {
-    const l = (lang ?? "").toLowerCase();
-    if (l === "json") {
-        try {
-            const value = JSON.parse(raw);
-            return { lang, value, raw };
-        }
-        catch (e) {
-            return { lang, value: raw, raw, parseError: String(e?.message ?? e) };
-        }
-    }
-    return { lang, value: raw, raw };
-}
-export function parseFlexMd(input, options = {}) {
-    const arrayKeys = new Set((options.arrayMetaKeys ?? ["tags", "refs"]).map((s) => s.trim()));
-    const lines = input.split("\n");
-    const endsWithNewline = input.endsWith("\n");
-    const frames = [];
-    let cur = null;
-    // body accumulator for current frame (excluding meta and payload blocks)
-    let bodyLines = [];
-    // payload state: if declared, next code fence becomes its payload
-    let pendingPayloadName = null;
-    function flushCurrent() {
-        if (!cur)
-            return;
-        const body = bodyLines.join("\n");
-        // Preserve original trailing newline behavior inside body (best-effort):
-        cur.body_md = body.length ? body + "\n" : "";
-        // Trim to empty if it's only whitespace/newlines
-        if (cur.body_md.trim().length === 0)
-            delete cur.body_md;
-        frames.push(cur);
-        cur = null;
-        bodyLines = [];
-        pendingPayloadName = null;
-    }
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        // Frame header
-        const hm = line.match(HEADER_RE);
-        if (hm) {
-            flushCurrent();
-            cur = { ...parseHeader(hm[1]) };
-            i++;
-            continue;
-        }
-        // If we haven't seen a header yet, start an implicit frame.
-        cur ??= { type: "message" };
-        // Payload declaration
-        const pm = line.match(PAYLOAD_DECL_RE);
-        if (pm) {
-            pendingPayloadName = pm[1].trim();
-            i++;
-            continue;
-        }
-        // If a payload was declared, capture the next fenced code block
-        if (pendingPayloadName) {
-            const fenceStart = line.match(/^(```|~~~)\s*([A-Za-z0-9_-]+)?\s*$/);
-            if (fenceStart) {
-                const fence = fenceStart[1];
-                const lang = fenceStart[2]?.trim();
-                const rawLines = [];
-                i++;
-                while (i < lines.length && lines[i].trimEnd() !== fence) {
-                    rawLines.push(lines[i]);
-                    i++;
-                }
-                // consume closing fence if present
-                if (i < lines.length && lines[i].trimEnd() === fence)
-                    i++;
-                const raw = rawLines.join("\n");
-                cur.payloads ??= {};
-                cur.payloads[pendingPayloadName] = tryParsePayload(lang, raw);
-                pendingPayloadName = null;
-                continue;
-            }
-            else {
-                // payload declared but no fence; treat as body line
-                bodyLines.push(line);
-                pendingPayloadName = null;
-                i++;
-                continue;
-            }
-        }
-        // Metadata line
-        const mm = line.match(META_RE);
-        if (mm) {
-            const key = mm[1].trim();
-            const value = mm[2] ?? "";
-            cur.meta ??= {};
-            cur.meta[key] = parseMetaValue(key, value, arrayKeys, options);
-            i++;
-            continue;
-        }
-        // Default: part of body
-        bodyLines.push(line);
-        i++;
-    }
-    flushCurrent();
-    // Preserve overall trailing newline more closely: if input had no final newline,
-    // avoid forcing one by trimming last frame body newline.
-    if (!endsWithNewline && frames.length > 0) {
-        const last = frames[frames.length - 1];
-        if (typeof last.body_md === "string" && last.body_md.endsWith("\n")) {
-            last.body_md = last.body_md.slice(0, -1);
-            if (last.body_md.trim().length === 0)
-                delete last.body_md;
-        }
-    }
-    return { frames };
-}

package/dist/parsers/lists.d.ts

@@ -1,6 +0,0 @@
-import type { ParsedList } from "../types.js";
-/**
- * Parse nested Markdown lists into a tree structure.
- * Supports both unordered (-) and ordered (1.) lists.
- */
-export declare function parseList(md: string): ParsedList | null;

package/dist/parsers/lists.js

@@ -1,36 +0,0 @@
-/**
- * Parse nested Markdown lists into a tree structure.
- * Supports both unordered (-) and ordered (1.) lists.
- */
-export function parseList(md) {
-    const lines = md.split("\n");
-    const isListLine = (s) => /^\s*(-\s+|\d+\.\s+)/.test(s);
-    const listLines = lines.filter(isListLine);
-    if (!listLines.length)
-        return null;
-    // Determine if ordered by presence of numbered item
-    const ordered = listLines.some(l => /^\s*\d+\.\s+/.test(l));
-    const root = [];
-    const stack = [];
-    for (const line of listLines) {
-        const indent = (line.match(/^\s*/)?.[0].length) ?? 0;
-        const mOrdered = line.match(/^\s*(\d+)\.\s+(.*)$/);
-        const mUn = line.match(/^\s*-\s+(.*)$/);
-        const text = (mOrdered?.[2] ?? mUn?.[1] ?? "").trim();
-        const item = { text, children: [] };
-        if (mOrdered)
-            item.index = Number(mOrdered[1]);
-        // Pop stack until we find parent (lower indent)
-        while (stack.length && stack[stack.length - 1].indent >= indent) {
-            stack.pop();
-        }
-        if (!stack.length) {
-            root.push(item);
-        }
-        else {
-            stack[stack.length - 1].item.children.push(item);
-        }
-        stack.push({ indent, item });
-    }
-    return { kind: "list", ordered, items: root };
-}

package/dist/parsers/tables.d.ts

@@ -1,10 +0,0 @@
-import type { ParsedTable } from "../types.js";
-/**
- * Parse a single GFM pipe table block.
- * Returns null if the block is not a valid table.
- */
-export declare function parsePipeTable(block: string): ParsedTable | null;
-/**
- * Extract all pipe tables from a Markdown document.
- */
-export declare function extractAllTables(md: string): ParsedTable[];

package/dist/parsers/tables.js

@@ -1,58 +0,0 @@
-/**
- * Parse a single GFM pipe table block.
- * Returns null if the block is not a valid table.
- */
-export function parsePipeTable(block) {
-    const lines = block.split("\n").map(l => l.trim()).filter(Boolean);
-    if (lines.length < 2)
-        return null;
-    const header = lines[0];
-    const sep = lines[1];
-    if (!header || !header.includes("|"))
-        return null;
-    if (!sep || !sep.match(/^\|?[\s:-]+\|/))
-        return null;
-    const parseRow = (row) => row.replace(/^\|/, "").replace(/\|$/, "").split("|").map(c => c.trim());
-    const columns = parseRow(header);
-    const rows = lines.slice(2).map(parseRow);
-    // Normalize row lengths
-    for (const r of rows) {
-        while (r.length < columns.length)
-            r.push("");
-    }
-    // Detect ordered table (first column is "#")
-    const isOrdered = columns[0] === "#";
-    const kind = isOrdered ? "ordered_table" : "table";
-    return { kind, columns, rows };
-}
-/**
- * Extract all pipe tables from a Markdown document.
- */
-export function extractAllTables(md) {
-    const tables = [];
-    const lines = md.split("\n");
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        // Look for potential table start (contains |)
-        if (line && line.includes("|")) {
-            // Collect consecutive lines that look like table rows
-            const tableLines = [];
-            let j = i;
-            while (j < lines.length && lines[j] && lines[j].includes("|")) {
-                tableLines.push(lines[j]);
-                j++;
-            }
-            if (tableLines.length >= 2) {
-                const table = parsePipeTable(tableLines.join("\n"));
-                if (table) {
-                    tables.push(table);
-                    i = j;
-                    continue;
-                }
-            }
-        }
-        i++;
-    }
-    return tables;
-}

package/dist/stringify.d.ts

@@ -1,2 +0,0 @@
-import type { FlexDocument, StringifyOptions } from "./types.js";
-export declare function stringifyFlexMd(doc: FlexDocument, options?: StringifyOptions): string;

package/dist/stringify.js

@@ -1,110 +0,0 @@
-import { isBlank, isEmptyObject, quoteIfNeeded } from "./util.js";
-function metaValueToString(key, v, arrayKeys) {
-    if (v === null)
-        return null;
-    if (Array.isArray(v)) {
-        if (v.length === 0)
-            return null;
-        // Render arrays as comma-separated by default for known keys, otherwise JSON
-        if (arrayKeys.has(key))
-            return v.join(", ");
-        return JSON.stringify(v);
-    }
-    if (typeof v === "string")
-        return v;
-    if (typeof v === "number" || typeof v === "boolean")
-        return String(v);
-    // Fallback
-    return String(v);
-}
-function shouldSkipMetaValue(v) {
-    if (v === null || v === undefined)
-        return true;
-    if (typeof v === "string" && v.trim() === "")
-        return true;
-    if (Array.isArray(v) && v.length === 0)
-        return true;
-    return false;
-}
-function buildHeader(frame) {
-    // [[type key=value ...]]
-    const parts = [`[[${frame.type}`];
-    // include common attrs if present (role/id/ts) and any other top-level string attrs
-    const knownOrder = ["role", "id", "ts"];
-    for (const k of knownOrder) {
-        const val = frame[k];
-        if (typeof val === "string" && val.trim().length) {
-            parts.push(`${String(k)}=${quoteIfNeeded(val)}`);
-        }
-    }
-    // If the user adds extra header-like attributes, you can support them by convention:
-    // we intentionally do NOT auto-include unknown keys to keep JSON schema clean.
-    return parts.join(" ") + "]]";
-}
-export function stringifyFlexMd(doc, options = {}) {
-    const skipEmpty = options.skipEmpty ?? true;
-    const fence = options.fence ?? "```";
-    const arrayKeys = new Set((options.arrayMetaKeys ?? ["tags", "refs"]).map((s) => s.trim()));
-    const out = [];
-    for (let idx = 0; idx < doc.frames.length; idx++) {
-        const frame = doc.frames[idx];
-        out.push(buildHeader(frame));
-        // META
-        if (!isEmptyObject(frame.meta)) {
-            const keys = Object.keys(frame.meta ?? {});
-            for (const k of keys) {
-                const v = frame.meta[k];
-                if (skipEmpty && shouldSkipMetaValue(v))
-                    continue;
-                const rendered = metaValueToString(k, v, arrayKeys);
-                if (skipEmpty && (rendered === null || rendered.trim() === ""))
-                    continue;
-                out.push(`@${k}: ${rendered ?? ""}`.trimEnd());
-            }
-        }
-        // BODY
-        if (typeof frame.body_md === "string") {
-            const body = frame.body_md;
-            if (!(skipEmpty && isBlank(body))) {
-                // Keep body verbatim, but avoid double-blanking: ensure we don't accidentally
-                // merge with next header by always preserving its internal newlines.
-                const normalized = body.endsWith("\n") ? body.slice(0, -1) : body;
-                if (normalized.length > 0)
-                    out.push(normalized);
-            }
-        }
-        // PAYLOADS
-        const payloads = frame.payloads ?? {};
-        const payloadNames = Object.keys(payloads);
-        if (!(skipEmpty && payloadNames.length === 0)) {
-            for (const name of payloadNames) {
-                const p = payloads[name];
-                // Skip empty payload if requested
-                if (skipEmpty &&
-                    (p == null ||
-                        (typeof p.raw === "string" && p.raw.trim() === "") ||
-                        (p.value == null && (p.raw ?? "").trim() === ""))) {
-                    continue;
-                }
-                out.push(`@payload:name: ${name}`);
-                const lang = (p.lang ?? "").trim();
-                const header = lang ? `${fence}${lang}` : fence;
-                out.push(header);
-                // Prefer raw if present; if missing raw but value exists, serialize value
-                const raw = typeof p.raw === "string" && p.raw.length > 0
-                    ? p.raw
-                    : p.value !== undefined
-                        ? typeof p.value === "string"
-                            ? p.value
-                            : JSON.stringify(p.value, null, 2)
-                        : "";
-                out.push(raw);
-                out.push(fence);
-            }
-        }
-        // Frame separator: blank line between frames (readable) unless last
-        if (idx !== doc.frames.length - 1)
-            out.push("");
-    }
-    return out.join("\n") + "\n";
-}