@fuzdev/mdz 0.1.0

package/dist/mdz.d.ts

@@ -0,0 +1,152 @@
+/**
+ * mdz — strict markdown dialect built for streaming, Svelte authoring, docs
+ * sites, and untrusted content.
+ *
+ * Created for two motivating use cases: rendering TSDoc/JSDoc comments on
+ * docs websites (with domain-specific behavior like linkifying backticked
+ * identifiers) and authoring content with Svelte components. It also has a
+ * streaming parser that extends the same grammar to LLM output.
+ *
+ * This module is the synchronous entry: `mdz_parse` parses a complete string
+ * to an `MdzNode` tree. It is the canonical reference parser — the streaming
+ * pipeline (`mdz_stream_parser.ts`) emits opcodes that converge on the same
+ * tree, asserted by parity tests.
+ *
+ * The dialect supports:
+ * - inline formatting: `code`, **bold**, _italic_, ~~strikethrough~~
+ * - auto-detected links: external URLs (`https://...`) and internal paths (`/path`)
+ * - markdown links: `[text](url)` with custom display text
+ * - inline code in backticks (creates `Code` nodes; auto-linking to identifiers/modules
+ *   is handled by the rendering layer via `MdzNodeView.svelte`)
+ * - paragraph breaks (blank lines)
+ * - block elements: headings, horizontal rules, lists, blockquotes, code blocks
+ * - HTML elements and Svelte components (opt-in via context)
+ *
+ * Whitespace: the parser preserves whitespace in text node content (single
+ * newlines stay literal `\n`, no `<br>` nodes), while structural whitespace is
+ * interpreted — blank lines separate paragraphs, extra blank lines collapse,
+ * and a line of only whitespace (spaces, tabs, `\r`) counts as blank, so an
+ * invisible trailing space never changes document structure.
+ * Presentation is the renderer's choice: by default whitespace collapses like
+ * standard markdown (single newlines are soft breaks), and the `whitespace`
+ * prop on `Mdz`/`MdzStream` opts into `pre-line` or `pre-wrap` rendering.
+ *
+ * ## Design philosophy
+ *
+ * - **False negatives over false positives**: When in doubt, treat as plain text.
+ *   Block elements can interrupt paragraphs without blank lines; inline formatting is strict.
+ * - **One way to do things**: Single unambiguous syntax per feature. No alternatives.
+ * - **Explicit over implicit**: Clear delimiters and column-0 requirements avoid ambiguity.
+ * - **Simple over complete**: Prefer simple parsing rules over complex edge case handling.
+ * - **No implicit retroactivity**: the grammar admits no construct where later input changes
+ *   the rendering of unboundedly-earlier output, so the streaming pipeline corrects only via
+ *   bounded, explicit opcodes and never re-parses.
+ *
+ * ## Status
+ *
+ * Pre-stable — breaking changes are expected as the dialect matures.
+ * Next: attributes, editing.
+ *
+ * @module
+ */
+/**
+ * Parses text to an array of `MdzNode`.
+ *
+ * Two phases: `MdzLexer` tokenizes the input into a flat `MdzToken[]` stream,
+ * then `MdzTokenParser` builds the `MdzNode[]` tree from the tokens.
+ */
+export declare const mdz_parse: (text: string) => Array<MdzNode>;
+export type MdzNode = MdzNodeText | MdzNodeCode | MdzNodeCodeblock | MdzNodeBold | MdzNodeItalic | MdzNodeStrikethrough | MdzNodeLink | MdzNodeParagraph | MdzNodeHr | MdzNodeHeading | MdzNodeList | MdzNodeListItem | MdzNodeBlockquote | MdzNodeElement | MdzNodeComponent;
+export interface MdzNodeBase {
+    type: string;
+    start: number;
+    end: number;
+}
+export interface MdzNodeText extends MdzNodeBase {
+    type: 'Text';
+    content: string;
+}
+export interface MdzNodeCode extends MdzNodeBase {
+    type: 'Code';
+    /** The code content (identifier/module name). */
+    content: string;
+}
+export interface MdzNodeCodeblock extends MdzNodeBase {
+    type: 'Codeblock';
+    /** Language hint, if provided. */
+    lang: string | null;
+    /** Raw code content. */
+    content: string;
+}
+export interface MdzNodeBold extends MdzNodeBase {
+    type: 'Bold';
+    children: Array<MdzNode>;
+}
+export interface MdzNodeItalic extends MdzNodeBase {
+    type: 'Italic';
+    children: Array<MdzNode>;
+}
+export interface MdzNodeStrikethrough extends MdzNodeBase {
+    type: 'Strikethrough';
+    children: Array<MdzNode>;
+}
+export interface MdzNodeLink extends MdzNodeBase {
+    type: 'Link';
+    /** URL or path. */
+    reference: string;
+    /** Display content (can include inline formatting). */
+    children: Array<MdzNode>;
+    /** `external` is `https`/`http`; `internal` is `/path`, `./path`, or `../path`. */
+    link_type: 'external' | 'internal';
+}
+export interface MdzNodeParagraph extends MdzNodeBase {
+    type: 'Paragraph';
+    children: Array<MdzNode>;
+}
+export interface MdzNodeHr extends MdzNodeBase {
+    type: 'Hr';
+}
+export interface MdzNodeHeading extends MdzNodeBase {
+    type: 'Heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    /** Slugified heading text for fragment links. */
+    id: string;
+    /** Inline formatting allowed. */
+    children: Array<MdzNode>;
+}
+export interface MdzNodeList extends MdzNodeBase {
+    type: 'List';
+    ordered: boolean;
+    /** First item's authored number (ordered only) — the `<ol start>` attribute. */
+    start_number?: number;
+    children: Array<MdzNodeListItem>;
+}
+export interface MdzNodeListItem extends MdzNodeBase {
+    type: 'ListItem';
+    /** Authored number (ordered only); the renderer ignores it, tooling and the future formatter use it. */
+    number?: number;
+    /** Inline run first, then block children (`Paragraph` | `List` | `Codeblock` | `Blockquote`). */
+    children: Array<MdzNode>;
+}
+export interface MdzNodeBlockquote extends MdzNodeBase {
+    type: 'Blockquote';
+    /**
+     * Block children — a quote's content is a mini-document, so anything that
+     * can appear at the top level can appear here (`Paragraph` | `Heading` |
+     * `Hr` | `List` | `Codeblock` | `Blockquote`).
+     */
+    children: Array<MdzNode>;
+}
+export interface MdzNodeElement extends MdzNodeBase {
+    type: 'Element';
+    /** HTML element name (e.g. `div`, `span`, `aside`). */
+    name: string;
+    children: Array<MdzNode>;
+}
+export interface MdzNodeComponent extends MdzNodeBase {
+    type: 'Component';
+    /** Svelte component name (e.g. `Alert`, `Card`). */
+    name: string;
+    children: Array<MdzNode>;
+}
+//# sourceMappingURL=mdz.d.ts.map

