@intlayer/design-system 6.1.4 → 6.1.5

package/dist/components/MarkDownRender/{processer.mjs → processor.mjs}

@@ -351,6 +351,7 @@ const parseTableAlignCapture = (alignCapture) => {
   return "left";
 };
 const parseTableRow = (source, parse, state, tableOutput) => {
+  const start = performance.now();
   const prevInTable = state.inTable;
   state.inTable = true;
   let cells = [[]];
@@ -375,6 +376,12 @@ const parseTableRow = (source, parse, state, tableOutput) => {
   });
   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) => {
@@ -382,10 +389,18 @@ const parseTableAlign = (source) => {
   return alignText.map(parseTableAlignCapture);
 };
 const parseTableCells = (source, parse, state) => {
+  const start = performance.now();
   const rowsText = source.trim().split("\n");
-  return rowsText.map((rowText) => {
+  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;
@@ -416,6 +431,7 @@ const normalizeAttributeKey = (key) => {
   return key;
 };
 const parseStyleAttribute = (styleString) => {
+  const start = performance.now();
   const styles = [];
   let buffer = "";
   let inUrl = false;
@@ -462,9 +478,16 @@ const parseStyleAttribute = (styleString) => {
       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;
@@ -494,7 +517,14 @@ const trimLeadingWhitespaceOutsideFences = (text, whitespace) => {
     }
     return line.startsWith(whitespace) ? line.slice(whitespace.length) : line;
   });
-  return out.join("\n");
+  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") {
@@ -526,9 +556,18 @@ const attributeValueToJSXPropValue = (tag, key, value, sanitizeUrlFn) => {
   return value;
 };
 const normalizeWhitespace = (source) => {
-  return source.replace(CR_NEWLINE_R, "\n").replace(FORMFEED_R, "").replace(TAB_R, "    ");
+  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) => {
@@ -544,6 +583,7 @@ const parserFor = (rules) => {
     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()) {
@@ -556,10 +596,24 @@ const parserFor = (rules) => {
             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;
@@ -571,8 +625,20 @@ const parserFor = (rules) => {
       }
     }
     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) => {
@@ -629,6 +695,7 @@ const sanitizer = (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;
@@ -636,9 +703,16 @@ const parseInline = (parse, children, state) => {
   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;
@@ -646,13 +720,26 @@ const parseSimpleInline = (parse, children, state) => {
   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) => {
@@ -663,34 +750,56 @@ const parseCaptureInline = (capture, parse, 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 result = [];
+    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) {
-        result[result.length - 1] = result[result.length - 1] + nodeOut;
+        result2[result2.length - 1] = result2[result2.length - 1] + nodeOut;
       } else if (nodeOut !== null) {
-        result.push(nodeOut);
+        result2.push(nodeOut);
       }
       lastWasString = isString;
     }
     state.key = oldKey;
-    return result;
+    const duration2 = performance.now() - start;
+    if (duration2 > 1) {
+      console.log(
+        `reactFor (array): ${duration2.toFixed(3)}ms, ast length: ${ast.length}`
+      );
+    }
+    return result2;
   }
-  return render(
+  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;
-  return userRender ? userRender(() => renderer?.(ast, render, state), ast, render, state) : renderer?.(ast, render, state);
+  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) => {
@@ -734,7 +843,9 @@ const compiler = (markdown = "", options = {}) => {
   ];
   const containsBlockSyntax = (input) => {
     const cleaned = input.replace(TRIM_STARTING_NEWLINES, "");
-    return BLOCK_SYNTAXES.some((r) => r.test(cleaned));
+    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) {
@@ -772,90 +883,17 @@ const compiler = (markdown = "", options = {}) => {
     );
   };
   const compile = (input) => {
-    input = input.replace(FRONT_MATTER_R, "");
-    const transformFrameworkH5GroupsToTabs = (src) => {
-      const lines = src.split(/\r?\n/);
-      const out = [];
-      let i = 0;
-      let insideTabsDepth = 0;
-      while (i < lines.length) {
-        const line = lines[i];
-        if (/<\s*Tabs[>\s]/.test(line)) {
-          insideTabsDepth++;
-        }
-        if (/<\s*\/\s*Tabs\s*>/.test(line)) {
-          insideTabsDepth = Math.max(0, insideTabsDepth - 1);
-        }
-        if (!insideTabsDepth) {
-          const headingMatch = line.match(/^#{5}\s+(.+?)\s*$/);
-          if (headingMatch) {
-            const collected = [];
-            const captureSection = (startIndex) => {
-              let j2 = startIndex;
-              const buf = [];
-              while (j2 < lines.length) {
-                const l = lines[j2];
-                if (/^#{1,5}\s+/.test(l)) break;
-                if (/<\s*Tabs[>\s]/.test(l)) insideTabsDepth++;
-                if (/<\s*\/\s*Tabs\s*>/.test(l))
-                  insideTabsDepth = Math.max(0, insideTabsDepth - 1);
-                buf.push(l);
-                j2++;
-              }
-              return {
-                content: buf.join("\n").replace(/\n+$/, "\n"),
-                endIndex: j2
-              };
-            };
-            let j = i;
-            while (j < lines.length) {
-              const h2 = lines[j].match(/^#{5}\s+(.+?)\s*$/);
-              if (!h2) break;
-              const hLabel = h2[1].trim();
-              const { content, endIndex } = captureSection(j + 1);
-              collected.push({
-                label: hLabel,
-                value: hLabel.toLowerCase(),
-                content
-              });
-              j = endIndex;
-              if (!lines[j]?.startsWith("#####")) break;
-            }
-            if (collected.length >= 2) {
-              const defaultTab = (collected.find((t) => t.value === "intlayer") ?? collected[0]).value;
-              out.push(`<Tabs defaultTab="${defaultTab}">`);
-              const order = ["intlayer", "next-intl", "next-i18next"];
-              for (const key of order) {
-                const item = collected.find((c) => c.value === key);
-                if (!item) continue;
-                out.push(
-                  `  <TabItem label="${item.label}" value="${item.value}">`
-                );
-                const inner = item.content.replace(/^\n+|\n+$/g, "");
-                out.push(inner);
-                out.push("  </TabItem>");
-              }
-              out.push("</Tabs>");
-              i = j;
-              continue;
-            }
-          }
-        }
-        out.push(line);
-        i++;
-      }
-      return out.join("\n");
-    };
-    input = transformFrameworkH5GroupsToTabs(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(input) === false;
+      inline = SHOULD_RENDER_AS_BLOCK_R.test(result) === false;
     }
     const arr = emitter(
       parser(
-        inline ? input : `${trimEnd(input).replace(TRIM_STARTING_NEWLINES, "")}
+        inline ? result : `${trimEnd(result).replace(TRIM_STARTING_NEWLINES, "")}
 
 `,
         {
@@ -867,6 +905,12 @@ const compiler = (markdown = "", options = {}) => {
       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");
@@ -876,16 +920,35 @@ const compiler = (markdown = "", options = {}) => {
     } 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;
     }
@@ -893,7 +956,7 @@ const compiler = (markdown = "", options = {}) => {
     if (!attributes) {
       return null;
     }
-    return attributes.reduce((map, raw) => {
+    const result = attributes.reduce((map, raw) => {
       const delimiterIdx = raw.indexOf("=");
       if (delimiterIdx !== -1) {
         const key = normalizeAttributeKey(raw.slice(0, delimiterIdx)).trim();
@@ -914,6 +977,13 @@ const compiler = (markdown = "", options = {}) => {
       }
       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") {
@@ -939,15 +1009,24 @@ const compiler = (markdown = "", options = {}) => {
       _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] ?? "";
-        return {
+        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
         };
@@ -961,7 +1040,18 @@ const compiler = (markdown = "", options = {}) => {
             tag: "header"
           });
         }
-        return h("blockquote", props, _output(node.children, state));
+        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]: {
@@ -996,24 +1086,32 @@ const compiler = (markdown = "", options = {}) => {
         };
       },
       _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;
-        return h(
+        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, _parse, state) {
+      _parse(capture) {
         const rawText = capture[4];
-        const text = state.inHTML && rawText.indexOf("`") !== -1 ? rawText.replace(/\n/g, "\\n") : rawText;
+        const text = rawText;
         return {
           // if capture[3] it's additional metadata
           attrs: attrStringToMap("code", capture[3] ?? ""),
@@ -1033,7 +1131,15 @@ const compiler = (markdown = "", options = {}) => {
         };
       },
       _render(node, _output, state = {}) {
-        return h("code", { key: state.key }, node.text);
+        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;
       }
     },
     /**
@@ -1101,18 +1207,34 @@ const compiler = (markdown = "", options = {}) => {
       ),
       _order: Priority.HIGH,
       _parse(capture, parse, state) {
-        return {
+        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 = {}) {
-        return h(
+        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]: {
@@ -1127,7 +1249,13 @@ const compiler = (markdown = "", options = {}) => {
       }
     },
     [RuleType.htmlBlock]: {
-      _qualify: ["<"],
+      _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
        */
@@ -1164,15 +1292,27 @@ const compiler = (markdown = "", options = {}) => {
         return ast;
       },
       _render(node, _output, state = {}) {
-        return h(
+        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: ["<"],
+      _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
        */
@@ -1186,10 +1326,18 @@ const compiler = (markdown = "", options = {}) => {
         };
       },
       _render(node, _output, state = {}) {
-        return h(node.tag, {
+        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]: {
@@ -1377,9 +1525,27 @@ const compiler = (markdown = "", options = {}) => {
     [RuleType.paragraph]: {
       _match: allowInline(matchParagraph),
       _order: Priority.LOW,
-      _parse: parseCaptureInline,
+      _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 = {}) {
-        return /* @__PURE__ */ jsx("p", { children: _output(node.children, state) }, state.key);
+        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]: {
@@ -1444,10 +1610,21 @@ const compiler = (markdown = "", options = {}) => {
       _qualify: ["|"],
       _match: blockRegex(NP_TABLE_R),
       _order: Priority.HIGH,
-      _parse: parseTable,
+      _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;
-        return h(
+        const result = h(
           "table",
           { key: state.key },
           h(
@@ -1483,6 +1660,13 @@ const compiler = (markdown = "", options = {}) => {
             )
           )
         );
+        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]: {
@@ -1522,7 +1706,15 @@ const compiler = (markdown = "", options = {}) => {
         };
       },
       _render(node, _output, state = {}) {
-        return /* @__PURE__ */ jsx("strong", { children: _output(node.children, state) }, state.key);
+        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]: {
@@ -1540,7 +1732,15 @@ const compiler = (markdown = "", options = {}) => {
         };
       },
       _render(node, _output, state = {}) {
-        return /* @__PURE__ */ jsx("em", { children: _output(node.children, state) }, state.key);
+        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]: {
@@ -1616,4 +1816,4 @@ export {
   sanitizer,
   slugify
 };
-//# sourceMappingURL=processer.mjs.map
+//# sourceMappingURL=processor.mjs.map