shelving 1.267.2 → 1.267.4

package/markup/MarkupParser.d.ts

@@ -42,6 +42,13 @@ export type MarkupOptions = {
      * Default context to use if one isn't set. Defaults to `"block"`
      */
     readonly context?: string;
+    /**
+     * Current nesting depth — used to cap self-recursive rules (e.g. blockquotes) so pathological input can't
+     * overflow the stack. Internal: set automatically as rules recurse via `MarkupParser.nested()`; callers
+     * normally leave it at the default `0`.
+     * @default 0
+     */
+    readonly depth?: number | undefined;
 };
 /**
  * Parses a Markdownish markup string and renders it as a React node using a tiered, masking rule engine.
@@ -90,10 +97,29 @@ export declare class MarkupParser implements Parser<string, ReactNode> {
      * @see https://shelving.cc/markup/MarkupParser/context
      */
     readonly context: string;
-    constructor({ rules, rel, url, root, schemes, context }?: MarkupOptions);
+    /**
+     * Current nesting depth, incremented by `nested()` as self-recursive rules descend. Used to cap recursion so
+     * pathological input (e.g. a long `>>>>…` blockquote) can't overflow the stack.
+     * @see https://shelving.cc/markup/MarkupParser/depth
+     */
+    readonly depth: number;
+    constructor({ rules, rel, url, root, schemes, context, depth }?: MarkupOptions);
+    /**
+     * Return a copy of this parser with `depth` incremented by one, sharing all other options.
+     * - Self-recursive rules (e.g. blockquotes) parse their nested content through `nested()` so `depth` tracks how
+     *   deep the recursion has gone, letting them stop before the call stack overflows.
+     *
+     * @returns A new `MarkupParser` identical to this one but one level deeper.
+     * @see https://shelving.cc/markup/MarkupParser/nested
+     */
+    nested(): MarkupParser;
     /**
      * Parse a text string as Markdownish markup syntax and render it as a React node.
      * - Syntax is not defined by this code, but by the rules supplied to it.
+     * - **Untrusted input:** parsing is linear for normal content, but a few rules can still degrade on adversarial
+     *   input — long unbroken runs of backtick code fences, and deeply-nested `>` blockquotes (each leading `>`
+     *   recurses one level, so a pathological line can overflow the stack). When `input` is user-generated, cap its
+     *   length first; a sane maximum for your use case (for typical user content, tens of kilobytes) bounds worst-case work.
      *
      * @param input The string content possibly containing markup syntax, e.g. `"This is a *bold* string."`.
      * @param context The context to render in (defaults to this parser's `context`, i.e. `"block"` unless overridden).

package/markup/MarkupParser.js

@@ -48,7 +48,13 @@ export class MarkupParser {
      * @see https://shelving.cc/markup/MarkupParser/context
      */
     context;