package/dist/mdz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAOH;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,KAAG,KAAK,CAAC,OAAO,CACI,CAAC;AAE3D,MAAM,MAAM,OAAO,GAChB,WAAW,GACX,WAAW,GACX,gBAAgB,GAChB,WAAW,GACX,aAAa,GACb,oBAAoB,GACpB,WAAW,GACX,gBAAgB,GAChB,SAAS,GACT,cAAc,GACd,WAAW,GACX,eAAe,GACf,iBAAiB,GACjB,cAAc,GACd,gBAAgB,CAAC;AAEpB,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACpD,IAAI,EAAE,WAAW,CAAC;IAClB,kCAAkC;IAClC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,aAAc,SAAQ,WAAW;IACjD,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,oBAAqB,SAAQ,WAAW;IACxD,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,mBAAmB;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACzB,mFAAmF;IACnF,SAAS,EAAE,UAAU,GAAG,UAAU,CAAC;CACnC;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACpD,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,SAAU,SAAQ,WAAW;IAC7C,IAAI,EAAE,IAAI,CAAC;CACX;AAED,MAAM,WAAW,cAAe,SAAQ,WAAW;IAClD,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7B,iDAAiD;IACjD,EAAE,EAAE,MAAM,CAAC;IACX,iCAAiC;IACjC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,eAAgB,SAAQ,WAAW;IACnD,IAAI,EAAE,UAAU,CAAC;IACjB,wGAAwG;IACxG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iGAAiG;IACjG,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACrD,IAAI,EAAE,YAAY,CAAC;IACnB;;;;OAIG;IACH,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,cAAe,SAAQ,WAAW;IAClD,IAAI,EAAE,SAAS,CAAC;IAChB,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACpD,IAAI,EAAE,WAAW,CAAC;IAClB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACzB"}

