@bendyline/squisq 1.4.0 → 1.5.0

package/dist/markdown/index.d.ts

@@ -1,31 +1,486 @@
+import { V as ParseOptions, m as MarkdownDocument, W as StringifyOptions, H as HeadingAttributes, d as HtmlNode, I as MarkdownNode } from '../types-DlAZ7MW4.js';
+export { a as HeadingTemplateAnnotation, b as HtmlComment, c as HtmlElement, e as HtmlText, M as MarkdownBlockNode, f as MarkdownBlockquote, g as MarkdownBreak, h as MarkdownCodeBlock, i as MarkdownContainerDirective, j as MarkdownDefinitionDescription, k as MarkdownDefinitionList, l as MarkdownDefinitionTerm, n as MarkdownEmphasis, o as MarkdownFootnoteDefinition, p as MarkdownFootnoteReference, q as MarkdownHeading, r as MarkdownHtmlBlock, s as MarkdownImage, t as MarkdownImageReference, u as MarkdownInlineCode, v as MarkdownInlineHtml, w as MarkdownInlineMath, x as MarkdownInlineNode, y as MarkdownLeafDirective, z as MarkdownLink, A as MarkdownLinkDefinition, B as MarkdownLinkReference, C as MarkdownList, E as MarkdownListItem, F as MarkdownMathBlock, G as MarkdownMention, J as MarkdownParagraph, K as MarkdownPoint, L as MarkdownSourcePosition, N as MarkdownStrikethrough, O as MarkdownStrong, P as MarkdownTable, Q as MarkdownTableCell, R as MarkdownTableRow, S as MarkdownText, T as MarkdownTextDirective, U as MarkdownThematicBreak } from '../types-DlAZ7MW4.js';
+
 /**
- * @bendyline/squisq Markdown Module
+ * Markdown → JSON Parser
  *
- * Provides a complete JSON representation of markdown documents with
- * perfect-fidelity round-trip conversion (markdown ↔ JSON).
+ * Parses a markdown string into a MarkdownDocument JSON structure
+ * using the unified/remark ecosystem with GFM, math, and directive extensions.
+ */
+
+/**
+ * Parse a markdown string into a MarkdownDocument.
  *
- * Supports CommonMark + GFM (tables, strikethrough, task lists, footnotes) +
- * math ($...$, $$...$$) + directives (:::container, ::leaf, :text).
- * Raw HTML is parsed into a structured HtmlNode sub-DOM.
+ * All extensions (GFM, math, directives) are enabled by default.
+ * Use the `options` parameter to disable specific extensions.
+ *
+ * @param markdown - The markdown source text
+ * @param options - Parser options (extensions, HTML parsing)
+ * @returns A MarkdownDocument representing the parsed markdown
  *
  * @example
  * ```ts
- * import { parseMarkdown, stringifyMarkdown } from '@bendyline/squisq/markdown';
- *
- * // Parse markdown to JSON
  * const doc = parseMarkdown('# Hello\n\nWorld **bold** and *italic*');
+ * // doc.type === 'document'
+ * // doc.children[0].type === 'heading'
+ * // doc.children[1].type === 'paragraph'
+ * ```
+ */
+declare function parseMarkdown(markdown: string, options?: ParseOptions): MarkdownDocument;
+
+/**
+ * JSON → Markdown Serializer
+ *
+ * Converts a MarkdownDocument JSON structure back to a markdown string
+ * using the unified/remark ecosystem with GFM, math, and directive extensions.
+ */
+
+/**
+ * Serialize a MarkdownDocument back to a markdown string.
  *
- * // Inspect the tree
- * console.log(doc.children[0].type); // 'heading'
+ * All extensions (GFM, math, directives) are enabled by default.
+ * Use the `options` parameter to control formatting and disable extensions.
  *
- * // Serialize back to markdown
+ * @param doc - The MarkdownDocument to serialize
+ * @param options - Serialization options (formatting, extensions)
+ * @returns A markdown string
+ *
+ * @example
+ * ```ts
+ * const doc: MarkdownDocument = {
+ *   type: 'document',
+ *   children: [
+ *     { type: 'heading', depth: 1, children: [{ type: 'text', value: 'Hello' }] },
+ *     { type: 'paragraph', children: [{ type: 'text', value: 'World' }] },
+ *   ],
+ * };
  * const md = stringifyMarkdown(doc);
+ * // '# Hello\n\nWorld\n'
+ * ```
+ */
+declare function stringifyMarkdown(doc: MarkdownDocument, options?: StringifyOptions): string;
+
+/**
+ * mdast ↔ Squisq Markdown Node Conversion
+ *
+ * Converts between the remark/mdast AST format and the squisq
+ * MarkdownDocument JSON format. This is the bridge layer that allows
+ * us to use the battle-tested unified/remark ecosystem for parsing
+ * and serialization while exposing our own clean, well-typed interfaces.
+ *
+ * The conversion is designed for perfect round-tripping:
+ * toMdast(fromMdast(tree)) should produce an equivalent mdast tree.
+ */
+
+/**
+ * Minimal interface for mdast/unist nodes.
+ * Using a generic shape avoids hard dependency on @types/mdast
+ * and handles extension nodes (GFM, math, directive) uniformly.
+ */
+interface MdastPosition {
+    start: {
+        line: number;
+        column: number;
+        offset?: number;
+    };
+    end: {
+        line: number;
+        column: number;
+        offset?: number;
+    };
+}
+interface MdastNode {
+    type: string;
+    position?: MdastPosition;
+    children?: MdastNode[];
+    value?: string;
+    depth?: number;
+    ordered?: boolean | null;
+    start?: number | null;
+    spread?: boolean | null;
+    checked?: boolean | null;
+    lang?: string | null;
+    meta?: string | null;
+    url?: string;
+    title?: string | null;
+    alt?: string;
+    identifier?: string;
+    label?: string;
+    referenceType?: string;
+    align?: (string | null)[];
+    name?: string;
+    attributes?: Record<string, string>;
+    data?: Record<string, unknown>;
+}
+/**
+ * Parse the inner content of a Pandoc-style `{…}` block. Tokens are
+ * whitespace-separated, with quoted runs (single or double) treated as
+ * single tokens — tokenization is shared with the `{[…]}` template
+ * annotation parser via {@link tokenizeAttrTokens}.
+ *
+ * - `#id` → `attributes.id`
+ * - `.class` → push onto `attributes.classes`
+ * - `key=value` or `key="quoted value"` → `attributes.params[key] = value`
+ *
+ * Empty `{}` yields `{}` (preserved as an annotation marker for round-tripping).
+ * Duplicate ids and keys: last wins, silent.
+ */
+declare function parsePandocAttrTokens(inner: string): HeadingAttributes;
+/**
+ * Serialize a HeadingAttributes object back to a Pandoc `{#id .class key=value}` string.
+ * Returns null when the attributes object is entirely empty (nothing to emit).
+ *
+ * Canonical key order: `#id`, then `.classes` (in original order), then
+ * params in their original insertion order. Values are quoted via the
+ * shared {@link quoteAttrValue} rule (same as `{[…]}` serialization).
+ */
+declare function serializePandocAttributes(attrs: HeadingAttributes): string | null;
+/**
+ * Convert an mdast Root node to a MarkdownDocument.
+ *
+ * @param root - The mdast root node (from remark-parse)
+ * @param options - Conversion options
+ * @returns A MarkdownDocument
+ */
+declare function fromMdast(root: MdastNode, options?: {
+    parseHtml?: boolean;
+}): MarkdownDocument;
+/**
+ * Convert a MarkdownDocument back to an mdast Root node.
+ *
+ * @param doc - A MarkdownDocument
+ * @returns An mdast Root node suitable for remark-stringify
+ */
+declare function toMdast(doc: MarkdownDocument): MdastNode;
+
+/**
+ * Shared key=value attribute machinery for the two heading annotation forms:
+ * the squisq-native `{[templateName key=value …]}` template annotation and
+ * the Pandoc-style `{#id .class key=value}` attribute block.
+ *
+ * Both forms share one interior grammar — whitespace-separated tokens whose
+ * values may be quoted (double or single) to include spaces, brackets, or
+ * quote characters. This module is the single implementation of that
+ * grammar: one tokenizer, one value un/escaper, one quoting rule. The
+ * trailing-annotation recognizers live here too so the editor bridge
+ * (packages/editor-react/src/tiptapBridge.ts) stays in sync by importing
+ * them rather than copying regexes.
+ *
+ * Value syntax:
+ * - Unquoted: no whitespace, quotes, or `[ ] { }` (those would collide with
+ *   the surrounding annotation delimiters), e.g. `columns=3`, `name=O'Brien`
+ *   (a quote *inside* an unquoted value is literal).
+ * - Quoted: `key="value with spaces"` or `key='…'`. Inside a quoted run,
+ *   `\` escapes the active quote character and itself; any other `\` is
+ *   literal. Quoted values may contain `]` and `}`.
+ * - Serialization emits double quotes, switching to single quotes when the
+ *   value contains a double quote (markdown character-escape resolution
+ *   makes backslash-escaped quotes fragile in `.md` source, so picking the
+ *   other quote character is preferred over escaping). A value containing
+ *   BOTH quote characters falls back to double quotes with `\"` escapes —
+ *   that survives the API path but is best avoided in markdown source.
+ */
+/** Result of matching a trailing annotation against a text run. */
+interface TrailingAnnotationMatch {
+    /** Interior of the brace block (between `{[`/`{` and `]}`/`}`), untrimmed. */
+    inner: string;
+    /** Offset of the match start (including leading whitespace) in the input. */
+    index: number;
+}
+/**
+ * Match a trailing `{[templateName key=value …]}` annotation. Quote-aware
+ * (values may contain `]` when quoted), with a legacy fallback so inputs
+ * the old `[^\]]+` grammar accepted still match.
+ */
+declare function matchTrailingTemplateAnnotation(text: string): TrailingAnnotationMatch | null;
+/**
+ * Match a trailing Pandoc `{#id .class key=value}` block. Quote-aware
+ * (values may contain `}` when quoted), with a legacy fallback.
+ */
+declare function matchTrailingPandocAttr(text: string): TrailingAnnotationMatch | null;
+/**
+ * Quote-aware whitespace tokenizer for the interior of either annotation
+ * form.
+ *
+ * A quote run starts only at the beginning of a token or immediately after
+ * `=` — a quote elsewhere (e.g. `name=O'Brien`) is a literal character.
+ * Inside a run, `\` escapes the active quote character and itself; the
+ * escape pair is preserved in the returned token (callers strip and
+ * unescape via {@link splitKeyValueToken} / {@link unquoteAttrValue}).
+ * An unbalanced opening quote is tolerated: the run extends to the end of
+ * the input.
+ */
+declare function tokenizeAttrTokens(input: string): string[];
+/**
+ * Strip surrounding quotes from a raw token value and unescape the active
+ * quote character and backslash. Values not wrapped in matching quotes are
+ * returned verbatim (including any interior quotes or backslashes).
+ */
+declare function unquoteAttrValue(raw: string): string;
+/**
+ * Split a `key=value` token into its parts, unquoting/unescaping the value.
+ * Returns null for tokens with no `=` past the first character (bare words,
+ * `#id`, `.class`, or a leading `=`).
+ */
+declare function splitKeyValueToken(token: string): {
+    key: string;
+    value: string;
+} | null;
+/**
+ * Whether a value must be quoted to survive tokenization and the outer
+ * annotation regexes: any whitespace, quote character, bracket, or brace —
+ * or an empty value, which would otherwise serialize as a bare `key=`.
+ */
+declare function needsQuoting(value: string): boolean;
+/**
+ * Serialize an attribute value, quoting when {@link needsQuoting} says the
+ * bare form would not round-trip.
+ *
+ * Double quotes are canonical; a value containing a double quote (but no
+ * single quote) is single-quoted instead, because markdown resolves
+ * backslash escapes in text runs before our parser sees them — switching
+ * the quote character round-trips through `.md` source where `\"` would
+ * not. Backslashes and the active quote character are escaped.
+ */
+declare function quoteAttrValue(value: string): string;
+
+/**
+ * Heading-attribute value coercion.
+ *
+ * The Pandoc-style heading attribute block `{#id .class key=value}` parses
+ * to a flat `Record<string, string>` of `key → raw value`. This module
+ * coerces a known subset of keys to typed values (numbers, time-in-seconds,
+ * `BlockConnection[]`) so downstream consumers don't have to re-parse them.
+ *
+ * Unknown keys are returned in `metadata` as raw strings. Malformed known-key
+ * values are dropped from the typed result and reported via `warnings` (the
+ * raw string is preserved in `params` upstream for lossless round-tripping —
+ * coercion failures do not corrupt the source).
+ */
+
+/**
+ * Registry of known block-meta keys and their coercion strategies.
+ *
+ * Adding a new typed key: add an entry here, add the typed field to
+ * `HeadingAttributes.blockMeta` in `types.ts`, and apply the coerced value
+ * in `markdownToDoc.ts`.
+ */
+declare const KNOWN_BLOCK_META_KEYS: {
+    readonly x: "number";
+    readonly y: "number";
+    readonly startTime: "time";
+    readonly duration: "time";
+    readonly connectsTo: "connectionList";
+    readonly transition: "transition";
+    readonly transitionDuration: "time";
+    readonly transitionDirection: "transitionDirection";
+};
+type KnownBlockMetaKey = keyof typeof KNOWN_BLOCK_META_KEYS;
+/**
+ * Editor-facing description of a known block-meta key: what it does, and
+ * either its closed set of valid values or a free-form format hint. This is
+ * the single source the markdown editor's `{[name key=value]}` attribute
+ * autocomplete reads from, so the suggestion list stays in lockstep with
+ * `KNOWN_BLOCK_META_KEYS` and the transition vocabulary rather than drifting
+ * in a hand-maintained copy. `values`/`valueHint` are mutually exclusive: a
+ * key has a closed enum (`values`) or a format hint (`valueHint`), not both.
+ */
+interface BlockMetaKeyDescriptor {
+    key: KnownBlockMetaKey;
+    /** One-line description, shown as the completion item's detail. */
+    description: string;
+    /** Closed set of valid values, for keys backed by an enum. */
+    values?: readonly string[];
+    /** Format hint shown when the value is free-form (no closed set). */
+    valueHint?: string;
+}
+/**
+ * Ordered descriptors for every key in `KNOWN_BLOCK_META_KEYS`. Order is the
+ * suggestion display order: the transition family first (the most common
+ * authoring case), then timeline timing, then diagram geometry/links.
+ */
+declare const BLOCK_META_KEY_DESCRIPTORS: readonly BlockMetaKeyDescriptor[];
+/**
+ * Parse a time value to seconds. Accepts:
+ * - bare number: `5` → 5, `5.5` → 5.5
+ * - `mm:ss`: `01:30` → 90
+ * - `mm:ss.ms`: `01:30.500` → 90.5
+ * - `1500ms` → 1.5
+ *
+ * Returns null on malformed input.
+ */
+declare function parseTimeSeconds(raw: string): number | null;
+
+/**
+ * HTML ↔ HtmlNode Conversion
+ *
+ * Parses raw HTML strings into the squisq HtmlNode tree representation
+ * using hast-util-from-html (parse5-backed), and serializes HtmlNode trees
+ * back to HTML strings with a lightweight custom serializer.
+ */
+
+/**
+ * Parse a raw HTML string into an HtmlNode[] tree.
+ *
+ * Uses the HTML5 parsing algorithm (via parse5) for correct handling of
+ * self-closing tags, optional end tags, entity decoding, etc.
+ *
+ * @param html - Raw HTML string to parse
+ * @returns Array of top-level HtmlNode elements
+ */
+declare function parseHtmlToNodes(html: string): HtmlNode[];
+/**
+ * Serialize an HtmlNode[] tree back to an HTML string.
+ *
+ * @param nodes - Array of HtmlNode elements to serialize
+ * @returns HTML string
+ */
+declare function stringifyHtmlNodes(nodes: HtmlNode[]): string;
+
+type HtmlPolicy = 'strip' | 'sanitize' | 'trusted';
+type UrlKind = 'link' | 'media';
+/**
+ * Sanitize a URL for a rendered link or media attribute.
+ *
+ * Relative URLs are allowed. Absolute URLs are restricted to schemes that
+ * cannot execute script in a document context. Media URLs additionally allow
+ * `blob:` and image/audio/video `data:` URLs because Squisq uses both for
+ * browser-local media previews and self-contained exports.
+ */
+declare function sanitizeUrl(url: string | null | undefined, kind?: UrlKind): string | null;
+/**
+ * Return a sanitized copy of an HtmlNode tree. The original parsed tree is left
+ * untouched so markdown stringify can still preserve source fidelity.
+ */
+declare function sanitizeHtmlNodes(nodes: HtmlNode[]): HtmlNode[];
+
+/**
+ * Markdown Tree Utilities
+ *
+ * Helper functions for traversing and querying the MarkdownDocument tree.
+ * All functions are pure and operate on the JSON node interfaces.
+ */
+
+/**
+ * Get the children of any markdown node, if it has children.
+ * Returns an empty array for leaf nodes (text, code, break, etc.).
+ *
+ * This is useful for generic tree walking where you don't want to
+ * check the specific node type.
+ */
+declare function getChildren(node: MarkdownNode): MarkdownNode[];
+/**
+ * Walk the markdown tree depth-first, calling the visitor for each node.
+ *
+ * The visitor receives the current node and its parent. Return `true`
+ * from the visitor to skip the node's children (prune).
+ *
+ * @param node - The root node to start walking from
+ * @param visitor - Called for each node; return true to skip children
+ * @param parent - (internal) Parent node
+ */
+declare function walkMarkdownTree(node: MarkdownNode, visitor: (node: MarkdownNode, parent?: MarkdownNode) => void | boolean, parent?: MarkdownNode): void;
+/**
+ * Find all nodes of a specific type in the tree.
+ *
+ * @param root - The document or node to search within
+ * @param type - The node type to find (e.g., 'heading', 'link', 'text')
+ * @returns Array of matching nodes
+ *
+ * @example
+ * ```ts
+ * const headings = findNodesByType(doc, 'heading');
+ * const links = findNodesByType(doc, 'link');
+ * ```
+ */
+declare function findNodesByType<T extends MarkdownNode>(root: MarkdownNode, type: T['type']): T[];
+/**
+ * Extract all plain text content from a node and its descendants.
+ * Concatenates text values, ignoring formatting, links, etc.
+ *
+ * @param node - The node to extract text from
+ * @returns Plain text content
+ *
+ * @example
+ * ```ts
+ * const heading = doc.children[0]; // { type: 'heading', children: [{ type: 'text', value: 'Hello' }] }
+ * extractPlainText(heading); // 'Hello'
  * ```
  */
