@juspay/svelte-ui-components 4.11.5 → 4.12.0

package/dist/MarkdownText/markdown.js

@@ -1,8 +1,9 @@
 import { Marked } from 'marked';
+import { parseFragment } from 'parse5';
 /**
  * Chat content comes from models and users, not from the app's own templates,
  * so the output must be safe without asking consumers to run a sanitizer:
- * raw HTML never passes through (it renders as escaped text), and only these
+ * raw HTML never passes through (escaped by default, tags optionally stripped), and only these
  * URL protocols survive on links. Everything else in the output is built by
  * marked from markdown syntax alone.
  */
@@ -109,10 +110,36 @@ function resolveTagAllowList(allowedTags) {
 function tagAllowed(allowed, tag) {
     return allowed === null || allowed.has(tag);
 }
-function createSanitizingRenderer(protocols, allowedTags, disableTaskLists) {
+/**
+ * As with `narrow` and `resolveTagAllowList`, a plain-JS or web-component
+ * consumer can hand this anything at runtime, so anything other than the one
+ * recognised opt-in degrades to today's escaping rather than throwing — an
+ * unrecognised value must never be the reason content silently disappears.
+ */
+function resolveRawHtmlMode(rawHtml) {
+    return rawHtml === 'strip' ? 'strip' : 'escape';
+}
+// An inert, server-compatible HTML parser handles quoted delimiters, entities
+// and raw-text elements. Escaping its text nodes prevents decoded entities from
+// becoming markup when the resulting string is rendered by Svelte.
+function rawHtmlText(node) {
+    if ('value' in node) {
+        return escapeHtml(node.value);
+    }
+    // A <template>'s children live in a separate `content` fragment rather than
+    // in childNodes, so recursing only through childNodes loses its text.
+    if ('content' in node) {
+        return rawHtmlText(node.content);
+    }
+    if ('childNodes' in node) {
+        return node.childNodes.map(rawHtmlText).join('');
+    }
+    return '';
+}
+function createSanitizingRenderer(protocols, allowedTags, disableTaskLists, rawHtml) {
     return {
         html(token) {
-            return escapeHtml(token.text);
+            return rawHtml === 'strip' ? rawHtmlText(parseFragment(token.text)) : escapeHtml(token.text);
         },
         link(token) {
             if (hasSafeProtocol(token.href, protocols.links) && tagAllowed(allowedTags, 'a')) {
@@ -233,19 +260,21 @@ function instanceFor(options) {
     const protocols = resolveProtocolSets(options.sanitize);
     const allowedTags = resolveTagAllowList(options.sanitize?.allowedTags);
     const disableTaskLists = options.sanitize?.disableTaskLists === true;
+    const rawHtml = resolveRawHtmlMode(options.sanitize?.rawHtml);
     const key = [
         breaks ? 'breaks' : 'default',
         [...protocols.links].sort().join(','),
         [...protocols.images].sort().join(','),
         allowedTags ? [...allowedTags].sort().join(',') : '*',
-        disableTaskLists ? 'no-tasks' : 'tasks'
+        disableTaskLists ? 'no-tasks' : 'tasks',
+        rawHtml
     ].join('|');
     let instance = instances.get(key);
     if (!instance) {
         instance = new Marked({
             gfm: true,
             breaks,
-            renderer: createSanitizingRenderer(protocols, allowedTags, disableTaskLists)
+            renderer: createSanitizingRenderer(protocols, allowedTags, disableTaskLists, rawHtml)
         });
         instances.set(key, instance);
     }

package/dist/MarkdownText/properties.d.ts

@@ -2,7 +2,7 @@ export type MarkdownTextProperties = OptionalMarkdownTextProperties & MandatoryM
 export type MandatoryMarkdownTextProperties = {
     /**
      * Markdown source. Rendered through the library's sanitized-by-construction
-     * pipeline: raw HTML (block and inline) is escaped and shown as text, and
+     * pipeline: raw HTML is escaped by default (or stripped via sanitize.rawHtml), and
      * link/image URLs outside the safe-protocol allow-list are stripped while
      * their text is kept.
      */
@@ -34,8 +34,9 @@ export type OptionalMarkdownTextProperties = {
  * with the library's own allow-list for each surface, so it can only NARROW
  * what already renders, never widen it (listing `javascript:` here can never
  * resurrect it). Omitting `sanitize`, or `allowedProtocols`, keeps today's
- * defaults untouched. This is independent of the "raw HTML is always escaped"
- * guarantee, which has no opt-out.
+ * defaults untouched. This is independent of how raw HTML is disposed of,
+ * which `rawHtml` governs separately; raw HTML is never inserted as markup
+ * either way, so neither option can widen what renders.
  */
 export type MarkdownSanitizeOptions = {
     /**
@@ -58,9 +59,8 @@ export type MarkdownSanitizeOptions = {
      * `'blockquote'`, `'ul'`, `'ol'`, `'table'`, `'hr'`, and `'h1'`–`'h6'`. An
      * unrecognised name is simply ignored — it narrows nothing, it does not
      * error. Omitting `allowedTags` keeps today's defaults untouched: every tag
-     * renders as it does now. This is independent of the "raw HTML is always
-     * escaped" guarantee, which has no opt-out and is never affected by this
-     * list.
+     * renders as it does now. This list governs markdown-GENERATED tags only and
+     * never affects raw HTML from the source, whose disposal is `rawHtml`'s job.
      */
     allowedTags?: string[];
     /**
@@ -71,15 +71,35 @@ export type MarkdownSanitizeOptions = {
      * safety one. Defaults to `false`, keeping today's checkbox rendering.
      */
     disableTaskLists?: boolean;
+    /**
+     * What to do with raw HTML typed literally into the markdown source, as
+     * opposed to the tags markdown itself generates (which `allowedTags`
+     * governs). Defaults to `'escape'` — today's behaviour, where
+     * `<script>alert(1)</script>` renders as visible escaped tag text.
+     *
+     * `'strip'` removes raw tags and comments while retaining their text:
+     * `<div>hello</div>` becomes `hello`. An inert HTML parser handles quoted
+     * delimiters and entities; every retained text node is escaped before output.
+     * Script/style contents remain visible text, never executable elements.
+     * Fenced code and ordinary angle-bracket prose are not raw HTML tokens and
+     * keep their existing rendering. Neither mode inserts source HTML into the DOM.
+     */
+    rawHtml?: MarkdownRawHtmlMode;
 };
+/**
+ * `'escape'` renders raw HTML as visible escaped text (the default, and what
+ * the component has always done); `'strip'` removes it. See
+ * `MarkdownSanitizeOptions.rawHtml`.
+ */
+export type MarkdownRawHtmlMode = 'escape' | 'strip';
 export type RenderMarkdownOptions = {
     /** Render single newlines as `<br>` (GFM "breaks" mode). */
     breaks?: boolean;
     /**
      * Parse as inline markdown: no block elements (`<p>`, lists, tables) are
      * produced, so the output can sit inside an existing `<p>` or `<span>`.
-     * The same sanitization applies — inline raw HTML is escaped and unsafe
-     * link/image protocols are stripped.
+     * The same sanitization applies — inline raw HTML is escaped (or dropped,
+     * per `sanitize.rawHtml`) and unsafe link/image protocols are stripped.
      */
     inline?: boolean;
     /** Accessible name for the scroll region wrapping each table. See `MarkdownTextProperties.tableLabel`. */