package/dist/mdz.js

@@ -0,0 +1,61 @@
+/**
+ * mdz — strict markdown dialect built for streaming, Svelte authoring, docs
+ * sites, and untrusted content.
+ *
+ * Created for two motivating use cases: rendering TSDoc/JSDoc comments on
+ * docs websites (with domain-specific behavior like linkifying backticked
+ * identifiers) and authoring content with Svelte components. It also has a
+ * streaming parser that extends the same grammar to LLM output.
+ *
+ * This module is the synchronous entry: `mdz_parse` parses a complete string
+ * to an `MdzNode` tree. It is the canonical reference parser — the streaming
+ * pipeline (`mdz_stream_parser.ts`) emits opcodes that converge on the same
+ * tree, asserted by parity tests.
+ *
+ * The dialect supports:
+ * - inline formatting: `code`, **bold**, _italic_, ~~strikethrough~~
+ * - auto-detected links: external URLs (`https://...`) and internal paths (`/path`)
+ * - markdown links: `[text](url)` with custom display text
+ * - inline code in backticks (creates `Code` nodes; auto-linking to identifiers/modules
+ *   is handled by the rendering layer via `MdzNodeView.svelte`)
+ * - paragraph breaks (blank lines)
+ * - block elements: headings, horizontal rules, lists, blockquotes, code blocks
+ * - HTML elements and Svelte components (opt-in via context)
+ *
+ * Whitespace: the parser preserves whitespace in text node content (single
+ * newlines stay literal `\n`, no `<br>` nodes), while structural whitespace is
+ * interpreted — blank lines separate paragraphs, extra blank lines collapse,
+ * and a line of only whitespace (spaces, tabs, `\r`) counts as blank, so an
+ * invisible trailing space never changes document structure.
+ * Presentation is the renderer's choice: by default whitespace collapses like
+ * standard markdown (single newlines are soft breaks), and the `whitespace`
+ * prop on `Mdz`/`MdzStream` opts into `pre-line` or `pre-wrap` rendering.
+ *
+ * ## Design philosophy
+ *
+ * - **False negatives over false positives**: When in doubt, treat as plain text.
+ *   Block elements can interrupt paragraphs without blank lines; inline formatting is strict.
+ * - **One way to do things**: Single unambiguous syntax per feature. No alternatives.
+ * - **Explicit over implicit**: Clear delimiters and column-0 requirements avoid ambiguity.
+ * - **Simple over complete**: Prefer simple parsing rules over complex edge case handling.
+ * - **No implicit retroactivity**: the grammar admits no construct where later input changes
+ *   the rendering of unboundedly-earlier output, so the streaming pipeline corrects only via
+ *   bounded, explicit opcodes and never re-parses.
+ *
+ * ## Status
+ *
+ * Pre-stable — breaking changes are expected as the dialect matures.
+ * Next: attributes, editing.
+ *
+ * @module
+ */
+import { MdzLexer } from './mdz_lexer.js';
+import { MdzTokenParser } from './mdz_token_parser.js';
+// TODO design incremental parsing or some system that preserves Svelte components across re-renders when possible
+/**
+ * Parses text to an array of `MdzNode`.
+ *
+ * Two phases: `MdzLexer` tokenizes the input into a flat `MdzToken[]` stream,
+ * then `MdzTokenParser` builds the `MdzNode[]` tree from the tokens.
+ */
+export const mdz_parse = (text) => new MdzTokenParser(new MdzLexer(text).tokenize()).parse();

package/dist/mdz_contexts.d.ts

