shelving 1.219.1 → 1.221.0

package/extract/MarkdownExtractor.js

@@ -1,5 +1,4 @@
-import { renderMarkup } from "../markup/render.js";
-import { MARKUP_OPTIONS } from "../markup/rule/index.js";
+import { MARKUP_PARSER } from "../markup/MarkupParser.js";
 import { getElementText } from "../util/element.js";
 import { FileExtractor } from "./FileExtractor.js";
 /**
@@ -53,7 +52,7 @@ export function extractMarkdownDescription(text) {
     if (!paragraph.length)
         return;
     // Render the paragraph as markup then strip every tag, so inline syntax resolves to clean plain text.
-    const rendered = renderMarkup(paragraph.join(" "), MARKUP_OPTIONS);
+    const rendered = MARKUP_PARSER.parse(paragraph.join(" "));
     const summary = getElementText(rendered).replace(/\s+/g, " ").trim();
     return summary || undefined;
 }

package/markup/MarkupParser.d.ts

@@ -0,0 +1,97 @@
+import type { ReactNode } from "react";
+import type { ImmutableArray } from "../util/array.js";
+import { type PossibleLink } from "../util/link.js";
+import type { Nullish } from "../util/null.js";
+import { type ImmutableURI, type URISchemes } from "../util/uri.js";
+import type { ImmutableURL } from "../util/url.js";
+import type { MarkupRule, MarkupRules } from "./MarkupRule.js";
+import type { Parser } from "./Parser.js";
+/** The current parsing options (represents the current state of the parsing). */
+export type MarkupOptions = {
+    /**
+     * The active list of parsing rules.
+     * @default MARKUP_RULES The default list of markup rules.
+     */
+    readonly rules?: MarkupRules | undefined;
+    /**
+     * Set the `rel=""` property used for any links (e.g. `rel="nofollow ugc"`).
+     * @example "nofollow ugc" // Stop user-generated content ruining our SEO juice.
+     */
+    readonly rel?: string | undefined;
+    /**
+     * Current page URL — used as the base for resolving relative refs (`./foo`, `#x`, bare segments) in link hrefs.
+     */
+    readonly url?: ImmutableURL | undefined;
+    /**
+     * Site root URL — used as the base for resolving site-absolute path hrefs (`/foo`), honoring its subfolder.
+     */
+    readonly root?: ImmutableURL | undefined;
+    /**
+     * Valid URI schemes/protocols for URLs and URIs.
+     * @example ["http:", "https:"]
+     * @default ["http:", "https:"]
+     */
+    readonly schemes?: URISchemes | undefined;
+    /**
+     * Default context to use if one isn't set. Defaults to `"block"`
+     */
+    readonly context?: string;
+};
+export declare class MarkupParser implements Parser<string, ReactNode> {
+    /**
+     * The list of parsing rules this parser applies.
+     */
+    readonly rules: MarkupRules;
+    /**
+     * Calculated list of priorities to iterate over (extracted from the rules), e.g. [10, 0, -10]
+     */
+    readonly priorities: ImmutableArray<number>;
+    /**
+     * Set the `rel=""` property used for any links (e.g. `rel="nofollow ugc"`).
+     * @example "nofollow ugc"
+     */
+    readonly rel: string | undefined;
+    /**
+     * Current page URL — used as the base for resolving relative refs (`./foo`, `#x`, bare segments) in link hrefs.
+     * @default Falls back to `root` if not set.
+     */
+    readonly url: ImmutableURL | undefined;
+    /**
+     * Site root URL — used as the base for resolving site-absolute path hrefs (`/foo`), honoring its subfolder.
+     * @default Falls back to `url` if not set.
+     */
+    readonly root: ImmutableURL | undefined;
+    /**
+     * Valid URI schemes/protocols for URLs and URIs.
+     * @example ["http:", "https:"]
+     * @default ["http:", "https:"]
+     */
+    readonly schemes: URISchemes;
+    /**
+     * Default context to use if one isn't set. Defaults to `"block"`
+     */
+    readonly context: string;
+    constructor({ rules, rel, url, root, schemes, context }?: MarkupOptions);
+    /**
+     * Parse a text string as Markdownish markup syntax and render it as elements.
+     * - Syntax is not defined by this code, but by the rules supplied to it.
+     *
+     * @param input The string content possibly containing markup syntax, e.g. "This is a *bold* string.
+     * @param parser A markup parser instance.
+     * @param context The context to render in (defaults to `"block"`).
+     *
+     * @returns A React node — an element, a string, `null`, or an array of zero or more of those.
+     */
+    parse(input: string, context?: string): ReactNode;
+    /** Yield the rules active in `context` that sit in the given priority tier. */
+    getRules(context: string, priority: number): Iterable<MarkupRule>;
+    /**
+     * Get a HREF link with the correct context of our `options.url` and `options.root`
+     *
+     * @returns `ImmutableURI` a (URL) object if the link matches and is parseable and has an allowed scheme.
+     * @returns `undefined` if the link does not amtch the allowed `options.schemes`
+     */
+    getLink(href: Nullish<PossibleLink>): ImmutableURI | undefined;
+}
+/** MarkupParser sentinel with the default markup rules */
+export declare const MARKUP_PARSER: MarkupParser;

