@notrealstudio/nr-md 0.1.0

package/LICENSE

@@ -0,0 +1,52 @@
+MIT License
+
+Copyright (c) 2026 Denis Vinogradsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+The JSON5 reader in `src/json5.ts` is a port of JSON5 (https://github.com/json5/json5),
+used under the following terms. The test fixtures in `test/json5-suite/` are a
+verbatim copy of https://github.com/json5/json5-tests, under the same terms; see
+`test/json5-suite/LICENSE.md`.
+
+MIT License
+
+Copyright (c) 2012-2018 Aseem Kishore, and [others].
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+[others]: https://github.com/json5/json5/contributors

package/README.md

@@ -0,0 +1,136 @@
+# nr-md
+
+Markdown as structured data: headings become blocks, `$key: value` lines become attributes, and everything else stays the prose it always was.
+
+```markdown
+# $model gpt-4o
+$temperature: 0.7
+$stop: $["\n\n", "END"]
+$limits: {input: 8000, output: 800}
+
+You are a terse assistant.
+```
+
+```js
+import { parse, serialize } from '@notrealstudio/nr-md'
+
+const doc = parse(text)
+const model = doc.root.children[0]
+
+model.id                // 'gpt-4o'
+model.attrs[0].value    // 0.7  — coerced, not a string
+model.attrs[1].value    // ['\n\n', 'END']
+model.attrs[2].value    // { input: 8000, output: 800 }
+model.body              // 'You are a terse assistant.'
+
+serialize(doc)          // back to text, in canonical form
+```
+
+`serialize` emits the canonical spelling of a document, so `parse(serialize(doc))`
+gives back the same tree — values that need no quotes lose them, blank separator
+lines are not preserved. Byte-identical output is guaranteed for text that is
+already canonical, which is what `serialize` produces.
+
+The point is the file, not the API. It is a Markdown document — it renders in Obsidian, previews on GitHub, diffs by line, and a person can edit it without knowing there is a parser. It is also a tree with typed values, so a program can read it as configuration, as a prompt library, as records. You do not keep two files, one for humans and one for machines.
+
+## Install
+
+```sh
+npm install @notrealstudio/nr-md
+```
+
+Zero configuration, one dependency (a JSON5 microcodec), no host APIs — it runs wherever a string is a string.
+
+## The grammar
+
+**Blocks.** A heading whose text starts with the sigil opens a block; the rest of the line is its name, and anything after a space is its id. Heading depth nests them.
+
+```markdown
+# $character Aria      → block "character", id "Aria", level 1
+## $voice              → nested block "voice"
+## $                   → closing token: back to the top level
+```
+
+**Attributes.** A line starting with the sigil, up to the first `:`, is a key.
+
+```markdown
+$name: Aria            → 'Aria'      (string)
+$age: 24               → 24          (number)
+$active: true          → true        (boolean)
+$id: 007               → '007'       (leading zero — an id, not a number)
+$phone: +79051234567   → string      (a leading + is not a sign)
+$title: "42"           → '42'        (quotes force a string)
+```
+
+Repeating a key is reassignment: the last one wins.
+
+**Lists** are flow literals — sigil, brackets, commas:
+
+```markdown
+$tags: $[fantasy, "slice, of life", 3]
+```
+
+**Objects** are JSON5, on one line:
+
+```markdown
+$sampler: {steps: 30, cfg: 7.5, sched: 'karras'}
+```
+
+**Bodies.** Every line that is not a heading or an attribute belongs to the current block's body, verbatim — Markdown, code fences, tables, whatever. `serialize` escapes a body line that would re-parse as structure, so a round-trip through a document that talks *about* the format is still exact.
+
+**Interpolation.** `${...}` is recognised but never evaluated. A value carrying one parses to `{ raw, placeholders }`: the original text, plus the spans where interpolations sit. What the expression inside means is your language, not ours — bring your own evaluator. `\${` opts out, and the marker survives parsing intact.
+
+## Two sigils
+
+The sigil is a parameter. `$` is the mdz profile, `@` is mdd — same grammar, different marker, so two conventions can live in one document tree without colliding.
+
+```js
+parse(text)                  // '$' by default
+parse(text, { sigil: '@' })  // '@name: value', '# @block'
+serialize(doc, { sigil: '@' })
+```
+
+## Schema layer
+
+A subpath, because it is a different job — laying a JSON Schema out as a document and reading it back:
+
+```js
+import { serializeWithSchema, parseWithSchema } from '@notrealstudio/nr-md/schema'
+
+const text = serializeWithSchema(obj, schema)   // x-storage decides attr/body/block/tbl
+const back = parseWithSchema(text, schema)      // deep-equals obj
+```
+
+`x-storage` and `x-mdd` annotations say where each field lives: an attribute, the block body, a block of its own, a table, a flow list. Unknown fields round-trip losslessly instead of being dropped, so you can layer this over someone else's schema without owning it.
+
+`validate` delegates to Ajv2020, an **optional** peer — install `ajv` if you want it, or pass your own validator. The root import never touches it.
+
+Finding an installed `ajv` from ESM without importing a host module needs `process.getBuiltinModule` (Node 22.3+). Below that, and in the browser, auto-discovery is off and `validate` asks for `opts.validator` — everything else in the package is plain ES2022 and runs on Node 20 LTS and any current browser.
+
+## API
+
+| | |
+|---|---|
+| `parse(text, opts?)` | text → `Document` |
+| `serialize(doc, opts?)` | `Document` → text |
+| `parseAttributeValue`, `parseBodyValue` | value-level parsing |
+| `coerce`, `isFullyQuoted` | scalar coercion (§3) |
+| `serializeValue` | one value → its source form |
+| `parseTable`, `parseTableTyped`, `serializeTable`, `serializeTypedTable` | `tbl` bodies |
+| `parseHeaderCell`, `emitHeaderCell`, `coerceTyped`, `tableSchema` | typed table headers |
+| `isJson5Shaped`, `isJson5Object`, `parseJson5Object` | JSON5 attribute values |
+| `resolveIncludes`, `resolveIncludesAsync`, `extractSection` | `$[[path#section]]` preprocessing |
+
+Types: `Document`, `Block`, `Attribute`, `AttributeValue`, `BodyValue`, `Scalar`, `ListItem`, `InterpolatedValue`, `InterpolationSpan`, `Json5Object`, `Json5Value`, `Sigil`, `ParseOptions`, `SerializeOptions`, `Pos`.
+
+`Block` and `Attribute` carry an optional `pos` slot. Nothing populates it yet; it is reserved so that adding position tracking later cannot break an exhaustive walk written against this tree today.
+
+## What this is not
+
+It does not evaluate anything. No expressions, no includes resolved from disk (you inject the reader), no inheritance, no templating. Those belong to whoever consumes the tree, and keeping them out is what makes the tree portable — the same document can feed a different engine, in a different language, with a different idea of what `${x}` means.
+
+The normative grammar reference (format-spec, serialize-spec) is maintained with the engine that grew this format and ships alongside it.
+
+## License
+
+MIT

package/dist/coerce.d.ts

@@ -0,0 +1,30 @@
+import type { Scalar } from './types.js';
+/**
+ * Is `s` one quoted scalar and nothing else — opening quote at the first
+ * character, closing quote at the last, no closing quote in between (escapes
+ * honoured). Only in that position does a quote carry the force of a scalar
+ * literal: `${}` inside is literal text rather than an interpolation, and the
+ * quotes themselves come off.
+ *
+ * Partially quoted text (`"yes" or "no"`, JSON `{"m":"${x}"}`) is ordinary
+ * text — the quotes belong to the content, not to the markup.
+ */
+export declare function isFullyQuoted(s: string): boolean;
+/**
+ * Coerce a scalar string to a typed value (§3).
+ *
+ * Rules:
+ * - `""` (empty) → empty string
+ * - `"..."` (fully quoted) → string with quotes removed (no further coercion)
+ * - `null` → null
+ * - `true` / `false` → boolean
+ * - integer → number (leading `+` → string; leading-zero multi-digit `007` → string)
+ * - decimal → number (note: `1.10` → `1.1`)
+ * - anything else → string (incl. partially quoted `"yes" or "no"` — verbatim)
+ */
+export declare function coerce(s: string): Scalar;
+/**
+ * Unescape a double-quoted scalar literal. Inside quotes only the minimal
+ * set `\"`, `\\`, `\n`, `\t` is recognised; everything else stays literal.
+ */
+export declare function unescapeQuoted(s: string): string;

package/dist/coerce.js

@@ -0,0 +1,159 @@
+// YAML-like scalar coercion (§3).
+// Portable: string primitives only, no regex dialects.
+const CC_0 = 48;
+const CC_9 = 57;
+const CC_DOT = 46;
+const CC_MINUS = 45;
+function isDigit(c) {
+    return c >= CC_0 && c <= CC_9;
+}
+// Integer: optional leading `-`, then digits. NOT a number if:
+// - leading `+` — a `+` is not a sign (`+7905...` is a phone, §3) → string
+// - multi-digit with a leading zero (`007` is an id/code → string); bare `0`
+//   stays the number 0
+function isInt(s) {
+    if (s.length === 0)
+        return false;
+    let i = 0;
+    if (s.charCodeAt(0) === CC_MINUS)
+        i++;
+    if (i === s.length)
+        return false;
+    if (s.charCodeAt(i) === CC_0 && s.length - i > 1)
+        return false;
+    for (; i < s.length; i++) {
+        if (!isDigit(s.charCodeAt(i)))
+            return false;
+    }
+    return true;
+}
+// Float: optional leading `-`, digits with exactly one dot. Same sign/zero
+// exclusions as isInt (`+0.5` → string, `00.5` → string; lone `0.5` is fine).
+function isFloat(s) {
+    if (s.length === 0)
+        return false;
+    let i = 0;
+    if (s.charCodeAt(0) === CC_MINUS)
+        i++;
+    if (s.charCodeAt(i) === CC_0 && i + 1 < s.length && isDigit(s.charCodeAt(i + 1)))
+        return false;
+    let hasDigit = false;
+    let hasDot = false;
+    for (; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (isDigit(c)) {
+            hasDigit = true;
+        }
+        else if (c === CC_DOT) {
+            if (hasDot)
+                return false;
+            hasDot = true;
+        }
+        else {
+            return false;
+        }
+    }
+    return hasDigit && hasDot;
+}
+/**
+ * Is `s` one quoted scalar and nothing else — opening quote at the first
+ * character, closing quote at the last, no closing quote in between (escapes
+ * honoured). Only in that position does a quote carry the force of a scalar
+ * literal: `${}` inside is literal text rather than an interpolation, and the
+ * quotes themselves come off.
+ *
+ * Partially quoted text (`"yes" or "no"`, JSON `{"m":"${x}"}`) is ordinary
+ * text — the quotes belong to the content, not to the markup.
+ */
+export function isFullyQuoted(s) {
+    if (s.length < 2 || s.charCodeAt(0) !== 34 /* " */)
+        return false;
+    let i = 1;
+    while (i < s.length) {
+        if (s.charCodeAt(i) === 92 /* \ */ && i + 1 < s.length) {
+            i += 2;
+            continue;
+        }
+        if (s.charCodeAt(i) === 34)
+            return i === s.length - 1;
+        i++;
+    }
+    return false;
+}
+/**
+ * Coerce a scalar string to a typed value (§3).
+ *
+ * Rules:
+ * - `""` (empty) → empty string
+ * - `"..."` (fully quoted) → string with quotes removed (no further coercion)
+ * - `null` → null
+ * - `true` / `false` → boolean
+ * - integer → number (leading `+` → string; leading-zero multi-digit `007` → string)
+ * - decimal → number (note: `1.10` → `1.1`)
+ * - anything else → string (incl. partially quoted `"yes" or "no"` — verbatim)
+ */
+export function coerce(s) {
+    if (s.length === 0)
+        return '';
+    // Fully-quoted string — force string, drop quotes, do NOT re-coerce content.
+    if (isFullyQuoted(s)) {
+        return unescapeQuoted(s.slice(1, -1));
+    }
+    if (s === 'null')
+        return null;
+    if (s === 'true')
+        return true;
+    if (s === 'false')
+        return false;
+    if (isInt(s)) {
+        const n = Number(s);
+        if (Number.isFinite(n))
+            return n;
+    }
+    if (isFloat(s)) {
+        const n = Number(s);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return s;
+}
+/**
+ * Unescape a double-quoted scalar literal. Inside quotes only the minimal
+ * set `\"`, `\\`, `\n`, `\t` is recognised; everything else stays literal.
+ */
+export function unescapeQuoted(s) {
+    let out = '';
+    let i = 0;
+    while (i < s.length) {
+        const c = s.charCodeAt(i);
+        if (c === 92 /* \ */ && i + 1 < s.length) {
+            const n = s[i + 1];
+            if (n === '"') {
+                out += '"';
+                i += 2;
+                continue;
+            }
+            if (n === '\\') {
+                out += '\\';
+                i += 2;
+                continue;
+            }
+            if (n === 'n') {
+                out += '\n';
+                i += 2;
+                continue;
+            }
+            if (n === 't') {
+                out += '\t';
+                i += 2;
+                continue;
+            }
+            out += '\\' + n;
+            i += 2;
+            continue;
+        }
+        out += s[i];
+        i++;
+    }
+    return out;
+}

package/dist/includes.d.ts

@@ -0,0 +1,26 @@
+export interface IncludeOptions {
+    /** Maximum nesting depth (default: 10). */
+    maxDepth?: number;
+    /** Active sigil — only this sigil's includes are resolved. */
+    sigil?: '$' | '@';
+}
+/**
+ * Resolve file includes in text. Replaces `$[[path]]` / `$[[path#section]]`
+ * with file/section content, recursively. Cycle detection by path.
+ *
+ * readFile: `(path: string) => string | undefined` — returns file content
+ * or undefined if not found (left as-is in output).
+ *
+ * Async version: resolveIncludesAsync.
+ */
+export declare function resolveIncludes(text: string, readFile: (path: string) => string | undefined, opts?: IncludeOptions): string;
+/**
+ * Async version — readFile returns Promise.
+ */
+export declare function resolveIncludesAsync(text: string, readFile: (path: string) => Promise<string | undefined>, opts?: IncludeOptions): Promise<string>;
+/**
+ * Extract a section from markdown by heading name. Case-insensitive.
+ * Returns content from that heading until next heading of same/higher level.
+ * Returns undefined if not found.
+ */
+export declare function extractSection(content: string, sectionName: string): string | undefined;

package/dist/includes.js

@@ -0,0 +1,218 @@
+// File includes: $[[path]] / @[[path]] preprocessor (format-spec §2.6).
+// Text-level substitution BEFORE parsing. Recursive with cycle detection.
+// Supports sections: $[[path#section]], $[[#section]] (from current text).
+/**
+ * Resolve file includes in text. Replaces `$[[path]]` / `$[[path#section]]`
+ * with file/section content, recursively. Cycle detection by path.
+ *
+ * readFile: `(path: string) => string | undefined` — returns file content
+ * or undefined if not found (left as-is in output).
+ *
+ * Async version: resolveIncludesAsync.
+ */
+export function resolveIncludes(text, readFile, opts) {
+    const sigil = opts?.sigil ?? '$';
+    const maxDepth = opts?.maxDepth ?? 10;
+    return expand(text, readFile, sigil, maxDepth, new Set(), 0, text);
+}
+/**
+ * Async version — readFile returns Promise.
+ */
+export async function resolveIncludesAsync(text, readFile, opts) {
+    const sigil = opts?.sigil ?? '$';
+    const maxDepth = opts?.maxDepth ?? 10;
+    return expandAsync(text, readFile, sigil, maxDepth, new Set(), 0, text);
+}
+// ---------- Extract section from markdown ----------
+/**
+ * Extract a section from markdown by heading name. Case-insensitive.
+ * Returns content from that heading until next heading of same/higher level.
+ * Returns undefined if not found.
+ */
+export function extractSection(content, sectionName) {
+    const lines = content.split('\n');
+    const target = sectionName.trim().toLowerCase();
+    let startIdx = -1;
+    let startLevel = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const lvl = headingLevel(lines[i]);
+        if (lvl > 0) {
+            const name = lines[i].slice(lvl).trim().toLowerCase();
+            if (name === target) {
+                startIdx = i;
+                startLevel = lvl;
+                break;
+            }
+        }
+    }
+    if (startIdx === -1)
+        return undefined;
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        const lvl = headingLevel(lines[i]);
+        if (lvl > 0 && lvl <= startLevel) {
+            endIdx = i;
+            break;
+        }
+    }
+    // Trim trailing empty lines
+    while (endIdx > startIdx && lines[endIdx - 1].trim() === '')
+        endIdx--;
+    return lines.slice(startIdx, endIdx).join('\n');
+}
+function headingLevel(line) {
+    let i = 0;
+    while (i < line.length && line[i] === '#')
+        i++;
+    if (i === 0 || i > 6 || line[i] !== ' ')
+        return 0;
+    return i;
+}
+// ---------- Sync expand ----------
+function expand(text, readFile, sigil, maxDepth, visited, depth, currentText) {
+    if (depth > maxDepth)
+        return text;
+    let out = '';
+    let i = 0;
+    while (i < text.length) {
+        // Escaped include: \$[[ → literal $[[
+        if (text[i] === '\\' && i + 3 < text.length && text[i + 1] === sigil && text[i + 2] === '[' && text[i + 3] === '[') {
+            out += sigil + '[[';
+            i += 4;
+            continue;
+        }
+        // Include: $[[ or @[[
+        if (text[i] === sigil && i + 2 < text.length && text[i + 1] === '[' && text[i + 2] === '[') {
+            const start = i;
+            i += 3;
+            let raw = '';
+            let closed = false;
+            while (i < text.length) {
+                if (text[i] === ']' && i + 1 < text.length && text[i + 1] === ']') {
+                    closed = true;
+                    i += 2;
+                    break;
+                }
+                raw += text[i];
+                i++;
+            }
+            if (!closed) {
+                out += text.slice(start, i);
+                continue;
+            }
+            raw = raw.trim();
+            // Parse path#section
+            const hashIdx = raw.indexOf('#');
+            const filePath = hashIdx >= 0 ? raw.slice(0, hashIdx).trim() : raw;
+            const section = hashIdx >= 0 ? raw.slice(hashIdx + 1).trim() : undefined;
+            // $[[#section]] — section from current text
+            if (!filePath && section) {
+                const extracted = extractSection(currentText, section);
+                if (extracted !== undefined) {
+                    out += extracted;
+                }
+                else {
+                    out += text.slice(start, i); // not found — leave as-is
+                }
+                continue;
+            }
+            // Cycle detection
+            if (visited.has(filePath)) {
+                out += text.slice(start, i);
+                continue;
+            }
+            const content = readFile(filePath);
+            if (content === undefined) {
+                out += text.slice(start, i);
+                continue;
+            }
+            // Extract section if requested
+            let result = content;
+            if (section) {
+                const extracted = extractSection(content, section);
+                if (extracted === undefined) {
+                    out += text.slice(start, i); // section not found — leave as-is
+                    continue;
+                }
+                result = extracted;
+            }
+            // Recurse
+            visited.add(filePath);
+            out += expand(result, readFile, sigil, maxDepth, visited, depth + 1, content);
+            visited.delete(filePath);
+            continue;
+        }
+        out += text[i];
+        i++;
+    }
+    return out;
+}
+// ---------- Async expand ----------
+async function expandAsync(text, readFile, sigil, maxDepth, visited, depth, currentText) {
+    if (depth > maxDepth)
+        return text;
+    // Collect all include positions first, then resolve in order
+    // (sequential, not parallel — order matters for cycle detection)
+    let out = '';
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] === '\\' && i + 3 < text.length && text[i + 1] === sigil && text[i + 2] === '[' && text[i + 3] === '[') {
+            out += sigil + '[[';
+            i += 4;
+            continue;
+        }
+        if (text[i] === sigil && i + 2 < text.length && text[i + 1] === '[' && text[i + 2] === '[') {
+            const start = i;
+            i += 3;
+            let raw = '';
+            let closed = false;
+            while (i < text.length) {
+                if (text[i] === ']' && i + 1 < text.length && text[i + 1] === ']') {
+                    closed = true;
+                    i += 2;
+                    break;
+                }
+                raw += text[i];
+                i++;
+            }
+            if (!closed) {
+                out += text.slice(start, i);
+                continue;
+            }
+            raw = raw.trim();
+            const hashIdx = raw.indexOf('#');
+            const filePath = hashIdx >= 0 ? raw.slice(0, hashIdx).trim() : raw;
+            const section = hashIdx >= 0 ? raw.slice(hashIdx + 1).trim() : undefined;
+            if (!filePath && section) {
+                const extracted = extractSection(currentText, section);
+                out += extracted ?? text.slice(start, i);
+                continue;
+            }
+            if (visited.has(filePath)) {
+                out += text.slice(start, i);
+                continue;
+            }
+            const content = await readFile(filePath);
+            if (content === undefined) {
+                out += text.slice(start, i);
+                continue;
+            }
+            let result = content;
+            if (section) {
+                const extracted = extractSection(content, section);
+                if (extracted === undefined) {
+                    out += text.slice(start, i);
+                    continue;
+                }
+                result = extracted;
+            }
+            visited.add(filePath);
+            out += await expandAsync(result, readFile, sigil, maxDepth, visited, depth + 1, content);
+            visited.delete(filePath);
+            continue;
+        }
+        out += text[i];
+        i++;
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { parse } from './parser.js';
+export { coerce, isFullyQuoted } from './coerce.js';
+export { parseAttributeValue, parseBodyValue, unescape } from './value.js';
+export { isJson5Shaped, isJson5Object, parseJson5Object, Json5ParseError } from './json5-value.js';
+export { serialize, serializeValue, serializeTable, serializeTypedTable, parseTable, parseTableRows, parseTableTyped, } from './serialize.js';
+export type { TableSerializeOptions, TableRecord } from './serialize.js';
+export { parseHeaderCell, emitHeaderCell, coerceTyped, tableSchema, TableParseError } from './typed-header.js';
+export type { TypedColumn, ColumnType, JSONSchema } from './typed-header.js';
+export { resolveIncludes, resolveIncludesAsync, extractSection } from './includes.js';
+export type { IncludeOptions } from './includes.js';
+export type { Sigil, ParseOptions, SerializeOptions, Document, Block, Attribute, Pos, AttributeValue, BodyValue, Scalar, ListItem, Json5Object, Json5Value, InterpolatedValue, InterpolationSpan, } from './types.js';