@@ -0,0 +1,106 @@
+import type { Component } from 'svelte';
+/**
+ * Component registry for custom Svelte components that can be used in mdz content.
+ *
+ * For example, registering 'Alert' allows using `<Alert>...</Alert>` in mdz content.
+ *
+ * The Map values are Svelte components.
+ */
+export type MdzComponents = Map<string, Component<any, any>>;
+/**
+ * Element registry for HTML elements that can be used in mdz content.
+ *
+ * For example, registering 'div' allows using `<div>...</div>` in mdz content.
+ *
+ * The Map values are boolean placeholders for future configuration options.
+ */
+export type MdzElements = Map<string, boolean>;
+/**
+ * CSS `white-space` values for the `whitespace` prop on `Mdz`, `MdzStream`,
+ * and `MdzPrecompiled`. By default no style is applied, so whitespace
+ * collapses like standard markdown — single newlines are soft breaks.
+ * `pre-line` renders every newline as a line break (chat-style input);
+ * `pre-wrap` additionally preserves spaces and tabs.
+ */
+export type MdzWhitespace = 'normal' | 'nowrap' | 'pre' | 'pre-wrap' | 'pre-line' | 'break-spaces';
+/**
+ * Context for providing custom mdz components via a getter function.
+ * Set to a getter (e.g., `() => components`) so changes are reflected reactively.
+ */
+export declare const mdz_components_context: {
+    get: (error_message?: string) => () => MdzComponents | undefined;
+    get_maybe: () => (() => MdzComponents | undefined) | undefined;
+    set: (value: () => MdzComponents | undefined) => () => MdzComponents | undefined;
+};
+/**
+ * Context for providing allowed HTML elements via a getter function.
+ * Set to a getter (e.g., `() => elements`) so changes are reflected reactively.
+ * By default, no HTML elements are allowed.
+ */
+export declare const mdz_elements_context: {
+    get: (error_message?: string) => () => MdzElements | undefined;
+    get_maybe: () => (() => MdzElements | undefined) | undefined;
+    set: (value: () => MdzElements | undefined) => () => MdzElements | undefined;
+};
+/**
+ * Context for providing a base path getter for resolving relative links in mdz content.
+ * Set to a getter (e.g., `() => base`) so changes to the base prop are reflected
+ * without needing an effect. When the getter returns a path like `'/docs/usage/'`,
+ * relative paths like `./grammar` resolve to `/docs/usage/grammar` before rendering.
+ * When not set, relative paths use raw hrefs (browser resolves them).
+ */
+export declare const mdz_base_context: {
+    get: (error_message?: string) => () => string | undefined;
+    get_maybe: () => (() => string | undefined) | undefined;
+    set: (value: () => string | undefined) => () => string | undefined;
+};
+/**
+ * Component that renders an inline `` `code` `` span. Receives the raw span
+ * content as `reference` — the prop name matches `fuz_ui`'s `DocsLink`, so it
+ * can be injected directly to auto-link backticked API identifiers.
+ */
+export type MdzCodeComponent = Component<{
+    reference: string;
+}>;
+/**
+ * Context for overriding how inline `` `code` `` spans render, via a getter
+ * function. When not set, inline code renders as a plain `<code>` element.
+ */
+export declare const mdz_code_context: {
+    get: (error_message?: string) => () => MdzCodeComponent | undefined;
+    get_maybe: () => (() => MdzCodeComponent | undefined) | undefined;
+    set: (value: () => MdzCodeComponent | undefined) => () => MdzCodeComponent | undefined;
+};
+/**
+ * Component that renders a fenced code block. Receives `lang` and `content`,
+ * matching `@fuzdev/fuz_code`'s `Code`, so it can be injected directly for
+ * syntax highlighting.
+ */
+export type MdzCodeblockComponent = Component<{
+    lang: string | null;
+    content: string;
+}>;
+/**
+ * Context for overriding how fenced code blocks render, via a getter function.
+ * When not set, code blocks render as a plain `<pre><code>` element.
+ */
+export declare const mdz_codeblock_context: {
+    get: (error_message?: string) => () => MdzCodeblockComponent | undefined;
+    get_maybe: () => (() => MdzCodeblockComponent | undefined) | undefined;
+    set: (value: () => MdzCodeblockComponent | undefined) => () => MdzCodeblockComponent | undefined;
+};
+interface MdzGetterContext<T> {
+    get_maybe(): (() => T | undefined) | undefined;
+    set(value: () => T | undefined): unknown;
+}
+/**
+ * Set an mdz context to a getter that prefers the local `value_fn` and falls
+ * back to the ancestor's value when `value_fn()` returns `undefined`.
+ *
+ * Pass `value_fn` as a getter (not a snapshot) so prop changes remain reactive.
+ * The ancestor lookup happens once at component init — that's intentional, it
+ * captures the surrounding scope's context at mount time.
+ */
+export declare const mdz_set_context_with_fallback: <T>(context: MdzGetterContext<T>, value_fn: () => T | undefined) => void;
+export {};
+//# sourceMappingURL=mdz_contexts.d.ts.map