-export type { MarkdownPoint, MarkdownSourcePosition, HeadingTemplateAnnotation, HtmlElement, HtmlText, HtmlComment, HtmlNode, MarkdownDocument, MarkdownHeading, MarkdownParagraph, MarkdownBlockquote, MarkdownList, MarkdownListItem, MarkdownCodeBlock, MarkdownThematicBreak, MarkdownTable, MarkdownTableRow, MarkdownTableCell, MarkdownHtmlBlock, MarkdownMathBlock, MarkdownLinkDefinition, MarkdownFootnoteDefinition, MarkdownContainerDirective, MarkdownLeafDirective, MarkdownDefinitionList, MarkdownDefinitionTerm, MarkdownDefinitionDescription, MarkdownText, MarkdownEmphasis, MarkdownStrong, MarkdownStrikethrough, MarkdownInlineCode, MarkdownLink, MarkdownImage, MarkdownBreak, MarkdownInlineHtml, MarkdownInlineMath, MarkdownFootnoteReference, MarkdownLinkReference, MarkdownImageReference, MarkdownTextDirective, MarkdownMention, MarkdownBlockNode, MarkdownInlineNode, MarkdownNode, ParseOptions, StringifyOptions, } from './types.js';
-export { parseMarkdown } from './parse.js';
-export { stringifyMarkdown } from './stringify.js';
-export { fromMdast, toMdast } from './convert.js';
-export { parseHtmlToNodes, stringifyHtmlNodes } from './htmlParse.js';
-export { getChildren, walkMarkdownTree, findNodesByType, extractPlainText, countNodes, createDocument, parseFrontmatter, setFrontmatterValues, inferDocumentTitle, readFrontmatterThemeId, } from './utils.js';
-//# sourceMappingURL=index.d.ts.map
+declare function extractPlainText(node: MarkdownNode): string;
+/**
+ * Count the total number of nodes in the tree.
+ *
+ * @param node - The root node
+ * @returns Total node count (including the root)
+ */
+declare function countNodes(node: MarkdownNode): number;
+/**
+ * Parse a YAML frontmatter string into a key-value record.
+ *
+ * Handles simple `key: value` pairs common in markdown frontmatter.
+ * Values are trimmed; quoted strings have their quotes removed.
+ * Returns `null` if parsing fails or the input is empty.
+ *
+ * @param yaml - The raw YAML string (without the `---` delimiters)
+ * @returns A record of string keys to parsed values, or null
+ */
+declare function parseFrontmatter(yaml: string): Record<string, unknown> | null;
+/**
+ * Update a markdown source string's YAML frontmatter block, applying the
+ * given key/value updates. A `null` or `undefined` value removes the key.
+ * If no frontmatter block exists and any non-null update is supplied, a
+ * new block is prepended; if every update is a removal and no block
+ * exists, the source is returned unchanged.
+ *
+ * Existing key order is preserved; new keys are appended in the order
+ * they appear in `updates`. The simple parser used here handles plain
+ * `key: value` pairs only — comments, multi-line scalars, and nested
+ * structures are left untouched (we only rewrite lines whose key matches
+ * one in `updates`).
+ *
+ * @param source - The markdown source string.
+ * @param updates - Map of key → new value (or null/undefined to remove).
+ * @returns The updated markdown source string.
+ */
+declare function setFrontmatterValues(source: string, updates: Record<string, string | number | boolean | null | undefined>): string;
+/**
+ * Create a minimal MarkdownDocument from a list of block nodes.
+ * Convenience function for programmatic document construction.
+ */
+declare function createDocument(...children: MarkdownDocument['children']): MarkdownDocument;
+/**
+ * Infer a human-readable title for a markdown document.
+ *
+ * Resolution order:
+ *   1. `title:` value in YAML frontmatter (when present and non-empty)
+ *   2. Text of the first heading found, walking top-level depth (H1, then
+ *      H2, etc.) — the shallowest heading wins regardless of source order
+ *
+ * Returns `undefined` when no usable title is found.
+ */
+declare function inferDocumentTitle(doc: MarkdownDocument): string | undefined;
+/**
+ * Read a theme id from a markdown document's frontmatter.
+ *
+ * Checks the editor's canonical `squisq-theme` key first, then the
+ * shorter legacy aliases (`themeId`, `theme`). Returns `undefined`
+ * when none of them carry a non-empty string. Centralizing the lookup
+ * keeps the export pipelines (DOCX, PPTX, HTML, plain-HTML bundle) in
+ * sync with whatever the editor writes — adding a new frontmatter
+ * spelling later is a one-file change.
+ */
+declare function readFrontmatterThemeId(frontmatter: Record<string, unknown> | undefined): string | undefined;
+/**
+ * Project an inline-HTML string (as stored on `TextLayer.content.html`) down
+ * to plain text — the value mirrored into `content.text` for plain consumers
+ * (PDF/markdown export, search, accessibility) and the SVG `<text>` fallback.
+ *
+ * `<br>` and block-level tags (`p`, `div`, `h1`–`h6`, `li`, `blockquote`,
+ * `pre`) become line breaks so multi-line rich content reads sensibly. Entity
+ * decoding is handled by {@link parseHtmlToNodes} (parse5-backed), so this is
+ * more correct than a regex tag-stripper.
+ */
+declare function plainTextFromInlineHtml(html: string): string;
+
+export { BLOCK_META_KEY_DESCRIPTORS, type BlockMetaKeyDescriptor, HeadingAttributes, HtmlNode, type HtmlPolicy, KNOWN_BLOCK_META_KEYS, type KnownBlockMetaKey, MarkdownDocument, MarkdownNode, ParseOptions, StringifyOptions, type TrailingAnnotationMatch, type UrlKind, countNodes, createDocument, extractPlainText, findNodesByType, fromMdast, getChildren, inferDocumentTitle, matchTrailingPandocAttr, matchTrailingTemplateAnnotation, needsQuoting, parseFrontmatter, parseHtmlToNodes, parseMarkdown, parsePandocAttrTokens, parseTimeSeconds, plainTextFromInlineHtml, quoteAttrValue, readFrontmatterThemeId, sanitizeHtmlNodes, sanitizeUrl, serializePandocAttributes, setFrontmatterValues, splitKeyValueToken, stringifyHtmlNodes, stringifyMarkdown, toMdast, tokenizeAttrTokens, unquoteAttrValue, walkMarkdownTree };