package/markup/MarkupParser.js

@@ -0,0 +1,249 @@
+import { getLink } from "../util/link.js";
+import { HTTP_SCHEMES } from "../util/uri.js";
+import { MARKUP_RULES } from "./rule/index.js";
+export class MarkupParser {
+    /**
+     * The list of parsing rules this parser applies.
+     */
+    rules;
+    /**
+     * Calculated list of priorities to iterate over (extracted from the rules), e.g. [10, 0, -10]
+     */
+    priorities;
+    /**
+     * Set the `rel=""` property used for any links (e.g. `rel="nofollow ugc"`).
+     * @example "nofollow ugc"
+     */
+    rel;
+    /**
+     * Current page URL — used as the base for resolving relative refs (`./foo`, `#x`, bare segments) in link hrefs.
+     * @default Falls back to `root` if not set.
+     */
+    url;
+    /**
+     * Site root URL — used as the base for resolving site-absolute path hrefs (`/foo`), honoring its subfolder.
+     * @default Falls back to `url` if not set.
+     */
+    root;
+    /**
+     * Valid URI schemes/protocols for URLs and URIs.
+     * @example ["http:", "https:"]
+     * @default ["http:", "https:"]
+     */
+    schemes;
+    /**
+     * Default context to use if one isn't set. Defaults to `"block"`
+     */
+    context;
+    constructor({ rules = MARKUP_RULES, rel, url, root, schemes = HTTP_SCHEMES, context = "block" } = {}) {
+        this.rules = rules;
+        this.priorities = _getPriorities(rules);
+        this.rel = rel;
+        this.url = url;
+        this.root = root;
+        this.schemes = schemes;
+        this.context = context;
+    }
+    /**
+     * Parse a text string as Markdownish markup syntax and render it as elements.
+     * - Syntax is not defined by this code, but by the rules supplied to it.
+     *
+     * @param input The string content possibly containing markup syntax, e.g. "This is a *bold* string.
+     * @param parser A markup parser instance.
+     * @param context The context to render in (defaults to `"block"`).
+     *
+     * @returns A React node — an element, a string, `null`, or an array of zero or more of those.
+     */
+    parse(input, context = "block") {
+        const nodes = _parseNodes(input, this, context);
+        return !nodes.length ? null : nodes.length === 1 ? nodes[0] : nodes;
+    }
+    /** Yield the rules active in `context` that sit in the given priority tier. */
+    *getRules(context, priority) {
+        for (const r of this.rules)
+            if (r.priority === priority && r.contexts.includes(context))
+                yield r;
+    }
+    /**
+     * Get a HREF link with the correct context of our `options.url` and `options.root`
+     *
+     * @returns `ImmutableURI` a (URL) object if the link matches and is parseable and has an allowed scheme.
+     * @returns `undefined` if the link does not amtch the allowed `options.schemes`
+     */
+    getLink(href) {
+        const link = getLink(href, this.url, this.root);
+        if (link && this.schemes.includes(link.protocol))
+            return link;
+    }
+}
+/** Extract the unique rule priorities, ordered highest first — these are the tiers to resolve in turn. */
+function _getPriorities(rules) {
+    const priorities = [];
+    for (const { priority } of rules)
+        if (!priorities.includes(priority))
+            priorities.push(priority);
+    return priorities.sort().reverse();
+}
+/**
+ * Parse a string into its rendered nodes using a tiered / masking engine.
+ *
+ * Rules are grouped into priority tiers and resolved highest tier first. Once a tier claims a
+ * region it is "masked" (blanked in a working copy of the string) so lower-priority rules cannot
+ * match into — or across — it, but can still match around it. That single mechanism is the fix
+ * for code spans that straddle link delimiters: a code span is masked before links resolve, so a
+ * link either wraps a whole masked code span (and re-parses it) or cannot form at all.
+ *
+ * Rules own the recursion into their own children — they call `parser.parse` again, optionally
+ * with a different context — so the engine never reaches inside a rule's content itself.
+ */
+function _parseNodes(input, parser, context) {
+    // Resolve tier by tier. `claimed` collects the winning regions; `masked` hides each resolved
+    // region from every lower tier.
+    const claimed = [];
+    let masked = input;
+    for (const priority of parser.priorities) {
+        const higher = Array.from(claimed); // Snapshot — claims from already-resolved (higher) tiers.
+        for (const claim of _scanTier(masked, input, parser, context, priority, higher)) {
+            // A claim that wraps earlier (higher-tier) claims absorbs them: the wrapper re-parses
+            // that text itself (e.g. a link re-parsing its own title).
+            for (let i = claimed.length - 1; i >= 0; i--) {
+                const c = claimed[i];
+                if (c && c.start >= claim.start && c.end <= claim.end)
+                    claimed.splice(i, 1);
+            }
+            claimed.push(claim);
+            masked = _mask(masked, claim.start, claim.end);
+        }
+    }
+    // Walk left to right: raw text fills the gaps, rendered elements fill the claims. Each claim
+    // already carries the capture groups recovered against the original text, so no rule's regexp
+    // needs to run a second time here.
+    claimed.sort((a, b) => a.start - b.start);
+    const nodes = [];
+    let pos = 0;
+    for (const { rule, start, end, groups } of claimed) {
+        if (start > pos)
+            nodes.push(input.slice(pos, start));
+        nodes.push(rule.render(start.toString(), groups, parser));
+        pos = end;
+    }
+    if (pos < input.length)
+        nodes.push(input.slice(pos));
+    return nodes;
+}
+/**
+ * Yield one tier's winning claims, left to right, non-overlapping.
+ *
+ * "Leftmost wins" needs every rule's next match up front — but instead of throwing the losers
+ * away we cache one match per rule, and only recompute a rule's match when the chosen claim
+ * actually invalidated it. A rule whose match still lies ahead is reused untouched.
+ */
+function* _scanTier(masked, input, parser, context, priority, higher) {
+    // Materialise this tier's rules.
+    const rules = Array.from(parser.getRules(context, priority));
+    // Prime one cached match per rule.
+    const cache = [];
+    for (const rule of rules)
+        cache.push(_findFrom(rule, masked, input, 0, higher));
+    for (;;) {
+        // The leftmost cached match wins; on a tie the earlier rule in the list wins.
+        let best;
+        for (const claim of cache)
+            if (claim && (!best || claim.start < best.start))
+                best = claim;
+        if (!best)
+            return;
+        yield best;
+        // Keep every cached match still ahead of `best`; recompute only the rules whose match overlapped (or was) `best`.
+        for (let i = 0; i < rules.length; i++) {
+            const rule = rules[i];
+            const claim = cache[i];
+            if (rule && (!claim || claim.start < best.end))
+                cache[i] = _findFrom(rule, masked, input, best.end, higher);
+        }
+    }
+}
+/**
+ * Find the first valid claim for `rule` in `masked` at or after `from`, or `undefined`.
+ * - A claim is valid if it sits in free space, or if it genuinely wraps the higher-tier claims it spans.
+ * - Confirmed by re-running the rule on the original (unmasked) slice and checking it still matches the whole region.
+ * - A match that merely straddles a masked region (e.g. a paragraph's trailing whitespace swallowing a fenced block) is spurious and is retried bounded by the claim it crossed.
+ */
+function _findFrom(rule, masked, input, from, higher) {
+    let lo = from;
+    for (;;) {
+        // Advance `lo` past any higher-tier claim that covers it.
+        for (let moved = true; moved;) {
+            moved = false;
+            for (const h of higher)
+                if (h.start <= lo && lo < h.end) {
+                    lo = h.end;
+                    moved = true;
+                }
+        }
+        if (lo >= masked.length)
+            return undefined;
+        const match = rule.regexp.exec(masked.slice(lo));
+        if (!match)
+            return undefined;
+        const start = lo + match.index;
+        const end = start + match[0].length;
+        // Inspect the higher-tier claims this match touches in a single allocation-free pass:
+        // - `leadingEnd` — a claim starts at/before the match, so the match cannot begin here.
+        // - `interior` — every spanned claim sits strictly inside (a possible genuine wrapper).
+        // - `wallStart`/`wallEnd` — the first claim the match crosses, used to bound a retry.
+        let overlaps = false;
+        let leadingEnd = -1;
+        let interior = true;
+        let wallStart = masked.length;
+        let wallEnd = -1;
+        for (const h of higher) {
+            if (h.start < end && h.end > start) {
+                overlaps = true;
+                if (h.start <= start) {
+                    if (h.end > leadingEnd)
+                        leadingEnd = h.end;
+                }
+                else if (h.end >= end) {
+                    interior = false;
+                }
+                if (h.start < wallStart) {
+                    wallStart = h.start;
+                    wallEnd = h.end;
+                }
+            }
+        }
+        if (!overlaps)
+            return { rule, start, end, groups: match.groups };
+        // A higher claim starts at or before this match — it cannot begin here, skip past it.
+        if (leadingEnd >= 0) {
+            lo = leadingEnd;
+            continue;
+        }
+        // A genuine wrapper holds every spanned claim strictly inside it (delimiters of its own on
+        // both sides) and still matches the whole region when re-run on the original (unmasked)
+        // slice. A claim that merely shares a boundary — a paragraph whose trailing whitespace
+        // swallows the block below it — is spurious, not a wrapper.
+        if (interior) {
+            const original = rule.regexp.exec(input.slice(start, end));
+            if (original && !original.index && original[0].length === end - start)
+                return { rule, start, end, groups: original.groups };
+        }
+        // Spurious span — retry bounded by the first claim it crossed.
+        const bounded = rule.regexp.exec(masked.slice(lo, wallStart));
+        if (bounded) {
+            const s = lo + bounded.index;
+            return { rule, start: s, end: s + bounded[0].length, groups: bounded.groups };
+        }
+        lo = wallEnd;
+    }
+}
+/** Blank the `[start, end)` region of `text` — every character becomes a space, except newlines. */
+function _mask(text, start, end) {
+    let blanked = "";
+    for (let i = start; i < end; i++)
+        blanked += text[i] === "\n" ? "\n" : " ";
+    return `${text.slice(0, start)}${blanked}${text.slice(end)}`;
+}
+/** MarkupParser sentinel with the default markup rules */
+export const MARKUP_PARSER = new MarkupParser();

