mdream 0.1.1

package/dist/shared/mdream.DUeWbUFG.mjs

@@ -0,0 +1,1432 @@
+import { ae as TEXT_NODE, af as NodeEventEnter, ab as collectNodeContent, aa as ELEMENT_NODE, a3 as TAG_PRE, M as TAG_LI, a4 as TAG_BLOCKQUOTE, ag as NO_SPACING, ah as DEFAULT_BLOCK_SPACING, ai as TABLE_ROW_SPACING, aj as LIST_ITEM_SPACING, ak as BLOCKQUOTE_SPACING, al as MARKDOWN_STRIKETHROUGH, am as MARKDOWN_HORIZONTAL_RULE, J as TAG_DD, K as TAG_DT, L as TAG_DL, e as TAG_ADDRESS, an as TAG_RP, ao as TAG_RT, ap as TAG_RUBY, aq as TAG_BDO, ar as TAG_TIME, as as TAG_VAR, at as TAG_DFN, au as TAG_CITE, av as TAG_U, z as TAG_ASIDE, aw as TAG_PLAINTEXT, ax as TAG_XMP, ay as TAG_NOFRAMES, az as TAG_NOSCRIPT, aA as TAG_SMALL, aB as TAG_SAMP, aC as TAG_Q, aD as TAG_MARK, aE as TAG_ABBR, aF as TAG_TEMPLATE, aG as TAG_PROGRESS, aH as TAG_METER, aI as TAG_DIALOG, aJ as TAG_MAP, s as TAG_IFRAME, aK as TAG_CANVAS, _ as TAG_VIDEO, Z as TAG_AUDIO, aL as TAG_LEGEND, t as TAG_FIELDSET, aM as TAG_OPTION, v as TAG_TEXTAREA, u as TAG_SELECT, Y as TAG_SVG, aN as TAG_WBR, aO as TAG_TRACK, aP as TAG_SOURCE, aQ as TAG_PARAM, aR as TAG_KEYGEN, w as TAG_INPUT, r as TAG_EMBED, aS as TAG_COL, aT as TAG_BASE, aU as TAG_AREA, aV as TAG_LINK, y as TAG_FORM, B as TAG_FOOTER, aW as TAG_KBD, S as TAG_TFOOT, U as TAG_TBODY, aX as TAG_CENTER, X as TAG_TABLE, T as TAG_BODY, x as TAG_BUTTON, aY as TAG_LABEL, A as TAG_NAV, j as TAG_SPAN, a5 as TAG_DIV, a6 as TAG_P, P as TAG_TD, Q as TAG_TH, R as TAG_TR, V as TAG_THEAD, a1 as TAG_IMG, d as TAG_A, O as TAG_UL, N as TAG_OL, a2 as TAG_CODE, aZ as MARKDOWN_CODE_BLOCK, a_ as MARKDOWN_INLINE_CODE, a$ as TAG_INS, b0 as TAG_SUP, b1 as TAG_SUB, b2 as TAG_DEL, m as TAG_I, n as TAG_EM, o as TAG_B, p as TAG_STRONG, l as TAG_HR, D as TAG_H6, E as TAG_H5, F as TAG_H4, G as TAG_H3, H as TAG_H2, I as TAG_H1, k as TAG_BR, ad as TAG_META, h as TAG_STYLE, i as TAG_SCRIPT, ac as TAG_TITLE, f as TAG_SUMMARY, g as TAG_DETAILS, b as TAG_HEAD, b3 as MARKDOWN_EMPHASIS, b4 as MARKDOWN_STRONG, b5 as HTML_ENTITIES, b6 as MAX_TAG_ID, b7 as assembleBufferedContent, b8 as TagIdMap, b9 as NodeEventExit } from './mdream.-hdaPj9a.mjs';
+
+function needsSpacing(lastChar, firstChar) {
+  const noSpaceLastChars = /* @__PURE__ */ new Set(["\n", " ", "[", ">", "_", "*", "`", "|", "#", "<", "("]);
+  const noSpaceFirstChars = /* @__PURE__ */ new Set([" ", "\n", "	", "_", "*", "`", "|", ">", "#"]);
+  return !noSpaceLastChars.has(lastChar) && !noSpaceFirstChars.has(firstChar);
+}
+function shouldAddSpacingBeforeText(lastChar, lastNode, textNode) {
+  return lastChar && lastChar !== "\n" && lastChar !== " " && lastChar !== "[" && lastChar !== ">" && !lastNode?.tagHandler?.isInline && textNode.value[0] !== " ";
+}
+function processTextNodeWithPlugins(node, state) {
+  if (!state.plugins?.length)
+    return void 0;
+  for (const plugin of state.plugins) {
+    if (!plugin.processTextNode)
+      continue;
+    const result = plugin.processTextNode(node, state);
+    if (result) {
+      if (result.skip)
+        return result;
+      return { content: result.content, skip: false };
+    }
+  }
+  return void 0;
+}
+function processHtmlEventToMarkdown(event, state) {
+  const { type: eventType, node } = event;
+  const lastNode = state.lastNode;
+  state.lastNode = event.node;
+  const buff = state.regionContentBuffers.get(node.regionId || 0) || [];
+  const lastBuffEntry = buff[buff.length - 1];
+  const lastChar = lastBuffEntry?.charAt(lastBuffEntry.length - 1) || "";
+  let secondLastChar;
+  if (lastBuffEntry?.length > 1) {
+    secondLastChar = lastBuffEntry.charAt(lastBuffEntry.length - 2);
+  } else {
+    secondLastChar = buff[buff.length - 2]?.charAt(buff[buff.length - 2].length - 1);
+  }
+  if (node.type === TEXT_NODE && eventType === NodeEventEnter) {
+    const textNode = node;
+    if (textNode.value) {
+      if (state.plugins?.length) {
+        const pluginResult = processTextNodeWithPlugins(textNode, state);
+        if (pluginResult) {
+          if (pluginResult.skip) {
+            return;
+          }
+          textNode.value = pluginResult.content;
+        }
+      }
+      if (textNode.value === " " && lastChar === "\n") {
+        return;
+      }
+      if (shouldAddSpacingBeforeText(lastChar, lastNode, textNode)) {
+        textNode.value = ` ${textNode.value}`;
+      }
+      collectNodeContent(textNode, textNode.value, state);
+    }
+    state.lastTextNode = textNode;
+    return;
+  }
+  if (node.type !== ELEMENT_NODE) {
+    return;
+  }
+  const context = { node, state };
+  const output = [];
+  const lastFragment = state.lastContentCache;
+  if (state.plugins?.length) {
+    const results = [];
+    const fn = eventType === NodeEventEnter ? "onNodeEnter" : "onNodeExit";
+    for (const plugin of state.plugins) {
+      if (!plugin[fn])
+        continue;
+      const result = plugin[fn](event.node, state);
+      if (result) {
+        results.push(result);
+      }
+    }
+    output.push(...results);
+  }
+  let lastNewLines = 0;
+  if (lastChar === "\n") {
+    lastNewLines++;
+  }
+  if (secondLastChar === "\n") {
+    lastNewLines++;
+  }
+  const eventFn = eventType === NodeEventEnter ? "enter" : "exit";
+  const handler = node.tagHandler;
+  if (!output.length && handler?.[eventFn]) {
+    const res = handler[eventFn](context);
+    if (res) {
+      output.push(res);
+    }
+  }
+  const newLineConfig = calculateNewLineConfig(node);
+  const newLines = Math.max(0, (newLineConfig[eventType] || 0) - lastNewLines);
+  if (newLines > 0) {
+    if (!buff.length) {
+      for (const fragment of output) {
+        collectNodeContent(node, fragment, state);
+      }
+      return;
+    }
+    const newlinesStr = "\n".repeat(newLines);
+    if (lastChar === " " && buff?.length) {
+      buff[buff.length - 1] = buff[buff.length - 1].substring(0, buff[buff.length - 1].length - 1);
+    }
+    if (eventType === NodeEventEnter) {
+      output.unshift(newlinesStr);
+    } else {
+      output.push(newlinesStr);
+    }
+  } else {
+    if (lastFragment && state.lastTextNode?.containsWhitespace && !!node.parent && "value" in state.lastTextNode && typeof state.lastTextNode.value === "string") {
+      if (!node.parent.depthMap[TAG_PRE] || node.parent.tagId === TAG_PRE) {
+        const originalLength = lastFragment.length;
+        const trimmed = lastFragment.trimEnd();
+        const trimmedChars = originalLength - trimmed.length;
+        if (trimmedChars > 0) {
+          if (buff?.length && buff[buff.length - 1] === lastFragment) {
+            buff[buff.length - 1] = trimmed;
+          }
+        }
+        state.lastTextNode = void 0;
+      }
+    }
+  }
+  if (output[0]?.[0] && eventType === NodeEventEnter && lastChar && needsSpacing(lastChar, output[0][0])) {
+    collectNodeContent(node, " ", state);
+  }
+  for (const fragment of output) {
+    collectNodeContent(node, fragment, state);
+  }
+}
+function calculateNewLineConfig(node) {
+  const tagId = node.tagId;
+  const depthMap = node.depthMap;
+  if (tagId !== TAG_LI && depthMap[TAG_LI] > 0 || tagId !== TAG_BLOCKQUOTE && depthMap[TAG_BLOCKQUOTE] > 0) {
+    return NO_SPACING;
+  }
+  let currParent = node.parent;
+  while (currParent) {
+    if (currParent.tagHandler?.collapsesInnerWhiteSpace) {
+      return NO_SPACING;
+    }
+    currParent = currParent.parent;
+  }
+  if (node.tagHandler?.spacing) {
+    return node.tagHandler?.spacing;
+  }
+  return DEFAULT_BLOCK_SPACING;
+}
+
+function resolveUrl(url, origin) {
+  if (!url)
+    return url;
+  if (url.startsWith("//")) {
+    return `https:${url}`;
+  }
+  if (origin) {
+    if (url.startsWith("/") && origin) {
+      const cleanOrigin = origin.endsWith("/") ? origin.slice(0, -1) : origin;
+      return `${cleanOrigin}${url}`;
+    }
+    if (url.startsWith("./")) {
+      return `${origin}/${url.slice(2)}`;
+    }
+    if (!url.startsWith("http")) {
+      const cleanUrl = url.startsWith("/") ? url.slice(1) : url;
+      return `${origin}/${cleanUrl}`;
+    }
+  }
+  return url;
+}
+function isInsideTableCell(node) {
+  return node.depthMap[TAG_TD] > 0;
+}
+function getLanguageFromClass(className) {
+  if (!className)
+    return "";
+  const langParts = className.split(" ").map((c) => c.split("language-")[1]).filter(Boolean);
+  return langParts.length > 0 ? langParts[0].trim() : "";
+}
+function handleHeading(depth) {
+  return {
+    enter: ({ node }) => {
+      if (node.depthMap[TAG_A]) {
+        return `<h${depth}>`;
+      }
+      return `${"#".repeat(depth)} `;
+    },
+    exit: ({ node }) => {
+      if (node.depthMap[TAG_A]) {
+        return `</h${depth}>`;
+      }
+    },
+    collapsesInnerWhiteSpace: true
+  };
+}
+const Strong = {
+  enter: ({ node }) => {
+    if (node.depthMap[TAG_B] > 1) {
+      return "";
+    }
+    return MARKDOWN_STRONG;
+  },
+  exit: ({ node }) => {
+    if (node.depthMap[TAG_B] > 1) {
+      return "";
+    }
+    return MARKDOWN_STRONG;
+  },
+  collapsesInnerWhiteSpace: true,
+  spacing: NO_SPACING,
+  isInline: true
+};
+const Emphasis = {
+  enter: ({ node }) => {
+    if (node.depthMap[TAG_I] > 1) {
+      return "";
+    }
+    return MARKDOWN_EMPHASIS;
+  },
+  exit: ({ node }) => {
+    if (node.depthMap[TAG_I] > 1) {
+      return "";
+    }
+    return MARKDOWN_EMPHASIS;
+  },
+  collapsesInnerWhiteSpace: true,
+  spacing: NO_SPACING,
+  isInline: true
+};
+const tagHandlers = {
+  // Numeric tag constants
+  [TAG_HEAD]: {
+    // No special handling for head - plugins will handle frontmatter
+    spacing: NO_SPACING,
+    collapsesInnerWhiteSpace: true
+  },
+  [TAG_DETAILS]: {
+    enter: () => "<details>",
+    exit: () => "</details>\n\n"
+  },
+  [TAG_SUMMARY]: {
+    enter: () => "<summary>",
+    exit: () => "</summary>\n\n"
+  },
+  [TAG_TITLE]: {
+    // No special handling for title - plugins will handle frontmatter
+    collapsesInnerWhiteSpace: true,
+    isNonNesting: true,
+    spacing: NO_SPACING
+  },
+  [TAG_SCRIPT]: {
+    excludesTextNodes: true,
+    isNonNesting: true
+  },
+  [TAG_STYLE]: {
+    isNonNesting: true,
+    excludesTextNodes: true
+  },
+  [TAG_META]: {
+    // No special handling for meta - plugins will handle frontmatter
+    collapsesInnerWhiteSpace: true,
+    isSelfClosing: true,
+    spacing: NO_SPACING
+  },
+  [TAG_BR]: {
+    enter: ({ node }) => {
+      return isInsideTableCell(node) ? "<br>" : void 0;
+    },
+    isSelfClosing: true,
+    spacing: NO_SPACING,
+    collapsesInnerWhiteSpace: true,
+    isInline: true
+  },
+  [TAG_H1]: handleHeading(1),
+  [TAG_H2]: handleHeading(2),
+  [TAG_H3]: handleHeading(3),
+  [TAG_H4]: handleHeading(4),
+  [TAG_H5]: handleHeading(5),
+  [TAG_H6]: handleHeading(6),
+  [TAG_HR]: {
+    enter: () => MARKDOWN_HORIZONTAL_RULE,
+    isSelfClosing: true
+  },
+  [TAG_STRONG]: Strong,
+  [TAG_B]: Strong,
+  [TAG_EM]: Emphasis,
+  [TAG_I]: Emphasis,
+  [TAG_DEL]: {
+    enter: () => MARKDOWN_STRIKETHROUGH,
+    exit: () => MARKDOWN_STRIKETHROUGH,
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_SUB]: {
+    enter: () => "<sub>",
+    exit: () => "</sub>",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_SUP]: {
+    enter: () => "<sup>",
+    exit: () => "</sup>",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_INS]: {
+    enter: () => "<ins>",
+    exit: () => "</ins>",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_BLOCKQUOTE]: {
+    enter: ({ node }) => {
+      const depth = node.depthMap[TAG_BLOCKQUOTE] || 1;
+      let prefix = "> ".repeat(depth);
+      if (node.depthMap[TAG_LI] > 0) {
+        prefix = `
+${"  ".repeat(node.depthMap[TAG_LI])}${prefix}`;
+      }
+      return prefix;
+    },
+    spacing: BLOCKQUOTE_SPACING
+  },
+  [TAG_CODE]: {
+    enter: ({ node }) => {
+      if ((node.depthMap[TAG_PRE] || 0) > 0) {
+        const language = getLanguageFromClass(node.attributes?.class);
+        return `${MARKDOWN_CODE_BLOCK}${language}
+`;
+      }
+      return MARKDOWN_INLINE_CODE;
+    },
+    exit: ({ node }) => {
+      return node.depthMap[TAG_PRE] > 0 ? `
+${MARKDOWN_CODE_BLOCK}` : MARKDOWN_INLINE_CODE;
+    },
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_UL]: {
+    enter: ({ node }) => isInsideTableCell(node) ? "<ul>" : void 0,
+    exit: ({ node }) => isInsideTableCell(node) ? "</ul>" : void 0
+  },
+  [TAG_LI]: {
+    enter: ({ node }) => {
+      if (isInsideTableCell(node)) {
+        return "<li>";
+      }
+      const depth = (node.depthMap[TAG_UL] || 0) + (node.depthMap[TAG_OL] || 0) - 1;
+      const isOrdered = node.parent?.tagId === TAG_OL;
+      const indent = "  ".repeat(Math.max(0, depth));
+      const marker = isOrdered ? `${node.index + 1}. ` : "- ";
+      return `${indent}${marker}`;
+    },
+    exit: ({ node }) => isInsideTableCell(node) ? "</li>" : void 0,
+    spacing: LIST_ITEM_SPACING
+  },
+  [TAG_A]: {
+    enter: ({ node }) => {
+      if (node.attributes?.href) {
+        return "[";
+      }
+    },
+    exit: ({ node, state }) => {
+      if (!node.attributes?.href) {
+        return "";
+      }
+      const href = resolveUrl(node.attributes?.href || "", state.options?.origin);
+      let title = node.attributes?.title;
+      const lastContent = state.lastContentCache;
+      if (lastContent === title) {
+        title = "";
+      }
+      return title ? `](${href} "${title}")` : `](${href})`;
+    },
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_IMG]: {
+    enter: ({ node, state }) => {
+      const alt = node.attributes?.alt || "";
+      const src = resolveUrl(node.attributes?.src || "", state.options?.origin);
+      return `![${alt}](${src})`;
+    },
+    collapsesInnerWhiteSpace: true,
+    isSelfClosing: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_TABLE]: {
+    enter: ({ node, state }) => {
+      if (isInsideTableCell(node)) {
+        return "<table>";
+      }
+      if (node.depthMap[TAG_TABLE] <= 1) {
+        state.tableRenderedTable = false;
+      }
+      state.tableColumnAlignments = [];
+    },
+    exit: ({ node }) => isInsideTableCell(node) ? "</table>" : void 0
+  },
+  [TAG_THEAD]: {
+    enter: ({ node }) => {
+      if (isInsideTableCell(node)) {
+        return "<thead>";
+      }
+    },
+    exit: ({ node }) => isInsideTableCell(node) ? "</thead>" : void 0,
+    spacing: TABLE_ROW_SPACING,
+    excludesTextNodes: true
+  },
+  [TAG_TR]: {
+    enter: ({ node, state }) => {
+      if (isInsideTableCell(node)) {
+        return "<tr>";
+      }
+      state.tableCurrentRowCells = 0;
+      return "| ";
+    },
+    exit: ({ node, state }) => {
+      if (isInsideTableCell(node) || node.depthMap[TAG_TABLE] > 1) {
+        return "</tr>";
+      }
+      if (!state.tableRenderedTable) {
+        state.tableRenderedTable = true;
+        const alignments = state.tableColumnAlignments;
+        while (alignments.length < state.tableCurrentRowCells) {
+          alignments.push("");
+        }
+        const alignmentMarkers = alignments.map((align) => {
+          switch (align) {
+            case "left":
+              return ":---";
+            case "center":
+              return ":---:";
+            case "right":
+              return "---:";
+            default:
+              return "---";
+          }
+        });
+        return ` |
+| ${alignmentMarkers.join(" | ")} |`;
+      }
+      return " |";
+    },
+    excludesTextNodes: true,
+    spacing: TABLE_ROW_SPACING
+  },
+  [TAG_TH]: {
+    enter: ({ node, state }) => {
+      if (node.depthMap[TAG_TABLE] > 1) {
+        return "<th>";
+      }
+      const align = node.attributes?.align?.toLowerCase();
+      if (align) {
+        state.tableColumnAlignments.push(align);
+      } else if (state.tableColumnAlignments.length <= state.tableCurrentRowCells) {
+        state.tableColumnAlignments.push("");
+      }
+      return node.index === 0 ? "" : " | ";
+    },
+    exit: ({ node, state }) => {
+      if (node.depthMap[TAG_TABLE] > 1) {
+        return "</th>";
+      }
+      state.tableCurrentRowCells++;
+    },
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING
+  },
+  [TAG_TD]: {
+    enter: ({ node }) => {
+      if (node.depthMap[TAG_TABLE] > 1) {
+        return "<td>";
+      }
+      return node.index === 0 ? "" : " | ";
+    },
+    exit: ({ node, state }) => {
+      if (node.depthMap[TAG_TABLE] > 1) {
+        return "</td>";
+      }
+      state.tableCurrentRowCells++;
+    },
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING
+  },
+  [TAG_P]: {},
+  [TAG_DIV]: {},
+  [TAG_SPAN]: {
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_NAV]: {},
+  [TAG_LABEL]: {
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_BUTTON]: {
+    collapsesInnerWhiteSpace: true,
+    isInline: true
+  },
+  [TAG_BODY]: { spacing: NO_SPACING },
+  [TAG_CENTER]: {
+    // if in table cell we preserve
+    enter: ({ node }) => {
+      if (node.depthMap[TAG_TABLE] > 1) {
+        return "<center>";
+      }
+    },
+    exit: ({ node }) => {
+      if (node.depthMap[TAG_TABLE] > 1) {
+        return "</center>";
+      }
+    },
+    spacing: NO_SPACING
+  },
+  [TAG_TBODY]: {
+    spacing: NO_SPACING,
+    excludesTextNodes: true
+  },
+  [TAG_TFOOT]: {
+    spacing: TABLE_ROW_SPACING,
+    excludesTextNodes: true
+  },
+  [TAG_KBD]: {
+    enter: () => "`",
+    exit: () => "`",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_FOOTER]: {
+    spacing: NO_SPACING
+  },
+  [TAG_FORM]: {
+    spacing: NO_SPACING
+  },
+  [TAG_LINK]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING,
+    collapsesInnerWhiteSpace: true,
+    isInline: true
+  },
+  [TAG_AREA]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_BASE]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_COL]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING
+  },
+  [TAG_EMBED]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING
+  },
+  [TAG_INPUT]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_KEYGEN]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_PARAM]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING
+  },
+  [TAG_SOURCE]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING
+  },
+  [TAG_TRACK]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING
+  },
+  [TAG_WBR]: {
+    isSelfClosing: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_SVG]: {
+    spacing: NO_SPACING
+  },
+  [TAG_SELECT]: {
+    spacing: NO_SPACING
+  },
+  [TAG_TEXTAREA]: {
+    isNonNesting: true,
+    spacing: NO_SPACING
+  },
+  [TAG_OPTION]: {
+    isNonNesting: true,
+    spacing: NO_SPACING
+  },
+  [TAG_FIELDSET]: {
+    spacing: NO_SPACING
+  },
+  [TAG_LEGEND]: {
+    spacing: NO_SPACING
+  },
+  [TAG_AUDIO]: {
+    spacing: NO_SPACING
+  },
+  [TAG_VIDEO]: {
+    spacing: NO_SPACING
+  },
+  [TAG_CANVAS]: {
+    spacing: NO_SPACING
+  },
+  [TAG_IFRAME]: {
+    isNonNesting: true,
+    spacing: NO_SPACING
+  },
+  [TAG_MAP]: {
+    spacing: NO_SPACING
+  },
+  [TAG_DIALOG]: {
+    spacing: NO_SPACING
+  },
+  [TAG_METER]: {
+    spacing: NO_SPACING
+  },
+  [TAG_PROGRESS]: {
+    spacing: NO_SPACING
+  },
+  [TAG_TEMPLATE]: {
+    spacing: NO_SPACING
+  },
+  [TAG_ABBR]: {
+    enter: () => "",
+    exit: () => "",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_MARK]: {
+    enter: () => "<mark>",
+    exit: () => "</mark>",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_Q]: {
+    enter: () => '"',
+    exit: () => '"',
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_SAMP]: {
+    enter: () => "`",
+    exit: () => "`",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_SMALL]: {
+    enter: () => "",
+    exit: () => "",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_NOSCRIPT]: {
+    excludesTextNodes: true,
+    spacing: NO_SPACING
+  },
+  [TAG_NOFRAMES]: {
+    isNonNesting: true,
+    spacing: NO_SPACING
+  },
+  [TAG_XMP]: {
+    isNonNesting: true,
+    spacing: NO_SPACING
+  },
+  [TAG_PLAINTEXT]: {
+    isNonNesting: true,
+    spacing: NO_SPACING
+  },
+  [TAG_ASIDE]: {
+    spacing: NO_SPACING
+  },
+  [TAG_U]: {
+    enter: () => {
+      return "<u>";
+    },
+    exit: () => {
+      return "</u>";
+    },
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_CITE]: {
+    enter: () => "*",
+    exit: () => "*",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_DFN]: {
+    enter: () => "**",
+    exit: () => "**",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_VAR]: {
+    enter: () => "`",
+    exit: () => "`",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_TIME]: {
+    enter: () => "",
+    exit: () => "",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_BDO]: {
+    enter: () => "",
+    exit: () => "",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_RUBY]: {
+    enter: () => "",
+    exit: () => "",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_RT]: {
+    enter: () => "",
+    exit: () => "",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_RP]: {
+    enter: () => "",
+    exit: () => "",
+    collapsesInnerWhiteSpace: true,
+    spacing: NO_SPACING,
+    isInline: true
+  },
+  [TAG_ADDRESS]: {
+    enter: () => "<address>",
+    exit: () => "</address>",
+    spacing: NO_SPACING,
+    collapsesInnerWhiteSpace: true
+  },
+  [TAG_DL]: {
+    spacing: NO_SPACING,
+    enter: () => "<dl>",
+    exit: () => "</dl>"
+  },
+  [TAG_DT]: {
+    // Definition term
+    enter: () => "<dt>",
+    exit: () => "</dt>",
+    collapsesInnerWhiteSpace: true,
+    spacing: [0, 1]
+  },
+  [TAG_DD]: {
+    // Definition term
+    enter: () => "<dd>",
+    exit: () => "</dd>",
+    spacing: [0, 1]
+  }
+};
+
+function decodeHTMLEntities(text) {
+  let result = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === "&") {
+      let match = false;
+      for (const [entity, replacement] of Object.entries(HTML_ENTITIES)) {
+        if (text.startsWith(entity, i)) {
+          result += replacement;
+          i += entity.length;
+          match = true;
+          break;
+        }
+      }
+      if (match)
+        continue;
+      if (i + 2 < text.length && text[i + 1] === "#") {
+        const start = i;
+        i += 2;
+        const isHex = text[i] === "x" || text[i] === "X";
+        if (isHex)
+          i++;
+        const numStart = i;
+        while (i < text.length && text[i] !== ";") {
+          i++;
+        }
+        if (i < text.length && text[i] === ";") {
+          const numStr = text.substring(numStart, i);
+          const base = isHex ? 16 : 10;
+          try {
+            const codePoint = Number.parseInt(numStr, base);
+            if (!Number.isNaN(codePoint)) {
+              result += String.fromCodePoint(codePoint);
+              i++;
+              continue;
+            }
+          } catch {
+          }
+        }
+        i = start;
+      }
+    }
+    result += text[i];
+    i++;
+  }
+  return result;
+}
+function traverseUpToFirstBlockNode(node) {
+  let firstBlockParent = node;
+  const parentsToIncrement = [firstBlockParent];
+  while (firstBlockParent.tagHandler?.isInline) {
+    if (!firstBlockParent.parent) {
+      break;
+    }
+    firstBlockParent = firstBlockParent.parent;
+    parentsToIncrement.push(firstBlockParent);
+  }
+  return parentsToIncrement;
+}
+
+const LT_CHAR = 60;
+const GT_CHAR = 62;
+const SLASH_CHAR = 47;
+const EQUALS_CHAR = 61;
+const QUOTE_CHAR = 34;
+const APOS_CHAR = 39;
+const EXCLAMATION_CHAR = 33;
+const AMPERSAND_CHAR = 38;
+const BACKSLASH_CHAR = 92;
+const DASH_CHAR = 45;
+const SPACE_CHAR = 32;
+const TAB_CHAR = 9;
+const NEWLINE_CHAR = 10;
+const CARRIAGE_RETURN_CHAR = 13;
+const EMPTY_ATTRIBUTES = Object.freeze({});
+function copyDepthMap(depthMap) {
+  return new Uint8Array(depthMap);
+}
+function isWhitespace(charCode) {
+  return charCode === SPACE_CHAR || charCode === TAB_CHAR || charCode === NEWLINE_CHAR || charCode === CARRIAGE_RETURN_CHAR;
+}
+function runProcessAttributesHooks(node, state) {
+  if (!state.plugins?.length)
+    return;
+  for (const plugin of state.plugins) {
+    if (plugin.processAttributes) {
+      plugin.processAttributes(node, state);
+    }
+  }
+}
+function parseHTML(htmlChunk, state, handleEvent) {
+  let textBuffer = "";
+  state.depthMap ??= new Uint8Array(MAX_TAG_ID);
+  state.depth ??= 0;
+  state.lastCharWasWhitespace ??= true;
+  state.justClosedTag ??= false;
+  state.isFirstTextInElement ??= false;
+  let i = 0;
+  const chunkLength = htmlChunk.length;
+  while (i < chunkLength) {
+    const currentCharCode = htmlChunk.charCodeAt(i);
+    if (currentCharCode !== LT_CHAR) {
+      if (currentCharCode === AMPERSAND_CHAR) {
+        state.hasEncodedHtmlEntity = true;
+      }
+      if (isWhitespace(currentCharCode)) {
+        const inPreTag = state.depthMap[TAG_PRE] > 0;
+        if (state.justClosedTag) {
+          state.justClosedTag = false;
+          state.lastCharWasWhitespace = false;
+        }
+        if (!inPreTag && state.lastCharWasWhitespace) {
+          i++;
+          continue;
+        }
+        if (inPreTag) {
+          textBuffer += htmlChunk[i];
+        } else {
+          if (currentCharCode === SPACE_CHAR || !state.lastCharWasWhitespace) {
+            textBuffer += " ";
+          }
+        }
+        state.lastCharWasWhitespace = true;
+        state.textBufferContainsWhitespace = true;
+      } else {
+        state.textBufferContainsNonWhitespace = true;
+        state.lastCharWasWhitespace = false;
+        state.justClosedTag = false;
+        if (currentCharCode === 124 && state.depthMap[TAG_TABLE]) {
+          textBuffer += "\\|";
+        } else if (currentCharCode === 96 && (state.depthMap[TAG_CODE] || state.depthMap[TAG_PRE])) {
+          textBuffer += "\\`";
+        } else if (currentCharCode === 91 && state.depthMap[TAG_A]) {
+          textBuffer += "\\[";
+        } else if (currentCharCode === 93 && state.depthMap[TAG_A]) {
+          textBuffer += "\\]";
+        } else if (currentCharCode === 62 && state.depthMap[TAG_BLOCKQUOTE]) {
+          textBuffer += "\\>";
+        } else {
+          textBuffer += htmlChunk[i];
+        }
+      }
+      i++;
+      continue;
+    }
+    if (i + 1 >= chunkLength) {
+      textBuffer += htmlChunk[i];
+      break;
+    }
+    const nextCharCode = htmlChunk.charCodeAt(i + 1);
+    if (nextCharCode === EXCLAMATION_CHAR) {
+      if (textBuffer.length > 0) {
+        processTextBuffer(textBuffer, state, handleEvent);
+        textBuffer = "";
+      }
+      const result = processCommentOrDoctype(htmlChunk, i);
+      if (result.complete) {
+        i = result.newPosition;
+      } else {
+        textBuffer += result.remainingText;
+        break;
+      }
+    } else if (nextCharCode === SLASH_CHAR) {
+      if (textBuffer.length > 0) {
+        processTextBuffer(textBuffer, state, handleEvent);
+        textBuffer = "";
+      }
+      const result = processClosingTag(htmlChunk, i, state, handleEvent);
+      if (result.complete) {
+        i = result.newPosition;
+      } else {
+        textBuffer += result.remainingText;
+        break;
+      }
+    } else {
+      let i2 = i + 1;
+      const tagNameStart = i2;
+      let tagNameEnd = -1;
+      const chunkLength2 = htmlChunk.length;
+      while (i2 < chunkLength2) {
+        const c = htmlChunk.charCodeAt(i2);
+        if (isWhitespace(c) || c === SLASH_CHAR || c === GT_CHAR) {
+          tagNameEnd = i2;
+          break;
+        }
+        i2++;
+      }
+      if (tagNameEnd === -1) {
+        textBuffer += htmlChunk.substring(i);
+        break;
+      }
+      const tagName = htmlChunk.substring(tagNameStart, tagNameEnd).toLowerCase();
+      if (!tagName) {
+        i = tagNameEnd;
+        break;
+      }
+      const tagId = TagIdMap[tagName] ?? -1;
+      i2 = tagNameEnd;
+      if (state.currentNode?.tagHandler?.isNonNesting) {
+        if (tagId !== state.currentNode?.tagId) {
+          textBuffer += htmlChunk[i++];
+          continue;
+        }
+      }
+      if (textBuffer.length > 0) {
+        processTextBuffer(textBuffer, state, handleEvent);
+        textBuffer = "";
+      }
+      const result = processOpeningTag(tagName, tagId, htmlChunk, i2, state, handleEvent);
+      if (result.skip) {
+        textBuffer += htmlChunk[i++];
+      } else if (result.complete) {
+        i = result.newPosition;
+        if (!result.selfClosing) {
+          state.isFirstTextInElement = true;
+        }
+      } else {
+        textBuffer += result.remainingText;
+        break;
+      }
+    }
+  }
+  return textBuffer;
+}
+function processTextBuffer(textBuffer, state, handleEvent) {
+  const containsNonWhitespace = state.textBufferContainsNonWhitespace;
+  const containsWhitespace = state.textBufferContainsWhitespace;
+  state.textBufferContainsNonWhitespace = false;
+  state.textBufferContainsWhitespace = false;
+  if (!state.currentNode || state.currentNode?.tagHandler?.excludesTextNodes) {
+    return;
+  }
+  const inPreTag = state.depthMap[TAG_PRE] > 0;
+  if (!inPreTag && !containsNonWhitespace && !state.currentNode.childTextNodeIndex) {
+    return;
+  }
+  let text = textBuffer;
+  if (text.length === 0) {
+    return;
+  }
+  const parentsToIncrement = traverseUpToFirstBlockNode(state.currentNode);
+  const firstBlockParent = parentsToIncrement[parentsToIncrement.length - 1];
+  if (containsWhitespace && !firstBlockParent?.childTextNodeIndex) {
+    let start = 0;
+    while (start < text.length && (inPreTag ? text.charCodeAt(start) === 10 || text.charCodeAt(start) === 13 : isWhitespace(text.charCodeAt(start)))) {
+      start++;
+    }
+    if (start > 0) {
+      text = text.substring(start);
+    }
+  }
+  if (state.hasEncodedHtmlEntity) {
+    text = decodeHTMLEntities(String(text));
+    state.hasEncodedHtmlEntity = false;
+  }
+  const textNode = {
+    type: TEXT_NODE,
+    value: text,
+    parent: state.currentNode,
+    regionId: state.currentNode?.regionId,
+    index: state.currentNode.currentWalkIndex++,
+    depth: state.depth,
+    containsWhitespace
+  };
+  for (const parent of parentsToIncrement) {
+    parent.childTextNodeIndex = (parent.childTextNodeIndex || 0) + 1;
+  }
+  handleEvent({ type: NodeEventEnter, node: textNode });
+  state.lastTextNode = textNode;
+}
+function processClosingTag(htmlChunk, position, state, handleEvent) {
+  let i = position + 2;
+  const tagNameStart = i;
+  const chunkLength = htmlChunk.length;
+  let foundClose = false;
+  while (i < chunkLength) {
+    const charCode = htmlChunk.charCodeAt(i);
+    if (charCode === GT_CHAR) {
+      foundClose = true;
+      break;
+    }
+    i++;
+  }
+  if (!foundClose) {
+    return {
+      complete: false,
+      newPosition: position,
+      remainingText: htmlChunk.substring(position)
+    };
+  }
+  const tagName = htmlChunk.substring(tagNameStart, i).toLowerCase();
+  const tagId = TagIdMap[tagName] ?? -1;
+  if (state.currentNode?.tagHandler?.isNonNesting && tagId !== state.currentNode.tagId) {
+    return {
+      complete: false,
+      newPosition: position,
+      remainingText: htmlChunk.substring(position)
+    };
+  }
+  let curr = state.currentNode;
+  if (curr) {
+    let match = curr.tagId !== tagId;
+    while (curr && match) {
+      closeNode(curr, state, handleEvent);
+      curr = curr.parent;
+      match = curr?.tagId !== tagId;
+    }
+  }
+  if (curr) {
+    closeNode(state.currentNode, state, handleEvent);
+  }
+  state.justClosedTag = true;
+  return {
+    complete: true,
+    newPosition: i + 1,
+    // Skip past '>'
+    remainingText: ""
+  };
+}
+function closeNode(node, state, handleEvent) {
+  if (!node) {
+    return;
+  }
+  if (node.tagId === TAG_A && !node.childTextNodeIndex) {
+    const prefix = node.attributes?.title || node.attributes?.["aria-label"] || "";
+    if (prefix) {
+      node.childTextNodeIndex = 1;
+      const textNode = {
+        type: TEXT_NODE,
+        value: prefix,
+        parent: node,
+        index: 0,
+        depth: node.depth + 1
+      };
+      handleEvent({ type: NodeEventEnter, node: textNode });
+      for (const parent of traverseUpToFirstBlockNode(node)) {
+        parent.childTextNodeIndex = (parent.childTextNodeIndex || 0) + 1;
+      }
+    }
+  }
+  if (node.tagId) {
+    state.depthMap[node.tagId] = Math.max(0, state.depthMap[node.tagId] - 1);
+  }
+  state.depth--;
+  handleEvent({ type: NodeEventExit, node });
+  state.currentNode = state.currentNode.parent;
+  state.hasEncodedHtmlEntity = false;
+  state.justClosedTag = true;
+}
+function processCommentOrDoctype(htmlChunk, position) {
+  let i = position;
+  const chunkLength = htmlChunk.length;
+  if (i + 3 < chunkLength && htmlChunk.charCodeAt(i + 2) === DASH_CHAR && htmlChunk.charCodeAt(i + 3) === DASH_CHAR) {
+    i += 4;
+    while (i < chunkLength - 2) {
+      if (htmlChunk.charCodeAt(i) === DASH_CHAR && htmlChunk.charCodeAt(i + 1) === DASH_CHAR && htmlChunk.charCodeAt(i + 2) === GT_CHAR) {
+        i += 3;
+        return {
+          complete: true,
+          newPosition: i,
+          remainingText: ""
+        };
+      }
+      i++;
+    }
+    return {
+      complete: false,
+      newPosition: position,
+      remainingText: htmlChunk.substring(position)
+    };
+  } else {
+    i += 2;
+    while (i < chunkLength) {
+      if (htmlChunk.charCodeAt(i) === GT_CHAR) {
+        i++;
+        return {
+          complete: true,
+          newPosition: i,
+          remainingText: ""
+        };
+      }
+      i++;
+    }
+    return {
+      complete: false,
+      newPosition: i,
+      remainingText: htmlChunk.substring(position, i)
+    };
+  }
+}
+function processOpeningTag(tagName, tagId, htmlChunk, i, state, handleEvent) {
+  if (state.currentNode?.tagHandler?.isNonNesting) {
+    closeNode(state.currentNode, state, handleEvent);
+  }
+  const tagHandler = tagHandlers[tagId];
+  const result = processTagAttributes(htmlChunk, i, tagHandler);
+  if (!result.complete) {
+    return {
+      complete: false,
+      newPosition: i,
+      remainingText: `<${tagName}${result.attrBuffer}`,
+      selfClosing: false
+    };
+  }
+  const currentTagCount = state.depthMap[tagId];
+  state.depthMap[tagId] = currentTagCount + 1;
+  state.depth++;
+  i = result.newPosition;
+  if (state.currentNode) {
+    state.currentNode.currentWalkIndex = state.currentNode.currentWalkIndex || 0;
+  }
+  const currentWalkIndex = state.currentNode ? state.currentNode.currentWalkIndex++ : 0;
+  const tag = {
+    type: ELEMENT_NODE,
+    name: tagName,
+    attributes: result.attributes,
+    parent: state.currentNode,
+    depthMap: copyDepthMap(state.depthMap),
+    depth: state.depth,
+    index: currentWalkIndex,
+    regionId: state.currentNode?.regionId,
+    tagId,
+    tagHandler
+  };
+  state.lastTextNode = tag;
+  if (state.options?.plugins) {
+    runProcessAttributesHooks(tag, state);
+  }
+  handleEvent({ type: NodeEventEnter, node: tag });
+  const parentNode = tag;
+  parentNode.currentWalkIndex = 0;
+  state.currentNode = parentNode;
+  state.hasEncodedHtmlEntity = false;
+  if (result.selfClosing) {
+    closeNode(tag, state, handleEvent);
+    state.justClosedTag = true;
+  } else {
+    state.justClosedTag = false;
+  }
+  return {
+    complete: true,
+    newPosition: i,
+    remainingText: "",
+    selfClosing: result.selfClosing
+  };
+}
+function processTagAttributes(htmlChunk, position, tagHandler) {
+  let i = position;
+  const chunkLength = htmlChunk.length;
+  const selfClosing = tagHandler?.isSelfClosing || false;
+  const attrStartPos = i;
+  let insideQuote = false;
+  let quoteChar = 0;
+  let prevChar = 0;
+  while (i < chunkLength) {
+    const c = htmlChunk.charCodeAt(i);
+    if (insideQuote) {
+      if (c === quoteChar && prevChar !== BACKSLASH_CHAR) {
+        insideQuote = false;
+      }
+      i++;
+      continue;
+    } else if (c === QUOTE_CHAR || c === APOS_CHAR) {
+      insideQuote = true;
+      quoteChar = c;
+    } else if (c === SLASH_CHAR && i + 1 < chunkLength && htmlChunk.charCodeAt(i + 1) === GT_CHAR) {
+      const attrStr = htmlChunk.substring(attrStartPos, i).trim();
+      return {
+        complete: true,
+        newPosition: i + 2,
+        attributes: parseAttributes(attrStr),
+        selfClosing: true,
+        attrBuffer: attrStr
+      };
+    } else if (c === GT_CHAR) {
+      const attrStr = htmlChunk.substring(attrStartPos, i).trim();
+      return {
+        complete: true,
+        newPosition: i + 1,
+        attributes: parseAttributes(attrStr),
+        selfClosing,
+        attrBuffer: attrStr
+      };
+    }
+    i++;
+    prevChar = c;
+  }
+  return {
+    complete: false,
+    newPosition: i,
+    attributes: EMPTY_ATTRIBUTES,
+    selfClosing: false,
+    attrBuffer: htmlChunk.substring(attrStartPos, i)
+  };
+}
+function parseAttributes(attrStr) {
+  if (!attrStr)
+    return EMPTY_ATTRIBUTES;
+  const result = {};
+  const len = attrStr.length;
+  let i = 0;
+  const WHITESPACE = 0;
+  const NAME = 1;
+  const AFTER_NAME = 2;
+  const BEFORE_VALUE = 3;
+  const QUOTED_VALUE = 4;
+  const UNQUOTED_VALUE = 5;
+  let state = WHITESPACE;
+  let nameStart = 0;
+  let nameEnd = 0;
+  let valueStart = 0;
+  let quoteChar = 0;
+  let name = "";
+  while (i < len) {
+    const charCode = attrStr.charCodeAt(i);
+    const isSpace = isWhitespace(charCode);
+    switch (state) {
+      case WHITESPACE:
+        if (!isSpace) {
+          state = NAME;
+          nameStart = i;
+        }
+        break;
+      case NAME:
+        if (charCode === EQUALS_CHAR || isSpace) {
+          nameEnd = i;
+          name = attrStr.substring(nameStart, nameEnd).toLowerCase();
+          state = charCode === EQUALS_CHAR ? BEFORE_VALUE : AFTER_NAME;
+        }
+        break;
+      case AFTER_NAME:
+        if (charCode === EQUALS_CHAR) {
+          state = BEFORE_VALUE;
+        } else if (!isSpace) {
+          result[name] = "";
+          state = NAME;
+          nameStart = i;
+        }
+        break;
+      case BEFORE_VALUE:
+        if (charCode === QUOTE_CHAR || charCode === APOS_CHAR) {
+          quoteChar = charCode;
+          state = QUOTED_VALUE;
+          valueStart = i + 1;
+        } else if (!isSpace) {
+          state = UNQUOTED_VALUE;
+          valueStart = i;
+        }
+        break;
+      case QUOTED_VALUE:
+        if (charCode === BACKSLASH_CHAR && i + 1 < len) {
+          i++;
+        } else if (charCode === quoteChar) {
+          result[name] = attrStr.substring(valueStart, i);
+          state = WHITESPACE;
+        }
+        break;
+      case UNQUOTED_VALUE:
+        if (isSpace || charCode === GT_CHAR) {
+          result[name] = attrStr.substring(valueStart, i);
+          state = WHITESPACE;
+        }
+        break;
+    }
+    i++;
+  }
+  if (name) {
+    if (state === QUOTED_VALUE || state === UNQUOTED_VALUE) {
+      result[name] = attrStr.substring(valueStart, i);
+    } else if (state === NAME || state === AFTER_NAME || state === BEFORE_VALUE) {
+      nameEnd = nameEnd || i;
+      name = name || attrStr.substring(nameStart, nameEnd).toLowerCase();
+      result[name] = "";
+    }
+  }
+  return result;
+}
+function processPartialHTMLToMarkdown(partialHtml, state = {}) {
+  state.depthMap ??= new Uint8Array(MAX_TAG_ID);
+  state.plugins = [...state.options?.plugins || []];
+  state.regionToggles ??= /* @__PURE__ */ new Map();
+  state.regionContentBuffers ??= /* @__PURE__ */ new Map();
+  state.regionToggles.set(0, true);
+  state.regionContentBuffers.set(0, []);
+  const fullState = state;
+  function handleEvent(event) {
+    for (const plugin of fullState.plugins || []) {
+      const res = plugin.beforeNodeProcess?.(event, fullState);
+      if (typeof res === "object" && res.skip) {
+        return;
+      }
+    }
+    if (event.node.type === TEXT_NODE) {
+      processHtmlEventToMarkdown(event, fullState);
+      return;
+    }
+    processHtmlEventToMarkdown(event, fullState);
+  }
+  const unprocessedHtml = parseHTML(partialHtml, fullState, handleEvent);
+  const assembledContent = assembleBufferedContent(fullState);
+  return { chunk: assembledContent, remainingHTML: unprocessedHtml };
+}
+
+async function* streamHtmlToMarkdown(htmlStream, options = {}) {
+  if (!htmlStream) {
+    throw new Error("Invalid HTML stream provided");
+  }
+  const decoder = new TextDecoder();
+  const reader = htmlStream.getReader();
+  const state = {
+    options
+  };
+  let remainingHtml = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      const htmlContent = `${remainingHtml}${typeof value === "string" ? value : decoder.decode(value, { stream: true })}`;
+      const result = processPartialHTMLToMarkdown(htmlContent, state);
+      if (result.chunk) {
+        yield result.chunk;
+      }
+      remainingHtml = result.remainingHTML;
+    }
+  } finally {
+    if (remainingHtml) {
+      decoder.decode(new Uint8Array(0), { stream: false });
+    }
+    reader.releaseLock();
+  }
+}
+
+export { processPartialHTMLToMarkdown as p, streamHtmlToMarkdown as s };