@bendyline/squisq 1.3.0 → 1.4.1

package/dist/jsonForm/index.d.ts

@@ -0,0 +1,191 @@
+/**
+ * JSON Form types — Squisq's hint vocabulary layered on JSON Schema.
+ *
+ * Hints live inline on a JSON Schema under a single `squisq` key. The
+ * schema remains a valid JSON Schema; the extra key is ignored by
+ * standard validators. Renderers consult the hints to pick a control
+ * and tune its presentation.
+ */
+/**
+ * Every concrete control rendered by `<JsonView>` and `<JsonEditor>`.
+ *
+ * Auto-defaults pick one based on schema shape; hosts override via
+ * `squisq.control` when they want something specific (e.g. radio over
+ * segmented for a long, descriptive enum).
+ */
+type ControlKind = 'text' | 'multiline' | 'richtext' | 'color' | 'date' | 'time' | 'datetime' | 'slider' | 'stepper' | 'segmented' | 'radio' | 'combobox' | 'toggle' | 'checkbox' | 'card' | 'card-stack' | 'chip-bin' | 'tabs' | 'group';
+/**
+ * Conditional rule: looked up by field path against the root data and
+ * compared with one of the operators. The first defined operator wins
+ * (in declaration order: equals, oneOf, matches, truthy).
+ */
+interface SquisqWhen {
+    /**
+     * Path to the controlling field, relative to the root data.
+     * Accepts dotted-path (`user.role`) or JSON Pointer (`/user/role`).
+     */
+    field: string;
+    equals?: unknown;
+    oneOf?: readonly unknown[];
+    /** ECMAScript regex source; matched against the string value. */
+    matches?: string;
+    /** When true, condition holds if value is truthy; when false, if falsy. */
+    truthy?: boolean;
+}
+/**
+ * Hints for a single schema node. Attach via `squisq` on any JSON
+ * Schema object — properties, items, the root, or sub-schemas inside
+ * `oneOf`/`anyOf`.
+ */
+interface SquisqHints {
+    /** Force a specific control. If omitted, picked from type/format/enum cardinality. */
+    control?: ControlKind;
+    /** Override schema `title` for display. */
+    label?: string;
+    /** Override schema `description` for the inline helper text. */
+    help?: string;
+    /** Placeholder text for empty fields. */
+    placeholder?: string;
+    /** Suggested layout sizing in a parent grid. Renderers may ignore on narrow viewports. */
+    width?: 'full' | 'half' | 'third' | 'auto';
+    /** Hide the field — literal, or a `SquisqWhen` evaluated against root data. */
+    hidden?: boolean | SquisqWhen;
+    /** Disable the field — literal, or a `SquisqWhen` evaluated against root data. */
+    disabled?: boolean | SquisqWhen;
+    /** Override schema's required-ness for the UI only. */
+    required?: boolean;
+    /** For arrays of objects: how to label each card in a `card-stack`. */
+    itemLabel?: string | {
+        fromField: string;
+    };
+    /** Label for the "+ Add" button on arrays. */
+    addLabel?: string;
+    /** Label for the remove button on arrays. */
+    removeLabel?: string;
+    /** Slider/stepper visual step. Falls back to schema `multipleOf`. */
+    step?: number;
+    /** Optional human-readable labels for enum values. */
+    enumLabels?: Record<string, string>;
+}
+/**
+ * The subset of JSON Schema we understand, with an optional `squisq`
+ * key. We deliberately keep this as a structural type so any JSON
+ * Schema authored elsewhere can be passed in without conversion.
+ */
+interface SquisqAnnotatedSchema {
+    type?: string | readonly string[];
+    format?: string;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    examples?: readonly unknown[];
+    enum?: readonly unknown[];
+    const?: unknown;
+    properties?: Record<string, SquisqAnnotatedSchema>;
+    required?: readonly string[];
+    additionalProperties?: boolean | SquisqAnnotatedSchema;
+    items?: SquisqAnnotatedSchema | readonly SquisqAnnotatedSchema[];
+    minItems?: number;
+    maxItems?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    oneOf?: readonly SquisqAnnotatedSchema[];
+    anyOf?: readonly SquisqAnnotatedSchema[];
+    allOf?: readonly SquisqAnnotatedSchema[];
+    $ref?: string;
+    $defs?: Record<string, SquisqAnnotatedSchema>;
+    definitions?: Record<string, SquisqAnnotatedSchema>;
+    squisq?: SquisqHints;
+}
+/**
+ * A validation error reported by the consumer-supplied `validate` prop.
+ * Matches the shape of common validators (ajv, etc.) without depending
+ * on any specific one.
+ */
+interface JsonFormValidationError {
+    /** JSON Pointer to the failing value, e.g. `/sections/0/heading`. */
+    path: string;
+    /** Human-readable message. */
+    message: string;
+    /** Optional schema keyword that failed (e.g. "required", "minimum"). */
+    keyword?: string;
+}
+type JsonFormValidator = (value: unknown, schema: SquisqAnnotatedSchema) => readonly JsonFormValidationError[];
+
+/**
+ * Pick a `ControlKind` for a schema node. The single dispatcher used by
+ * both `<JsonView>` and `<JsonEditor>` so view and edit modes always
+ * agree on what each field _is_, even when their UIs differ.
+ *
+ * Order of precedence:
+ *   1. Explicit `squisq.control` hint
+ *   2. `format` keyword (color/date/time/datetime/markdown/textarea)
+ *   3. Enum cardinality (segmented vs. combobox)
+ *   4. Numeric range (slider when both min and max present)
+ *   5. String length (multiline when maxLength > 200)
+ *   6. Type-default (object/array/boolean/string/number)
+ */
+
+declare function chooseControl(schema: SquisqAnnotatedSchema): ControlKind;
+/** Return the first concrete type of a schema, ignoring `null` for nullable shorthand. */
+declare function primaryType(schema: SquisqAnnotatedSchema): string | undefined;
+/** Inspect `items` to decide whether an array holds objects or primitives. */
+declare function arrayItemKind(schema: SquisqAnnotatedSchema): 'object' | 'primitive';
+
+/**
+ * Evaluate a `SquisqWhen` rule against the current root data. Pure;
+ * renderers call this on every render with fresh data.
+ */
+
+declare function evaluateWhen(when: SquisqWhen, rootData: unknown): boolean;
+/**
+ * Resolve a `boolean | SquisqWhen` flag (used by `hidden`/`disabled`)
+ * to a final boolean. Literal booleans pass through.
+ */
+declare function resolveFlag(flag: boolean | SquisqWhen | undefined, rootData: unknown): boolean;
+
+/**
+ * JSON Pointer helpers (RFC 6901) plus immutable get/set, plus a tiny
+ * dotted-path normalizer so hosts can write `user.role` instead of
+ * `/user/role`. `$ref` resolution is local-only (`#/$defs/Foo`).
+ */
+
+/** Normalize a path to a JSON Pointer string. Accepts both forms. */
+declare function toPointer(path: string): string;
+/** Split a JSON Pointer into decoded segments. Empty string → []. */
+declare function pointerSegments(pointer: string): string[];
+/** Read a value from data by path (dotted or pointer). Returns undefined if missing. */
+declare function getByPointer(data: unknown, path: string): unknown;
+/**
+ * Return a structurally-shared copy of `data` with the value at `path`
+ * replaced. Intermediate objects/arrays are cloned along the path; the
+ * rest is shared by reference. Creates intermediate objects if missing.
+ */
+declare function setByPointer<T>(data: T, path: string, value: unknown): T;
+/**
+ * Resolve a local `$ref` (e.g. `#/$defs/Foo`) against the root schema.
+ * Returns the original schema if no `$ref` is present, or `undefined`
+ * if the reference cannot be resolved. Cross-document refs are not
+ * supported.
+ */
+declare function resolveRef(schema: SquisqAnnotatedSchema, root: SquisqAnnotatedSchema): SquisqAnnotatedSchema | undefined;
+
+/**
+ * Infer a JSON Schema from an example JSON value. Thin facade over
+ * `genson-js` so consumers don't depend on it directly and we can swap
+ * the implementation later.
+ */
+
+interface InferSchemaOptions {
+    /** Additional samples merged into the inferred schema for broader coverage. */
+    additionalSamples?: readonly unknown[];
+}
+declare function inferSchema(sample: unknown, options?: InferSchemaOptions): SquisqAnnotatedSchema;
+
+export { type ControlKind, type InferSchemaOptions, type JsonFormValidationError, type JsonFormValidator, type SquisqAnnotatedSchema, type SquisqHints, type SquisqWhen, arrayItemKind, chooseControl, evaluateWhen, getByPointer, inferSchema, pointerSegments, primaryType, resolveFlag, resolveRef, setByPointer, toPointer };