package/dist/markdown/index.js

@@ -1,34 +1,73 @@
-/**
- * @bendyline/squisq Markdown Module
- *
- * Provides a complete JSON representation of markdown documents with
- * perfect-fidelity round-trip conversion (markdown ↔ JSON).
- *
- * Supports CommonMark + GFM (tables, strikethrough, task lists, footnotes) +
- * math ($...$, $$...$$) + directives (:::container, ::leaf, :text).
- * Raw HTML is parsed into a structured HtmlNode sub-DOM.
- *
- * @example
- * ```ts
- * import { parseMarkdown, stringifyMarkdown } from '@bendyline/squisq/markdown';
- *
- * // Parse markdown to JSON
- * const doc = parseMarkdown('# Hello\n\nWorld **bold** and *italic*');
- *
- * // Inspect the tree
- * console.log(doc.children[0].type); // 'heading'
- *
- * // Serialize back to markdown
- * const md = stringifyMarkdown(doc);
- * ```
- */
-// Parser + serializer
-export { parseMarkdown } from './parse.js';
-export { stringifyMarkdown } from './stringify.js';
-// Conversion layer (for advanced use: working with remark plugins directly)
-export { fromMdast, toMdast } from './convert.js';
-// HTML sub-DOM utilities
-export { parseHtmlToNodes, stringifyHtmlNodes } from './htmlParse.js';
-// Tree utilities
-export { getChildren, walkMarkdownTree, findNodesByType, extractPlainText, countNodes, createDocument, parseFrontmatter, setFrontmatterValues, inferDocumentTitle, readFrontmatterThemeId, } from './utils.js';
+import {
+  sanitizeHtmlNodes,
+  sanitizeUrl,
+  stringifyMarkdown
+} from "../chunk-KZNXZ5SM.js";
+import {
+  BLOCK_META_KEY_DESCRIPTORS,
+  KNOWN_BLOCK_META_KEYS,
+  fromMdast,
+  matchTrailingPandocAttr,
+  matchTrailingTemplateAnnotation,
+  needsQuoting,
+  parseMarkdown,
+  parsePandocAttrTokens,
+  parseTimeSeconds,
+  quoteAttrValue,
+  serializePandocAttributes,
+  splitKeyValueToken,
+  toMdast,
+  tokenizeAttrTokens,
+  unquoteAttrValue
+} from "../chunk-OH43RPTP.js";
+import {
+  countNodes,
+  createDocument,
+  extractPlainText,
+  findNodesByType,
+  getChildren,
+  inferDocumentTitle,
+  parseFrontmatter,
+  parseHtmlToNodes,
+  plainTextFromInlineHtml,
+  readFrontmatterThemeId,
+  setFrontmatterValues,
+  stringifyHtmlNodes,
+  walkMarkdownTree
+} from "../chunk-OKJOQXK4.js";
+import "../chunk-DBS6RIFL.js";
+import "../chunk-QE7TWGVT.js";
+export {
+  BLOCK_META_KEY_DESCRIPTORS,
+  KNOWN_BLOCK_META_KEYS,
+  countNodes,
+  createDocument,
+  extractPlainText,
+  findNodesByType,
+  fromMdast,
+  getChildren,
+  inferDocumentTitle,
+  matchTrailingPandocAttr,
+  matchTrailingTemplateAnnotation,
+  needsQuoting,
+  parseFrontmatter,
+  parseHtmlToNodes,
+  parseMarkdown,
+  parsePandocAttrTokens,
+  parseTimeSeconds,
+  plainTextFromInlineHtml,
+  quoteAttrValue,
+  readFrontmatterThemeId,
+  sanitizeHtmlNodes,
+  sanitizeUrl,
+  serializePandocAttributes,
+  setFrontmatterValues,
+  splitKeyValueToken,
+  stringifyHtmlNodes,
+  stringifyMarkdown,
+  toMdast,
+  tokenizeAttrTokens,
+  unquoteAttrValue,
+  walkMarkdownTree
+};
 //# sourceMappingURL=index.js.map