package/dist/index.js

@@ -0,0 +1,23 @@
+// @notrealstudio/nr-md — Markdown as structured data.
+//
+// Text ↔ tree, both directions, nothing else: parse a Markdown document whose
+// headings and `$key: value` lines carry structure, get a plain AST back;
+// serialize an AST, get the document back. The sigil is a parameter — `$` (mdz)
+// and `@` (mdd) are two profiles of one grammar.
+//
+// The boundary this package keeps: it emits FACTS (shapes of data), never
+// interpretations. `${...}` is recognised as a span, not parsed as an
+// expression; a `$nr-extends` line is an attribute like any other. What the
+// facts mean is the caller's language, on top.
+// ---------- Parser (format-spec §1–§7) ----------
+export { parse } from './parser.js';
+export { coerce, isFullyQuoted } from './coerce.js';
+export { parseAttributeValue, parseBodyValue, unescape } from './value.js';
+// ---------- JSON5 object as an attribute value (§3; json5-scalar-spec) ----------
+export { isJson5Shaped, isJson5Object, parseJson5Object, Json5ParseError } from './json5-value.js';
+// ---------- Serialization (serialize-spec §1, §2) ----------
+export { serialize, serializeValue, serializeTable, serializeTypedTable, parseTable, parseTableRows, parseTableTyped, } from './serialize.js';
+// ---------- Typed tbl header + tableSchema (serialize-spec §2.3) ----------
+export { parseHeaderCell, emitHeaderCell, coerceTyped, tableSchema, TableParseError } from './typed-header.js';
+// ---------- Includes (format-spec §2.6) ----------
+export { resolveIncludes, resolveIncludesAsync, extractSection } from './includes.js';