@x15ventures/x15-ui-library 3.19.0 → 3.20.0

package/dist/esm/widgets/shared/documents/engines/markdownEditor/markdownTextIndex.js

@@ -0,0 +1,170 @@
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+
+/*
+  The text a reader sees for a markdown document (what rich-text mode renders), with a map back to
+  source offsets. Comment quotes are taken from, and resolved against, this text in both views, so
+  `Keep **passwords** private.` quotes as `passwords private` whichever view the comment was made in.
+
+  As in the DOM text index, blocks and line breaks are separated by a newline.
+ */
+
+const markdownParser = unified().use(remarkParse).use(remarkGfm);
+// Nodes rendered inline; every other node with children is a block.
+const INLINE_TYPES = new Set(['emphasis', 'strong', 'delete', 'link', 'linkReference']);
+// Leaves whose value is shown as document text.
+const TEXT_TYPES = new Set(['text', 'inlineCode', 'code']);
+// Code is shown verbatim, so escapes and entities in it are literal text.
+const VERBATIM_TYPES = new Set(['inlineCode', 'code']);
+const HTML_BREAK = /^<br\s*\/?>$/i;
+const FENCE = /^[ \t]*(`{3,}|~{3,})/;
+const ENTITY = /^&(?:#[0-9]{1,7}|#[xX][0-9a-fA-F]{1,6}|[A-Za-z][A-Za-z0-9]{1,31});/;
+const ESCAPABLE = /[!-/:-@[-`{-~]/;
+// Markup between characters (indentation, `>` markers and so on) is skipped, up to this many characters.
+const MAX_ALIGNMENT_GAP = 256;
+
+// Entities are decoded by the same parser as the document so both agree on what each one renders.
+const entityCache = new Map();
+const decodeEntity = entity => {
+  let decoded = entityCache.get(entity);
+  if (decoded === undefined) {
+    const paragraph = markdownParser.parse(entity).children?.[0];
+    decoded = paragraph?.children?.[0]?.value ?? entity;
+    entityCache.set(entity, decoded);
+  }
+  return decoded;
+};
+
+// The part of a code node's source that holds its value, excluding fences and the info string.
+const getCodeContentSpan = (markdown, node, start, end) => {
+  const source = markdown.slice(start, end);
+  if (node.type === 'inlineCode') {
+    const ticks = /^`+/.exec(source)?.[0].length ?? 0;
+    return [start + ticks, Math.max(start + ticks, end - ticks)];
+  }
+  if (FENCE.test(source)) {
+    const lineEnd = source.indexOf('\n');
+    return [lineEnd === -1 ? end : start + lineEnd + 1, end];
+  }
+  return [start, end];
+};
+export const buildMarkdownTextIndex = markdown => {
+  let text = '';
+  const starts = [];
+  const ends = [];
+  const push = (characters, from, to) => {
+    text += characters;
+    for (let unit = 0; unit < characters.length; unit += 1) {
+      starts.push(from);
+      ends.push(to);
+    }
+  };
+  const addSeparator = sourceOffset => {
+    if (text.length && !text.endsWith('\n')) {
+      push('\n', sourceOffset, sourceOffset);
+    }
+  };
+
+  // Consumes the source token that renders as the next part of the value: an entity, a backslash
+  // escape or the literal character, skipping any markup in between.
+  const addValue = (value, from, to, verbatim) => {
+    let cursor = from;
+    let index = 0;
+    while (index < value.length) {
+      const limit = Math.min(to, cursor + MAX_ALIGNMENT_GAP);
+      let token = null;
+      for (let position = cursor; position < limit && !token; position += 1) {
+        const source = markdown[position];
+        if (!verbatim && source === '&') {
+          const entity = ENTITY.exec(markdown.slice(position, Math.min(to, position + 40)))?.[0];
+          const decoded = entity ? decodeEntity(entity) : '';
+          if (entity && decoded !== entity && value.startsWith(decoded, index)) {
+            token = {
+              position,
+              length: entity.length,
+              characters: decoded
+            };
+            break;
+          }
+        }
+        if (!verbatim && source === '\\' && ESCAPABLE.test(value[index]) && markdown[position + 1] === value[index]) {
+          token = {
+            position,
+            length: 2,
+            characters: value[index]
+          };
+        } else if (source === value[index]) {
+          token = {
+            position,
+            length: 1,
+            characters: value[index]
+          };
+        }
+      }
+      if (token) {
+        push(token.characters, token.position, token.position + token.length);
+        cursor = token.position + token.length;
+        index += token.characters.length;
+      } else {
+        // Unmatched text has no source span of its own; it is pinned to the current position.
+        push(value[index], cursor, cursor);
+        index += 1;
+      }
+    }
+  };
+  let previousBlock = null;
+  const visit = (node, block) => {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (node.type === 'break' || node.type === 'html' && HTML_BREAK.test(node.value?.trim() ?? '')) {
+      if (start !== undefined) {
+        addSeparator(start);
+      }
+      return;
+    }
+    if (TEXT_TYPES.has(node.type) && node.value && start !== undefined && end !== undefined) {
+      if (previousBlock && previousBlock !== block) {
+        addSeparator(start);
+      }
+      previousBlock = block;
+      const verbatim = VERBATIM_TYPES.has(node.type);
+      const [from, to] = verbatim ? getCodeContentSpan(markdown, node, start, end) : [start, end];
+      addValue(node.value, from, to, verbatim);
+      return;
+    }
+    const childBlock = INLINE_TYPES.has(node.type) ? block : node;
+    node.children?.forEach(child => visit(child, childBlock));
+  };
+  const tree = markdownParser.parse(markdown);
+  visit(tree, tree);
+  starts.push(markdown.length);
+  ends.push(markdown.length);
+  return {
+    text,
+    starts,
+    ends
+  };
+};
+
+// The index of the first text character starting at or after a source offset.
+export const sourceToTextOffset = (index, sourceOffset) => {
+  let low = 0;
+  let high = index.text.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (index.starts[middle] < sourceOffset) {
+      low = middle + 1;
+    } else {
+      high = middle;
+    }
+  }
+  return low;
+};
+
+// The source range covering text[start, end).
+export const textToSourceRange = (index, start, end) => ({
+  from: index.starts[start],
+  to: end > start ? index.ends[end - 1] : index.starts[start]
+});
+//# sourceMappingURL=markdownTextIndex.js.map

package/dist/esm/widgets/shared/documents/engines/markdownEditor/markdownTextIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTextIndex.js","names":["remarkGfm","remarkParse","unified","markdownParser","use","INLINE_TYPES","Set","TEXT_TYPES","VERBATIM_TYPES","HTML_BREAK","FENCE","ENTITY","ESCAPABLE","MAX_ALIGNMENT_GAP","entityCache","Map","decodeEntity","entity","decoded","get","undefined","paragraph","parse","children","value","set","getCodeContentSpan","markdown","node","start","end","source","slice","type","ticks","exec","length","Math","max","test","lineEnd","indexOf","buildMarkdownTextIndex","text","starts","ends","push","characters","from","to","unit","addSeparator","sourceOffset","endsWith","addValue","verbatim","cursor","index","limit","min","token","position","startsWith","previousBlock","visit","block","offset","trim","has","childBlock","forEach","child","tree","sourceToTextOffset","low","high","middle","floor","textToSourceRange"],"sources":["../../../../../../../src/widgets/shared/documents/engines/markdownEditor/markdownTextIndex.ts"],"sourcesContent":["import remarkGfm from 'remark-gfm';\nimport remarkParse from 'remark-parse';\nimport { unified } from 'unified';\n\n/*\n  The text a reader sees for a markdown document (what rich-text mode renders), with a map back to\n  source offsets. Comment quotes are taken from, and resolved against, this text in both views, so\n  `Keep **passwords** private.` quotes as `passwords private` whichever view the comment was made in.\n\n  As in the DOM text index, blocks and line breaks are separated by a newline.\n */\nexport type MarkdownTextIndex = {\n  text: string;\n  // text[i] came from source[starts[i], ends[i]); an escape or entity spans several source characters.\n  // Each array has an extra final entry of the source length.\n  starts: number[];\n  ends: number[];\n};\n\nconst markdownParser = unified().use(remarkParse).use(remarkGfm);\n\ntype MarkdownNode = {\n  type: string;\n  value?: string;\n  children?: MarkdownNode[];\n  position?: { start: { offset?: number }; end: { offset?: number } };\n};\n\n// Nodes rendered inline; every other node with children is a block.\nconst INLINE_TYPES = new Set(['emphasis', 'strong', 'delete', 'link', 'linkReference']);\n// Leaves whose value is shown as document text.\nconst TEXT_TYPES = new Set(['text', 'inlineCode', 'code']);\n// Code is shown verbatim, so escapes and entities in it are literal text.\nconst VERBATIM_TYPES = new Set(['inlineCode', 'code']);\nconst HTML_BREAK = /^<br\\s*\\/?>$/i;\nconst FENCE = /^[ \\t]*(`{3,}|~{3,})/;\nconst ENTITY = /^&(?:#[0-9]{1,7}|#[xX][0-9a-fA-F]{1,6}|[A-Za-z][A-Za-z0-9]{1,31});/;\nconst ESCAPABLE = /[!-/:-@[-`{-~]/;\n// Markup between characters (indentation, `>` markers and so on) is skipped, up to this many characters.\nconst MAX_ALIGNMENT_GAP = 256;\n\n// Entities are decoded by the same parser as the document so both agree on what each one renders.\nconst entityCache = new Map<string, string>();\nconst decodeEntity = (entity: string): string => {\n  let decoded = entityCache.get(entity);\n  if (decoded === undefined) {\n    const paragraph = (markdownParser.parse(entity) as MarkdownNode).children?.[0];\n    decoded = paragraph?.children?.[0]?.value ?? entity;\n    entityCache.set(entity, decoded);\n  }\n  return decoded;\n};\n\n// The part of a code node's source that holds its value, excluding fences and the info string.\nconst getCodeContentSpan = (markdown: string, node: MarkdownNode, start: number, end: number): [number, number] => {\n  const source = markdown.slice(start, end);\n  if (node.type === 'inlineCode') {\n    const ticks = /^`+/.exec(source)?.[0].length ?? 0;\n    return [start + ticks, Math.max(start + ticks, end - ticks)];\n  }\n  if (FENCE.test(source)) {\n    const lineEnd = source.indexOf('\\n');\n    return [lineEnd === -1 ? end : start + lineEnd + 1, end];\n  }\n  return [start, end];\n};\n\nexport const buildMarkdownTextIndex = (markdown: string): MarkdownTextIndex => {\n  let text = '';\n  const starts: number[] = [];\n  const ends: number[] = [];\n\n  const push = (characters: string, from: number, to: number) => {\n    text += characters;\n    for (let unit = 0; unit < characters.length; unit += 1) {\n      starts.push(from);\n      ends.push(to);\n    }\n  };\n\n  const addSeparator = (sourceOffset: number) => {\n    if (text.length && !text.endsWith('\\n')) {\n      push('\\n', sourceOffset, sourceOffset);\n    }\n  };\n\n  // Consumes the source token that renders as the next part of the value: an entity, a backslash\n  // escape or the literal character, skipping any markup in between.\n  const addValue = (value: string, from: number, to: number, verbatim: boolean) => {\n    let cursor = from;\n    let index = 0;\n    while (index < value.length) {\n      const limit = Math.min(to, cursor + MAX_ALIGNMENT_GAP);\n      let token: { position: number; length: number; characters: string } | null = null;\n      for (let position = cursor; position < limit && !token; position += 1) {\n        const source = markdown[position];\n        if (!verbatim && source === '&') {\n          const entity = ENTITY.exec(markdown.slice(position, Math.min(to, position + 40)))?.[0];\n          const decoded = entity ? decodeEntity(entity) : '';\n          if (entity && decoded !== entity && value.startsWith(decoded, index)) {\n            token = { position, length: entity.length, characters: decoded };\n            break;\n          }\n        }\n        if (!verbatim && source === '\\\\' && ESCAPABLE.test(value[index]) && markdown[position + 1] === value[index]) {\n          token = { position, length: 2, characters: value[index] };\n        } else if (source === value[index]) {\n          token = { position, length: 1, characters: value[index] };\n        }\n      }\n      if (token) {\n        push(token.characters, token.position, token.position + token.length);\n        cursor = token.position + token.length;\n        index += token.characters.length;\n      } else {\n        // Unmatched text has no source span of its own; it is pinned to the current position.\n        push(value[index], cursor, cursor);\n        index += 1;\n      }\n    }\n  };\n\n  let previousBlock: MarkdownNode | null = null;\n  const visit = (node: MarkdownNode, block: MarkdownNode) => {\n    const start = node.position?.start.offset;\n    const end = node.position?.end.offset;\n    if (node.type === 'break' || (node.type === 'html' && HTML_BREAK.test(node.value?.trim() ?? ''))) {\n      if (start !== undefined) {\n        addSeparator(start);\n      }\n      return;\n    }\n    if (TEXT_TYPES.has(node.type) && node.value && start !== undefined && end !== undefined) {\n      if (previousBlock && previousBlock !== block) {\n        addSeparator(start);\n      }\n      previousBlock = block;\n      const verbatim = VERBATIM_TYPES.has(node.type);\n      const [from, to] = verbatim ? getCodeContentSpan(markdown, node, start, end) : [start, end];\n      addValue(node.value, from, to, verbatim);\n      return;\n    }\n    const childBlock = INLINE_TYPES.has(node.type) ? block : node;\n    node.children?.forEach((child) => visit(child, childBlock));\n  };\n\n  const tree = markdownParser.parse(markdown) as MarkdownNode;\n  visit(tree, tree);\n  starts.push(markdown.length);\n  ends.push(markdown.length);\n  return { text, starts, ends };\n};\n\n// The index of the first text character starting at or after a source offset.\nexport const sourceToTextOffset = (index: MarkdownTextIndex, sourceOffset: number): number => {\n  let low = 0;\n  let high = index.text.length;\n  while (low < high) {\n    const middle = Math.floor((low + high) / 2);\n    if (index.starts[middle] < sourceOffset) {\n      low = middle + 1;\n    } else {\n      high = middle;\n    }\n  }\n  return low;\n};\n\n// The source range covering text[start, end).\nexport const textToSourceRange = (index: MarkdownTextIndex, start: number, end: number): { from: number; to: number } => ({\n  from: index.starts[start],\n  to: end > start ? index.ends[end - 1] : index.starts[start]\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/widgets/shared/documents/engines/markdownEditor/sanitizeForMdx.js

@@ -0,0 +1,270 @@
+/*
+  MDXEditor parses markdown as MDX, so two kinds of input need neutralising before it sees them:
+  1. HTML injection: every `<` that is not part of explicitly allowed HTML is encoded as `&lt;`,
+     making it inert text the parser cannot interpret as markup.
+  2. MDX expressions: `{` is encoded as `&#123;` so it is never evaluated.
+
+  Allowed HTML is protected with placeholders rather than an HTML sanitiser, so content never
+  passes through an HTML serialiser (which would encode `&` and other text and cause false diffs).
+  
+  SECURITY NOTE: HTML tokens are scanned linearly and validated without constructing regexes from
+  the allowlist. Remaining regexes are fixed patterns with no nested ambiguous repetitions.
+ */
+
+const PLACEHOLDER_MARK = String.fromCharCode(0xffff);
+const placeholderPattern = /\uFFFF(\d+)\uFFFF/g;
+const hasPlaceholder = /\uFFFF\d+\uFFFF/;
+const isWhitespace = character => character !== undefined && /\s/.test(character);
+const findTagEnd = (input, start) => {
+  let quote;
+  for (let index = start; index < input.length; index += 1) {
+    const character = input[index];
+    if (character === '<') {
+      return -1;
+    }
+    if (quote) {
+      if (character === quote) {
+        quote = undefined;
+      }
+    } else if (character === '"' || character === '\'') {
+      quote = character;
+    } else if (character === '>') {
+      return index;
+    }
+  }
+  return -1;
+};
+const findHtmlTokens = (input, tag) => {
+  const tokens = [];
+  const openingPrefix = `<${tag}`;
+  const closingToken = `</${tag}>`;
+  let searchFrom = 0;
+  while (searchFrom < input.length) {
+    const index = input.indexOf('<', searchFrom);
+    if (index < 0) {
+      break;
+    }
+    if (input.startsWith(closingToken, index)) {
+      tokens.push({
+        index,
+        token: closingToken,
+        closing: true
+      });
+      searchFrom = index + closingToken.length;
+      continue;
+    }
+    if (!input.startsWith(openingPrefix, index)) {
+      searchFrom = index + 1;
+      continue;
+    }
+    const nameEnd = index + openingPrefix.length;
+    const boundary = input[nameEnd];
+    if (boundary !== '/' && boundary !== '>' && !isWhitespace(boundary)) {
+      searchFrom = index + 1;
+      continue;
+    }
+    const end = findTagEnd(input, nameEnd);
+    if (end < 0) {
+      searchFrom = index + 1;
+      continue;
+    }
+    tokens.push({
+      index,
+      token: input.slice(index, end + 1),
+      closing: false
+    });
+    searchFrom = end + 1;
+  }
+  return tokens;
+};
+const isAllowedOpening = ({
+  tag,
+  classes,
+  attrs
+}, token) => {
+  const suffix = token.slice(tag.length + 1, -1);
+  const hasRestrictions = Boolean(classes?.length || attrs?.length);
+  const allowedClasses = classes ?? [];
+  if (!hasRestrictions) {
+    return suffix === '' || suffix === '/' || isWhitespace(suffix[0]) && !suffix.includes('>');
+  }
+  let index = 0;
+  while (isWhitespace(suffix[index])) {
+    index += 1;
+  }
+  if (index === suffix.length || suffix[index] === '/' && index === suffix.length - 1) {
+    return true;
+  }
+  while (index < suffix.length) {
+    const attributeStart = index;
+    while (index < suffix.length && !isWhitespace(suffix[index]) && suffix[index] !== '=') {
+      index += 1;
+    }
+    if (index === attributeStart || suffix[index] !== '=') {
+      return false;
+    }
+    const attribute = suffix.slice(attributeStart, index);
+    index += 1;
+    if (suffix[index] !== '"') {
+      return false;
+    }
+    const valueStart = ++index;
+    while (index < suffix.length && suffix[index] !== '"') {
+      index += 1;
+    }
+    if (index === suffix.length) {
+      return false;
+    }
+    const value = suffix.slice(valueStart, index);
+    const isAllowedClass = attribute === 'class' && allowedClasses.length > 0 && value.split(/\s+/).every(className => className.length > 0 && allowedClasses.includes(className));
+    if (!attrs?.includes(attribute) && !isAllowedClass) {
+      return false;
+    }
+    index += 1;
+    if (index === suffix.length) {
+      return true;
+    }
+    const separatorStart = index;
+    while (isWhitespace(suffix[index])) {
+      index += 1;
+    }
+    if (index === suffix.length || suffix[index] === '/' && index === suffix.length - 1) {
+      return true;
+    }
+    if (index === separatorStart) {
+      return false;
+    }
+  }
+  return true;
+};
+const isVoidToken = (token, entry) => token.endsWith('/>') || ['img', 'br'].includes(entry.tag);
+const preserve = (value, preserved) => {
+  preserved.push(value);
+  return `${PLACEHOLDER_MARK}${preserved.length - 1}${PLACEHOLDER_MARK}`;
+};
+const protectInlineCode = (markdown, preserved) => {
+  const runs = [];
+  for (let index = 0; index < markdown.length;) {
+    if (markdown[index] !== '`') {
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (markdown[end] === '`') {
+      end += 1;
+    }
+    let precedingBackslashes = 0;
+    for (let previous = index - 1; previous >= 0 && markdown[previous] === '\\'; previous -= 1) {
+      precedingBackslashes += 1;
+    }
+    const escapedTickCount = precedingBackslashes % 2;
+    if (end - index > escapedTickCount) {
+      runs.push({
+        start: index + escapedTickCount,
+        end,
+        length: end - index - escapedTickCount
+      });
+    }
+    index = end;
+  }
+  const nextRunByLength = new Map();
+  const nextRun = new Array(runs.length);
+  for (let index = runs.length - 1; index >= 0; index -= 1) {
+    nextRun[index] = nextRunByLength.get(runs[index].length);
+    nextRunByLength.set(runs[index].length, index);
+  }
+  let result = '';
+  let copiedThrough = 0;
+  for (let index = 0; index < runs.length; index += 1) {
+    const closingIndex = nextRun[index];
+    if (closingIndex === undefined) {
+      continue;
+    }
+    const opening = runs[index];
+    const closing = runs[closingIndex];
+    result += markdown.slice(copiedThrough, opening.start);
+    result += preserve(markdown.slice(opening.start, closing.end), preserved);
+    copiedThrough = closing.end;
+    index = closingIndex;
+  }
+  return result + markdown.slice(copiedThrough);
+};
+const protectCode = (markdown, preserved) => {
+  const lines = markdown.split('\n');
+  const protectedLines = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const opening = /^ {0,3}(`{3,}|~{3,})/.exec(lines[index]);
+    if (!opening) {
+      protectedLines.push(lines[index]);
+      continue;
+    }
+    const marker = opening[1];
+    let closingIndex = index + 1;
+    for (; closingIndex < lines.length; closingIndex += 1) {
+      const closing = /^ {0,3}(`+|~+)[ \t]*$/.exec(lines[closingIndex]);
+      if (closing && closing[1][0] === marker[0] && closing[1].length >= marker.length) {
+        break;
+      }
+    }
+    const lastCodeLine = Math.min(closingIndex, lines.length - 1);
+    protectedLines.push(preserve(lines.slice(index, lastCodeLine + 1).join('\n'), preserved));
+    index = lastCodeLine;
+  }
+  return protectInlineCode(protectedLines.join('\n'), preserved);
+};
+export const sanitizeEditorInput = (markdown, allowedHtml = []) => {
+  const preserved = [];
+  let withPlaceholders = protectCode(markdown, preserved);
+  allowedHtml.forEach(entry => {
+    const tokens = findHtmlTokens(withPlaceholders, entry.tag);
+    const keep = new Set();
+    const openings = [];
+    tokens.forEach(({
+      token,
+      index,
+      closing
+    }) => {
+      if (closing) {
+        // A closing tag survives only alongside the allowed opening tag it pairs with.
+        const opening = openings.pop();
+        if (opening?.allowed) {
+          keep.add(opening.index);
+          keep.add(index);
+        }
+      } else if (isVoidToken(token, entry)) {
+        if (isAllowedOpening(entry, token)) {
+          keep.add(index);
+        }
+      } else {
+        openings.push({
+          index,
+          allowed: isAllowedOpening(entry, token)
+        });
+      }
+    });
+    let copiedThrough = 0;
+    withPlaceholders = tokens.reduce((result, {
+      index,
+      token
+    }) => {
+      result += withPlaceholders.slice(copiedThrough, index);
+      result += keep.has(index) ? preserve(token, preserved) : token;
+      copiedThrough = index + token.length;
+      return result;
+    }, '') + withPlaceholders.slice(copiedThrough);
+  });
+  let result = withPlaceholders.replace(/</g, '&lt;').replace(/\{/g, '&#123;');
+  // Nested allowed elements leave placeholders inside restored placeholders, so repeat until none remain.
+  while (hasPlaceholder.test(result)) {
+    result = result.replace(placeholderPattern, (_, index) => preserved[Number(index)]);
+  }
+  return result;
+};
+
+/*
+  Reverses the backslash escapes MDXEditor's serialiser adds for MDX/HTML reasons during its
+  markdown -> AST -> markdown round-trip, so `&`, `{`, `}`, `<`, `>` and `"` are saved literally.
+  Markdown syntax escapes (\*, \#, \-, ...) are deliberately left alone.
+ */
+export const desanitizeEditorOutput = markdown => markdown.replace(/\\&/g, '&').replace(/\\{/g, '{').replace(/\\}/g, '}').replace(/\\</g, '<').replace(/\\>/g, '>').replace(/\\"/g, '"');
+//# sourceMappingURL=sanitizeForMdx.js.map

package/dist/esm/widgets/shared/documents/engines/markdownEditor/sanitizeForMdx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeForMdx.js","names":["PLACEHOLDER_MARK","String","fromCharCode","placeholderPattern","hasPlaceholder","isWhitespace","character","undefined","test","findTagEnd","input","start","quote","index","length","findHtmlTokens","tag","tokens","openingPrefix","closingToken","searchFrom","indexOf","startsWith","push","token","closing","nameEnd","boundary","end","slice","isAllowedOpening","classes","attrs","suffix","hasRestrictions","Boolean","allowedClasses","includes","attributeStart","attribute","valueStart","value","isAllowedClass","split","every","className","separatorStart","isVoidToken","entry","endsWith","preserve","preserved","protectInlineCode","markdown","runs","precedingBackslashes","previous","escapedTickCount","nextRunByLength","Map","nextRun","Array","get","set","result","copiedThrough","closingIndex","opening","protectCode","lines","protectedLines","exec","marker","lastCodeLine","Math","min","join","sanitizeEditorInput","allowedHtml","withPlaceholders","forEach","keep","Set","openings","pop","allowed","add","reduce","has","replace","_","Number","desanitizeEditorOutput"],"sources":["../../../../../../../src/widgets/shared/documents/engines/markdownEditor/sanitizeForMdx.ts"],"sourcesContent":["/*\n  MDXEditor parses markdown as MDX, so two kinds of input need neutralising before it sees them:\n  1. HTML injection: every `<` that is not part of explicitly allowed HTML is encoded as `&lt;`,\n     making it inert text the parser cannot interpret as markup.\n  2. MDX expressions: `{` is encoded as `&#123;` so it is never evaluated.\n\n  Allowed HTML is protected with placeholders rather than an HTML sanitiser, so content never\n  passes through an HTML serialiser (which would encode `&` and other text and cause false diffs).\n  \n  SECURITY NOTE: HTML tokens are scanned linearly and validated without constructing regexes from\n  the allowlist. Remaining regexes are fixed patterns with no nested ambiguous repetitions.\n */\n\nexport type AllowedHtmlEntry = {\n  tag: string;\n  classes?: string[];\n  attrs?: string[];\n};\n\nconst PLACEHOLDER_MARK = String.fromCharCode(0xffff);\nconst placeholderPattern = /\\uFFFF(\\d+)\\uFFFF/g;\nconst hasPlaceholder = /\\uFFFF\\d+\\uFFFF/;\n\ntype HtmlToken = {\n  index: number;\n  token: string;\n  closing: boolean;\n};\n\nconst isWhitespace = (character: string | undefined): boolean =>\n  character !== undefined && /\\s/.test(character);\n\nconst findTagEnd = (input: string, start: number): number => {\n  let quote: '\"' | '\\'' | undefined;\n  for (let index = start; index < input.length; index += 1) {\n    const character = input[index];\n    if (character === '<') {\n      return -1;\n    }\n    if (quote) {\n      if (character === quote) {\n        quote = undefined;\n      }\n    } else if (character === '\"' || character === '\\'') {\n      quote = character;\n    } else if (character === '>') {\n      return index;\n    }\n  }\n  return -1;\n};\n\nconst findHtmlTokens = (input: string, tag: string): HtmlToken[] => {\n  const tokens: HtmlToken[] = [];\n  const openingPrefix = `<${ tag }`;\n  const closingToken = `</${ tag }>`;\n  let searchFrom = 0;\n\n  while (searchFrom < input.length) {\n    const index = input.indexOf('<', searchFrom);\n    if (index < 0) {\n      break;\n    }\n\n    if (input.startsWith(closingToken, index)) {\n      tokens.push({ index, token: closingToken, closing: true });\n      searchFrom = index + closingToken.length;\n      continue;\n    }\n\n    if (!input.startsWith(openingPrefix, index)) {\n      searchFrom = index + 1;\n      continue;\n    }\n\n    const nameEnd = index + openingPrefix.length;\n    const boundary = input[nameEnd];\n    if (boundary !== '/' && boundary !== '>' && !isWhitespace(boundary)) {\n      searchFrom = index + 1;\n      continue;\n    }\n\n    const end = findTagEnd(input, nameEnd);\n    if (end < 0) {\n      searchFrom = index + 1;\n      continue;\n    }\n\n    tokens.push({ index, token: input.slice(index, end + 1), closing: false });\n    searchFrom = end + 1;\n  }\n\n  return tokens;\n};\n\nconst isAllowedOpening = ({ tag, classes, attrs }: AllowedHtmlEntry, token: string): boolean => {\n  const suffix = token.slice(tag.length + 1, -1);\n  const hasRestrictions = Boolean(classes?.length || attrs?.length);\n  const allowedClasses = classes ?? [];\n\n  if (!hasRestrictions) {\n    return suffix === '' ||\n      suffix === '/' ||\n      (isWhitespace(suffix[0]) && !suffix.includes('>'));\n  }\n\n  let index = 0;\n  while (isWhitespace(suffix[index])) {\n    index += 1;\n  }\n  if (index === suffix.length || (suffix[index] === '/' && index === suffix.length - 1)) {\n    return true;\n  }\n\n  while (index < suffix.length) {\n    const attributeStart = index;\n    while (index < suffix.length && !isWhitespace(suffix[index]) && suffix[index] !== '=') {\n      index += 1;\n    }\n    if (index === attributeStart || suffix[index] !== '=') {\n      return false;\n    }\n\n    const attribute = suffix.slice(attributeStart, index);\n    index += 1;\n    if (suffix[index] !== '\"') {\n      return false;\n    }\n    const valueStart = ++index;\n    while (index < suffix.length && suffix[index] !== '\"') {\n      index += 1;\n    }\n    if (index === suffix.length) {\n      return false;\n    }\n\n    const value = suffix.slice(valueStart, index);\n    const isAllowedClass = attribute === 'class' && allowedClasses.length > 0 &&\n      value.split(/\\s+/).every((className) => className.length > 0 && allowedClasses.includes(className));\n    if (!attrs?.includes(attribute) && !isAllowedClass) {\n      return false;\n    }\n\n    index += 1;\n    if (index === suffix.length) {\n      return true;\n    }\n    const separatorStart = index;\n    while (isWhitespace(suffix[index])) {\n      index += 1;\n    }\n    if (index === suffix.length || (suffix[index] === '/' && index === suffix.length - 1)) {\n      return true;\n    }\n    if (index === separatorStart) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\nconst isVoidToken = (token: string, entry: AllowedHtmlEntry): boolean => token.endsWith('/>') || ['img', 'br'].includes(entry.tag);\n\nconst preserve = (value: string, preserved: string[]): string => {\n  preserved.push(value);\n  return `${ PLACEHOLDER_MARK }${ preserved.length - 1 }${ PLACEHOLDER_MARK }`;\n};\n\nconst protectInlineCode = (markdown: string, preserved: string[]): string => {\n  const runs: { start: number; end: number; length: number }[] = [];\n  for (let index = 0; index < markdown.length;) {\n    if (markdown[index] !== '`') {\n      index += 1;\n      continue;\n    }\n\n    let end = index + 1;\n    while (markdown[end] === '`') {\n      end += 1;\n    }\n    let precedingBackslashes = 0;\n    for (let previous = index - 1; previous >= 0 && markdown[previous] === '\\\\'; previous -= 1) {\n      precedingBackslashes += 1;\n    }\n    const escapedTickCount = precedingBackslashes % 2;\n    if (end - index > escapedTickCount) {\n      runs.push({ start: index + escapedTickCount, end, length: end - index - escapedTickCount });\n    }\n    index = end;\n  }\n\n  const nextRunByLength = new Map<number, number>();\n  const nextRun: (number | undefined)[] = new Array(runs.length);\n  for (let index = runs.length - 1; index >= 0; index -= 1) {\n    nextRun[index] = nextRunByLength.get(runs[index].length);\n    nextRunByLength.set(runs[index].length, index);\n  }\n\n  let result = '';\n  let copiedThrough = 0;\n  for (let index = 0; index < runs.length; index += 1) {\n    const closingIndex = nextRun[index];\n    if (closingIndex === undefined) {\n      continue;\n    }\n\n    const opening = runs[index];\n    const closing = runs[closingIndex];\n    result += markdown.slice(copiedThrough, opening.start);\n    result += preserve(markdown.slice(opening.start, closing.end), preserved);\n    copiedThrough = closing.end;\n    index = closingIndex;\n  }\n  return result + markdown.slice(copiedThrough);\n};\n\nconst protectCode = (markdown: string, preserved: string[]): string => {\n  const lines = markdown.split('\\n');\n  const protectedLines: string[] = [];\n\n  for (let index = 0; index < lines.length; index += 1) {\n    const opening = /^ {0,3}(`{3,}|~{3,})/.exec(lines[index]);\n    if (!opening) {\n      protectedLines.push(lines[index]);\n      continue;\n    }\n\n    const marker = opening[1];\n    let closingIndex = index + 1;\n    for (; closingIndex < lines.length; closingIndex += 1) {\n      const closing = /^ {0,3}(`+|~+)[ \\t]*$/.exec(lines[closingIndex]);\n      if (closing && closing[1][0] === marker[0] && closing[1].length >= marker.length) {\n        break;\n      }\n    }\n\n    const lastCodeLine = Math.min(closingIndex, lines.length - 1);\n    protectedLines.push(preserve(lines.slice(index, lastCodeLine + 1).join('\\n'), preserved));\n    index = lastCodeLine;\n  }\n\n  return protectInlineCode(protectedLines.join('\\n'), preserved);\n};\n\nexport const sanitizeEditorInput = (markdown: string, allowedHtml: AllowedHtmlEntry[] = []): string => {\n  const preserved: string[] = [];\n  let withPlaceholders = protectCode(markdown, preserved);\n\n  allowedHtml.forEach((entry) => {\n    const tokens = findHtmlTokens(withPlaceholders, entry.tag);\n    const keep = new Set<number>();\n    const openings: { index: number; allowed: boolean }[] = [];\n\n    tokens.forEach(({ token, index, closing }) => {\n      if (closing) {\n        // A closing tag survives only alongside the allowed opening tag it pairs with.\n        const opening = openings.pop();\n        if (opening?.allowed) {\n          keep.add(opening.index);\n          keep.add(index);\n        }\n      } else if (isVoidToken(token, entry)) {\n        if (isAllowedOpening(entry, token)) {\n          keep.add(index);\n        }\n      } else {\n        openings.push({ index, allowed: isAllowedOpening(entry, token) });\n      }\n    });\n\n    let copiedThrough = 0;\n    withPlaceholders = tokens.reduce((result, { index, token }) => {\n      result += withPlaceholders.slice(copiedThrough, index);\n      result += keep.has(index) ? preserve(token, preserved) : token;\n      copiedThrough = index + token.length;\n      return result;\n    }, '') + withPlaceholders.slice(copiedThrough);\n  });\n\n  let result = withPlaceholders.replace(/</g, '&lt;').replace(/\\{/g, '&#123;');\n  // Nested allowed elements leave placeholders inside restored placeholders, so repeat until none remain.\n  while (hasPlaceholder.test(result)) {\n    result = result.replace(placeholderPattern, (_, index: string) => preserved[Number(index)]);\n  }\n  return result;\n};\n\n/*\n  Reverses the backslash escapes MDXEditor's serialiser adds for MDX/HTML reasons during its\n  markdown -> AST -> markdown round-trip, so `&`, `{`, `}`, `<`, `>` and `\"` are saved literally.\n  Markdown syntax escapes (\\*, \\#, \\-, ...) are deliberately left alone.\n */\nexport const desanitizeEditorOutput = (markdown: string): string => markdown\n  .replace(/\\\\&/g, '&')\n  .replace(/\\\\{/g, '{')\n  .replace(/\\\\}/g, '}')\n  .replace(/\\\\</g, '<')\n  .replace(/\\\\>/g, '>')\n  .replace(/\\\\\"/g, '\"');\n"],"mappings":"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","ignoreList":[]}