package/dist/jsonForm/index.js

@@ -0,0 +1,27 @@
+import {
+  arrayItemKind,
+  chooseControl,
+  evaluateWhen,
+  getByPointer,
+  inferSchema,
+  pointerSegments,
+  primaryType,
+  resolveFlag,
+  resolveRef,
+  setByPointer,
+  toPointer
+} from "../chunk-K32VJONL.js";
+export {
+  arrayItemKind,
+  chooseControl,
+  evaluateWhen,
+  getByPointer,
+  inferSchema,
+  pointerSegments,
+  primaryType,
+  resolveFlag,
+  resolveRef,
+  setByPointer,
+  toPointer
+};
+//# sourceMappingURL=index.js.map

package/dist/jsonForm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/markdown/index.d.ts

@@ -1,31 +1,277 @@
+import { T as ParseOptions, l as MarkdownDocument, U as StringifyOptions, c as HtmlNode, F as MarkdownNode } from '../types-BdZkdJ3z.js';
+export { H as HeadingTemplateAnnotation, a as HtmlComment, b as HtmlElement, d as HtmlText, M as MarkdownBlockNode, e as MarkdownBlockquote, f as MarkdownBreak, g as MarkdownCodeBlock, h as MarkdownContainerDirective, i as MarkdownDefinitionDescription, j as MarkdownDefinitionList, k as MarkdownDefinitionTerm, m as MarkdownEmphasis, n as MarkdownFootnoteDefinition, o as MarkdownFootnoteReference, p as MarkdownHeading, q as MarkdownHtmlBlock, r as MarkdownImage, s as MarkdownImageReference, t as MarkdownInlineCode, u as MarkdownInlineHtml, v as MarkdownInlineMath, w as MarkdownInlineNode, x as MarkdownLeafDirective, y as MarkdownLink, z as MarkdownLinkDefinition, A as MarkdownLinkReference, B as MarkdownList, C as MarkdownListItem, D as MarkdownMathBlock, E as MarkdownMention, G as MarkdownParagraph, I as MarkdownPoint, J as MarkdownSourcePosition, K as MarkdownStrikethrough, L as MarkdownStrong, N as MarkdownTable, O as MarkdownTableCell, P as MarkdownTableRow, Q as MarkdownText, R as MarkdownTextDirective, S as MarkdownThematicBreak } from '../types-BdZkdJ3z.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.
+ *
+ * All extensions (GFM, math, directives) are enabled by default.
+ * Use the `options` parameter to disable specific extensions.
  *
