@intlayer/design-system 6.1.3 → 6.1.5

package/dist/components/MarkDownRender/processor.mjs

@@ -0,0 +1,1819 @@
+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 = {}) {
+        return /* @__PURE__ */ jsx(
+          "a",
+          {
+            href: sanitize(node.target, "a", "href") ?? void 0,
+            title: node.title,
+            children: _output(node.children, state)
+          },
+          state.key
+        );
+      }
+    },
+    // 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