package/dist/markdown/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/markdown/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAoEH,sBAAsB;AACtB,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,4EAA4E;AAC5E,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAElD,yBAAyB;AACzB,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEtE,iBAAiB;AACjB,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,YAAY,CAAC"}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/random/index.d.ts

@@ -1,2 +1,51 @@
-export { SeededRandom, hashString } from './SeededRandom.js';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Seeded pseudo-random number generator (Mulberry32 algorithm).
+ *
+ * Provides deterministic, reproducible randomness from an integer seed.
+ * Useful for consistent slideshow generation, shuffling, and selection.
+ *
+ * ```ts
+ * const rng = new SeededRandom(42);
+ * rng.next();            // 0.0–1.0
+ * rng.nextInt(10);       // 0–9
+ * rng.pick(['a', 'b']);  // 'a' or 'b'
+ * ```
+ */
+declare class SeededRandom {
+    private state;
+    constructor(seed: number);
+    /** Random float in [0, 1). */
+    next(): number;
+    /** Random integer in [0, max). */
+    nextInt(max: number): number;
+    /** Random integer in [min, max). */
+    nextIntRange(min: number, max: number): number;
+    /** Random boolean with given probability of `true` (default 0.5). */
+    nextBool(probability?: number): boolean;
+    /** Pick a random element, or `undefined` if array is empty. */
+    pick<T>(array: T[]): T | undefined;
+    /** Pick a random element; throws if empty. */
+    pickRequired<T>(array: T[]): T;
+    /** Pick `count` unique random elements (fewer if array is smaller). */
+    pickMultiple<T>(array: T[], count: number): T[];
+    /** Fisher-Yates shuffle **in place**. Returns the same array. */
+    shuffle<T>(array: T[]): T[];
+    /** Return a **new** shuffled copy. */
+    shuffled<T>(array: readonly T[]): T[];
+    /** Weighted random selection. Returns `undefined` if items is empty. */
+    pickWeighted<T>(items: {
+        item: T;
+        weight: number;
+    }[]): T | undefined;
+    /** Current internal state (for debugging / serialization). */
+    getState(): number;
+    /** Create an independent sub-stream keyed by a modifier. */
+    derive(modifier: string | number): SeededRandom;
+}
+/**
+ * Simple string → 32-bit hash (djb2 algorithm).
+ * Useful for turning a document ID into a numeric seed.
+ */
+declare function hashString(str: string): number;
+
+export { SeededRandom, hashString };