package/dist/mdz_contexts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_contexts.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_contexts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,QAAQ,CAAC;AAItC;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAE7D;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,QAAQ,GAAG,KAAK,GAAG,UAAU,GAAG,UAAU,GAAG,cAAc,CAAC;AAEnG;;;GAGG;AACH,eAAO,MAAM,sBAAsB;2CAAwB,aAAa,GAAG,SAAS;4BAAzB,aAAa,GAAG,SAAS;uBAAzB,aAAa,GAAG,SAAS,WAAzB,aAAa,GAAG,SAAS;CAAG,CAAC;AAExF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;2CAAwB,WAAW,GAAG,SAAS;4BAAvB,WAAW,GAAG,SAAS;uBAAvB,WAAW,GAAG,SAAS,WAAvB,WAAW,GAAG,SAAS;CAAG,CAAC;AAEpF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;2CAAwB,MAAM,GAAG,SAAS;4BAAlB,MAAM,GAAG,SAAS;uBAAlB,MAAM,GAAG,SAAS,WAAlB,MAAM,GAAG,SAAS;CAAG,CAAC;AAE3E;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,gBAAgB;2CAAwB,gBAAgB,GAAG,SAAS;4BAA5B,gBAAgB,GAAG,SAAS;uBAA5B,gBAAgB,GAAG,SAAS,WAA5B,gBAAgB,GAAG,SAAS;CAAG,CAAC;AAErF;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AAEtF;;;GAGG;AACH,eAAO,MAAM,qBAAqB;2CAAwB,qBAAqB,GAAG,SAAS;4BAAjC,qBAAqB,GAAG,SAAS;uBAAjC,qBAAqB,GAAG,SAAS,WAAjC,qBAAqB,GAAG,SAAS;CAAG,CAAC;AAE/F,UAAU,gBAAgB,CAAC,CAAC;IAC3B,SAAS,IAAI,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;IAC/C,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS,GAAG,OAAO,CAAC;CACzC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B,GAAI,CAAC,EAC9C,SAAS,gBAAgB,CAAC,CAAC,CAAC,EAC5B,UAAU,MAAM,CAAC,GAAG,SAAS,KAC3B,IAGF,CAAC"}

package/dist/mdz_contexts.js

@@ -0,0 +1,42 @@
+import { create_context } from './context_helpers.js';
+/**
+ * Context for providing custom mdz components via a getter function.
+ * Set to a getter (e.g., `() => components`) so changes are reflected reactively.
+ */
+export const mdz_components_context = create_context();
+/**
+ * Context for providing allowed HTML elements via a getter function.
+ * Set to a getter (e.g., `() => elements`) so changes are reflected reactively.
+ * By default, no HTML elements are allowed.
+ */
+export const mdz_elements_context = create_context();
+/**
+ * Context for providing a base path getter for resolving relative links in mdz content.
+ * Set to a getter (e.g., `() => base`) so changes to the base prop are reflected
+ * without needing an effect. When the getter returns a path like `'/docs/usage/'`,
+ * relative paths like `./grammar` resolve to `/docs/usage/grammar` before rendering.
+ * When not set, relative paths use raw hrefs (browser resolves them).
+ */
+export const mdz_base_context = create_context();
+/**
+ * Context for overriding how inline `` `code` `` spans render, via a getter
+ * function. When not set, inline code renders as a plain `<code>` element.
+ */
+export const mdz_code_context = create_context();
+/**
+ * Context for overriding how fenced code blocks render, via a getter function.
+ * When not set, code blocks render as a plain `<pre><code>` element.
+ */
+export const mdz_codeblock_context = create_context();
+/**
+ * Set an mdz context to a getter that prefers the local `value_fn` and falls
+ * back to the ancestor's value when `value_fn()` returns `undefined`.
+ *
+ * Pass `value_fn` as a getter (not a snapshot) so prop changes remain reactive.
+ * The ancestor lookup happens once at component init — that's intentional, it
+ * captures the surrounding scope's context at mount time.
+ */
+export const mdz_set_context_with_fallback = (context, value_fn) => {
+    const ancestor = context.get_maybe();
+    context.set(() => value_fn() ?? ancestor?.());
+};