@ethisyscore/plugin-ui 1.110.0 → 1.112.0

package/dist/markdown/index.js

@@ -0,0 +1,524 @@
+import { useMemo } from 'react';
+import ReactMarkdown from 'react-markdown';
+import rehypeSanitize from 'rehype-sanitize';
+import remarkGfm from 'remark-gfm';
+import remarkBreaks from 'remark-breaks';
+import { defaultSchema } from 'hast-util-sanitize';
+import { jsx } from 'react/jsx-runtime';
+
+// src/markdown/MarkdownView.tsx
+
+// src/markdown/guards/attributeNames.ts
+function attributeNameOf(entry) {
+  return Array.isArray(entry) ? String(entry[0]) : String(entry);
+}
+var XLINK_PREFIX = /^xlink/;
+function normalisedAttributeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]/g, "").replace(XLINK_PREFIX, "");
+}
+
+// src/markdown/guards/schemaMaps.ts
+function ownMapEntry(map, key) {
+  if (map === void 0 || map === null) return void 0;
+  return Object.prototype.hasOwnProperty.call(map, key) ? map[key] : void 0;
+}
+function ownSchemaKey(schema, key) {
+  return ownMapEntry(schema, key);
+}
+
+// src/markdown/guards/attributes.ts
+var FORBIDDEN_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set([
+  "style",
+  "srcset",
+  "poster",
+  "formaction",
+  "ping",
+  "background",
+  "lowsrc",
+  "dynsrc"
+]);
+var REMOTE_SOURCE_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set([
+  "src",
+  "data",
+  "href"
+]);
+var FUNCIRI_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set([
+  "fill",
+  "stroke",
+  "filter",
+  "clippath",
+  "mask",
+  "marker",
+  "markerstart",
+  "markermid",
+  "markerend",
+  "cursor",
+  "colorprofile"
+]);
+function grantedNames(capabilityId, tag, entries) {
+  if (entries === null || entries === void 0) return [];
+  if (Array.isArray(entries)) return entries;
+  throw new Error(
+    `Markdown capability "${capabilityId}" returned a sanitize schema whose attributes entry for <${tag}> is not a list. hast-util-sanitize reads each entry as an array of property definitions \u2014 "href" or ["className", /^hljs-/] \u2014 and every rule here reads it the same way. Write attributes: { ${tag}: ["\u2026"] }.`
+  );
+}
+function assertAttributesNotWidened(capabilityId, schemas, trust) {
+  const previousAttributes = ownSchemaKey(schemas.previous, "attributes") ?? {};
+  const nextAttributes = ownSchemaKey(schemas.next, "attributes") ?? {};
+  for (const [tag, entries] of Object.entries(nextAttributes)) {
+    const inherited = new Set((ownMapEntry(previousAttributes, tag) ?? []).map(attributeNameOf));
+    for (const entry of grantedNames(capabilityId, tag, entries)) {
+      const name = attributeNameOf(entry);
+      if (/^on/i.test(name)) {
+        throw new Error(
+          `Markdown capability "${capabilityId}" widened the sanitize schema to allow the event-handler attribute "${name}" on <${tag}>, which is never permitted.`
+        );
+      }
+      if (inherited.has(name)) continue;
+      const normalised = normalisedAttributeName(name);
+      if (FORBIDDEN_ATTRIBUTE_NAMES.has(normalised)) {
+        throw new Error(
+          `Markdown capability "${capabilityId}" widened the sanitize schema to allow the attribute "${name}" on <${tag}>, which fetches or retargets with no user action and is never permitted.`
+        );
+      }
+      if (trust === "untrusted" && REMOTE_SOURCE_ATTRIBUTE_NAMES.has(normalised)) {
+        throw new Error(
+          `Markdown capability "${capabilityId}" widened the sanitize schema to allow the attribute "${name}" on <${tag}> under trust="untrusted", which is never permitted: untrusted content must fire no outbound request on view, and the image-blocking transform only covers <img>. If you meant a link, allow it on <a>, which already carries "href".`
+        );
+      }
+      if (trust === "untrusted" && FUNCIRI_ATTRIBUTE_NAMES.has(normalised)) {
+        throw new Error(
+          `Markdown capability "${capabilityId}" widened the sanitize schema to allow the attribute "${name}" on <${tag}> under trust="untrusted", which is never permitted: its value may be a \`url(\u2026)\` reference, and the browser fetches that on paint exactly as it fetches an image. A schema grants the NAME, so there is no way from here to allow the safe values and not the remote one.`
+        );
+      }
+    }
+  }
+}
+
+// src/markdown/guards/attributeAliases.ts
+var attributesOf = (schema) => ownSchemaKey(schema, "attributes") ?? {};
+var SPELLING_SOURCES = [
+  (schema) => Object.keys(ownSchemaKey(schema, "protocols") ?? {}),
+  (schema) => ownSchemaKey(schema, "clobber") ?? [],
+  // Own entries only, the way the sanitizer resolves these maps — see `./schemaMaps`.
+  (schema) => (ownMapEntry(attributesOf(schema), "*") ?? []).map(attributeNameOf),
+  (schema, tag) => (ownMapEntry(attributesOf(schema), tag) ?? []).map(attributeNameOf)
+];
+function policedSpellings(schemas, tag) {
+  const canonical = /* @__PURE__ */ new Map();
+  for (const spellingsOf of SPELLING_SOURCES) {
+    for (const name of [...spellingsOf(schemas.previous, tag), ...spellingsOf(schemas.next, tag)]) {
+      const normalised = normalisedAttributeName(name);
+      if (!canonical.has(normalised)) canonical.set(normalised, name);
+    }
+  }
+  return canonical;
+}
+function assertNoAliasedAttributeNames(capabilityId, schemas) {
+  for (const [tag, entries] of Object.entries(attributesOf(schemas.next))) {
+    const canonical = policedSpellings(schemas, tag);
+    for (const entry of entries ?? []) {
+      const name = attributeNameOf(entry);
+      const policed = canonical.get(normalisedAttributeName(name));
+      if (policed === void 0 || policed === name) continue;
+      throw new Error(
+        `Markdown capability "${capabilityId}" widened the sanitize schema to allow the attribute "${name}" on <${tag}>, which is "${policed}" spelled differently. hast-util-sanitize keys its URL-scheme allowlist and its DOM-clobbering prefix on the exact property name, while the DOM lower-cases it \u2014 so the second spelling reaches the browser as the same attribute with none of the restrictions attached to the first. Write "${policed}".`
+      );
+    }
+  }
+}
+
+// src/markdown/guards/protocols.ts
+var SAFE_PROTOCOLS = /* @__PURE__ */ new Set([
+  "http",
+  "https",
+  "mailto",
+  "tel",
+  "ftp",
+  "irc",
+  "ircs",
+  "xmpp"
+]);
+function restrictionsOf(schema) {
+  const restrictions = /* @__PURE__ */ new Map();
+  const map = ownSchemaKey(schema, "protocols") ?? {};
+  for (const [property, protocols] of Object.entries(map)) {
+    if (protocols && protocols.length > 0) restrictions.set(property, protocols);
+  }
+  return restrictions;
+}
+function assertProtocolsNotWidened(capabilityId, schemas) {
+  const next = restrictionsOf(schemas.next);
+  for (const [property, protocols] of next) {
+    for (const protocol of protocols) {
+      if (SAFE_PROTOCOLS.has(String(protocol).toLowerCase())) continue;
+      throw new Error(
+        `Markdown capability "${capabilityId}" widened the sanitize schema to allow the "${protocol}" URL scheme on "${property}", which is never permitted. Allowed schemes: ${[...SAFE_PROTOCOLS].join(", ")}.`
+      );
+    }
+  }
+  for (const property of restrictionsOf(schemas.previous).keys()) {
+    if (next.has(property)) continue;
+    throw new Error(
+      `Markdown capability "${capabilityId}" removed the URL-scheme restriction on "${property}". hast-util-sanitize treats a missing or empty protocol list as no restriction at all, so this admits every scheme, javascript: included. Spread the protocols you were given: (s) => ({ ...s, protocols: { ...s.protocols, ... } }).`
+    );
+  }
+}
+
+// src/markdown/guards/mutableKeyShapes.ts
+var MUTABLE_KEY_SHAPES = {
+  tagNames: {
+    shape: "list",
+    whenFalsy: 'hast-util-sanitize reads a missing, null or otherwise falsy tagNames as "every element name is allowed" rather than as an empty allowlist, so this does not narrow the schema, it removes the element allowlist entirely \u2014 <script> included'
+  },
+  attributes: {
+    shape: "map",
+    whenFalsy: 'hast-util-sanitize resolves an attributes entry with own.call(attributes, tagName) and reads a missing or falsy map as "no element carries any attribute", so this widens nothing and silently strips every attribute the pipeline allowed \u2014 className, href and the DOM-clobber prefix with them'
+  },
+  protocols: {
+    shape: "map",
+    whenFalsy: "hast-util-sanitize scheme-checks a URL property only while the protocols map restricts it, so a missing or falsy map applies no URL-scheme restriction at all and every scheme survives, javascript: included"
+  }
+};
+var EXAMPLE = {
+  list: '(s) => ({ ...s, <key>: [...s.<key>, "\u2026"] })',
+  map: "(s) => ({ ...s, <key>: { ...s.<key>, \u2026 } })"
+};
+function hasShape(value, shape) {
+  if (shape === "list") return Array.isArray(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function shapeError(capabilityId, key, rule) {
+  return new Error(
+    `Markdown capability "${capabilityId}" widened the sanitize schema so that "${key}" is not a ${rule.shape}. ${rule.whenFalsy}. Spread the ${rule.shape} you were given: ${EXAMPLE[rule.shape].replaceAll("<key>", key)}.`
+  );
+}
+function assertMutableKeyShape(capabilityId, key, value) {
+  const rule = MUTABLE_KEY_SHAPES[key];
+  if (hasShape(value, rule.shape)) return;
+  throw shapeError(capabilityId, key, rule);
+}
+function assertMutableKeysWellShaped(capabilityId, effective) {
+  for (const key of Object.keys(MUTABLE_KEY_SHAPES)) {
+    assertMutableKeyShape(capabilityId, key, ownSchemaKey(effective, key));
+  }
+}
+
+// src/markdown/guards/mutableKeys.ts
+var MUTABLE_SCHEMA_KEYS = new Set(Object.keys(MUTABLE_KEY_SHAPES));
+function sameValue(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a instanceof RegExp || b instanceof RegExp) {
+    return a instanceof RegExp && b instanceof RegExp && a.source === b.source && a.flags === b.flags;
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((entry, index) => sameValue(entry, b[index]));
+  }
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  const left = a;
+  const right = b;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) && sameValue(left[key], right[key])
+  );
+}
+function assertOnlyMutableKeysChanged(capabilityId, schemas) {
+  const previous = schemas.previous;
+  const next = schemas.next;
+  const changed = Object.keys(next).filter(
+    (key) => !MUTABLE_SCHEMA_KEYS.has(key) && (!Object.prototype.hasOwnProperty.call(previous, key) || !sameValue(next[key], ownMapEntry(previous, key)))
+  );
+  if (changed.length === 0) return;
+  throw new Error(
+    `Markdown capability "${capabilityId}" changed the sanitize schema key ${changed.map((key) => `"${key}"`).join(", ")}, which a capability may not change. A capability may widen only ${[...MUTABLE_SCHEMA_KEYS].map((key) => `"${key}"`).join(", ")} \u2014 the keys a rendering feature needs. The rest are the sanitizer's own policy (clobber/clobberPrefix stop DOM clobbering; a \`required\` default is written out with no protocol check), so changing one is a change to the markdown package with a reviewer attached, not something a capability does. Spread what you were given and touch only the keys your own markup needs.`
+  );
+}
+
+// src/markdown/guards/returnedSchema.ts
+function assertSchemaReturned(capabilityId, value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) return;
+  throw new Error(
+    `Markdown capability "${capabilityId}" has an extendSchema that returned ${Array.isArray(value) ? "an array" : String(value)} rather than a schema. extendSchema must return the schema it was given, widened: (s) => ({ ...s, ... }). Returning nothing on some branch is the usual cause.`
+  );
+}
+
+// src/markdown/guards/schemaKeys.ts
+function assertNoDroppedKeys(capabilityId, schemas) {
+  const dropped = Object.keys(schemas.previous).filter(
+    (key) => !Object.prototype.hasOwnProperty.call(schemas.next, key)
+  );
+  if (dropped.length === 0) return;
+  throw new Error(
+    `Markdown capability "${capabilityId}" returned a schema without ${dropped.map((key) => `"${key}"`).join(", ")} as an own property. hast-util-sanitize merges a schema over its own defaults one level deep and copies own properties only, so a dropped (or merely inherited) key falls back to the library default rather than to the pipeline's schema. Spread the schema you were given: (s) => ({ ...s, ... }).`
+  );
+}
+
+// src/markdown/guards/schemaValues.ts
+var SCHEMA_VALUE_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "undefined"
+]);
+function describe(value) {
+  if (typeof value === "function") return "a function";
+  return `a ${typeof value}`;
+}
+function assertSchemaIsData(capabilityId, schema) {
+  walk(capabilityId, schema, "");
+}
+function walk(capabilityId, value, path) {
+  if (value === null || value instanceof RegExp) return;
+  if (SCHEMA_VALUE_TYPES.has(typeof value)) return;
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => walk(capabilityId, entry, `${path}[${index}]`));
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [key, entry] of Object.entries(value)) {
+      walk(capabilityId, entry, path ? `${path}.${key}` : key);
+    }
+    return;
+  }
+  throw new Error(
+    `Markdown capability "${capabilityId}" returned a sanitize schema whose ${path || "root"} is ${describe(value)}, not data. A schema is read by the guards here and then again by hast-util-sanitize at render time, and the sanitizer ASKS its values rather than iterating them \u2014 \`tagNames.includes(name)\` \u2014 so a value that can run can answer the two differently. Only strings, numbers, booleans, arrays, plain objects and RegExp belong in a schema.`
+  );
+}
+
+// src/markdown/guards/tagNames.ts
+var FORBIDDEN_TAG_NAMES = [
+  "script",
+  "style",
+  "iframe",
+  "object",
+  "embed",
+  "base",
+  "meta",
+  "form",
+  // The third spelling of `style`. `<style>` is the inline one and `style=` the
+  // attribute (denied in `./attributes`); `<link rel="stylesheet" href>` is the same
+  // primitive fetched from off-origin, and it was the one missing. Under
+  // `trust="untrusted"` the `href` denial in `./attributes` happens to stop it, but
+  // under `internal` it rendered live: `<link rel="stylesheet" href="https://…">`.
+  // Attacker CSS is not cosmetic — it reads the page through selectors and exfiltrates
+  // through background URLs.
+  "link"
+];
+var ANIMATION_TAG_NAMES = [
+  "animate",
+  "animatecolor",
+  "animatemotion",
+  "animatetransform",
+  "set"
+];
+var IMAGE_TAG_NAMES = ["img", "picture", "source"];
+var FORBIDDEN_TAG_SET = new Set(FORBIDDEN_TAG_NAMES);
+var ANIMATION_TAG_SET = new Set(ANIMATION_TAG_NAMES);
+var IMAGE_TAG_SET = new Set(IMAGE_TAG_NAMES);
+function assertTagNamesAllowed(capabilityId, effective, trust) {
+  const tagNames = ownSchemaKey(effective, "tagNames");
+  assertMutableKeyShape(capabilityId, "tagNames", tagNames);
+  for (const tagName of tagNames) {
+    const normalised = String(tagName).toLowerCase();
+    if (FORBIDDEN_TAG_SET.has(normalised)) {
+      throw new Error(
+        `Markdown capability "${capabilityId}" widened the sanitize schema to allow <${tagName}>, which is never permitted.`
+      );
+    }
+    if (ANIMATION_TAG_SET.has(normalised)) {
+      throw new Error(
+        `Markdown capability "${capabilityId}" widened the sanitize schema to allow <${tagName}>, which rewrites another element's attributes after sanitize and so steps around every value rule here, the URL-scheme allowlist included. Never permitted, on any trust profile.`
+      );
+    }
+    if (trust === "untrusted" && IMAGE_TAG_SET.has(normalised)) {
+      throw new Error(
+        `Markdown capability "${capabilityId}" widened the sanitize schema to allow <${tagName}> under trust="untrusted", which is never permitted: untrusted content must fire no outbound request on view.`
+      );
+    }
+  }
+}
+
+// src/markdown/rehypeBlockRemoteImages.ts
+var BLOCKED_IMAGE_TAG_NAME = "blockedimage";
+var BLOCKED_IMAGE_ALT_PROP = "dataAlt";
+function rehypeBlockRemoteImages() {
+  return (tree) => {
+    visit(tree);
+  };
+}
+function visit(node) {
+  const children = node.children;
+  if (!children) return;
+  for (let index = 0; index < children.length; index += 1) {
+    const child = children[index];
+    if (child.type !== "element") continue;
+    if (child.tagName === "img") {
+      children[index] = toPlaceholder(child);
+      continue;
+    }
+    visit(child);
+  }
+}
+function toPlaceholder(image) {
+  const alt = image.properties?.alt;
+  return {
+    type: "element",
+    tagName: BLOCKED_IMAGE_TAG_NAME,
+    properties: typeof alt === "string" && alt ? { [BLOCKED_IMAGE_ALT_PROP]: alt } : {},
+    children: []
+  };
+}
+
+// src/markdown/schemaClone.ts
+function cloneSchema(value) {
+  if (Array.isArray(value)) {
+    return Array.from(value, (entry) => cloneSchema(entry));
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+  if (value !== null && typeof value === "object") {
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const [key, entry] of Object.entries(value)) {
+      out[key] = cloneSchema(entry);
+    }
+    return out;
+  }
+  return value;
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof RegExp) return value;
+  Object.freeze(value);
+  for (const entry of Object.values(value)) deepFreeze(entry);
+  return value;
+}
+
+// src/markdown/schema.ts
+var defaults = cloneSchema(defaultSchema);
+var IMAGE_TAG_SET2 = new Set(IMAGE_TAG_NAMES);
+var baseMarkdownSchema = deepFreeze({
+  ...defaults,
+  tagNames: [.../* @__PURE__ */ new Set([...defaults.tagNames ?? [], "input"])],
+  attributes: {
+    ...defaults.attributes ?? {},
+    input: ["type", "checked", "disabled", "className"]
+  }
+});
+var untrustedSchema = deepFreeze({
+  ...baseMarkdownSchema,
+  tagNames: [
+    ...(baseMarkdownSchema.tagNames ?? []).filter((tag) => !IMAGE_TAG_SET2.has(tag)),
+    BLOCKED_IMAGE_TAG_NAME
+  ],
+  attributes: {
+    ...baseMarkdownSchema.attributes ?? {},
+    [BLOCKED_IMAGE_TAG_NAME]: [BLOCKED_IMAGE_ALT_PROP]
+  }
+});
+function effectiveSchema(schema) {
+  return { ...defaultSchema, ...schema };
+}
+function assertCapabilitySchema(schema, capabilityId, context) {
+  assertSchemaIsData(capabilityId, schema);
+  const returned = { next: schema, previous: context.previous };
+  assertNoDroppedKeys(capabilityId, returned);
+  assertOnlyMutableKeysChanged(capabilityId, returned);
+  const effective = {
+    next: effectiveSchema(returned.next),
+    previous: effectiveSchema(returned.previous)
+  };
+  assertMutableKeysWellShaped(capabilityId, effective.next);
+  assertTagNamesAllowed(capabilityId, effective.next, context.trust);
+  assertAttributesNotWidened(capabilityId, effective, context.trust);
+  assertNoAliasedAttributeNames(capabilityId, effective);
+  assertProtocolsNotWidened(capabilityId, effective);
+}
+
+// src/markdown/trust.ts
+var MARKDOWN_TRUST_VALUES = ["untrusted", "internal"];
+var DEFAULT_MARKDOWN_TRUST = "untrusted";
+var TRUST_VALUE_SET = new Set(MARKDOWN_TRUST_VALUES);
+function normalizeTrust(value) {
+  return typeof value === "string" && TRUST_VALUE_SET.has(value) ? value : DEFAULT_MARKDOWN_TRUST;
+}
+function BlockedImage({ node }) {
+  const alt = node?.properties?.[BLOCKED_IMAGE_ALT_PROP];
+  const label = typeof alt === "string" && alt ? `[Image not shown: ${alt}]` : "[Image not shown]";
+  return /* @__PURE__ */ jsx("span", { className: "ethisys-md-blocked-image", "data-testid": "markdown-blocked-image", children: label });
+}
+var BLOCKED_IMAGE_COMPONENTS = {
+  [BLOCKED_IMAGE_TAG_NAME]: BlockedImage
+};
+
+// src/markdown/pipeline.ts
+function buildMarkdownPipeline(options = {}) {
+  const { softBreaks = false, capabilities = [], components } = options;
+  const trust = normalizeTrust(options.trust);
+  const seen = /* @__PURE__ */ new Set();
+  for (const cap of capabilities) {
+    if (seen.has(cap.id)) throw new Error(`Duplicate markdown capability id: ${cap.id}`);
+    seen.add(cap.id);
+  }
+  const schema = capabilities.reduce(
+    (acc, cap) => {
+      if (!cap.extendSchema) return acc;
+      const returned = cap.extendSchema(cloneSchema(acc));
+      assertSchemaReturned(cap.id, returned);
+      const widened = cloneSchema(returned);
+      assertCapabilitySchema(widened, cap.id, { trust, previous: acc });
+      return deepFreeze(widened);
+    },
+    trust === "untrusted" ? untrustedSchema : baseMarkdownSchema
+  );
+  const remarkPlugins = Object.freeze([
+    remarkGfm,
+    ...softBreaks ? [remarkBreaks] : [],
+    ...capabilities.flatMap((c) => [...c.remarkPlugins ?? []])
+  ]);
+  const rehypePlugins = Object.freeze([
+    ...trust === "untrusted" ? [rehypeBlockRemoteImages] : [],
+    ...capabilities.flatMap((c) => [...c.rehypeBeforeSanitize ?? []]),
+    // The TUPLE is frozen too, not just the array around it. `Object.freeze` is one
+    // level deep: a frozen array still holds a writable tuple, and
+    // `rehypePlugins.at(-1)[1] = permissiveSchema` would then replace the schema this
+    // function spent its whole body validating — or `[0]` the sanitizer itself —
+    // without touching anything frozen. Unreachable today (nothing outside this module
+    // holds the array), but `MarkdownPipeline` documents the last entry as frozen, and
+    // a freeze that does not freeze what it appears to is the trap this package exists
+    // to stop shipping.
+    Object.freeze([rehypeSanitize, schema])
+  ]);
+  const mergedComponents = Object.assign(
+    {},
+    ...capabilities.map((c) => c.components ?? {}),
+    components ?? {},
+    // LAST: the built-in blocked-image renderer cannot be overridden by a caller.
+    trust === "untrusted" ? BLOCKED_IMAGE_COMPONENTS : {}
+  );
+  return Object.freeze({
+    remarkPlugins,
+    rehypePlugins,
+    components: mergedComponents,
+    skipHtml: true
+  });
+}
+function MarkdownView({
+  children,
+  // No default here on purpose: `buildMarkdownPipeline` normalises `trust`, and one
+  // definition of "the profile you get by forgetting" is the point — see `./trust`.
+  trust,
+  softBreaks = false,
+  capabilities,
+  components
+}) {
+  const pipeline = useMemo(
+    () => buildMarkdownPipeline({ trust, softBreaks, capabilities, components }),
+    [trust, softBreaks, capabilities, components]
+  );
+  return /* @__PURE__ */ jsx(ReactMarkdown, { ...pipeline, children });
+}
+
+export { MarkdownView, baseMarkdownSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map