package/markup/MarkupRule.d.ts

@@ -0,0 +1,19 @@
+import type { ReactElement } from "react";
+import type { EmptyDictionary } from "../util/dictionary.js";
+import type { NamedRegExp, NamedRegExpData } from "../util/regexp.js";
+import type { MarkupParser } from "./MarkupParser.js";
+export type MarkupContexts = [string, ...string[]];
+export interface MarkupRule {
+    /** Regular expression used for matching the rule. */
+    regexp: RegExp;
+    /** Use the matched data to render an element. */
+    render(key: string, data: NamedRegExpData | undefined, parser: MarkupParser): ReactElement;
+    /** One or more contexts this rule should render in. */
+    contexts: MarkupContexts;
+    /** Priority for this rule (higher priority rules override lower priority rules). */
+    priority: number;
+}
+export type MarkupRules = readonly MarkupRule[];
+/** Helper to make it easier to create typed `MarkupRule` instances using `NamedRegExp` regular expressions. */
+export declare function createMarkupRule<T extends NamedRegExpData>(regexp: NamedRegExp<T>, render: (key: string, data: T, parser: MarkupParser) => ReactElement, contexts: MarkupContexts, priority?: number): MarkupRule;
+export declare function createMarkupRule(regexp: RegExp, render: (key: string, data: EmptyDictionary, parser: MarkupParser) => ReactElement, contexts: MarkupContexts, priority?: number): MarkupRule;

