basalt-ui 1.10.0 → 1.12.0

package/dist/content/markdown.js

@@ -1,18 +1,19 @@
 import { jsx } from "react/jsx-runtime";
-import { lazy, memo, Suspense, useMemo } from "react";
-import remend from "remend";
+import { lazy, memo, Suspense, useEffect, useMemo, useState } from "react";
 import { ALERT_CALLOUT_KIND, ALERT_TITLE, detectAlert, stripAlertMarker } from "./callout-alert.js";
 import { FenceBlock } from "./fence-block.js";
 import { createHeadingComponents } from "./heading-components.js";
 import { Callout } from "./callout.js";
 import { Prose } from "./prose.js";
+import { BASALT_SANITIZE_SCHEMA, mergeSanitizeSchema } from "./sanitize.js";
 import { SlugTracker } from "./slug.js";
 import { blockSplit } from "./block-split.js";
 import { createUrlTransform } from "./url-hardening.js";
-function LinkRenderer({ href, children }) {
-  if (href === void 0) return /* @__PURE__ */ jsx("span", { children });
+import { settledOnly } from "./fence-block.js";
+function LinkRenderer({ href, children, node: _node, ...rest }) {
+  if (href === void 0) return /* @__PURE__ */ jsx("span", { ...rest, children });
   const external = href.startsWith("http://") || href.startsWith("https://");
-  return /* @__PURE__ */ jsx("a", { href, ...external && { target: "_blank", rel: "noreferrer noopener" }, children });
+  return /* @__PURE__ */ jsx("a", { href, ...rest, ...external && { target: "_blank", rel: "noreferrer noopener" }, children });
 }
 function ImageRenderer({ src, alt }) {
   if (typeof src !== "string" || src === "") return /* @__PURE__ */ jsx("span", { "aria-label": alt });
@@ -23,45 +24,92 @@ function BlockquoteRenderer({ children }) {
   if (!alert) return /* @__PURE__ */ jsx("blockquote", { children });
   return /* @__PURE__ */ jsx(Callout, { kind: ALERT_CALLOUT_KIND[alert.kind], title: ALERT_TITLE[alert.kind], children: stripAlertMarker(children, alert.marker) });
 }
-function createPreRenderer(settled) {
+function createPreRenderer(settled, fenceRenderers) {
   return function PreRenderer({ node }) {
-    return /* @__PURE__ */ jsx(FenceBlock, { settled, ...node !== void 0 && { node } });
+    return /* @__PURE__ */ jsx(
+      FenceBlock,
+      {
+        settled,
+        ...node !== void 0 && { node },
+        ...fenceRenderers !== void 0 && { renderers: fenceRenderers }
+      }
+    );
   };
 }
-function buildMarkdownComponents(tracker, settled) {
+function buildMarkdownComponents(tracker, settled, fenceRenderers) {
   return {
     ...createHeadingComponents(tracker),
-    pre: createPreRenderer(settled),
+    pre: createPreRenderer(settled, fenceRenderers),
     blockquote: BlockquoteRenderer,
     a: LinkRenderer,
     img: ImageRenderer
   };
 }
+let sanitizerPromise = null;
+function loadSanitizer() {
+  sanitizerPromise ??= import("rehype-sanitize").then((mod) => ({
+    plugin: mod.default,
+    // No cast: `SanitizeSchemaInput` mirrors hast-util-sanitize's `Schema` INCLUDING its
+    // `| null | undefined` field arms, so `defaultSchema` assigns straight across;
+    // `mergeSanitizeSchema` normalizes the nulls away and hands back a `SanitizeSchema`.
+    baseSchema: mod.defaultSchema
+  })).catch(() => {
+    if (process.env["NODE_ENV"] !== "production") {
+      console.warn(
+        '[basalt] Markdown: optional peer "rehype-sanitize" is not installed \u2014 the sanitize pass is skipped. react-markdown does not parse raw HTML by default, so this only opens a hole if a rehypePlugin (rehype-raw and friends) puts untrusted nodes into the tree. Install it with: bun add rehype-sanitize'
+      );
+    }
+    return null;
+  });
+  return sanitizerPromise;
+}
+function withSingleClobberLayer(schema) {
+  return { ...schema, clobberPrefix: "" };
+}
+function composeRehypePlugins({
+  sanitizer,
+  consumerPlugins,
+  sanitizeSchema
+}) {
+  const consumer = consumerPlugins ?? [];
+  if (sanitizer === null) return consumer;
+  const merged = mergeSanitizeSchema(sanitizer.baseSchema, BASALT_SANITIZE_SCHEMA, sanitizeSchema);
+  return [...consumer, [sanitizer.plugin, withSingleClobberLayer(merged)]];
+}
 function PlainTextFallback({ text }) {
   return /* @__PURE__ */ jsx("span", { style: { whiteSpace: "pre-wrap" }, children: text });
 }
 const LazyReactMarkdown = lazy(
-  () => Promise.all([import("react-markdown"), import("remark-gfm")]).then(([{ default: ReactMarkdown }, { default: remarkGfm }]) => {
+  () => Promise.all([import("react-markdown"), import("remark-gfm"), loadSanitizer()]).then(([{ default: ReactMarkdown }, { default: remarkGfm }, sanitizer]) => {
     function Bridge({
       text,
       components,
       urlTransform,
       remarkPlugins,
-      rehypePlugins
+      rehypePlugins,
+      sanitizeSchema
     }) {
       const remarkPluginsList = [
         remarkGfm,
         ...remarkPlugins ?? []
       ];
+      const rehypePluginsList = useMemo(
+        () => composeRehypePlugins({
+          sanitizer,
+          ...rehypePlugins !== void 0 && { consumerPlugins: rehypePlugins },
+          ...sanitizeSchema !== void 0 && { sanitizeSchema }
+        }),
+        // `sanitizer` is a constant of the enclosing load closure — resolved once, before this
+        // component exists, so it is deliberately not a dependency.
+        [rehypePlugins, sanitizeSchema]
+      );
       return /* @__PURE__ */ jsx(
         ReactMarkdown,
         {
           components,
           urlTransform,
           remarkPlugins: remarkPluginsList,
-          ...rehypePlugins !== void 0 && {
-            rehypePlugins
-          },
+          rehypePlugins: rehypePluginsList,
           children: text
         }
       );
@@ -73,14 +121,16 @@ function BlockRenderer({
   text,
   settled,
   components,
+  fenceRenderers,
   urlTransform,
   remarkPlugins,
-  rehypePlugins
+  rehypePlugins,
+  sanitizeSchema
 }) {
   const tracker = useMemo(() => new SlugTracker(), [text]);
   const componentsMap = useMemo(
-    () => ({ ...buildMarkdownComponents(tracker, settled), ...components }),
-    [tracker, settled, components]
+    () => ({ ...buildMarkdownComponents(tracker, settled, fenceRenderers), ...components }),
+    [tracker, settled, fenceRenderers, components]
   );
   return /* @__PURE__ */ jsx(
     LazyReactMarkdown,
@@ -89,16 +139,53 @@ function BlockRenderer({
       components: componentsMap,
       urlTransform,
       ...remarkPlugins !== void 0 && { remarkPlugins },
-      ...rehypePlugins !== void 0 && { rehypePlugins }
+      ...rehypePlugins !== void 0 && { rehypePlugins },
+      ...sanitizeSchema !== void 0 && { sanitizeSchema }
     }
   );
 }
 const MemoizedBlock = memo(BlockRenderer);
+let remendPromise = null;
+let resolvedRemend = null;
+function loadRemend() {
+  remendPromise ??= import("remend").then((mod) => {
+    resolvedRemend = mod.default;
+    return resolvedRemend;
+  }).catch(() => null);
+  return remendPromise;
+}
+function useRemend() {
+  const [repair, setRepair] = useState(() => resolvedRemend);
+  useEffect(() => {
+    if (repair !== null) return;
+    let cancelled = false;
+    loadRemend().then((loaded) => {
+      if (!cancelled && loaded !== null) setRepair(() => loaded);
+      return void 0;
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [repair]);
+  return repair;
+}
 function StreamingTailBlock(props) {
-  const repaired = useMemo(() => remend(props.text), [props.text]);
+  const repair = useRemend();
+  const repaired = useMemo(
+    () => repair === null ? props.text : repair(props.text),
+    [repair, props.text]
+  );
   return /* @__PURE__ */ jsx(BlockRenderer, { ...props, text: repaired, settled: false });
 }
-function SettledBody({ text, components, urlTransform, remarkPlugins, rehypePlugins }) {
+function SettledBody({
+  text,
+  components,
+  fenceRenderers,
+  urlTransform,
+  remarkPlugins,
+  rehypePlugins,
+  sanitizeSchema
+}) {
   return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(PlainTextFallback, { text }), children: /* @__PURE__ */ jsx(
     BlockRenderer,
     {
@@ -106,17 +193,21 @@ function SettledBody({ text, components, urlTransform, remarkPlugins, rehypePlug
       settled: true,
       urlTransform,
       ...components !== void 0 && { components },
+      ...fenceRenderers !== void 0 && { fenceRenderers },
       ...remarkPlugins !== void 0 && { remarkPlugins },
-      ...rehypePlugins !== void 0 && { rehypePlugins }
+      ...rehypePlugins !== void 0 && { rehypePlugins },
+      ...sanitizeSchema !== void 0 && { sanitizeSchema }
     }
   ) });
 }
 function StreamingBody({
   text,
   components,
+  fenceRenderers,
   urlTransform,
   remarkPlugins,
-  rehypePlugins
+  rehypePlugins,
+  sanitizeSchema
 }) {
   const blocks = useMemo(() => blockSplit(text), [text]);
   const lastIndex = blocks.length - 1;
@@ -125,23 +216,41 @@ function StreamingBody({
       text: block,
       urlTransform,
       ...components !== void 0 && { components },
+      ...fenceRenderers !== void 0 && { fenceRenderers },
       ...remarkPlugins !== void 0 && { remarkPlugins },
-      ...rehypePlugins !== void 0 && { rehypePlugins }
+      ...rehypePlugins !== void 0 && { rehypePlugins },
+      ...sanitizeSchema !== void 0 && { sanitizeSchema }
     };
     return index === lastIndex ? /* @__PURE__ */ jsx(StreamingTailBlock, { ...shared }, index) : /* @__PURE__ */ jsx(MemoizedBlock, { ...shared, settled: true }, index);
   }) });
 }
 const DEFAULT_LINK_PREFIXES = ["https://", "mailto:", "#", "/"];
-const DEFAULT_IMAGE_PREFIXES = ["https://", "/"];
-const STREAMING_IMAGE_PREFIXES = ["/"];
+const TRUSTED_IMAGE_PREFIXES = ["https://", "/"];
+const UNTRUSTED_IMAGE_PREFIXES = ["/"];
+const IMAGE_PREFIXES_BY_TRUST = {
+  trusted: TRUSTED_IMAGE_PREFIXES,
+  untrusted: UNTRUSTED_IMAGE_PREFIXES
+};
+function isKnownContentTrust(value) {
+  return Object.hasOwn(IMAGE_PREFIXES_BY_TRUST, value);
+}
+function imagePrefixesForTrust(contentTrust) {
+  return isKnownContentTrust(contentTrust) ? IMAGE_PREFIXES_BY_TRUST[contentTrust] : UNTRUSTED_IMAGE_PREFIXES;
+}
 function Markdown({
   children,
   density = "article",
   measure,
   streaming = false,
+  // `streaming` as the trust DEFAULT is backward compatibility only (pre-1.12 the image policy was
+  // read straight off `streaming`, so dropping it would silently widen every existing streaming
+  // call site). It is a floor, never the policy — see the prop's JSDoc.
+  contentTrust = streaming ? "untrusted" : "trusted",
   components,
+  fenceRenderers,
+  sanitizeSchema,
   allowedLinkPrefixes = DEFAULT_LINK_PREFIXES,
-  allowedImagePrefixes = streaming ? STREAMING_IMAGE_PREFIXES : DEFAULT_IMAGE_PREFIXES,
+  allowedImagePrefixes = imagePrefixesForTrust(contentTrust),
   defaultOrigin,
   remarkPlugins,
   rehypePlugins,
@@ -161,8 +270,10 @@ function Markdown({
     text: children,
     urlTransform,
     ...components !== void 0 && { components },
+    ...fenceRenderers !== void 0 && { fenceRenderers },
     ...remarkPlugins !== void 0 && { remarkPlugins },
-    ...rehypePlugins !== void 0 && { rehypePlugins }
+    ...rehypePlugins !== void 0 && { rehypePlugins },
+    ...sanitizeSchema !== void 0 && { sanitizeSchema }
   };
   return /* @__PURE__ */ jsx(
     Prose,
@@ -176,5 +287,7 @@ function Markdown({
   );
 }
 export {
-  Markdown
+  Markdown,
+  composeRehypePlugins,
+  settledOnly
 };

package/dist/content/markdown.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=markdown.test.d.ts.map

package/dist/content/markdown.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.test.d.ts","sourceRoot":"","sources":["../../src/content/markdown.test.tsx"],"names":[],"mappings":""}

package/dist/content/prose.module.css.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prose.module.css.test.d.ts.map

package/dist/content/prose.module.css.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prose.module.css.test.d.ts","sourceRoot":"","sources":["../../src/content/prose.module.css.test.ts"],"names":[],"mappings":""}

package/dist/content/sanitize.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Sanitize-schema composition for `Markdown` (docs/AGENT-CHAT-SPEC.md §7). Owns three things: the
+ * additions-only extension type a consumer hands to `Markdown`'s `sanitizeSchema` prop, basalt's
+ * own additions layer, and the additive deep merge that composes both over `rehype-sanitize`'s
+ * `defaultSchema`.
+ *
+ * WHY A DATA EXTENSION, NOT A `(base) => Schema` CALLBACK: a callback can return `{}` and silently
+ * disable sanitization, and a "never replace" comment is not enforcement. `SanitizeSchemaExtension`
+ * makes removal UNREPRESENTABLE — there is no code path in `mergeSanitizeSchema` that shrinks the
+ * base. That, plus `./markdown` appending its sanitize pass AFTER the consumer's `rehypePlugins`,
+ * is what keeps the baseline un-defeatable from outside the package.
+ *
+ * The `Schema` shape is MIRRORED here rather than imported from `hast-util-sanitize`, so the
+ * content layer's types never depend on an optional peer. `rehype-sanitize` is dynamically imported
+ * by `./markdown`, which composes the effective schema at load time:
+ *
+ *     mergeSanitizeSchema(defaultSchema, BASALT_SANITIZE_SCHEMA, props.sanitizeSchema)
+ *
+ * THE TRAP THIS MODULE EXISTS TO AVOID: `hast-util-sanitize` merges a supplied schema with a
+ * shallow top-level spread (`{...defaultSchema, ...options}`). Passing an `attributes` object
+ * therefore REPLACES every default attribute allowance rather than adding to it — one consumer
+ * addition would silently strip `href` from links, `className` from code fences, and the whole
+ * `'*'` fallback. Upstream's answer is the third-party `deepmerge` package; basalt owns the small
+ * merge below instead of taking the dependency.
+ *
+ * "ADDITIONS ONLY" IS A STATEMENT ABOUT THE SANITIZER'S BEHAVIOUR, NOT ABOUT THE SCHEMA'S SHAPE.
+ * A merge that only ever grows arrays still removes allowances, because of three things
+ * `hast-util-sanitize@5` does when it CONSUMES the schema (`lib/index.js`, verified against the
+ * installed copy). Each is load-bearing for the code below:
+ *
+ *  1. `clobberPrefix` is gated on TRUTHINESS — `schema.clobber && schema.clobberPrefix &&
+ *     schema.clobber.includes(key)`. ANY falsy prefix (`''`, but equally `null`, `0`, `false`,
+ *     `NaN` — whatever an untyped caller or a cast smuggles through) therefore turns clobber
+ *     protection OFF entirely and emits `id`/`name`/`ariaLabelledBy`/`ariaDescribedBy` unprefixed,
+ *     which is the DOM-clobbering hole `user-content-` exists to close. See `adoptClobberPrefix`.
+ *  2. The `'*'` fallback is consulted ONLY when the tag-specific lookup yields `null`/`undefined`.
+ *     For an ARRAY-valued property (`className`, `headers`, …) a matching tag-specific entry
+ *     returns `[]` — neither — so the fallback is skipped. Introducing a tag-specific entry for a
+ *     property the base only allowed via `'*'` therefore DELETES that allowance. See
+ *     `rescueWildcardDefinitions`.
+ *  3. `findDefinition` returns the FIRST entry whose name matches, so any later entry for the same
+ *     property name is dead code (it also treats a `'data*'` entry as the fallback for any
+ *     `data`-prefixed key). Concatenating a consumer's entry after the base's is a silent no-op.
+ *     See `unionDefinitions`, which collapses to ONE entry per property name.
+ */
+/**
+ * One entry in an `attributes` allow-list. A bare string allows any value for that property; the
+ * tuple form allow-lists specific values (a `RegExp` matches a value, e.g. `['className',
+ * /^language-./]`). A ONE-element tuple (`['className']`) also allows any value — upstream only
+ * treats an entry as an allow-list when `definition.length > 1`.
+ *
+ * The `null`/`undefined` arms mirror upstream's `PropertyDefinition` exactly (its rest element is
+ * `Exclude<Properties[keyof Properties], Array<any>> | RegExp`, which includes both). They are
+ * inert: a sanitized value is always a boolean, number or string, so `allowed === value` can never
+ * match one.
+ */
+export type SanitizePropertyDefinition = string | readonly [string, ...ReadonlyArray<boolean | number | string | RegExp | null | undefined>];
+/**
+ * Structural mirror of `hast-util-sanitize`'s `Schema`, defined here rather than imported so the
+ * content layer never depends on an OPTIONAL peer's types. This is the OUTPUT shape: no `null`
+ * arms, so nothing downstream has to re-check a field the merge already normalized away.
+ */
+export type SanitizeSchema = {
+    readonly allowComments?: boolean;
+    readonly allowDoctypes?: boolean;
+    readonly ancestors?: Readonly<Record<string, readonly string[]>>;
+    readonly attributes?: Readonly<Record<string, readonly SanitizePropertyDefinition[]>>;
+    readonly clobber?: readonly string[];
+    readonly clobberPrefix?: string;
+    readonly protocols?: Readonly<Record<string, readonly string[]>>;
+    readonly required?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    readonly strip?: readonly string[];
+    readonly tagNames?: readonly string[];
+};
+/**
+ * INPUT shape for `mergeSanitizeSchema`'s base — `SanitizeSchema` with upstream's `| null |
+ * undefined` on every field (and on every `protocols` value), so `rehype-sanitize`'s own
+ * `defaultSchema` assigns to it directly with NO cast at the call site.
+ *
+ * It is deliberately separate from `SanitizeSchema` rather than a widening of it: the null arms
+ * belong to what callers may HAND IN, not to what the merge HANDS BACK. `normalizeSchemaInput`
+ * drops them, so no `null` ever reaches the exported output type.
+ */
+export type SanitizeSchemaInput = {
+    readonly allowComments?: boolean | null | undefined;
+    readonly allowDoctypes?: boolean | null | undefined;
+    readonly ancestors?: Readonly<Record<string, readonly string[]>> | null | undefined;
+    readonly attributes?: Readonly<Record<string, readonly SanitizePropertyDefinition[]>> | null | undefined;
+    readonly clobber?: readonly string[] | null | undefined;
+    readonly clobberPrefix?: string | null | undefined;
+    readonly protocols?: Readonly<Record<string, readonly string[] | null | undefined>> | null | undefined;
+    readonly required?: Readonly<Record<string, Readonly<Record<string, unknown>>>> | null | undefined;
+    readonly strip?: readonly string[] | null | undefined;
+    readonly tagNames?: readonly string[] | null | undefined;
+};
+/**
+ * ADDITIONS ONLY — the four fields it is safe to widen from outside the package. Removal is
+ * deliberately not expressible: there is no way to shrink `tagNames`, drop an attribute allowance,
+ * narrow `protocols`, or clear `strip`/`clobber`/`ancestors`/`required`.
+ *
+ * `clobberPrefix` is the one replace-valued field. Upstream's actual gate is `schema.clobberPrefix`
+ * read for TRUTHINESS (`lib/index.js`), not `=== ''` — so `null`, `0`, `false`, `NaN`, and `''` are
+ * ALL disarming values, and only a genuine non-empty string keeps the guard live. TypeScript cannot
+ * express "a non-empty string" on a plain data field (and the declared `string` type is a
+ * compile-time claim a JS caller or an `as` cast can defeat), so `adoptClobberPrefix` re-checks
+ * `typeof` at runtime and treats anything that is not a non-empty string as a disarm attempt —
+ * ignored with a dev warning, never applied.
+ */
+export type SanitizeSchemaExtension = {
+    readonly tagNames?: readonly string[];
+    readonly attributes?: Readonly<Record<string, readonly SanitizePropertyDefinition[]>>;
+    readonly protocols?: Readonly<Record<string, readonly string[]>>;
+    readonly clobberPrefix?: string;
+};
+/**
+ * basalt's own element allowances, layered over `rehype-sanitize`'s `defaultSchema`.
+ *
+ * THIS IS THE ADDITIONS LAYER, NOT THE FULL BASELINE. It is deliberately NOT a materialized
+ * `defaultSchema + basalt` schema: `defaultSchema` lives in `rehype-sanitize`, an OPTIONAL peer, so
+ * materializing it at module scope would require a static import that hard-requires the peer for
+ * every consumer of `basalt-ui/content` — and vendoring a copy would silently drift from upstream's
+ * GitHub-grade baseline, which for a security default is worse. The effective schema is composed
+ * where the peer is dynamically imported (see the module JSDoc).
+ *
+ * IT IS EMPTY, AND THAT IS THE HONEST ANSWER — everything basalt's markdown pipeline emits into the
+ * hast tree is already permitted by `defaultSchema`, verified entry by entry:
+ *  - fenced code — `pre` > `code` with a `language-*` class: `defaultSchema.attributes.code` is
+ *    `[['className', /^language-./]]`, which covers `language-mermaid` too. The fence's title comes
+ *    from the `code` node's `data.meta`, and `data` is preserved by the sanitizer verbatim.
+ *  - headings — plain `h1`..`h6`; the slug `id` and the hover anchor are added by basalt's React
+ *    renderers AFTER sanitization, so they never pass through the schema.
+ *  - GFM alerts — an ordinary `blockquote` whose first paragraph carries a `[!NOTE]`-style text
+ *    marker; `Callout` is chosen in the renderer, again downstream of the hast tree.
+ *  - GFM tables / task lists / footnotes / strikethrough — `table`+`align`, `input[type=checkbox]
+ *    [disabled]`, `.task-list-item`, `section[data-footnotes]`, `del` are all explicit
+ *    `defaultSchema` allowances.
+ *  - links/images — `href`/`src` survive the schema and are then narrowed further by
+ *    `./url-hardening`'s prefix allowlist.
+ *
+ * So: do not "fill this in". Every entry added here widens the security baseline for every consumer
+ * and must be justified by output basalt actually emits. `style`, event handlers, and new protocols
+ * are out of bounds; an app-specific need belongs in that app's `sanitizeSchema` prop.
+ */
+export declare const BASALT_SANITIZE_SCHEMA: SanitizeSchemaExtension;
+/**
+ * Deep-merges additions into a base schema. Additive ONLY — and "additive" is measured by what the
+ * SANITIZER then allows, not by array lengths (see the module JSDoc for the three upstream lookup
+ * rules this has to model):
+ *
+ *  - `tagNames` and `protocols` are concatenated per key, de-duplicated.
+ *  - `attributes` are merged per tag into ONE entry per property name whose allow-list is the union
+ *    of base and addition — and a tag gaining its first entry for a property keeps whatever `'*'`
+ *    granted it, so a widening never shadows the wildcard off.
+ *  - `clobberPrefix` is the single replace-valued field (a later extension wins; an omitted one
+ *    leaves the previous value intact) — except the empty string, which is ignored.
+ *
+ * Never removes anything from `base`: keys no extension mentions (`strip`, `clobber`, `ancestors`,
+ * `required`, `allowComments`, `allowDoctypes`) pass through untouched.
+ *
+ * The `base` parameter takes the nullable `SanitizeSchemaInput` so `rehype-sanitize`'s own
+ * `defaultSchema` assigns with no cast; the RETURN type stays non-null.
+ *
+ * Pure and order-stable: no input is mutated, and the output ordering is a deterministic function
+ * of the inputs, so snapshots don't churn.
+ *
+ * @example
+ * mergeSanitizeSchema(defaultSchema, BASALT_SANITIZE_SCHEMA, { tagNames: ['hermes-badge'] })
+ */
+export declare function mergeSanitizeSchema(base: SanitizeSchemaInput, ...extensions: readonly (SanitizeSchemaExtension | undefined)[]): SanitizeSchema;
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/content/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/content/sanitize.ts"],"names":[],"mappings":"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"}

package/dist/content/sanitize.js

@@ -0,0 +1,178 @@
+const BASALT_SANITIZE_SCHEMA = {};
+const WILDCARD = "*";
+function isPresent(value) {
+  return value !== null && value !== void 0;
+}
+function normalizeSchemaInput(base) {
+  return {
+    ...isPresent(base.allowComments) && { allowComments: base.allowComments },
+    ...isPresent(base.allowDoctypes) && { allowDoctypes: base.allowDoctypes },
+    ...isPresent(base.ancestors) && { ancestors: base.ancestors },
+    ...isPresent(base.attributes) && { attributes: base.attributes },
+    ...isPresent(base.clobber) && { clobber: base.clobber },
+    ...isPresent(base.clobberPrefix) && { clobberPrefix: base.clobberPrefix },
+    ...isPresent(base.protocols) && { protocols: normalizeProtocols(base.protocols) },
+    ...isPresent(base.required) && { required: base.required },
+    ...isPresent(base.strip) && { strip: base.strip },
+    ...isPresent(base.tagNames) && { tagNames: base.tagNames }
+  };
+}
+function normalizeProtocols(protocols) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, values] of Object.entries(protocols)) {
+    if (isPresent(values)) out.set(key, values);
+  }
+  return Object.fromEntries(out);
+}
+function definitionName(definition) {
+  return typeof definition === "string" ? definition : definition[0];
+}
+function definitionAllowsAnyValue(definition) {
+  return typeof definition === "string" || definition.length < 2;
+}
+function definitionValues(definition) {
+  return typeof definition === "string" ? [] : definition.slice(1);
+}
+function definitionValueKey(value) {
+  if (typeof value === "object" && value !== null) return `expression\0${String(value)}`;
+  return `${typeof value}\0${String(value)}`;
+}
+function toDefinition(name, values) {
+  return values.length === 0 ? name : [name, ...values];
+}
+function unionDefinitions(definitions) {
+  const order = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    const name = definitionName(definition);
+    let slot = byName.get(name);
+    if (!slot) {
+      slot = { allowAny: false, values: [], keys: /* @__PURE__ */ new Set() };
+      byName.set(name, slot);
+      order.push(name);
+    }
+    if (definitionAllowsAnyValue(definition)) {
+      slot.allowAny = true;
+      continue;
+    }
+    for (const value of definitionValues(definition)) {
+      const key = definitionValueKey(value);
+      if (slot.keys.has(key)) continue;
+      slot.keys.add(key);
+      slot.values.push(value);
+    }
+  }
+  const out = [];
+  for (const name of order) {
+    const slot = byName.get(name);
+    if (!slot) continue;
+    out.push(slot.allowAny ? name : toDefinition(name, slot.values));
+  }
+  return out;
+}
+function findFallbackDefinition(definitions, key) {
+  let dataDefault;
+  for (const definition of definitions ?? []) {
+    const name = definitionName(definition);
+    if (name === key) return definition;
+    if (name === "data*") dataDefault = definition;
+  }
+  if (key.length > 4 && key.slice(0, 4).toLowerCase() === "data") return dataDefault;
+  return void 0;
+}
+function renameDefinition(definition, name) {
+  if (definitionName(definition) === name) return definition;
+  return definitionAllowsAnyValue(definition) ? name : toDefinition(name, definitionValues(definition));
+}
+function rescueWildcardDefinitions({
+  wildcard,
+  current,
+  additions
+}) {
+  if (!wildcard || wildcard.length === 0) return [];
+  const shadowed = new Set((current ?? []).map(definitionName));
+  const rescued = [];
+  for (const definition of additions) {
+    const name = definitionName(definition);
+    if (shadowed.has(name)) continue;
+    shadowed.add(name);
+    const fallback = findFallbackDefinition(wildcard, name);
+    if (fallback !== void 0) rescued.push(renameDefinition(fallback, name));
+  }
+  return rescued;
+}
+function concatUniqueStrings(base, additions) {
+  const out = base ? [...base] : [];
+  const seen = new Set(out);
+  for (const value of additions) {
+    if (seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+function mergeRecordOfLists(base, addition, concat) {
+  const merged = new Map(Object.entries(base ?? {}));
+  for (const [key, values] of Object.entries(addition)) {
+    merged.set(key, concat(merged.get(key), values));
+  }
+  return Object.fromEntries(merged);
+}
+function mergeAttributes(base, addition) {
+  const merged = new Map(Object.entries(base ?? {}));
+  const tags = Object.keys(addition);
+  const ordered = tags.includes(WILDCARD) ? [WILDCARD, ...tags.filter((tag) => tag !== WILDCARD)] : tags;
+  for (const tag of ordered) {
+    const additions = addition[tag] ?? [];
+    const current = merged.get(tag);
+    if (tag === WILDCARD) {
+      merged.set(tag, unionDefinitions([...current ?? [], ...additions]));
+      continue;
+    }
+    const rescued = rescueWildcardDefinitions({
+      wildcard: merged.get(WILDCARD),
+      current,
+      additions
+    });
+    merged.set(tag, unionDefinitions([...current ?? [], ...rescued, ...additions]));
+  }
+  return Object.fromEntries(merged);
+}
+function adoptClobberPrefix(current, next) {
+  if (typeof next === "string" && next !== "") return next;
+  if (process.env["NODE_ENV"] !== "production") {
+    console.warn(
+      '[basalt] mergeSanitizeSchema: ignoring an invalid `clobberPrefix`. hast-util-sanitize gates clobber prefixing on truthiness, so a falsy value (or a non-string) disables it entirely and emits id/name unprefixed \u2014 the DOM-clobbering hole "user-content-" exists to close. The previous prefix is kept.'
+    );
+  }
+  return current;
+}
+function mergeSanitizeSchema(base, ...extensions) {
+  const normalized = normalizeSchemaInput(base);
+  let tagNames = normalized.tagNames;
+  let attributes = normalized.attributes;
+  let protocols = normalized.protocols;
+  let clobberPrefix = normalized.clobberPrefix;
+  for (const extension of extensions) {
+    if (!extension) continue;
+    if (extension.tagNames) tagNames = concatUniqueStrings(tagNames, extension.tagNames);
+    if (extension.attributes) attributes = mergeAttributes(attributes, extension.attributes);
+    if (extension.protocols) {
+      protocols = mergeRecordOfLists(protocols, extension.protocols, concatUniqueStrings);
+    }
+    if (extension.clobberPrefix !== void 0) {
+      clobberPrefix = adoptClobberPrefix(clobberPrefix, extension.clobberPrefix);
+    }
+  }
+  return {
+    ...normalized,
+    ...tagNames !== void 0 && { tagNames },
+    ...attributes !== void 0 && { attributes },
+    ...protocols !== void 0 && { protocols },
+    ...clobberPrefix !== void 0 && { clobberPrefix }
+  };
+}
+export {
+  BASALT_SANITIZE_SCHEMA,
+  mergeSanitizeSchema
+};

package/dist/content/sanitize.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sanitize.test.d.ts.map

package/dist/content/sanitize.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.test.d.ts","sourceRoot":"","sources":["../../src/content/sanitize.test.ts"],"names":[],"mappings":""}