- * Supports CommonMark + GFM (tables, strikethrough, task lists, footnotes) +
- * math ($...$, $$...$$) + directives (:::container, ::leaf, :text).
- * Raw HTML is parsed into a structured HtmlNode sub-DOM.
+ * @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'
  * ```
  */
-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, } from './utils.js';
-//# sourceMappingURL=index.d.ts.map
+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>;
+}
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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'
+ * ```
+ */
+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;
+
+export { HtmlNode, MarkdownDocument, MarkdownNode, ParseOptions, StringifyOptions, countNodes, createDocument, extractPlainText, findNodesByType, fromMdast, getChildren, inferDocumentTitle, parseFrontmatter, parseHtmlToNodes, parseMarkdown, readFrontmatterThemeId, setFrontmatterValues, stringifyHtmlNodes, stringifyMarkdown, toMdast, walkMarkdownTree };

package/dist/markdown/index.js

@@ -1,34 +1,40 @@
-/**
- * @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, } from './utils.js';
+import {
+  fromMdast,
+  parseHtmlToNodes,
+  parseMarkdown,
+  stringifyHtmlNodes,
+  stringifyMarkdown,
+  toMdast
+} from "../chunk-3K5OG6KI.js";
+import "../chunk-DBS6RIFL.js";
+import {
+  countNodes,
+  createDocument,
+  extractPlainText,
+  findNodesByType,
+  getChildren,
+  inferDocumentTitle,
+  parseFrontmatter,
+  readFrontmatterThemeId,
+  setFrontmatterValues,
+  walkMarkdownTree
+} from "../chunk-H3AXU4MJ.js";
+export {
+  countNodes,
+  createDocument,
+  extractPlainText,
+  findNodesByType,
+  fromMdast,
+  getChildren,
+  inferDocumentTitle,
+  parseFrontmatter,
+  parseHtmlToNodes,
+  parseMarkdown,
+  readFrontmatterThemeId,
+  setFrontmatterValues,
+  stringifyHtmlNodes,
+  stringifyMarkdown,
+  toMdast,
+  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,GACjB,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 };

package/dist/random/index.js

@@ -1,2 +1,10 @@
-export { SeededRandom, hashString } from './SeededRandom.js';
+import "../chunk-V543AI2F.js";
+import {
+  SeededRandom,
+  hashString
+} from "../chunk-FVTQSNR7.js";
+export {
+  SeededRandom,
+  hashString
+};
 //# sourceMappingURL=index.js.map

package/dist/random/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/random/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}