package/markup/{util/rule.js → MarkupRule.js}

@@ -1,4 +1,3 @@
-/** Helper to make it easier to create typed `MarkupRule` instances using `NamedRegExp` regular expressions. */
 export function createMarkupRule(regexp, render, contexts, priority = 0) {
     return {
         regexp,

package/markup/Parser.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class Parser<I, O> {
+    abstract parse(input: I): O;
+}

package/markup/Parser.js

@@ -0,0 +1,2 @@
+export class Parser {
+}

package/markup/index.d.ts

@@ -1,5 +1,4 @@
-export * from "./util/options.js";
-export * from "./util/regexp.js";
-export * from "./util/rule.js";
-export * from "./render.js";
+export * from "./MarkupParser.js";
+export * from "./MarkupRule.js";
 export * from "./rule/index.js";
+export * from "./util/regexp.js";

package/markup/index.js

@@ -1,6 +1,4 @@
-export * from "./util/options.js";
-export * from "./util/regexp.js";
-export * from "./util/rule.js";
-// export * from "./util/internal.js"; // Not exported.
-export * from "./render.js";
+export * from "./MarkupParser.js";
+export * from "./MarkupRule.js";
 export * from "./rule/index.js";
+export * from "./util/regexp.js";

package/markup/rule/blockquote.d.ts

@@ -1,8 +1,7 @@
-export declare const BLOCKQUOTE_REGEXP: RegExp;
 /**
  * Blockquote block.
  * - `>` quote character followed by zero or more spaces.
  * - No spaces can appear before the `>` quote character.
  * - Quote block is only broken by `\n\n` two newline characters.
  */
-export declare const BLOCKQUOTE_RULE: import("../util/rule.js").MarkupRule;
+export declare const BLOCKQUOTE_RULE: import("../MarkupRule.js").MarkupRule;

package/markup/rule/blockquote.js

@@ -1,14 +1,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { renderMarkup } from "../render.js";
+import { createMarkupRule } from "../MarkupRule.js";
 import { BLOCK_CONTENT_REGEXP, createBlockRegExp } from "../util/regexp.js";
-import { createMarkupRule } from "../util/rule.js";
 const PREFIX = ">";
 const INDENT = new RegExp(`^${PREFIX}`, "gm");
-export const BLOCKQUOTE_REGEXP = createBlockRegExp(`${PREFIX}${BLOCK_CONTENT_REGEXP}`);
 /**
  * Blockquote block.
  * - `>` quote character followed by zero or more spaces.
  * - No spaces can appear before the `>` quote character.
  * - Quote block is only broken by `\n\n` two newline characters.
  */
-export const BLOCKQUOTE_RULE = createMarkupRule(BLOCKQUOTE_REGEXP, ([quote], options, key) => _jsx("blockquote", { children: renderMarkup(quote.replace(INDENT, ""), options, "block") }, key), ["block", "list"]);
+export const BLOCKQUOTE_RULE = createMarkupRule(createBlockRegExp(`(?<quote>${PREFIX}${BLOCK_CONTENT_REGEXP})`), (key, { quote }, parser) => _jsx("blockquote", { children: parser.parse(quote.replace(INDENT, ""), "block") }, key), ["block", "list"]);

package/markup/rule/code.d.ts

@@ -3,6 +3,7 @@
  * - Text surrounded by one or more "`" backtick tilde characters.
  * - Unlike strong/emphasis first or last character of the element can be space, (e.g. `- abc -` will not work).
  * - Closing characters must exactly match opening characters.
+ * - Works inside link text too, e.g. `` [`code`](url) ``.
  * - Same as Markdown syntax.
  */
-export declare const CODE_RULE: import("../util/rule.js").MarkupRule;
+export declare const CODE_RULE: import("../MarkupRule.js").MarkupRule;

package/markup/rule/code.js

@@ -1,13 +1,15 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { getRegExp } from "../../util/regexp.js";
+import { createMarkupRule } from "../MarkupRule.js";
 import { BLOCK_CONTENT_REGEXP } from "../util/regexp.js";
-import { createMarkupRule } from "../util/rule.js";
-const CODE_REGEXP = getRegExp(`(?<fence>\`+)(?<code>${BLOCK_CONTENT_REGEXP})\\k<fence>`);
 /**
  * Inline code.
  * - Text surrounded by one or more "`" backtick tilde characters.
  * - Unlike strong/emphasis first or last character of the element can be space, (e.g. `- abc -` will not work).
  * - Closing characters must exactly match opening characters.
+ * - Works inside link text too, e.g. `` [`code`](url) ``.
  * - Same as Markdown syntax.
  */
-export const CODE_RULE = createMarkupRule(CODE_REGEXP, ({ groups: { code } }, _options, key) => _jsx("code", { children: code }, key), ["inline", "list"], 10);
+// Priority 10: code is a higher-precedence tier, resolved and masked before links/emphasis, so a
+// code span that straddles a link delimiter wins and the link cannot form across it.
+export const CODE_RULE = createMarkupRule(getRegExp(`(?<fence>\`+)(?<code>${BLOCK_CONTENT_REGEXP})\\k<fence>`), (key, { code }) => _jsx("code", { children: code }, key), ["inline", "list", "link"], 10);

package/markup/rule/fenced.d.ts

@@ -7,4 +7,4 @@
  * - If there's no closing fence the code block will run to the end of the current string.
  * - Markdown-style four-space indent syntax is not supported (only fenced code since it's less confusing and more common).
  */
-export declare const FENCED_RULE: import("../util/rule.js").MarkupRule;
+export declare const FENCED_RULE: import("../MarkupRule.js").MarkupRule;

package/markup/rule/fenced.js

@@ -1,12 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { createMarkupRule } from "../MarkupRule.js";
 import { BLOCK_CONTENT_REGEXP, BLOCK_START_REGEXP, createBlockRegExp, LINE_CONTENT_REGEXP, LINE_SPACE_REGEXP } from "../util/regexp.js";
-import { createMarkupRule } from "../util/rule.js";
 const FENCE = "`{3,}|~{3,}";
-const FENCED_REGEXP = createBlockRegExp(`(?<code>${BLOCK_CONTENT_REGEXP})`, 
-// Starts with the fence
-`${BLOCK_START_REGEXP}(?<fence>${FENCE}) *(?<title>${LINE_CONTENT_REGEXP})\n`, 
-// Ends when we hit the end of the string or the matching closing fence (trims any matching newlines after the fence).
-`(?:${LINE_SPACE_REGEXP}*\n\\k<fence>(?:\\s*\\n)?|$)`);
 /**
  * Fenced code blocks
  * - Same as Markdown syntax.
@@ -16,4 +11,5 @@ const FENCED_REGEXP = createBlockRegExp(`(?<code>${BLOCK_CONTENT_REGEXP})`,
  * - If there's no closing fence the code block will run to the end of the current string.
  * - Markdown-style four-space indent syntax is not supported (only fenced code since it's less confusing and more common).
  */
-export const FENCED_RULE = createMarkupRule(FENCED_REGEXP, ({ groups: { title, code } }, _options, key) => (_jsx("pre", { children: _jsx("code", { title: title?.trim() || undefined, children: code.trim() }) }, key)), ["block", "list"], 10);
+export const FENCED_RULE = createMarkupRule(createBlockRegExp(`(?<code>${BLOCK_CONTENT_REGEXP})`, `${BLOCK_START_REGEXP}(?<fence>${FENCE}) *(?<title>${LINE_CONTENT_REGEXP})\n`, // Starts with the fence
+`(?:${LINE_SPACE_REGEXP}*\n\\k<fence>(?:\\s*\\n)?|$)`), (key, { title, code }) => (_jsx("pre", { children: _jsx("code", { title: title?.trim() || undefined, children: code.trim() }) }, key)), ["block", "list"], 10);

package/markup/rule/heading.d.ts

@@ -4,4 +4,4 @@
  * - `#` must be the first character on the line.
  * - Markdown's underline syntax is not supported (for simplification).
  */
-export declare const HEADING_RULE: import("../util/rule.js").MarkupRule;
+export declare const HEADING_RULE: import("../MarkupRule.js").MarkupRule;

package/markup/rule/heading.js

@@ -1,16 +1,14 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { renderMarkup } from "../render.js";
+import { createMarkupRule } from "../MarkupRule.js";
 import { createLineRegExp, LINE_CONTENT_REGEXP, LINE_SPACE_REGEXP } from "../util/regexp.js";
-import { createMarkupRule } from "../util/rule.js";
-const HEADING_REGEXP = createLineRegExp(`(?<prefix>#{1,6})(?:${LINE_SPACE_REGEXP}+(?<heading>${LINE_CONTENT_REGEXP}))?`);
 /**
  * Headings are single line only (don't allow multiline).
  * - `#` 1-6 hashes, then one or more spaces, then the title.
  * - `#` must be the first character on the line.
  * - Markdown's underline syntax is not supported (for simplification).
  */
-export const HEADING_RULE = createMarkupRule(HEADING_REGEXP, ({ groups: { prefix, heading = "" } }, options, key) => {
+export const HEADING_RULE = createMarkupRule(createLineRegExp(`(?<prefix>#{1,6})(?:${LINE_SPACE_REGEXP}+(?<heading>${LINE_CONTENT_REGEXP}))?`), (key, { prefix, heading = "" }, parser) => {
     // The hash count picks the heading level; cast the dynamic tag to the known `h1`–`h6` set.
     const Heading = `h${prefix.length}`;
-    return _jsx(Heading, { children: renderMarkup(heading.trim(), options, "inline") }, key);
+    return _jsx(Heading, { children: parser.parse(heading.trim(), "inline") }, key);
 }, ["block"]);

package/markup/rule/index.d.ts

@@ -1,5 +1,4 @@
-import type { MarkupOptions } from "../util/options.js";
-import type { MarkupRules } from "../util/rule.js";
+import type { MarkupRules } from "../MarkupRule.js";
 /** Markup rules that work in a block context. */
 export declare const MARKUP_RULES_BLOCK: MarkupRules;
 /** Markup rules that work in an inline context. */
@@ -11,27 +10,8 @@ export declare const MARKUP_RULES_INLINE: MarkupRules;
  * 1. Syntax is more intuitive (e.g. `*strong*` always uses `*` asterisk and `_em_` always uses `_` underscore, and URLs are always autolinked).
  * 2. More compatible with textboxes that wrap lines by default (e.g. single `\n` linebreaks don't need the trailing double space to, they're always treated as `<br />`).
  * 3. Don't support fussy fragile syntax that lets users make mistakes (e.g. literal HTML tags or `&amp;` character entities).
- *
- * @todo Default rules support "list items containing paragraphs" syntax (CommonMark calls this loose lists).
- *   - i.e. Lists can include `\n\n` double line breaks, and wrap all their contents in `<p>` entities, i.e. childContext is "block"
- *   - Hard because you have to capture the entire list including `\n\n`, so there's no obvious place to end it.
- *   - If there are breaks then any sub-lines need to be indented by two or more spaces otherwise it will break the list.
- *   - Make reference lists support this loose format too.
- * @todo [ ] Default rules support todo lists using `- [x]` syntax.
- * @todo [ ] Default rules support new reference syntax (combines reference lists/sidenotes/footnotes/reference and produces <dl> syntax).
- *   - All of these can be the same because reference links and Extended Markdown footnotes are basically the same.
- *   - e.g. `[Google Maps][1]` → `[1]: http://google.com Content goes here` (Markdown reference link syntax).
- *   - e.g. `[Google Maps]` → `[Google Maps]: http://google.com Content goes here` syntax.
- *   - e.g. `[DNS]` → `[DNS]: Domain Name System (extended Markdown definition list format).
- *   - If a `[Reference]` does not correspond to anything it will not be linked and e.g. will appear unlinked.
- *   - Single/double quotes around definition part are optional and are trimmed from the start/end (Extended Markdown definition lists require quotes, but that's dumb).
- *   - A `<dl>` definition list is used as the output format for all of these different use cases.
- *   - If the first thing in the definition is a URL, then it's recognised as a link reference (and produces an `<a href=""></a>`)
- *   - If the first thing in the definition isn't a URL, then it's recognised as a sidenote/footnote and tapping it will scroll you to that point (and popup the definition like Marco Arment's Bigfoot code).
  */
 export declare const MARKUP_RULES: MarkupRules;
-/** Default markup options — uses `MARKUP_RULES` with no other overrides. */
-export declare const MARKUP_OPTIONS: MarkupOptions;
 export * from "./blockquote.js";
 export * from "./code.js";
 export * from "./fenced.js";

package/markup/rule/index.js

@@ -22,7 +22,13 @@ export const MARKUP_RULES_BLOCK = [
     PARAGRAPH_RULE,
 ];
 /** Markup rules that work in an inline context. */
-export const MARKUP_RULES_INLINE = [CODE_RULE, LINK_RULE, AUTOLINK_RULE, INLINE_RULE, LINEBREAK_RULE];
+export const MARKUP_RULES_INLINE = [
+    CODE_RULE, //
+    LINK_RULE,
+    AUTOLINK_RULE,
+    INLINE_RULE,
+    LINEBREAK_RULE,
+];
 /**
  * Default markup rules
  *
@@ -30,27 +36,11 @@ export const MARKUP_RULES_INLINE = [CODE_RULE, LINK_RULE, AUTOLINK_RULE, INLINE_
  * 1. Syntax is more intuitive (e.g. `*strong*` always uses `*` asterisk and `_em_` always uses `_` underscore, and URLs are always autolinked).
  * 2. More compatible with textboxes that wrap lines by default (e.g. single `\n` linebreaks don't need the trailing double space to, they're always treated as `<br />`).
  * 3. Don't support fussy fragile syntax that lets users make mistakes (e.g. literal HTML tags or `&amp;` character entities).
- *
- * @todo Default rules support "list items containing paragraphs" syntax (CommonMark calls this loose lists).
- *   - i.e. Lists can include `\n\n` double line breaks, and wrap all their contents in `<p>` entities, i.e. childContext is "block"
- *   - Hard because you have to capture the entire list including `\n\n`, so there's no obvious place to end it.
- *   - If there are breaks then any sub-lines need to be indented by two or more spaces otherwise it will break the list.
- *   - Make reference lists support this loose format too.
- * @todo [ ] Default rules support todo lists using `- [x]` syntax.
- * @todo [ ] Default rules support new reference syntax (combines reference lists/sidenotes/footnotes/reference and produces <dl> syntax).
- *   - All of these can be the same because reference links and Extended Markdown footnotes are basically the same.
- *   - e.g. `[Google Maps][1]` → `[1]: http://google.com Content goes here` (Markdown reference link syntax).
- *   - e.g. `[Google Maps]` → `[Google Maps]: http://google.com Content goes here` syntax.
- *   - e.g. `[DNS]` → `[DNS]: Domain Name System (extended Markdown definition list format).
- *   - If a `[Reference]` does not correspond to anything it will not be linked and e.g. will appear unlinked.
- *   - Single/double quotes around definition part are optional and are trimmed from the start/end (Extended Markdown definition lists require quotes, but that's dumb).
- *   - A `<dl>` definition list is used as the output format for all of these different use cases.
- *   - If the first thing in the definition is a URL, then it's recognised as a link reference (and produces an `<a href=""></a>`)
- *   - If the first thing in the definition isn't a URL, then it's recognised as a sidenote/footnote and tapping it will scroll you to that point (and popup the definition like Marco Arment's Bigfoot code).
  */
-export const MARKUP_RULES = [...MARKUP_RULES_BLOCK, ...MARKUP_RULES_INLINE];
-/** Default markup options — uses `MARKUP_RULES` with no other overrides. */
-export const MARKUP_OPTIONS = { rules: MARKUP_RULES };
+export const MARKUP_RULES = [
+    ...MARKUP_RULES_BLOCK, //
+    ...MARKUP_RULES_INLINE,
+];
 export * from "./blockquote.js";
 export * from "./code.js";
 export * from "./fenced.js";

package/markup/rule/inline.d.ts

@@ -11,4 +11,4 @@
  * - Closing characters must exactly match opening characters.
  * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
  */
-export declare const INLINE_RULE: import("../util/rule.js").MarkupRule;
+export declare const INLINE_RULE: import("../MarkupRule.js").MarkupRule;