-    constructor({ rules = MARKUP_RULES, rel, url, root, schemes = HTTP_SCHEMES, context = "block" } = {}) {
+    /**
+     * Current nesting depth, incremented by `nested()` as self-recursive rules descend. Used to cap recursion so
+     * pathological input (e.g. a long `>>>>…` blockquote) can't overflow the stack.
+     * @see https://shelving.cc/markup/MarkupParser/depth
+     */
+    depth;
+    constructor({ rules = MARKUP_RULES, rel, url, root, schemes = HTTP_SCHEMES, context = "block", depth = 0 } = {}) {
         this.rules = rules;
         this.priorities = _getPriorities(rules);
         this.rel = rel;
@@ -56,10 +62,34 @@ export class MarkupParser {
         this.root = root;
         this.schemes = schemes;
         this.context = context;
+        this.depth = depth;
+    }
+    /**
+     * Return a copy of this parser with `depth` incremented by one, sharing all other options.
+     * - Self-recursive rules (e.g. blockquotes) parse their nested content through `nested()` so `depth` tracks how
+     *   deep the recursion has gone, letting them stop before the call stack overflows.
+     *
+     * @returns A new `MarkupParser` identical to this one but one level deeper.
+     * @see https://shelving.cc/markup/MarkupParser/nested
+     */
+    nested() {
+        return new MarkupParser({
+            rules: this.rules,
+            rel: this.rel,
+            url: this.url,
+            root: this.root,
+            schemes: this.schemes,
+            context: this.context,
+            depth: this.depth + 1,
+        });
     }
     /**
      * Parse a text string as Markdownish markup syntax and render it as a React node.
      * - Syntax is not defined by this code, but by the rules supplied to it.
+     * - **Untrusted input:** parsing is linear for normal content, but a few rules can still degrade on adversarial
+     *   input — long unbroken runs of backtick code fences, and deeply-nested `>` blockquotes (each leading `>`
+     *   recurses one level, so a pathological line can overflow the stack). When `input` is user-generated, cap its
+     *   length first; a sane maximum for your use case (for typical user content, tens of kilobytes) bounds worst-case work.
      *
      * @param input The string content possibly containing markup syntax, e.g. `"This is a *bold* string."`.
      * @param context The context to render in (defaults to this parser's `context`, i.e. `"block"` unless overridden).

package/markup/rule/blockquote.d.ts

@@ -3,6 +3,7 @@
  * - `>` 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.
+ * - Nesting is capped at `MAX_DEPTH` (10) levels; deeper `>` prefixes are rendered as plain text rather than recursed, so pathological input can't overflow the stack.
  *
  * @example new MarkupParser({ rules: [BLOCKQUOTE_RULE] }).parse("> Quoted text")
  * @see https://shelving.cc/markup/BLOCKQUOTE_RULE

package/markup/rule/blockquote.js

@@ -3,13 +3,23 @@ import { createMarkupRule } from "../MarkupRule.js";
 import { BLOCK_CONTENT_REGEXP, createBlockRegExp } from "../util/regexp.js";
 const PREFIX = ">";
 const INDENT = new RegExp(`^${PREFIX}`, "gm");
+/** Maximum blockquote nesting depth. Each `>` level recurses once, so an unbounded `>>>>…` line would overflow the stack; beyond this the remaining source is left as plain text. */
+const MAX_DEPTH = 10;
 /**
  * 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.
+ * - Nesting is capped at `MAX_DEPTH` (10) levels; deeper `>` prefixes are rendered as plain text rather than recursed, so pathological input can't overflow the stack.
  *
  * @example new MarkupParser({ rules: [BLOCKQUOTE_RULE] }).parse("> Quoted text")
  * @see https://shelving.cc/markup/BLOCKQUOTE_RULE
  */
-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"]);
+export const BLOCKQUOTE_RULE = createMarkupRule(createBlockRegExp(`(?<quote>${PREFIX}${BLOCK_CONTENT_REGEXP})`), (key, { quote }, parser) => {
+    const inner = quote.replace(INDENT, "");
+    // This blockquote is level `depth + 1`; once it reaches the cap, render the (still `>`-prefixed) remainder as
+    // plain text instead of recursing, so nesting stops at exactly MAX_DEPTH levels and can't overflow the stack.
+    if (parser.depth + 1 >= MAX_DEPTH)
+        return _jsx("blockquote", { children: inner }, key);
+    return _jsx("blockquote", { children: parser.nested().parse(inner, "block") }, key);
+}, ["block", "list"]);

package/markup/rule/code.js

@@ -15,4 +15,6 @@ import { BLOCK_CONTENT_REGEXP } from "../util/regexp.js";
  */
 // 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);
+export const CODE_RULE = createMarkupRule(
+// Fence length is bounded (`{1,64}`) so a long run of backticks can't force O(n²) backtracking against the closing backreference.
+getRegExp(`(?<fence>\`{1,64})(?<code>${BLOCK_CONTENT_REGEXP})\\k<fence>`), (key, { code }) => _jsx("code", { children: code }, key), ["inline", "list", "link"], 10);

package/markup/rule/inline.js

@@ -19,7 +19,10 @@ const INLINE_CHARS = { "~": "del", "+": "ins", "*": "strong", _: "em", "=": "mar
  * @example new MarkupParser({ rules: [INLINE_RULE] }).parse("This is *bold* and _italic_")
  * @see https://shelving.cc/markup/INLINE_RULE
  */
-export const INLINE_RULE = createMarkupRule(createWordRegExp(`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}])+)(?<text>(?!\\k<char>)\\S(?:[\\s\\S]*?(?!\\k<char>)\\S)?)\\k<wrap>`), (key, { char, text }, parser) => {
+export const INLINE_RULE = createMarkupRule(createWordRegExp(
+// Marker run is bounded (`{1,8}`) and the inner span is bounded (`{0,2000}?`) so a long run of
+// unclosed markers can't force O(n²) backtracking — real emphasis never approaches these limits.
+`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}]){1,8})(?<text>(?!\\k<char>)\\S(?:[\\s\\S]{0,2000}?(?!\\k<char>)\\S)?)\\k<wrap>`), (key, { char, text }, parser) => {
     const Inline = INLINE_CHARS[char];
     return _jsx(Inline, { children: parser.parse(text, "inline") }, key);
 }, ["inline", "list", "link"]);

package/markup/rule/link.js

@@ -30,5 +30,7 @@ _renderLink, ["inline", "list"]);
  * @example new MarkupParser({ rules: [AUTOLINK_RULE] }).parse("http://google.com/maps (Google Maps)")
  * @see https://shelving.cc/markup/AUTOLINK_RULE
  */
-export const AUTOLINK_RULE = createMarkupRule(getRegExp(/(?<href>[a-z]{3,}?:\S+)(?: +(?:\((?<title>[^)\n]*?)\)))?/), //
+export const AUTOLINK_RULE = createMarkupRule(
+// Scheme length is bounded (`{3,64}?`) so a long run of letters with no `:` can't force O(n²) backtracking.
+getRegExp(/(?<href>[a-z]{3,64}?:\S+)(?: +(?:\((?<title>[^)\n]*?)\)))?/), //
 _renderLink, ["inline", "list"]);

package/markup/rule/separator.js

@@ -11,6 +11,8 @@ import { createLineRegExp } from "../util/regexp.js";
  * @example new MarkupParser({ rules: [SEPARATOR_RULE] }).parse("---")
  * @see https://shelving.cc/markup/SEPARATOR_RULE
  */
-export const SEPARATOR_RULE = createMarkupRule(createLineRegExp("([-*•+_=])(?: *\\1){2,}"), //
+export const SEPARATOR_RULE = createMarkupRule(
+// Inter-character whitespace is bounded (`{0,2000}`) so a long run of spaces can't force O(n²) backtracking.
+createLineRegExp("([-*•+_=])(?: {0,2000}\\1){2,}"), //
 //
 key => _jsx("hr", {}, key), ["block"]);

package/markup/rule/table.js

@@ -2,7 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { createMarkupRule } from "../MarkupRule.js";
 import { createBlockRegExp, LINE_SPACE_REGEXP } from "../util/regexp.js";
 // Constants.
-const _SPACE = `${LINE_SPACE_REGEXP}*`; // Run of line whitespace (never crosses a newline).
+const _SPACE = `${LINE_SPACE_REGEXP}{0,2000}`; // Run of line whitespace (never crosses a newline); bounded so a long whitespace line can't force O(n²) backtracking in the delimiter row.
 const _CELL = `${_SPACE}:?-+:?${_SPACE}`; // Delimiter-row cell: one or more dashes with optional `:` alignment markers.
 const _DELIMITER_SOURCE = `${_SPACE}\\|?(?:${_CELL}\\|)+(?:${_CELL})?${_SPACE}`; // Delimiter row: pipe-separated dash cells.
 const _DELIMITER = new RegExp(`^${_DELIMITER_SOURCE}$`, "u"); // Tests whether a single line is a delimiter row.

package/markup/util/regexp.d.ts

@@ -13,12 +13,12 @@ export declare const BLOCK_SPACE_REGEXP = "\\s";
  * Regular expression source matching the start of a block — the start of the string, or one linebreak.
  * @see https://shelving.cc/markup/BLOCK_START_REGEXP
  */
-export declare const BLOCK_START_REGEXP = "(?:\\s*\\n|^)";
+export declare const BLOCK_START_REGEXP = "(?:\\s{0,2000}\\n|^)";
 /**
  * Regular expression source matching the end of a block — the end of the string, or two linebreaks, with trailing whitespace trimmed.
  * @see https://shelving.cc/markup/BLOCK_END_REGEXP
  */
-export declare const BLOCK_END_REGEXP = "\\s*(?:$|\\n\\s*\\n)";
+export declare const BLOCK_END_REGEXP = "\\s{0,2000}(?:$|\\n\\s{0,2000}\\n)";
 /**
  * Regular expression source matching line content — the shortest run of any character except newline.
  * @see https://shelving.cc/markup/LINE_CONTENT_REGEXP
@@ -33,12 +33,12 @@ export declare const LINE_SPACE_REGEXP = "[^\\n\\S]";
  * Regular expression source matching the start of a line — the start of the string, or one linebreak.
  * @see https://shelving.cc/markup/LINE_START_REGEXP
  */
-export declare const LINE_START_REGEXP = "(?:\\s*\\n|^)";
+export declare const LINE_START_REGEXP = "(?:\\s{0,2000}\\n|^)";
 /**
  * Regular expression source matching the end of a line — the end of the string, or one linebreak, with trailing whitespace trimmed.
  * @see https://shelving.cc/markup/LINE_END_REGEXP
  */
-export declare const LINE_END_REGEXP = "[^\\n\\S]*(?:\\s*\\n|$)";
+export declare const LINE_END_REGEXP = "[^\\n\\S]{0,2000}(?:\\s{0,2000}\\n|$)";
 /**
  * Regular expression source matching word content — at least one letter or number character.
  * @see https://shelving.cc/markup/WORD_CONTENT_REGEXP

package/markup/util/regexp.js

@@ -13,12 +13,12 @@ export const BLOCK_SPACE_REGEXP = "\\s"; // Block whitespace (run of any whitesp
  * Regular expression source matching the start of a block — the start of the string, or one linebreak.
  * @see https://shelving.cc/markup/BLOCK_START_REGEXP
  */
-export const BLOCK_START_REGEXP = "(?:\\s*\\n|^)"; // Start of block (start of string, or one linebreak).
+export const BLOCK_START_REGEXP = "(?:\\s{0,2000}\\n|^)"; // Start of block (start of string, or one linebreak). Whitespace is bounded so a long whitespace run can't force O(n²) backtracking at every offset.
 /**
  * Regular expression source matching the end of a block — the end of the string, or two linebreaks, with trailing whitespace trimmed.
  * @see https://shelving.cc/markup/BLOCK_END_REGEXP
  */
-export const BLOCK_END_REGEXP = "\\s*(?:$|\\n\\s*\\n)"; // End of block (end of string, or two linebreaks, trimmed whitespace).
+export const BLOCK_END_REGEXP = "\\s{0,2000}(?:$|\\n\\s{0,2000}\\n)"; // End of block (end of string, or two linebreaks, trimmed whitespace). Whitespace runs bounded to avoid O(n²) backtracking.
 /**
  * Regular expression source matching line content — the shortest run of any character except newline.
  * @see https://shelving.cc/markup/LINE_CONTENT_REGEXP
@@ -38,7 +38,7 @@ export const LINE_START_REGEXP = BLOCK_START_REGEXP; // Start of line (start of
  * Regular expression source matching the end of a line — the end of the string, or one linebreak, with trailing whitespace trimmed.
  * @see https://shelving.cc/markup/LINE_END_REGEXP
  */
-export const LINE_END_REGEXP = `${LINE_SPACE_REGEXP}*(?:\\s*\\n|$)`; // End of line (end of string, or one linebreak, trimmed whitespace).
+export const LINE_END_REGEXP = `${LINE_SPACE_REGEXP}{0,2000}(?:\\s{0,2000}\\n|$)`; // End of line (end of string, or one linebreak, trimmed whitespace). Whitespace runs bounded to avoid O(n²) backtracking.
 /**
  * Regular expression source matching word content — at least one letter or number character.
  * @see https://shelving.cc/markup/WORD_CONTENT_REGEXP

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.267.2",
+	"version": "1.267.4",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",

package/ui/misc/Markup.d.ts

@@ -14,6 +14,7 @@ export interface MarkupProps extends Partial<MarkupOptions> {
  * - Defaults to `MARKUP_OPTIONS` (full block + inline rule set). Pass `rules`, `rel`, `url`, `root`, or `schemes` as props to override.
  * - `url`/`root` default to the current `<Meta>` context so link rules resolve site-absolute and relative hrefs.
  * - Renders inside whatever ancestor element the caller provides — wrap in `<Prose>` to get the standard prose typography for the produced `<p>` / `<ul>` / `<pre>` / etc.
+ * - **Untrusted input:** when `children` comes from users, cap its length before rendering — parsing is linear for normal content but a few rules can degrade on adversarial input (a sane maximum for your use case, typically tens of kilobytes, bounds worst-case work). See `MarkupParser.parse()`.
  *
  * @param children The source markup string to parse and render (renders `null` when empty).
  * @returns The parsed markup as React nodes, or `null` when `children` is empty.

package/ui/misc/Markup.js

@@ -5,6 +5,7 @@ import { requireMeta } from "./MetaContext.js";
  * - Defaults to `MARKUP_OPTIONS` (full block + inline rule set). Pass `rules`, `rel`, `url`, `root`, or `schemes` as props to override.
  * - `url`/`root` default to the current `<Meta>` context so link rules resolve site-absolute and relative hrefs.
  * - Renders inside whatever ancestor element the caller provides — wrap in `<Prose>` to get the standard prose typography for the produced `<p>` / `<ul>` / `<pre>` / etc.
+ * - **Untrusted input:** when `children` comes from users, cap its length before rendering — parsing is linear for normal content but a few rules can degrade on adversarial input (a sane maximum for your use case, typically tens of kilobytes, bounds worst-case work). See `MarkupParser.parse()`.
  *
  * @param children The source markup string to parse and render (renders `null` when empty).
  * @returns The parsed markup as React nodes, or `null` when `children` is empty.

package/ui/misc/Markup.md

@@ -7,6 +7,7 @@ Parses a markup string and renders the resulting React nodes inline. Defaults to
 - `url` and `root` default to the current `<Meta>` context, so link rules resolve site-absolute and relative hrefs correctly. Override any `MarkupOptions` prop (`rules`, `rel`, `url`, `root`, `schemes`) directly on `<Markup>` for a custom rule set or base URL.
 - Renders `null` when `children` is empty.
 - Wrap in `<Prose>` to give the produced `<p>` / `<ul>` / `<pre>` / etc. the standard prose typography.
+- When `children` comes from users, cap its length before rendering: parsing is linear for normal content, but a few rules can degrade on adversarial input (long backtick runs, deeply-nested `>` blockquotes). A sane maximum for your use case — tens of kilobytes for typical user content — keeps worst-case work bounded.
 
 ## Usage
 

package/ui/misc/Markup.tsx

@@ -17,6 +17,7 @@ export interface MarkupProps extends Partial<MarkupOptions> {
  * - Defaults to `MARKUP_OPTIONS` (full block + inline rule set). Pass `rules`, `rel`, `url`, `root`, or `schemes` as props to override.
  * - `url`/`root` default to the current `<Meta>` context so link rules resolve site-absolute and relative hrefs.
  * - Renders inside whatever ancestor element the caller provides — wrap in `<Prose>` to get the standard prose typography for the produced `<p>` / `<ul>` / `<pre>` / etc.
+ * - **Untrusted input:** when `children` comes from users, cap its length before rendering — parsing is linear for normal content but a few rules can degrade on adversarial input (a sane maximum for your use case, typically tens of kilobytes, bounds worst-case work). See `MarkupParser.parse()`.
  *
  * @param children The source markup string to parse and render (renders `null` when empty).
  * @returns The parsed markup as React nodes, or `null` when `children` is empty.

package/ui/tree/TreeMarkup.d.ts

@@ -21,6 +21,7 @@ export declare const TREE_MARKUP_RULES: MarkupRules;
  * - Like `<Markup>` but defaults to `TREE_MARKUP_RULES`, so each backtick span resolves through `TreeLink` against the surrounding `<TreeProvider>` — a known token links to its canonical page, an unknown one stays plain code.
  * - The standard way to render documentation-site content (READMEs, docblocks, per-symbol pages); plain `<Markup>` stays the choice for general user content that shouldn't cross-link.
  * - Falls back to plain code spans outside a `<TreeProvider>`, so it's safe to use anywhere. Pass any `MarkupOptions` prop (including `rules`) to override.
+ * - Inherits `<Markup>`'s input-length guidance: when `children` is untrusted, cap its length before rendering (see `MarkupParser.parse()`).
  *
  * @param children The source markup string to parse and render (renders `null` when empty).
  * @returns The parsed markup as React nodes, or `null` when `children` is empty.

package/ui/tree/TreeMarkup.js

@@ -26,6 +26,7 @@ export const TREE_MARKUP_RULES = MARKUP_RULES.map(rule => (rule === CODE_RULE ?
  * - Like `<Markup>` but defaults to `TREE_MARKUP_RULES`, so each backtick span resolves through `TreeLink` against the surrounding `<TreeProvider>` — a known token links to its canonical page, an unknown one stays plain code.
  * - The standard way to render documentation-site content (READMEs, docblocks, per-symbol pages); plain `<Markup>` stays the choice for general user content that shouldn't cross-link.
  * - Falls back to plain code spans outside a `<TreeProvider>`, so it's safe to use anywhere. Pass any `MarkupOptions` prop (including `rules`) to override.
+ * - Inherits `<Markup>`'s input-length guidance: when `children` is untrusted, cap its length before rendering (see `MarkupParser.parse()`).
  *
  * @param children The source markup string to parse and render (renders `null` when empty).
  * @returns The parsed markup as React nodes, or `null` when `children` is empty.

package/ui/tree/TreeMarkup.md

@@ -7,7 +7,7 @@ Renders a markup string just like `<Markup>`, but auto-links every inline code s
 - Defaults to `TREE_MARKUP_RULES` — the full default rule set with the inline-code rule swapped for `TREE_CODE_RULE`, which renders each span through `TreeLink`.
 - Resolution is exact-match against the tree map: a hit (`` `BooleanSchema` ``, `` `Store.get` ``) links; a miss (`` `bun run fix` ``, `` `string` ``) falls back to a plain code token, so unknown spans never produce a broken link.
 - Falls back to plain code spans outside a `<TreeProvider>`, so it's safe to use anywhere — it simply stops linking.
-- Inherits everything else from `<Markup>`: `url` / `root` default to the current `<Meta>` context, and any `MarkupOptions` prop (`rules`, `rel`, `url`, `root`, `schemes`) can be overridden directly.
+- Inherits everything else from `<Markup>`: `url` / `root` default to the current `<Meta>` context, and any `MarkupOptions` prop (`rules`, `rel`, `url`, `root`, `schemes`) can be overridden directly. That includes the input-length guidance — cap untrusted `children` length before rendering.
 - Wrap in `<Prose>` to give the produced `<p>` / `<ul>` / `<pre>` / etc. the standard prose typography.
 
 ## Usage

package/ui/tree/TreeMarkup.tsx

@@ -30,6 +30,7 @@ export const TREE_MARKUP_RULES: MarkupRules = MARKUP_RULES.map(rule => (rule ===
  * - Like `<Markup>` but defaults to `TREE_MARKUP_RULES`, so each backtick span resolves through `TreeLink` against the surrounding `<TreeProvider>` — a known token links to its canonical page, an unknown one stays plain code.
  * - The standard way to render documentation-site content (READMEs, docblocks, per-symbol pages); plain `<Markup>` stays the choice for general user content that shouldn't cross-link.
  * - Falls back to plain code spans outside a `<TreeProvider>`, so it's safe to use anywhere. Pass any `MarkupOptions` prop (including `rules`) to override.
+ * - Inherits `<Markup>`'s input-length guidance: when `children` is untrusted, cap its length before rendering (see `MarkupParser.parse()`).
  *
  * @param children The source markup string to parse and render (renders `null` when empty).
  * @returns The parsed markup as React nodes, or `null` when `children` is empty.

package/util/dictionary.d.ts

@@ -163,6 +163,7 @@ export declare const omitDictionaryItem: <T>(dict: ImmutableDictionary<T>, key:
 export declare const pickDictionaryItems: <T>(dict: ImmutableDictionary<T>, ...keys: string[]) => ImmutableDictionary<T>;
 /**
  * Set a single named item on a dictionary object (by reference) and return its value.
+ * - The key is trusted by contract: a runtime-untrusted key like `"__proto__"` would mutate the target's prototype, so validate or filter untrusted keys before calling (or use a null-prototype target).
  *
  * @param dict The dictionary to set the item on (modified by reference).
  * @param key The key of the item to set.
@@ -173,6 +174,7 @@ export declare const pickDictionaryItems: <T>(dict: ImmutableDictionary<T>, ...k
 export declare const setDictionaryItem: <T>(dict: MutableDictionary<T>, key: string, value: T) => T;
 /**
  * Set several named items on a dictionary object (by reference).
+ * - Keys are trusted by contract: a runtime-untrusted key like `"__proto__"` would mutate the target's prototype, so validate or filter untrusted keys before calling (or use a null-prototype target).
  *
  * @param dict The dictionary to set the items on (modified by reference).
  * @param entries The items to set, as a dictionary or iterable set of key/value entry tuples.

package/util/dictionary.js

@@ -139,6 +139,7 @@ export const omitDictionaryItem = omitProps;
 export const pickDictionaryItems = pickProps;
 /**
  * Set a single named item on a dictionary object (by reference) and return its value.
+ * - The key is trusted by contract: a runtime-untrusted key like `"__proto__"` would mutate the target's prototype, so validate or filter untrusted keys before calling (or use a null-prototype target).
  *
  * @param dict The dictionary to set the item on (modified by reference).
  * @param key The key of the item to set.
@@ -149,6 +150,7 @@ export const pickDictionaryItems = pickProps;
 export const setDictionaryItem = setProp;
 /**
  * Set several named items on a dictionary object (by reference).
+ * - Keys are trusted by contract: a runtime-untrusted key like `"__proto__"` would mutate the target's prototype, so validate or filter untrusted keys before calling (or use a null-prototype target).
  *
  * @param dict The dictionary to set the items on (modified by reference).
  * @param entries The items to set, as a dictionary or iterable set of key/value entry tuples.

package/util/diff.d.ts

@@ -44,6 +44,7 @@ export declare function deepDiffArray<R extends ImmutableArray>(left: ImmutableA
  * @returns Object containing the missing/updated properties that `left` needs to become `right`.
  * - If the two values are deeply equal the `SAME` constant is returned.
  * - If `left` isn't an object then the result can't be diffed so entire `right` is returned.
+ * - Diff object has a `null` prototype, so an untrusted `"__proto__"` key in `right` becomes an inert own property instead of injecting a prototype.
  * @see https://shelving.cc/util/diff/deepDiffObject
  */
 export declare function deepDiffObject<R extends ImmutableObject>(left: ImmutableObject, right: R): R | DeepPartial<R> | typeof SAME;

package/util/diff.js

@@ -42,7 +42,10 @@ export function deepDiffObject(left, right) {
     // If left is empty, entire right is returned.
     if (!leftKeys.length)
         return rightKeys.length ? right : SAME;
-    const diff = {};
+    // Null-prototype accumulator: an untrusted `"__proto__"` key in `right` then becomes an inert own property
+    // instead of invoking the inherited `__proto__` setter, so a crafted `{ "__proto__": … }` input can't reassign
+    // the diff object's prototype.
+    const diff = Object.create(null);
     let changed = false;
     for (const k of rightKeys) {
         const d = deepDiff(left[k], right[k]);

package/util/merge.d.ts

@@ -67,6 +67,7 @@ export declare function mergeArray<L, R>(left: ImmutableArray<L>, right: Immutab
  * - Only works on enumerable own keys (as returned by `Object.keys()`).
  * - Always returns a new object (or the `left` object if no changes were made).
  * - Resulting object is `cleaned`, i.e. properties in `left` or `right` that are `undefined` will be removed from the merged object.
+ * - Merged object has a `null` prototype, so an untrusted `"__proto__"` key in `right` becomes an inert own property instead of injecting a prototype.
  *
  * @param left The left object to merge into.
  * @param right The right object whose props replace or merge with `left`.

package/util/merge.js

@@ -45,7 +45,10 @@ export function mergeObject(left, right, recursor = exactMerge) {
     if (!rightEntries.length)
         return left;
     const leftKeys = Object.keys(left);
-    const merged = { ...left };
+    // Null-prototype accumulator: an untrusted `"__proto__"` key in `right` then becomes an inert own property
+    // instead of invoking the inherited `__proto__` setter, so a crafted `{ "__proto__": … }` input can't reassign
+    // the merged object's prototype.
+    const merged = Object.assign(Object.create(null), left);
     let changed = false;
     for (const [k, r] of rightEntries) {
         if (leftKeys.includes(k)) {

package/util/object.d.ts

@@ -249,6 +249,7 @@ export declare const omitProp: <T, K extends Key<T>>(input: T, key: K) => Omit<T
 export declare function pickProps<T, K extends Key<T>>(obj: T, ...keys: K[]): Pick<T, K>;
 /**
  * Set a single named prop on an object (by reference) and return its value.
+ * - The key is trusted by contract: a runtime-untrusted key like `"__proto__"` would mutate the target's prototype, so validate or filter untrusted keys before calling (or use a null-prototype target).
  *
  * @param obj The object to set the prop on (modified by reference).
  * @param key The key of the prop to set.
@@ -259,6 +260,7 @@ export declare function pickProps<T, K extends Key<T>>(obj: T, ...keys: K[]): Pi
 export declare function setProp<T extends MutableObject, K extends Key<T>>(obj: T, key: K, value: T[K]): T[K];
 /**
  * Set several named props on an object (by reference).
+ * - Keys are trusted by contract: a runtime-untrusted key like `"__proto__"` would mutate the target's prototype, so validate or filter untrusted keys before calling (or use a null-prototype target).
  *
  * @param obj The object to set the props on (modified by reference).
  * @param entries The props to set, as an object or iterable set of key/value entry tuples.

package/util/object.js

@@ -157,6 +157,7 @@ function _hasKey([key]) {
 }
 /**
  * Set a single named prop on an object (by reference) and return its value.
+ * - The key is trusted by contract: a runtime-untrusted key like `"__proto__"` would mutate the target's prototype, so validate or filter untrusted keys before calling (or use a null-prototype target).
  *
  * @param obj The object to set the prop on (modified by reference).
  * @param key The key of the prop to set.
@@ -170,6 +171,7 @@ export function setProp(obj, key, value) {
 }
 /**
  * Set several named props on an object (by reference).
+ * - Keys are trusted by contract: a runtime-untrusted key like `"__proto__"` would mutate the target's prototype, so validate or filter untrusted keys before calling (or use a null-prototype target).
  *
  * @param obj The object to set the props on (modified by reference).
  * @param entries The props to set, as an object or iterable set of key/value entry tuples.

package/util/uri.d.ts

@@ -192,6 +192,7 @@ export type PossibleURIParams = PossibleURI | URLSearchParams | ImmutableDiction
 /**
  * Get a set of params for a URI as a dictionary.
  * - Any params with `undefined` value will be ignored.
+ * - Returned dictionary has a `null` prototype, so an untrusted `__proto__` param becomes an inert own entry (instead of being silently dropped by the inherited `__proto__` setter).
  *
  * @param params Possible URI params to convert.
  * @param caller Function to attribute a thrown error to (defaults to `getURIParams` itself).

package/util/uri.js

@@ -99,6 +99,7 @@ function* getURIEntries(params, caller = getURIParams) {
 /**
  * Get a set of params for a URI as a dictionary.
  * - Any params with `undefined` value will be ignored.
+ * - Returned dictionary has a `null` prototype, so an untrusted `__proto__` param becomes an inert own entry (instead of being silently dropped by the inherited `__proto__` setter).
  *
  * @param params Possible URI params to convert.
  * @param caller Function to attribute a thrown error to (defaults to `getURIParams` itself).
@@ -108,7 +109,9 @@ function* getURIEntries(params, caller = getURIParams) {
  * @see https://shelving.cc/util/uri/getURIParams
  */
 export function getURIParams(params, caller = getURIParams) {
-    const output = {};
+    // Null-prototype accumulator: param keys are runtime-untrusted, so an untrusted `"__proto__"` key becomes an
+    // inert own entry instead of invoking the inherited `__proto__` setter (which would silently drop the param).
+    const output = Object.create(null);
     for (const [key, str] of getURIEntries(params, caller))
         output[key] = str;
     return output;