@intlayer/design-system 6.1.6 → 7.0.0-canary.1

package/dist/components/MarkDownRender/processor.mjs

@@ -1,1822 +0,0 @@
-import { jsxs, jsx } from "react/jsx-runtime";
-import { createElement, cloneElement } from "react";
-var define_process_env_default = {};
-const RuleType = {
-  blockQuote: "0",
-  breakLine: "1",
-  breakThematic: "2",
-  codeBlock: "3",
-  codeFenced: "4",
-  codeInline: "5",
-  footnote: "6",
-  footnoteReference: "7",
-  gfmTask: "8",
-  heading: "9",
-  headingSetext: "10",
-  /** only available if not `disableHTMLParsing` */
-  htmlBlock: "11",
-  htmlComment: "12",
-  /** only available if not `disableHTMLParsing` */
-  htmlSelfClosing: "13",
-  /** Custom components like <Tabs>, <TabItem> */
-  customComponent: "34",
-  image: "14",
-  link: "15",
-  /** emits a `link` 'node', does not render directly */
-  linkAngleBraceStyleDetector: "16",
-  /** emits a `link` 'node', does not render directly */
-  linkBareUrlDetector: "17",
-  /** emits a `link` 'node', does not render directly */
-  linkMailtoDetector: "18",
-  newlineCoalescer: "19",
-  orderedList: "20",
-  paragraph: "21",
-  ref: "22",
-  refImage: "23",
-  refLink: "24",
-  table: "25",
-  tableSeparator: "26",
-  text: "27",
-  textBolded: "28",
-  textEmphasized: "29",
-  textEscaped: "30",
-  textMarked: "31",
-  textStrikethroughed: "32",
-  unorderedList: "33"
-};
-if (define_process_env_default.NODE_ENV === "test") {
-  Object.keys(RuleType).forEach((key) => RuleType[key] = key);
-}
-const Priority = {
-  /**
-   * anything that must scan the tree before everything else
-   */
-  MAX: 0,
-  /**
-   * scans for block-level constructs
-   */
-  HIGH: 1,
-  /**
-   * inline w/ more priority than other inline
-   */
-  MED: 2,
-  /**
-   * inline elements
-   */
-  LOW: 3,
-  /**
-   * bare text and stuff that is considered leftovers
-   */
-  MIN: 4
-};
-const ATTRIBUTE_TO_JSX_PROP_MAP = [
-  "allowFullScreen",
-  "allowTransparency",
-  "autoComplete",
-  "autoFocus",
-  "autoPlay",
-  "cellPadding",
-  "cellSpacing",
-  "charSet",
-  "classId",
-  "colSpan",
-  "contentEditable",
-  "contextMenu",
-  "crossOrigin",
-  "encType",
-  "formAction",
-  "formEncType",
-  "formMethod",
-  "formNoValidate",
-  "formTarget",
-  "frameBorder",
-  "hrefLang",
-  "inputMode",
-  "keyParams",
-  "keyType",
-  "marginHeight",
-  "marginWidth",
-  "maxLength",
-  "mediaGroup",
-  "minLength",
-  "noValidate",
-  "radioGroup",
-  "readOnly",
-  "rowSpan",
-  "spellCheck",
-  "srcDoc",
-  "srcLang",
-  "srcSet",
-  "tabIndex",
-  "useMap"
-].reduce(
-  (obj, x) => {
-    obj[x.toLowerCase()] = x;
-    return obj;
-  },
-  { class: "className", for: "htmlFor" }
-);
-const namedCodesToUnicode = {
-  amp: "&",
-  apos: "'",
-  gt: ">",
-  lt: "<",
-  nbsp: " ",
-  quot: "“"
-};
-const DO_NOT_PROCESS_HTML_ELEMENTS = ["style", "script", "pre"];
-const ATTRIBUTES_TO_SANITIZE = [
-  "src",
-  "href",
-  "data",
-  "formAction",
-  "srcDoc",
-  "action"
-];
-const ATTR_EXTRACTOR_R = /([-A-Z0-9_:]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|(?:\{((?:\\.|{[^}]*?}|[^}])*)\})))?/gi;
-const AUTOLINK_MAILTO_CHECK_R = /mailto:/i;
-const BLOCK_END_R = /\n{2,}$/;
-const BLOCKQUOTE_R = /^(\s*>[\s\S]*?)(?=\n\n|$)/;
-const BLOCKQUOTE_TRIM_LEFT_MULTILINE_R = /^ *> ?/gm;
-const BLOCKQUOTE_ALERT_R = /^(?:\[!([^\]]*)\]\n)?([\s\S]*)/;
-const BREAK_LINE_R = /^ {2,}\n/;
-const BREAK_THEMATIC_R = /^(?:( *[-*_])){3,} *(?:\n *)+\n/;
-const CODE_BLOCK_FENCED_R = /^(?: {1,3})?(`{3,}|~{3,}) *(\S+)? *([^\n]*?)?\n([\s\S]*?)(?:\1\n?|$)/;
-const CODE_BLOCK_R = /^(?: {4}[^\n]+\n*)+(?:\n *)+\n?/;
-const CODE_INLINE_R = /^(`+)((?:\\`|(?!\1)`|[^`])+)\1/;
-const CONSECUTIVE_NEWLINE_R = /^(?:\n *)*\n/;
-const CR_NEWLINE_R = /\r\n?/g;
-const FOOTNOTE_R = /^\[\^([^\]]+)](:(.*)((\n+ {4,}.*)|(\n(?!\[\^).+))*)/;
-const FOOTNOTE_REFERENCE_R = /^\[\^([^\]]+)]/;
-const FORMFEED_R = /\f/g;
-const FRONT_MATTER_R = /^---[ \t]*\n(.|\n)*\n---[ \t]*\n/;
-const GFM_TASK_R = /^\s*?\[(x|\s)\]/;
-const HEADING_R = /^ *(#{1,6}) *([^\n]+?)(?: +#*)?(?:\n *)*(?:\n|$)/;
-const HEADING_ATX_COMPLIANT_R = /^ *(#{1,6}) +([^\n]+?)(?: +#*)?(?:\n *)*(?:\n|$)/;
-const HEADING_SETEXT_R = /^([^\n]+)\n *(=|-){3,} *\n/;
-const HTML_BLOCK_ELEMENT_R = /^ *(?!<[a-zA-Z][^ >/]* ?\/>)<([a-zA-Z][^ >/]*) ?((?:[^>]*[^/])?)>\n?(\s*(?:<\1[^>]*?>[\s\S]*?<\/\1>|(?!<\1\b)[\s\S])*?)<\/\1>(?!<\/\1>)\n*/i;
-const HTML_CHAR_CODE_R = /&([a-z0-9]+|#[0-9]{1,6}|#x[0-9a-fA-F]{1,6});/gi;
-const HTML_COMMENT_R = /^<!--[\s\S]*?(?:-->)/;
-const HTML_CUSTOM_ATTR_R = /^(data|aria|x)-[a-z_][a-z\d_.-]*$/;
-const HTML_SELF_CLOSING_ELEMENT_R = /^ *<([a-zA-Z][a-zA-Z0-9:]*)(?:\s+((?:<.*?>|[^>])*))?\/?>(?!<\/\1>)(\s*\n)?/i;
-const CUSTOM_COMPONENT_R = /^ *<([A-Z][a-zA-Z0-9]*)(?:\s+((?:<.*?>|[^>])*))?>\n?(\s*(?:<\1[^>]*?>[\s\S]*?<\/\1>|(?!<\1\b)[\s\S])*?)<\/\1>(?!<\/\1>)\n*/;
-const INTERPOLATION_R = /^\{.*\}$/;
-const LINK_AUTOLINK_BARE_URL_R = /^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/;
-const LINK_AUTOLINK_MAILTO_R = /^<([^ >]+@[^ >]+)>/;
-const LINK_AUTOLINK_R = /^<([^ >]+:\/[^ >]+)>/;
-const CAPTURE_LETTER_AFTER_HYPHEN = /-([a-z])?/gi;
-const NP_TABLE_R = /^(\|.*)\n(?: *(\|? *[-:]+ *\|[-| :]*)\n((?:.*\|.*\n)*))?\n?/;
-const PARAGRAPH_R = /^[^\n]+(?:  \n|\n{2,})/;
-const REFERENCE_IMAGE_OR_LINK = /^\[([^\]]*)\]:\s+<?([^\s>]+)>?\s*("([^"]*)")?/;
-const REFERENCE_IMAGE_R = /^!\[([^\]]*)\] ?\[([^\]]*)\]/;
-const REFERENCE_LINK_R = /^\[([^\]]*)\] ?\[([^\]]*)\]/;
-const SHOULD_RENDER_AS_BLOCK_R = /(\n|^[-*]\s|^#|^ {2,}|^-{2,}|^>\s)/;
-const TAB_R = /\t/g;
-const TABLE_TRIM_PIPES = /(^ *\||\| *$)/g;
-const TABLE_CENTER_ALIGN = /^ *:-+: *$/;
-const TABLE_LEFT_ALIGN = /^ *:-+ *$/;
-const TABLE_RIGHT_ALIGN = /^ *-+: *$/;
-const LOOKAHEAD = (double) => `(?=[\\s\\S]+?\\1${double ? "\\1" : ""})`;
-const INLINE_SKIP_R = "((?:\\[.*?\\][([].*?[)\\]]|<.*?>(?:.*?<.*?>)?|`.*?`|\\\\\\1|[\\s\\S])+?)";
-const TEXT_BOLD_R = new RegExp(
-  `^([*_])\\1${LOOKAHEAD(1)}${INLINE_SKIP_R}\\1\\1(?!\\1)`
-);
-const TEXT_EMPHASIZED_R = new RegExp(
-  `^([*_])${LOOKAHEAD(0)}${INLINE_SKIP_R}\\1(?!\\1)`
-);
-const TEXT_MARKED_R = new RegExp(`^(==)${LOOKAHEAD(0)}${INLINE_SKIP_R}\\1`);
-const TEXT_STRIKETHROUGHED_R = new RegExp(
-  `^(~~)${LOOKAHEAD(0)}${INLINE_SKIP_R}\\1`
-);
-const SHORTCODE_R = /^(:[a-zA-Z0-9-_]+:)/;
-const TEXT_ESCAPED_R = /^\\([^0-9A-Za-z\s])/;
-const UNESCAPE_R = /\\([^0-9A-Za-z\s])/g;
-const TEXT_PLAIN_R = /^[\s\S](?:(?!  \n|[0-9]\.|http)[^=*_~\-\n:<`\\\[!])*/;
-const TRIM_STARTING_NEWLINES = /^\n+/;
-const HTML_LEFT_TRIM_AMOUNT_R = /^([ \t]*)/;
-const ORDERED = 1;
-const UNORDERED = 2;
-const LIST_LOOKBEHIND_R = /(?:^|\n)( *)$/;
-const ORDERED_LIST_BULLET = "(?:\\d+\\.)";
-const UNORDERED_LIST_BULLET = "(?:[*+-])";
-const generateListItemPrefix = (type) => {
-  return "( *)(" + (type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET) + ") +";
-};
-const ORDERED_LIST_ITEM_PREFIX = generateListItemPrefix(ORDERED);
-const UNORDERED_LIST_ITEM_PREFIX = generateListItemPrefix(UNORDERED);
-const generateListItemPrefixRegex = (type) => {
-  return new RegExp(
-    "^" + (type === ORDERED ? ORDERED_LIST_ITEM_PREFIX : UNORDERED_LIST_ITEM_PREFIX)
-  );
-};
-const ORDERED_LIST_ITEM_PREFIX_R = generateListItemPrefixRegex(ORDERED);
-const UNORDERED_LIST_ITEM_PREFIX_R = generateListItemPrefixRegex(UNORDERED);
-const generateListItemRegex = (type) => {
-  return new RegExp(
-    "^" + (type === ORDERED ? ORDERED_LIST_ITEM_PREFIX : UNORDERED_LIST_ITEM_PREFIX) + "[^\\n]*(?:\\n(?!\\1" + (type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET) + " )[^\\n]*)*(\\n|$)",
-    "gm"
-  );
-};
-const ORDERED_LIST_ITEM_R = generateListItemRegex(ORDERED);
-const UNORDERED_LIST_ITEM_R = generateListItemRegex(UNORDERED);
-const generateListRegex = (type) => {
-  const bullet = type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET;
-  return new RegExp(
-    "^( *)(" + bullet + ") [\\s\\S]+?(?:\\n{2,}(?! )(?!\\1" + bullet + " (?!" + bullet + " ))\\n*|\\s*\\n*$)"
-  );
-};
-const ORDERED_LIST_R = generateListRegex(ORDERED);
-const UNORDERED_LIST_R = generateListRegex(UNORDERED);
-const generateListRule = (type, factory) => {
-  const ordered = type === ORDERED;
-  const LIST_R = ordered ? ORDERED_LIST_R : UNORDERED_LIST_R;
-  const LIST_ITEM_R = ordered ? ORDERED_LIST_ITEM_R : UNORDERED_LIST_ITEM_R;
-  const LIST_ITEM_PREFIX_R = ordered ? ORDERED_LIST_ITEM_PREFIX_R : UNORDERED_LIST_ITEM_PREFIX_R;
-  return {
-    _qualify: (source) => LIST_ITEM_PREFIX_R.test(source),
-    _match: allowInline((source, state) => {
-      const isStartOfLine = LIST_LOOKBEHIND_R.exec(state.prevCapture ?? "");
-      const isListAllowed = state.list ?? (!state.inline && !state.simple);
-      if (isStartOfLine && isListAllowed) {
-        source = isStartOfLine[1] + source;
-        return LIST_R.exec(source);
-      } else {
-        return null;
-      }
-    }),
-    _order: Priority.HIGH,
-    _parse(capture, parse, state) {
-      const bullet = capture[2];
-      const start = ordered ? +bullet : void 0;
-      const items = capture[0].replace(BLOCK_END_R, "\n").match(LIST_ITEM_R);
-      if (!items) return { items: [], ordered, start };
-      let lastItemWasAParagraph = false;
-      const itemContent = items.map((item, i) => {
-        const spaceMatch = LIST_ITEM_PREFIX_R.exec(item);
-        if (!spaceMatch) return [];
-        const space = spaceMatch[0].length;
-        const spaceRegex = new RegExp("^ {1," + space + "}", "gm");
-        const content = item.replace(spaceRegex, "").replace(LIST_ITEM_PREFIX_R, "");
-        const isLastItem = i === items.length - 1;
-        const containsBlocks = content.indexOf("\n\n") !== -1;
-        const thisItemIsAParagraph = containsBlocks || isLastItem && lastItemWasAParagraph;
-        lastItemWasAParagraph = thisItemIsAParagraph;
-        const oldStateInline = state.inline;
-        const oldStateList = state.list;
-        state.list = true;
-        let adjustedContent;
-        if (thisItemIsAParagraph) {
-          state.inline = false;
-          adjustedContent = trimEnd(content) + "\n\n";
-        } else {
-          state.inline = true;
-          adjustedContent = trimEnd(content);
-        }
-        const result = parse(adjustedContent, state);
-        state.inline = oldStateInline;
-        state.list = oldStateList;
-        return result;
-      });
-      return {
-        items: itemContent,
-        ordered,
-        start
-      };
-    },
-    _render(node, _output, state = {}) {
-      const Tag = node.ordered ? "ol" : "ul";
-      const props = { key: state.key };
-      if (node.ordered && node.start != null) props.start = node.start;
-      if (factory) {
-        return factory(
-          Tag,
-          props,
-          ...node.items.map(
-            (item, i) => factory("li", { key: i }, _output(item, state))
-          )
-        );
-      }
-      return /* @__PURE__ */ jsx(
-        Tag,
-        {
-          start: node.type === RuleType.orderedList ? node.start : void 0,
-          children: node.items.map((item, i) => {
-            return /* @__PURE__ */ jsx("li", { children: _output(item, state) }, i);
-          })
-        },
-        state.key
-      );
-    }
-  };
-};
-const LINK_INSIDE = "(?:\\[[^\\[\\]]*(?:\\[[^\\[\\]]*\\][^\\[\\]]*)*\\]|[^\\[\\]])*";
-const LINK_HREF_AND_TITLE = `\\s*<?((?:\\([^)]*\\)|[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['"]([\\s\\S]*?)['"])?\\s*`;
-const LINK_R = new RegExp(
-  "^\\[(" + LINK_INSIDE + ")\\]\\(" + LINK_HREF_AND_TITLE + "\\)"
-);
-const IMAGE_R = /^!\[(.*?)\]\( *((?:\([^)]*\)|[^() ])*) *"?([^)"]*)?"?\)/;
-const trimEnd = (str) => {
-  let end = str.length;
-  while (end > 0 && str[end - 1] <= " ") end--;
-  return str.slice(0, end);
-};
-const startsWith = (str, prefix) => {
-  return str.startsWith(prefix);
-};
-const qualifies = (source, state, qualify) => {
-  if (Array.isArray(qualify)) {
-    for (let i = 0; i < qualify.length; i++) {
-      if (startsWith(source, qualify[i])) return true;
-    }
-    return false;
-  }
-  return qualify(source, state);
-};
-const unquote = (str) => {
-  const first = str[0];
-  if ((first === '"' || first === "'") && str.length >= 2 && str[str.length - 1] === first) {
-    return str.slice(1, -1);
-  }
-  return str;
-};
-const slugify = (str) => str.replace(/[ÀÁÂÃÄÅàáâãäåæÆ]/g, "a").replace(/[çÇ]/g, "c").replace(/[ðÐ]/g, "d").replace(/[ÈÉÊËéèêë]/g, "e").replace(/[ÏïÎîÍíÌì]/g, "i").replace(/[Ññ]/g, "n").replace(/[øØœŒÕõÔôÓóÒò]/g, "o").replace(/[ÜüÛûÚúÙù]/g, "u").replace(/[ŸÿÝý]/g, "y").replace(/[^a-z0-9- ]/gi, "").replace(/ /gi, "-").toLowerCase();
-const parseTableAlignCapture = (alignCapture) => {
-  if (TABLE_RIGHT_ALIGN.test(alignCapture)) {
-    return "right";
-  } else if (TABLE_CENTER_ALIGN.test(alignCapture)) {
-    return "center";
-  } else if (TABLE_LEFT_ALIGN.test(alignCapture)) {
-    return "left";
-  }
-  return "left";
-};
-const parseTableRow = (source, parse, state, tableOutput) => {
-  const start = performance.now();
-  const prevInTable = state.inTable;
-  state.inTable = true;
-  let cells = [[]];
-  let acc = "";
-  const flush = () => {
-    if (!acc) return;
-    const cell = cells[cells.length - 1];
-    cell.push.apply(cell, parse(acc, state));
-    acc = "";
-  };
-  source.trim().split(/(`[^`]*`|\\\||\|)/).filter(Boolean).forEach((fragment, i, arr) => {
-    if (fragment.trim() === "|") {
-      flush();
-      if (tableOutput) {
-        if (i !== 0 && i !== arr.length - 1) {
-          cells.push([]);
-        }
-        return;
-      }
-    }
-    acc += fragment;
-  });
-  flush();
-  state.inTable = prevInTable;
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `parseTableRow: ${duration.toFixed(3)}ms, source length: ${source.length}, cells count: ${cells.length}`
-    );
-  }
-  return cells;
-};
-const parseTableAlign = (source) => {
-  const alignText = source.replace(TABLE_TRIM_PIPES, "").split("|");
-  return alignText.map(parseTableAlignCapture);
-};
-const parseTableCells = (source, parse, state) => {
-  const start = performance.now();
-  const rowsText = source.trim().split("\n");
-  const result = rowsText.map((rowText) => {
-    return parseTableRow(rowText, parse, state, true);
-  });
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `parseTableCells: ${duration.toFixed(3)}ms, source length: ${source.length}, rows count: ${rowsText.length}`
-    );
-  }
-  return result;
-};
-const parseTable = (capture, parse, state) => {
-  state.inline = true;
-  const align = capture[2] ? parseTableAlign(capture[2]) : [];
-  const cells = capture[3] ? parseTableCells(capture[3], parse, state) : [];
-  const header = parseTableRow(capture[1], parse, state, !!cells.length);
-  state.inline = false;
-  return cells.length ? {
-    align,
-    cells,
-    header,
-    type: RuleType.table
-  } : {
-    children: header.flat(),
-    type: RuleType.paragraph
-  };
-};
-const getTableStyle = (node, colIndex) => node.align[colIndex] == null ? {} : {
-  textAlign: node.align[colIndex]
-};
-const normalizeAttributeKey = (key) => {
-  const hyphenIndex = key.indexOf("-");
-  if (hyphenIndex !== -1 && key.match(HTML_CUSTOM_ATTR_R) === null) {
-    key = key.replace(CAPTURE_LETTER_AFTER_HYPHEN, (_, letter) => {
-      return letter.toUpperCase();
-    });
-  }
-  return key;
-};
-const parseStyleAttribute = (styleString) => {
-  const start = performance.now();
-  const styles = [];
-  let buffer = "";
-  let inUrl = false;
-  let inQuotes = false;
-  let quoteChar = "";
-  if (!styleString) return styles;
-  for (let i = 0; i < styleString.length; i++) {
-    const char = styleString[i];
-    if ((char === '"' || char === "'") && !inUrl) {
-      if (!inQuotes) {
-        inQuotes = true;
-        quoteChar = char;
-      } else if (char === quoteChar) {
-        inQuotes = false;
-        quoteChar = "";
-      }
-    }
-    if (char === "(" && buffer.endsWith("url")) {
-      inUrl = true;
-    } else if (char === ")" && inUrl) {
-      inUrl = false;
-    }
-    if (char === ";" && !inQuotes && !inUrl) {
-      const declaration2 = buffer.trim();
-      if (declaration2) {
-        const colonIndex = declaration2.indexOf(":");
-        if (colonIndex > 0) {
-          const key = declaration2.slice(0, colonIndex).trim();
-          const value = declaration2.slice(colonIndex + 1).trim();
-          styles.push([key, value]);
-        }
-      }
-      buffer = "";
-    } else {
-      buffer += char;
-    }
-  }
-  const declaration = buffer.trim();
-  if (declaration) {
-    const colonIndex = declaration.indexOf(":");
-    if (colonIndex > 0) {
-      const key = declaration.slice(0, colonIndex).trim();
-      const value = declaration.slice(colonIndex + 1).trim();
-      styles.push([key, value]);
-    }
-  }
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `parseStyleAttribute: ${duration.toFixed(3)}ms, styleString length: ${styleString.length}, styles count: ${styles.length}`
-    );
-  }
-  return styles;
-};
-const trimLeadingWhitespaceOutsideFences = (text, whitespace) => {
-  const start = performance.now();
-  if (!whitespace) return text;
-  const lines = text.split("\n");
-  let inFence = false;
-  let fenceToken = null;
-  const isFenceLine = (line) => line.match(/^\s*(`{3,}|~{3,})/);
-  const maybeToggleFence = (line) => {
-    const m = isFenceLine(line);
-    if (!m) return;
-    const token = m[1];
-    if (!inFence) {
-      inFence = true;
-      fenceToken = token;
-    } else if (fenceToken && line.includes(fenceToken)) {
-      inFence = false;
-      fenceToken = null;
-    }
-  };
-  const out = lines.map((line) => {
-    const fenceMatch = isFenceLine(line);
-    if (fenceMatch) {
-      const trimmedFenceLine = line.startsWith(whitespace) ? line.slice(whitespace.length) : line;
-      maybeToggleFence(line);
-      return trimmedFenceLine;
-    }
-    if (inFence) {
-      return line;
-    }
-    return line.startsWith(whitespace) ? line.slice(whitespace.length) : line;
-  });
-  const result = out.join("\n");
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `trimLeadingWhitespaceOutsideFences: ${duration.toFixed(3)}ms, text length: ${text.length}, lines count: ${lines.length}`
-    );
-  }
-  return result;
-};
-const attributeValueToJSXPropValue = (tag, key, value, sanitizeUrlFn) => {
-  if (key === "style") {
-    return parseStyleAttribute(value).reduce(
-      (styles, [key2, value2]) => {
-        const camelCasedKey = key2.replace(
-          /(-[a-z])/g,
-          (substr) => substr[1].toUpperCase()
-        );
-        styles[camelCasedKey] = sanitizeUrlFn(
-          value2,
-          tag,
-          key2
-        );
-        return styles;
-      },
-      {}
-    );
-  } else if (ATTRIBUTES_TO_SANITIZE.indexOf(key) !== -1) {
-    return sanitizeUrlFn(unescape(value), tag, key);
-  } else if (value.match(INTERPOLATION_R)) {
-    value = unescape(value.slice(1, value.length - 1));
-  }
-  if (value === "true") {
-    return true;
-  } else if (value === "false") {
-    return false;
-  }
-  return value;
-};
-const normalizeWhitespace = (source) => {
-  const start = performance.now();
-  const result = source.replace(CR_NEWLINE_R, "\n").replace(FORMFEED_R, "").replace(TAB_R, "    ");
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `normalizeWhitespace: ${duration.toFixed(3)}ms, source length: ${source.length}`
-    );
-  }
-  return result;
-};
-const parserFor = (rules) => {
-  const start = performance.now();
-  var ruleList = Object.keys(rules);
-  if (define_process_env_default.NODE_ENV !== "production") {
-    ruleList.forEach((type) => {
-      const order = rules[type]._order;
-      if (typeof order !== "number" || !isFinite(order)) {
-        console.warn(
-          "intlayer: Invalid order for rule `" + type + "`: " + order
-        );
-      }
-    });
-  }
-  ruleList.sort((a, b) => {
-    return rules[a]._order - rules[b]._order || (a < b ? -1 : 1);
-  });
-  const nestedParse = (source, state = {}) => {
-    const parseStart = performance.now();
-    var result = [];
-    state.prevCapture = state.prevCapture || "";
-    if (source.trim()) {
-      while (source) {
-        var i = 0;
-        while (i < ruleList.length) {
-          var ruleType = ruleList[i];
-          var rule = rules[ruleType];
-          if (rule._qualify && !qualifies(source, state, rule._qualify)) {
-            i++;
-            continue;
-          }
-          const matchStart = performance.now();
-          var capture = rule._match(source, state);
-          const matchDuration = performance.now() - matchStart;
-          if (matchDuration > 1) {
-            console.log(
-              `${ruleType}._match: ${matchDuration.toFixed(3)}ms, source length: ${source.length}`
-            );
-          }
-          if (capture && capture[0]) {
-            source = source.substring(capture[0].length);
-            const ruleParseStart = performance.now();
-            const parsedAny = rule._parse(capture, nestedParse, state);
-            const ruleParseDuration = performance.now() - ruleParseStart;
-            if (ruleParseDuration > 1) {
-              console.log(
-                `${ruleType}._parse: ${ruleParseDuration.toFixed(3)}ms, capture length: ${capture[0].length}`
-              );
-            }
-            state.prevCapture += capture[0];
-            if (!parsedAny.type)
-              parsedAny.type = ruleType;
-            result.push(parsedAny);
-            break;
-          }
-          i++;
-        }
-      }
-    }
-    state.prevCapture = "";
-    const parseDuration = performance.now() - parseStart;
-    if (parseDuration > 1) {
-      console.log(
-        `nestedParse: ${parseDuration.toFixed(3)}ms, source length: ${source.length}, result count: ${result.length}`
-      );
-    }
-    return result;
-  };
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `parserFor: ${duration.toFixed(3)}ms, rules count: ${ruleList.length}`
-    );
-  }
-  return (source, state) => nestedParse(normalizeWhitespace(source), state);
-};
-const allowInline = (fn) => {
-  fn.inline = 1;
-  return fn;
-};
-const inlineRegex = (regex) => allowInline((source, state) => {
-  if (state.inline) {
-    return regex.exec(source);
-  } else {
-    return null;
-  }
-});
-const simpleInlineRegex = (regex) => allowInline((source, state) => {
-  if (state.inline || state.simple) {
-    return regex.exec(source);
-  } else {
-    return null;
-  }
-});
-const blockRegex = (regex) => (source, state) => {
-  if (state.inline || state.simple) {
-    return null;
-  } else {
-    return regex.exec(source);
-  }
-};
-const anyScopeRegex = (regex) => allowInline(
-  (source) => regex.exec(source)
-);
-const SANITIZE_R = /(javascript|vbscript|data(?!:image)):/i;
-const sanitizer = (input) => {
-  try {
-    const decoded = decodeURIComponent(input).replace(/[^A-Za-z0-9/:]/g, "");
-    if (SANITIZE_R.test(decoded)) {
-      if (define_process_env_default.NODE_ENV !== "production") {
-        console.warn(
-          "Input contains an unsafe JavaScript/VBScript/data expression, it will not be rendered.",
-          decoded
-        );
-      }
-      return null;
-    }
-  } catch (e) {
-    if (define_process_env_default.NODE_ENV !== "production") {
-      console.warn(
-        "Input could not be decoded due to malformed syntax or characters, it will not be rendered.",
-        input
-      );
-    }
-    return null;
-  }
-  return input;
-};
-const unescape = (rawString) => rawString ? rawString.replace(UNESCAPE_R, "$1") : rawString;
-const parseInline = (parse, children, state) => {
-  const start = performance.now();
-  const isCurrentlyInline = state.inline ?? false;
-  const isCurrentlySimple = state.simple ?? false;
-  state.inline = true;
-  state.simple = true;
-  const result = parse(children, state);
-  state.inline = isCurrentlyInline;
-  state.simple = isCurrentlySimple;
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `parseInline: ${duration.toFixed(3)}ms, children length: ${children.length}, result count: ${result.length}`
-    );
-  }
-  return result;
-};
-const parseSimpleInline = (parse, children, state) => {
-  const start = performance.now();
-  const isCurrentlyInline = state.inline ?? false;
-  const isCurrentlySimple = state.simple ?? false;
-  state.inline = false;
-  state.simple = true;
-  const result = parse(children, state);
-  state.inline = isCurrentlyInline;
-  state.simple = isCurrentlySimple;
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `parseSimpleInline: ${duration.toFixed(3)}ms, children length: ${children.length}, result count: ${result.length}`
-    );
-  }
-  return result;
-};
-const parseBlock = (parse, children, state = {}) => {
-  const start = performance.now();
-  const isCurrentlyInline = state.inline || false;
-  state.inline = false;
-  const result = parse(children, state);
-  state.inline = isCurrentlyInline;
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `parseBlock: ${duration.toFixed(3)}ms, children length: ${children.length}, result count: ${result.length}`
-    );
-  }
-  return result;
-};
-const parseCaptureInline = (capture, parse, state) => {
-  return {
-    children: parseInline(parse, capture[2], state)
-  };
-};
-const captureNothing = () => ({});
-const renderNothing = () => null;
-const reactFor = (render) => (ast, state = {}) => {
-  const start = performance.now();
-  const patchedRender = (ast2, state2 = {}) => reactFor(render)(ast2, state2);
-  if (Array.isArray(ast)) {
-    const oldKey = state.key;
-    const result2 = [];
-    let lastWasString = false;
-    for (let i = 0; i < ast.length; i++) {
-      state.key = i;
-      const nodeOut = patchedRender(ast[i], state);
-      const isString = typeof nodeOut === "string";
-      if (isString && lastWasString) {
-        result2[result2.length - 1] = result2[result2.length - 1] + nodeOut;
-      } else if (nodeOut !== null) {
-        result2.push(nodeOut);
-      }
-      lastWasString = isString;
-    }
-    state.key = oldKey;
-    const duration2 = performance.now() - start;
-    if (duration2 > 1) {
-      console.log(
-        `reactFor (array): ${duration2.toFixed(3)}ms, ast length: ${ast.length}`
-      );
-    }
-    return result2;
-  }
-  const result = render(
-    ast,
-    patchedRender,
-    state
-  );
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `reactFor (single): ${duration.toFixed(3)}ms, ast type: ${ast.type}`
-    );
-  }
-  return result;
-};
-const createRenderer = (rules, userRender) => (ast, render, state) => {
-  const start = performance.now();
-  const renderer = rules[ast.type]._render;
-  const result = userRender ? userRender(() => renderer?.(ast, render, state), ast, render, state) : renderer?.(ast, render, state);
-  const duration = performance.now() - start;
-  if (duration > 1) {
-    console.log(
-      `createRenderer: ${duration.toFixed(3)}ms, ast type: ${ast.type}, hasUserRender: ${!!userRender}`
-    );
-  }
-  return result;
-};
-const cx = (...args) => args.filter(Boolean).join(" ");
-const get = (src, path, fb) => {
-  let ptr = src;
-  const frags = path.split(".");
-  while (frags.length) {
-    ptr = ptr[frags[0]];
-    if (ptr === void 0) break;
-    else frags.shift();
-  }
-  return ptr ?? fb;
-};
-const getTag = (tag, overrides) => {
-  const override = get(overrides, tag);
-  if (!override) return tag;
-  return typeof override === "function" || typeof override === "object" && "render" in override ? override : get(overrides, `${tag}.component`, tag);
-};
-const compiler = (markdown = "", options = {}) => {
-  options.overrides = options.overrides ?? {};
-  options.namedCodesToUnicode = options.namedCodesToUnicode ? { ...namedCodesToUnicode, ...options.namedCodesToUnicode } : namedCodesToUnicode;
-  const slug = options.slugify ?? slugify;
-  const sanitize = options.sanitizer ?? sanitizer;
-  const createElementFn = options.createElement ?? createElement;
-  const NON_PARAGRAPH_BLOCK_SYNTAXES = [
-    BLOCKQUOTE_R,
-    CODE_BLOCK_FENCED_R,
-    CODE_BLOCK_R,
-    options.enforceAtxHeadings ? HEADING_ATX_COMPLIANT_R : HEADING_R,
-    HEADING_SETEXT_R,
-    NP_TABLE_R,
-    ORDERED_LIST_R,
-    UNORDERED_LIST_R
-  ];
-  const BLOCK_SYNTAXES = [
-    ...NON_PARAGRAPH_BLOCK_SYNTAXES,
-    PARAGRAPH_R,
-    HTML_BLOCK_ELEMENT_R,
-    HTML_COMMENT_R,
-    HTML_SELF_CLOSING_ELEMENT_R,
-    CUSTOM_COMPONENT_R
-  ];
-  const containsBlockSyntax = (input) => {
-    const cleaned = input.replace(TRIM_STARTING_NEWLINES, "");
-    const slice = cleaned.length > 2048 ? cleaned.slice(0, 2048) : cleaned;
-    const syntaxes = options.disableParsingRawHTML ? [...NON_PARAGRAPH_BLOCK_SYNTAXES, PARAGRAPH_R, CUSTOM_COMPONENT_R] : BLOCK_SYNTAXES;
-    return syntaxes.some((r) => r.test(slice));
-  };
-  const matchParagraph = (source, state) => {
-    if (state.inline || state.simple || state.inHTML && source.indexOf("\n\n") === -1 && state.prevCapture?.indexOf("\n\n") === -1) {
-      return null;
-    }
-    let match = "";
-    source.split("\n").every((line) => {
-      line += "\n";
-      if (NON_PARAGRAPH_BLOCK_SYNTAXES.some((regex) => regex.test(line))) {
-        return false;
-      }
-      match += line;
-      return !!line.trim();
-    });
-    const captured = trimEnd(match);
-    if (captured === "") {
-      return null;
-    }
-    return [match, , captured];
-  };
-  const h = (tag, props, ...children) => {
-    const overrideProps = get(
-      options.overrides ?? {},
-      `${tag}.props`,
-      {}
-    );
-    return createElementFn(
-      getTag(tag, options.overrides ?? {}),
-      {
-        ...props,
-        ...overrideProps,
-        className: cx(props?.className, overrideProps.className) ?? void 0
-      },
-      ...children
-    );
-  };
-  const compile = (input) => {
-    const start = performance.now();
-    const result = input.replace(FRONT_MATTER_R, "");
-    let inline = false;
-    if (options.forceInline) {
-      inline = true;
-    } else if (!options.forceBlock) {
-      inline = SHOULD_RENDER_AS_BLOCK_R.test(result) === false;
-    }
-    const arr = emitter(
-      parser(
-        inline ? result : `${trimEnd(result).replace(TRIM_STARTING_NEWLINES, "")}
-
-`,
-        {
-          inline
-        }
-      )
-    );
-    while (typeof arr[arr.length - 1] === "string" && !arr[arr.length - 1].trim()) {
-      arr.pop();
-    }
-    if (options.wrapper === null) {
-      const duration2 = performance.now() - start;
-      if (duration2 > 1) {
-        console.log(
-          `compile: ${duration2.toFixed(3)}ms, input length: ${input.length}, inline: ${inline}`
-        );
-      }
-      return arr;
-    }
-    const wrapper = options.wrapper ?? (inline ? "span" : "div");
-    let jsx3;
-    if (arr.length > 1 || options.forceWrapper) {
-      jsx3 = arr;
-    } else if (arr.length === 1) {
-      jsx3 = arr[0];
-      if (typeof jsx3 === "string") {
-        const duration2 = performance.now() - start;
-        if (duration2 > 1) {
-          console.log(
-            `compile: ${duration2.toFixed(3)}ms, input length: ${input.length}, inline: ${inline}`
-          );
-        }
-        return /* @__PURE__ */ jsx("span", { children: jsx3 }, "outer");
-      } else {
-        const duration2 = performance.now() - start;
-        if (duration2 > 1) {
-          console.log(
-            `compile: ${duration2.toFixed(3)}ms, input length: ${input.length}, inline: ${inline}`
-          );
-        }
-        return jsx3;
-      }
-    } else {
-      jsx3 = null;
-    }
-    const duration = performance.now() - start;
-    if (duration > 1) {
-      console.log(
-        `compile: ${duration.toFixed(3)}ms, input length: ${input.length}, inline: ${inline}`
-      );
-    }
-    return createElementFn(wrapper, { key: "outer" }, jsx3);
-  };
-  const attrStringToMap = (tag, str) => {
-    const start = performance.now();
-    if (!str || !str.trim()) {
-      return null;
-    }
-    const attributes = str.match(ATTR_EXTRACTOR_R);
-    if (!attributes) {
-      return null;
-    }
-    const result = attributes.reduce((map, raw) => {
-      const delimiterIdx = raw.indexOf("=");
-      if (delimiterIdx !== -1) {
-        const key = normalizeAttributeKey(raw.slice(0, delimiterIdx)).trim();
-        const value = unquote(raw.slice(delimiterIdx + 1).trim());
-        const mappedKey = ATTRIBUTE_TO_JSX_PROP_MAP[key] ?? key;
-        if (mappedKey === "ref") return map;
-        const normalizedValue = map[mappedKey] = attributeValueToJSXPropValue(
-          tag,
-          key,
-          value,
-          sanitize
-        );
-        if (typeof normalizedValue === "string" && (HTML_BLOCK_ELEMENT_R.test(normalizedValue) || HTML_SELF_CLOSING_ELEMENT_R.test(normalizedValue))) {
-          map[mappedKey] = compile(normalizedValue.trim());
-        }
-      } else if (raw !== "style") {
-        map[ATTRIBUTE_TO_JSX_PROP_MAP[raw] ?? raw] = true;
-      }
-      return map;
-    }, {});
-    const duration = performance.now() - start;
-    if (duration > 1) {
-      console.log(
-        `attrStringToMap: ${duration.toFixed(3)}ms, str length: ${str.length}, attributes count: ${attributes.length}`
-      );
-    }
-    return result;
-  };
-  if (define_process_env_default.NODE_ENV !== "production") {
-    if (typeof markdown !== "string") {
-      throw new Error(`intlayer: the first argument must be
-                             a string`);
-    }
-    if (Object.prototype.toString.call(options.overrides) !== "[object Object]") {
-      throw new Error(`intlayer: options.overrides (second argument property) must be
-                             undefined or an object literal with shape:
-                             {
-                                htmltagname: {
-                                    component: string|ReactComponent(optional),
-                                    props: object(optional)
-                                }
-                             }`);
-    }
-  }
-  const footnotes = [];
-  const refs = {};
-  const rules = {
-    [RuleType.blockQuote]: {
-      _qualify: [">"],
-      _match: blockRegex(BLOCKQUOTE_R),
-      _order: Priority.HIGH,
-      _parse(capture, parse, state) {
-        const start = performance.now();
-        const matchAlert = capture[0].replace(BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, "").match(BLOCKQUOTE_ALERT_R);
-        const alert = matchAlert?.[1];
-        const content = matchAlert?.[2] ?? "";
-        const result = {
-          alert,
-          children: parse(content, state)
-        };
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `blockQuote._parse: ${duration.toFixed(3)}ms, capture length: ${capture[0].length}`
-          );
-        }
-        return result;
-      },
-      _render(node, _output, state = {}) {
-        const start = performance.now();
-        const props = {
-          key: state?.key
-        };
-        if (node.alert) {
-          props.className = "markdown-alert-" + slug(node.alert.toLowerCase(), slugify);
-          node.children.unshift({
-            attrs: {},
-            children: [{ type: RuleType.text, text: node.alert }],
-            noInnerParse: true,
-            type: RuleType.htmlBlock,
-            tag: "header"
-          });
-        }
-        const result = h(
-          "blockquote",
-          props,
-          _output(node.children, state)
-        );
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `blockQuote._render: ${duration.toFixed(3)}ms, children count: ${node.children.length}, has alert: ${!!node.alert}`
-          );
-        }
-        return result;
-      }
-    },
-    [RuleType.breakLine]: {
-      _match: anyScopeRegex(BREAK_LINE_R),
-      _order: Priority.HIGH,
-      _parse: captureNothing,
-      _render(_, __, state = {}) {
-        return /* @__PURE__ */ jsx("br", {}, state.key);
-      }
-    },
-    [RuleType.breakThematic]: {
-      _qualify: (source) => {
-        const char = source[0];
-        return char === "-" || char === "*" || char === "_";
-      },
-      _match: blockRegex(BREAK_THEMATIC_R),
-      _order: Priority.HIGH,
-      _parse: captureNothing,
-      _render(_, __, state = {}) {
-        return /* @__PURE__ */ jsx("hr", {}, state.key);
-      }
-    },
-    [RuleType.codeBlock]: {
-      _qualify: ["    "],
-      _match: blockRegex(CODE_BLOCK_R),
-      _order: Priority.MAX,
-      _parse(capture) {
-        return {
-          type: RuleType.codeBlock,
-          lang: void 0,
-          text: unescape(trimEnd(capture[0].replace(/^ {4}/gm, "")))
-        };
-      },
-      _render(node, _output, state = {}) {
-        const start = performance.now();
-        const attrs = { ...node.attrs ?? {} };
-        const langClass = node.lang ? `lang-${node.lang}` : "lang-plaintext";
-        attrs.className = attrs.className ? `${attrs.className} ${langClass}` : langClass;
-        if (node.lang && !attrs.lang) attrs.lang = node.lang;
-        const result = h(
-          "pre",
-          { key: state.key },
-          h("code", attrs, node.text)
-        );
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `codeBlock._render: ${duration.toFixed(3)}ms, text length: ${node.text.length}, lang: ${node.lang || "none"}`
-          );
-        }
-        return result;
-      }
-    },
-    [RuleType.codeFenced]: {
-      _qualify: ["```", "~~~"],
-      _match: blockRegex(CODE_BLOCK_FENCED_R),
-      _order: Priority.MAX,
-      _parse(capture) {
-        const rawText = capture[4];
-        const text = rawText;
-        return {
-          // if capture[3] it's additional metadata
-          attrs: attrStringToMap("code", capture[3] ?? ""),
-          lang: capture[2] || void 0,
-          text,
-          type: RuleType.codeBlock
-        };
-      }
-    },
-    [RuleType.codeInline]: {
-      _qualify: ["`"],
-      _match: simpleInlineRegex(CODE_INLINE_R),
-      _order: Priority.LOW,
-      _parse(capture) {
-        return {
-          text: unescape(capture[2])
-        };
-      },
-      _render(node, _output, state = {}) {
-        const start = performance.now();
-        const result = h("code", { key: state.key }, node.text);
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `codeInline._render: ${duration.toFixed(3)}ms, text length: ${node.text.length}`
-          );
-        }
-        return result;
-      }
-    },
-    /**
-     * footnotes are emitted at the end of compilation in a special <footer> block
-     */
-    [RuleType.footnote]: {
-      _qualify: ["[^"],
-      _match: blockRegex(FOOTNOTE_R),
-      _order: Priority.MAX,
-      _parse(capture) {
-        footnotes.push({
-          footnote: capture[2],
-          identifier: capture[1]
-        });
-        return {};
-      },
-      _render: renderNothing
-    },
-    [RuleType.footnoteReference]: {
-      _qualify: ["[^"],
-      _match: inlineRegex(FOOTNOTE_REFERENCE_R),
-      _order: Priority.HIGH,
-      _parse(capture) {
-        return {
-          target: `#${slug(capture[1], slugify)}`,
-          text: capture[1]
-        };
-      },
-      _render(node, _output, state = {}) {
-        return /* @__PURE__ */ jsx(
-          "a",
-          {
-            href: sanitize(node.target, "a", "href") ?? void 0,
-            children: /* @__PURE__ */ jsx("sup", { children: node.text }, state.key)
-          },
-          state.key
-        );
-      }
-    },
-    [RuleType.gfmTask]: {
-      _qualify: ["[ ]", "[x]"],
-      _match: inlineRegex(GFM_TASK_R),
-      _order: Priority.HIGH,
-      _parse(capture) {
-        return {
-          completed: capture[1].toLowerCase() === "x"
-        };
-      },
-      _render(node, _output, state = {}) {
-        return /* @__PURE__ */ jsx(
-          "input",
-          {
-            checked: node.completed,
-            readOnly: true,
-            type: "checkbox"
-          },
-          state.key
-        );
-      }
-    },
-    [RuleType.heading]: {
-      _qualify: ["#"],
-      _match: blockRegex(
-        options.enforceAtxHeadings ? HEADING_ATX_COMPLIANT_R : HEADING_R
-      ),
-      _order: Priority.HIGH,
-      _parse(capture, parse, state) {
-        const start = performance.now();
-        const result = {
-          children: parseInline(parse, capture[2], state),
-          id: slug(capture[2], slugify),
-          level: capture[1].length
-        };
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `heading._parse: ${duration.toFixed(3)}ms, capture length: ${capture[0].length}, level: ${capture[1].length}`
-          );
-        }
-        return result;
-      },
-      _render(node, _output, state = {}) {
-        const start = performance.now();
-        const result = h(
-          `h${node.level}`,
-          { id: node.id, key: state.key },
-          _output(node.children, state)
-        );
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `heading._render: ${duration.toFixed(3)}ms, level: ${node.level}, children count: ${node.children.length}, id: ${node.id}`
-          );
-        }
-        return result;
-      }
-    },
-    [RuleType.headingSetext]: {
-      _match: blockRegex(HEADING_SETEXT_R),
-      _order: Priority.MAX,
-      _parse(capture, parse, state) {
-        return {
-          children: parseInline(parse, capture[1], state),
-          level: capture[2] === "=" ? 1 : 2,
-          type: RuleType.heading
-        };
-      }
-    },
-    [RuleType.htmlBlock]: {
-      _qualify: (source) => {
-        if (options.disableParsingRawHTML) return false;
-        if (source[0] !== "<") return false;
-        if (!/^<([a-z][a-z0-9:-]*)\b/.test(source)) return false;
-        const tag = source.match(/^<([a-z][a-z0-9:-]*)\b/)?.[1];
-        return tag ? source.indexOf(`</${tag}>`) !== -1 : false;
-      },
-      /**
-       * find the first matching end tag and process the interior
-       */
-      _match: anyScopeRegex(HTML_BLOCK_ELEMENT_R),
-      _order: Priority.HIGH,
-      _parse(capture, parse, state) {
-        const m = capture[3].match(
-          HTML_LEFT_TRIM_AMOUNT_R
-        );
-        const whitespace = m?.[1] ?? "";
-        const trimmed = trimLeadingWhitespaceOutsideFences(
-          capture[3],
-          whitespace
-        );
-        const parseFunc = containsBlockSyntax(trimmed) ? parseBlock : parseInline;
-        const tagName = capture[1].toLowerCase();
-        const noInnerParse = DO_NOT_PROCESS_HTML_ELEMENTS.indexOf(tagName) !== -1;
-        const tag = (noInnerParse ? tagName : capture[1]).trim();
-        const ast = {
-          attrs: attrStringToMap(tag, capture[2] ?? ""),
-          noInnerParse,
-          tag
-        };
-        state.inAnchor = state.inAnchor || tagName === "a";
-        if (noInnerParse) {
-          ast.text = capture[3];
-        } else {
-          const prevInHTML = state.inHTML;
-          state.inHTML = true;
-          ast.children = parseFunc(parse, trimmed, state);
-          state.inHTML = prevInHTML;
-        }
-        state.inAnchor = false;
-        return ast;
-      },
-      _render(node, _output, state = {}) {
-        const start = performance.now();
-        const result = h(
-          node.tag,
-          { key: state.key, ...node.attrs ?? {} },
-          node.text ?? (node.children ? _output(node.children, state) : "")
-        );
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `htmlBlock._render: ${duration.toFixed(3)}ms, tag: ${node.tag}, has text: ${!!node.text}, has children: ${!!node.children}`
-          );
-        }
-        return result;
-      }
-    },
-    [RuleType.htmlSelfClosing]: {
-      _qualify: (source) => {
-        if (options.disableParsingRawHTML) return false;
-        if (source[0] !== "<") return false;
-        return /^<([a-zA-Z][a-zA-Z0-9:]*)[\s>/]/.test(source);
-      },
-      /**
-       * find the first matching end tag and process the interior
-       */
-      _match: anyScopeRegex(HTML_SELF_CLOSING_ELEMENT_R),
-      _order: Priority.HIGH,
-      _parse(capture) {
-        const tag = capture[1].trim();
-        return {
-          attrs: attrStringToMap(tag, capture[2] || ""),
-          tag
-        };
-      },
-      _render(node, _output, state = {}) {
-        const start = performance.now();
-        const result = h(node.tag, {
-          key: state.key,
-          ...node.attrs ?? {}
-        });
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `htmlSelfClosing._render: ${duration.toFixed(3)}ms, tag: ${node.tag}`
-          );
-        }
-        return result;
-      }
-    },
-    [RuleType.htmlComment]: {
-      _qualify: ["<!--"],
-      _match: anyScopeRegex(HTML_COMMENT_R),
-      _order: Priority.HIGH,
-      _parse() {
-        return {};
-      },
-      _render: renderNothing
-    },
-    [RuleType.customComponent]: {
-      _qualify: (source) => {
-        const match = source.match(/^ *<([A-Z][a-zA-Z0-9]*)/);
-        return !!match;
-      },
-      _match: blockRegex(CUSTOM_COMPONENT_R),
-      _order: Priority.MAX,
-      _parse(capture, parse, state) {
-        const m = capture[3].match(
-          HTML_LEFT_TRIM_AMOUNT_R
-        );
-        const whitespace = m?.[1] ?? "";
-        const trimmed = trimLeadingWhitespaceOutsideFences(
-          capture[3],
-          whitespace
-        );
-        const parseFunc = containsBlockSyntax(trimmed) ? parseBlock : parseInline;
-        const tagName = capture[1];
-        const noInnerParse = false;
-        const ast = {
-          attrs: attrStringToMap(tagName, capture[2] ?? ""),
-          noInnerParse,
-          tag: tagName
-        };
-        {
-          const prevInHTML = state.inHTML;
-          state.inHTML = true;
-          const parsedChildren = parseFunc(parse, trimmed, state);
-          ast.children = parsedChildren;
-          state.inHTML = prevInHTML;
-        }
-        return ast;
-      },
-      _render(node, _output, state = {}) {
-        const customComponent = getTag(node.tag, options.overrides ?? {});
-        if (typeof customComponent === "function") {
-          const renderedChildren = node.children ? _output(node.children, state) : null;
-          return customComponent({
-            key: state.key,
-            ...node.attrs,
-            children: renderedChildren
-          });
-        }
-        return createElementFn(
-          node.tag,
-          { key: state.key, ...node.attrs },
-          node.text ?? (node.children ? _output(node.children, state) : "")
-        );
-      }
-    },
-    [RuleType.image]: {
-      _qualify: ["!["],
-      _match: simpleInlineRegex(IMAGE_R),
-      _order: Priority.HIGH,
-      _parse(capture) {
-        return {
-          alt: unescape(capture[1]),
-          target: unescape(capture[2]),
-          title: unescape(capture[3])
-        };
-      },
-      _render(node, _output, state = {}) {
-        return /* @__PURE__ */ jsx(
-          "img",
-          {
-            alt: node.alt ?? void 0,
-            title: node.title ?? void 0,
-            src: sanitize(node.target, "img", "src") ?? void 0
-          },
-          state.key
-        );
-      }
-    },
-    [RuleType.link]: {
-      _qualify: ["["],
-      _match: inlineRegex(LINK_R),
-      _order: Priority.LOW,
-      _parse(capture, parse, state) {
-        return {
-          children: parseSimpleInline(parse, capture[1], state),
-          target: unescape(capture[2]),
-          title: unescape(capture[3])
-        };
-      },
-      _render(node, _output, state = {}) {
-        const renderedChildren = _output(node.children, state);
-        const overrideComponent = getTag("a", options.overrides ?? {});
-        const props = {
-          key: state.key,
-          href: sanitize(node.target, "a", "href") ?? void 0,
-          title: node.title,
-          children: renderedChildren
-        };
-        if (typeof overrideComponent === "function") {
-          return overrideComponent(props);
-        }
-        return h("a", props, renderedChildren);
-      }
-    },
-    // https://daringfireball.net/projects/markdown/syntax#autolink
-    [RuleType.linkAngleBraceStyleDetector]: {
-      _qualify: ["<"],
-      _match: inlineRegex(LINK_AUTOLINK_R),
-      _order: Priority.MAX,
-      _parse(capture) {
-        return {
-          children: [
-            {
-              text: capture[1],
-              type: RuleType.text
-            }
-          ],
-          target: capture[1],
-          type: RuleType.link
-        };
-      }
-    },
-    [RuleType.linkBareUrlDetector]: {
-      _qualify: (source, state) => {
-        if (state.inAnchor || options.disableAutoLink) return false;
-        return startsWith(source, "http://") || startsWith(source, "https://");
-      },
-      _match: inlineRegex(LINK_AUTOLINK_BARE_URL_R),
-      _order: Priority.MAX,
-      _parse(capture) {
-        return {
-          children: [
-            {
-              text: capture[1],
-              type: RuleType.text
-            }
-          ],
-          target: capture[1],
-          title: void 0,
-          type: RuleType.link
-        };
-      }
-    },
-    [RuleType.linkMailtoDetector]: {
-      _qualify: ["<"],
-      _match: inlineRegex(LINK_AUTOLINK_MAILTO_R),
-      _order: Priority.MAX,
-      _parse(capture) {
-        let address = capture[1];
-        let target = capture[1];
-        if (!AUTOLINK_MAILTO_CHECK_R.test(target)) {
-          target = "mailto:" + target;
-        }
-        return {
-          children: [
-            {
-              text: address.replace("mailto:", ""),
-              type: RuleType.text
-            }
-          ],
-          target,
-          type: RuleType.link
-        };
-      }
-    },
-    [RuleType.orderedList]: generateListRule(
-      ORDERED,
-      (tag, props, ...children) => h(tag, props, ...children)
-    ),
-    [RuleType.unorderedList]: generateListRule(
-      UNORDERED,
-      (tag, props, ...children) => h(tag, props, ...children)
-    ),
-    [RuleType.newlineCoalescer]: {
-      _match: blockRegex(CONSECUTIVE_NEWLINE_R),
-      _order: Priority.LOW,
-      _parse: captureNothing,
-      _render() {
-        return "\n";
-      }
-    },
-    [RuleType.paragraph]: {
-      _match: allowInline(matchParagraph),
-      _order: Priority.LOW,
-      _parse(capture, parse, state) {
-        const start = performance.now();
-        const result = parseCaptureInline(capture, parse, state);
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `paragraph._parse: ${duration.toFixed(3)}ms, capture length: ${capture[0].length}`
-          );
-        }
-        return result;
-      },
-      _render(node, _output, state = {}) {
-        const start = performance.now();
-        const result = /* @__PURE__ */ jsx("p", { children: _output(node.children, state) }, state.key);
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `paragraph._render: ${duration.toFixed(3)}ms, children count: ${node.children.length}`
-          );
-        }
-        return result;
-      }
-    },
-    [RuleType.ref]: {
-      _qualify: ["["],
-      _match: inlineRegex(REFERENCE_IMAGE_OR_LINK),
-      _order: Priority.MAX,
-      _parse(capture) {
-        refs[capture[1]] = {
-          target: capture[2],
-          title: capture[4]
-        };
-        return {};
-      },
-      _render: renderNothing
-    },
-    [RuleType.refImage]: {
-      _qualify: ["!["],
-      _match: simpleInlineRegex(REFERENCE_IMAGE_R),
-      _order: Priority.MAX,
-      _parse(capture) {
-        return {
-          alt: capture[1] ? unescape(capture[1]) : void 0,
-          ref: capture[2]
-        };
-      },
-      _render(node, _output, state = {}) {
-        return refs[node.ref] ? /* @__PURE__ */ jsx(
-          "img",
-          {
-            alt: node.alt,
-            src: sanitize(refs[node.ref].target, "img", "src") ?? void 0,
-            title: refs[node.ref].title
-          },
-          state.key
-        ) : null;
-      }
-    },
-    [RuleType.refLink]: {
-      _qualify: (source) => source[0] === "[" && source.indexOf("](") === -1,
-      _match: inlineRegex(REFERENCE_LINK_R),
-      _order: Priority.MAX,
-      _parse(capture, parse, state) {
-        return {
-          children: parse(capture[1], state),
-          fallbackChildren: capture[0],
-          ref: capture[2]
-        };
-      },
-      _render(node, _output, state = {}) {
-        return refs[node.ref] ? /* @__PURE__ */ jsx(
-          "a",
-          {
-            href: sanitize(refs[node.ref].target, "a", "href") ?? void 0,
-            title: refs[node.ref].title,
-            children: _output(node.children, state)
-          },
-          state.key
-        ) : /* @__PURE__ */ jsx("span", { children: node.fallbackChildren }, state.key);
-      }
-    },
-    [RuleType.table]: {
-      _qualify: ["|"],
-      _match: blockRegex(NP_TABLE_R),
-      _order: Priority.HIGH,
-      _parse(capture, parse, state) {
-        const start = performance.now();
-        const result = parseTable(capture, parse, state);
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `table._parse: ${duration.toFixed(3)}ms, capture length: ${capture[0].length}`
-          );
-        }
-        return result;
-      },
-      _render(node, _output, state = {}) {
-        const start = performance.now();
-        const table = node;
-        const result = h(
-          "table",
-          { key: state.key },
-          h(
-            "thead",
-            {},
-            h(
-              "tr",
-              {},
-              ...table.header.map(
-                (content, i) => h(
-                  "th",
-                  { key: i, style: getTableStyle(table, i) },
-                  _output(content, state)
-                )
-              )
-            )
-          ),
-          h(
-            "tbody",
-            {},
-            ...table.cells.map(
-              (row, i) => h(
-                "tr",
-                { key: i },
-                ...row.map(
-                  (content, c) => h(
-                    "td",
-                    { key: c, style: getTableStyle(table, c) },
-                    _output(content, state)
-                  )
-                )
-              )
-            )
-          )
-        );
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `table._render: ${duration.toFixed(3)}ms, header count: ${table.header.length}, rows count: ${table.cells.length}`
-          );
-        }
-        return result;
-      }
-    },
-    [RuleType.text]: {
-      // Here we look for anything followed by non-symbols,
-      // double newlines, or double-space-newlines
-      // We break on any symbol characters so that this grammar
-      // is easy to extend without needing to modify this regex
-      _match: allowInline((source, _state) => {
-        let ret;
-        if (startsWith(source, ":")) ret = SHORTCODE_R.exec(source);
-        if (ret) return ret;
-        return TEXT_PLAIN_R.exec(source);
-      }),
-      _order: Priority.MIN,
-      _parse(capture) {
-        const text = capture[0];
-        return {
-          text: text.indexOf("&") === -1 ? text : text.replace(
-            HTML_CHAR_CODE_R,
-            (full, inner) => options.namedCodesToUnicode?.[inner] ?? full
-          )
-        };
-      },
-      _render(node) {
-        return node.text;
-      }
-    },
-    [RuleType.textBolded]: {
-      _qualify: ["**", "__"],
-      _match: simpleInlineRegex(TEXT_BOLD_R),
-      _order: Priority.MED,
-      _parse(capture, parse, state) {
-        return {
-          // capture[1] -> the syntax control character
-          // capture[2] -> inner content
-          children: parse(capture[2], state)
-        };
-      },
-      _render(node, _output, state = {}) {
-        const start = performance.now();
-        const result = /* @__PURE__ */ jsx("strong", { children: _output(node.children, state) }, state.key);
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `textBolded._render: ${duration.toFixed(3)}ms, children count: ${node.children.length}`
-          );
-        }
-        return result;
-      }
-    },
-    [RuleType.textEmphasized]: {
-      _qualify: (source) => {
-        const char = source[0];
-        return (char === "*" || char === "_") && source[1] !== char;
-      },
-      _match: simpleInlineRegex(TEXT_EMPHASIZED_R),
-      _order: Priority.LOW,
-      _parse(capture, parse, state) {
-        return {
-          // capture[1] -> opening * or _
-          // capture[2] -> inner content
-          children: parse(capture[2], state)
-        };
-      },
-      _render(node, _output, state = {}) {
-        const start = performance.now();
-        const result = /* @__PURE__ */ jsx("em", { children: _output(node.children, state) }, state.key);
-        const duration = performance.now() - start;
-        if (duration > 1) {
-          console.log(
-            `textEmphasized._render: ${duration.toFixed(3)}ms, children count: ${node.children.length}`
-          );
-        }
-        return result;
-      }
-    },
-    [RuleType.textEscaped]: {
-      _qualify: ["\\"],
-      // We don't allow escaping numbers, letters, or spaces here so that
-      // backslashes used in plain text still get rendered. But allowing
-      // escaping anything else provides a very flexible escape mechanism,
-      // regardless of how this grammar is extended.
-      _match: simpleInlineRegex(TEXT_ESCAPED_R),
-      _order: Priority.HIGH,
-      _parse(capture) {
-        return {
-          text: capture[1],
-          type: RuleType.text
-        };
-      }
-    },
-    [RuleType.textMarked]: {
-      _qualify: ["=="],
-      _match: simpleInlineRegex(TEXT_MARKED_R),
-      _order: Priority.LOW,
-      _parse: parseCaptureInline,
-      _render(node, _output, state = {}) {
-        return /* @__PURE__ */ jsx("mark", { children: _output(node.children, state) }, state.key);
-      }
-    },
-    [RuleType.textStrikethroughed]: {
-      _qualify: ["~~"],
-      _match: simpleInlineRegex(TEXT_STRIKETHROUGHED_R),
-      _order: Priority.LOW,
-      _parse: parseCaptureInline,
-      _render(node, _output, state = {}) {
-        return /* @__PURE__ */ jsx("del", { children: _output(node.children, state) }, state.key);
-      }
-    }
-  };
-  if (options.disableParsingRawHTML === true) {
-    delete rules[RuleType.htmlBlock];
-    delete rules[RuleType.htmlSelfClosing];
-  }
-  const parser = parserFor(rules);
-  const emitter = reactFor(createRenderer(rules, options.renderRule));
-  const jsx2 = compile(markdown);
-  if (footnotes.length) {
-    return /* @__PURE__ */ jsxs("div", { children: [
-      jsx2,
-      /* @__PURE__ */ jsx("footer", { children: footnotes.map((def) => /* @__PURE__ */ jsxs("div", { id: slug(def.identifier, slugify), children: [
-        def.identifier,
-        emitter(
-          parser(def.footnote, { inline: true })
-        )
-      ] }, def.identifier)) }, "footer")
-    ] });
-  }
-  return jsx2;
-};
-const MarkdownProcessor = ({ children = "", options, ...props }) => {
-  if (define_process_env_default.NODE_ENV !== "production" && typeof children !== "string") {
-    console.error(
-      "intlayer: <Markdown> component only accepts a single string as a child, received:",
-      children
-    );
-  }
-  return cloneElement(
-    compiler(children, options),
-    props
-  );
-};
-export {
-  MarkdownProcessor,
-  RuleType,
-  compiler,
-  sanitizer,
-  slugify
-};
-//# sourceMappingURL=processor.mjs.map