@wdprlib/decompiler 0.1.0

package/dist/index.js

@@ -0,0 +1,2103 @@
+// packages/decompiler/src/html2ast/index.ts
+import { parseDocument } from "htmlparser2";
+
+// packages/decompiler/src/html2ast/context.ts
+class DecompileContext {
+  options;
+  footnoteContents = new Map;
+  tocIndex = 0;
+  constructor(options = {}) {
+    this.options = {
+      inlineFootnotes: options.inlineFootnotes ?? true
+    };
+  }
+  nextTocIndex() {
+    return this.tocIndex++;
+  }
+}
+
+// packages/decompiler/src/html2ast/recognizer.ts
+import { isTag as isTag11, isText } from "domhandler";
+
+// packages/decompiler/src/html2ast/text.ts
+import { text, lineBreak, horizontalRule } from "@wdprlib/ast";
+function recognizeText(data) {
+  return text(data);
+}
+function recognizeLineBreak() {
+  return lineBreak();
+}
+function recognizeHorizontalRule() {
+  return horizontalRule();
+}
+
+// packages/decompiler/src/html2ast/container.ts
+import { container } from "@wdprlib/ast";
+
+// packages/decompiler/src/html2ast/utils.ts
+function parseStyleProperties(style) {
+  return style.split(";").map((s) => s.trim()).filter((s) => s.length > 0).map((s) => {
+    const colonIndex = s.indexOf(":");
+    if (colonIndex === -1)
+      return null;
+    return {
+      property: s.slice(0, colonIndex).trim(),
+      value: s.slice(colonIndex + 1).trim()
+    };
+  }).filter((p) => p !== null);
+}
+function hasOnlyStyleProperty(style, property) {
+  const props = parseStyleProperties(style);
+  return props.length === 1 && props[0]?.property === property;
+}
+function getStyleValue(style, property) {
+  const props = parseStyleProperties(style);
+  const found = props.find((p) => p.property === property);
+  return found?.value ?? null;
+}
+function getTextContent(node) {
+  let result = "";
+  for (const child of node.childNodes) {
+    if (child.type === "text") {
+      result += child.data;
+    } else if ("childNodes" in child) {
+      result += getTextContent(child);
+    }
+  }
+  return result.replace(/\u00a0/g, " ");
+}
+
+// packages/decompiler/src/html2ast/container.ts
+function containerUnchecked(type, elements, attributes = {}) {
+  return container(type, elements, attributes);
+}
+function recognizeParagraph(node, rec) {
+  const attrs = extractAttributes(node, []);
+  const elements = rec(node);
+  return container("paragraph", elements, attrs);
+}
+function recognizeInlineFormat(node, type, rec) {
+  const attrs = extractAttributes(node, ["style"]);
+  const elements = rec(node);
+  return containerUnchecked(type, elements, attrs);
+}
+function recognizeSpanContainer(node, rec) {
+  const style = node.attribs.style ?? "";
+  if (hasOnlyStyleProperty(style, "text-decoration")) {
+    const value = getStyleValue(style, "text-decoration");
+    if (value === "underline") {
+      return recognizeInlineFormat(node, "underline", rec);
+    }
+    if (value === "line-through") {
+      return recognizeInlineFormat(node, "strikethrough", rec);
+    }
+  }
+  if (hasOnlyStyleProperty(style, "font-size")) {
+    const attrs2 = extractAttributes(node, []);
+    const elements2 = rec(node);
+    return container("size", elements2, attrs2);
+  }
+  if (hasOnlyStyleProperty(style, "white-space")) {
+    const value = getStyleValue(style, "white-space");
+    if (value === "pre-wrap") {
+      const textContent = getTextContent(node);
+      return { element: "raw", data: textContent };
+    }
+  }
+  if (style.includes("display: none") || style.includes("display:none")) {
+    const attrs2 = extractAttributes(node, []);
+    const elements2 = rec(node);
+    return container("span", elements2, attrs2);
+  }
+  if (style.includes("visibility: hidden") || style.includes("visibility:hidden")) {
+    const attrs2 = extractAttributes(node, []);
+    const elements2 = rec(node);
+    return container("span", elements2, attrs2);
+  }
+  const attrs = extractAttributes(node, []);
+  const elements = rec(node);
+  return container("span", elements, attrs);
+}
+function recognizeBlockquote(node, rec) {
+  const attrs = extractAttributes(node, []);
+  const elements = rec(node);
+  return container("blockquote", elements, attrs);
+}
+function recognizeDiv(node, rec) {
+  const style = node.attribs.style ?? "";
+  const alignMatch = style.match(/text-align:\s*(left|right|center|justify)/);
+  if (alignMatch) {
+    const align = alignMatch[1];
+    const attrs2 = extractAttributes(node, ["style"]);
+    const elements2 = rec(node);
+    return container({ align }, elements2, attrs2);
+  }
+  const attrs = extractAttributes(node, []);
+  const elements = rec(node);
+  return container("div", elements, attrs);
+}
+function extractAttributes(node, exclude) {
+  const attrs = {};
+  const excludeSet = new Set(exclude);
+  for (const [key, value] of Object.entries(node.attribs)) {
+    if (excludeSet.has(key))
+      continue;
+    if (key === "id" && /^toc\d+/.test(value))
+      continue;
+    attrs[key] = value;
+  }
+  return Object.keys(attrs).length > 0 ? attrs : {};
+}
+
+// packages/decompiler/src/html2ast/heading.ts
+import { heading } from "@wdprlib/ast";
+import { isTag } from "domhandler";
+function recognizeHeading(node, ctx, rec) {
+  const levelStr = node.name.charAt(1);
+  const level = parseInt(levelStr, 10);
+  const id = node.attribs.id ?? "";
+  const hasToc = /^toc\d+/.test(id);
+  if (hasToc) {
+    ctx.nextTocIndex();
+  }
+  const innerChildren = unwrapSpan(node);
+  const elements = innerChildren.flatMap((child) => {
+    if (isTag(child)) {
+      return rec(child);
+    }
+    if (child.type === "text") {
+      const data = child.data;
+      if (data.trim() === "")
+        return [];
+      return [{ element: "text", data }];
+    }
+    return [];
+  });
+  return heading(level, elements, hasToc);
+}
+function unwrapSpan(node) {
+  for (const child of node.childNodes) {
+    if (isTag(child) && child.name === "span") {
+      return child.childNodes;
+    }
+  }
+  return node.childNodes;
+}
+
+// packages/decompiler/src/html2ast/link.ts
+import { link } from "@wdprlib/ast";
+function recognizeLink(node, _ctx, rec) {
+  const href = node.attribs.href ?? "";
+  const nameAttr = node.attribs.name;
+  if (nameAttr && !href) {
+    return [{ element: "anchor-name", data: nameAttr }];
+  }
+  if (href.startsWith("mailto:")) {
+    const email = href.slice(7);
+    return [{ element: "email", data: email }];
+  }
+  const target = parseTarget(node.attribs.target);
+  const labelElements = rec(node);
+  const labelText = extractTextContent(labelElements);
+  if (href === "javascript:;") {
+    const label2 = labelText ? { text: labelText } : { text: "" };
+    return [link(href, label2, { type: "anchor", target })];
+  }
+  if (href.startsWith("/") && !href.startsWith("//")) {
+    const pageName = href.slice(1).replace(/#.*$/, "");
+    const extra = href.includes("#") ? href.slice(href.indexOf("#")) : null;
+    const location = { site: null, page: pageName };
+    const label2 = labelText && labelText !== pageName ? { text: labelText } : "page";
+    return [link(location, label2, { type: "page", extra, target })];
+  }
+  const linkType = "direct";
+  const label = labelText && labelText !== href ? { text: labelText } : { url: href };
+  return [link(href, label, { type: linkType, target })];
+}
+function parseTarget(target) {
+  switch (target) {
+    case "_blank":
+      return "new-tab";
+    case "_parent":
+      return "parent";
+    case "_top":
+      return "top";
+    case "_self":
+      return "same";
+    default:
+      return null;
+  }
+}
+function extractTextContent(elements) {
+  let result = "";
+  for (const el of elements) {
+    if (el.element === "text") {
+      result += el.data;
+    }
+  }
+  return result;
+}
+
+// packages/decompiler/src/html2ast/image.ts
+import { isTag as isTag2 } from "domhandler";
+function recognizeImage(node) {
+  const src = node.attribs.src ?? "";
+  const source = parseImageSource(src);
+  const attrs = extractImageAttributes(node);
+  const linkLocation = findImageLink(node);
+  const alignment = findImageAlignment(node);
+  return {
+    element: "image",
+    data: {
+      source,
+      link: linkLocation,
+      alignment,
+      attributes: attrs
+    }
+  };
+}
+function recognizeImageContainer(node) {
+  const className = node.attribs.class ?? "";
+  if (!className.includes("image-container"))
+    return null;
+  const img = findDescendant(node, "img");
+  if (!img)
+    return null;
+  const src = img.attribs.src ?? "";
+  const source = parseImageSource(src);
+  const attrs = extractImageAttributes(img);
+  const linkLocation = findImageLink(img);
+  const alignment = parseAlignmentFromClass(className);
+  return {
+    element: "image",
+    data: {
+      source,
+      link: linkLocation,
+      alignment,
+      attributes: attrs
+    }
+  };
+}
+function parseImageSource(src) {
+  if (src.startsWith("http://") || src.startsWith("https://") || src.startsWith("/")) {
+    return { type: "url", data: src };
+  }
+  return { type: "url", data: src };
+}
+function extractImageAttributes(node) {
+  const attrs = {};
+  if (node.attribs.alt)
+    attrs.alt = node.attribs.alt;
+  if (node.attribs.width)
+    attrs.width = node.attribs.width;
+  if (node.attribs.height)
+    attrs.height = node.attribs.height;
+  if (node.attribs.class && node.attribs.class !== "image") {
+    attrs.class = node.attribs.class;
+  }
+  if (node.attribs.style)
+    attrs.style = node.attribs.style;
+  return attrs;
+}
+function findImageLink(imgNode) {
+  const parent = imgNode.parent;
+  if (parent && isTag2(parent) && parent.name === "a") {
+    const href = parent.attribs.href;
+    if (href)
+      return href;
+  }
+  return null;
+}
+function findImageAlignment(imgNode) {
+  const parent = imgNode.parent;
+  if (parent && isTag2(parent)) {
+    const containerNode = parent.name === "a" ? parent.parent : parent;
+    if (containerNode && isTag2(containerNode)) {
+      const className = containerNode.attribs.class ?? "";
+      if (className.includes("image-container")) {
+        return parseAlignmentFromClass(className);
+      }
+    }
+  }
+  return null;
+}
+function parseAlignmentFromClass(className) {
+  const floatMatch = className.match(/float(left|right|center)/);
+  if (floatMatch) {
+    return { align: floatMatch[1], float: true };
+  }
+  const alignMatch = className.match(/align(left|right|center)/);
+  if (alignMatch) {
+    return { align: alignMatch[1], float: false };
+  }
+  return null;
+}
+function findDescendant(node, tagName) {
+  for (const child of node.childNodes) {
+    if (isTag2(child)) {
+      if (child.name === tagName)
+        return child;
+      const found = findDescendant(child, tagName);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+}
+
+// packages/decompiler/src/html2ast/list.ts
+import { list, listItemElements, listItemSubList } from "@wdprlib/ast";
+import { isTag as isTag3 } from "domhandler";
+function recognizeList(node, ctx, rec) {
+  const type = node.name === "ol" ? "numbered" : "bullet";
+  const items = recognizeListItems(node, ctx, rec);
+  return list(type, items);
+}
+function recognizeListItems(node, ctx, rec) {
+  const items = [];
+  for (const child of node.childNodes) {
+    if (!isTag3(child))
+      continue;
+    if (child.name === "li") {
+      items.push(recognizeListItem(child, ctx, rec));
+    }
+  }
+  return items;
+}
+function recognizeListItem(node, ctx, rec) {
+  for (const child of node.childNodes) {
+    if (isTag3(child) && (child.name === "ul" || child.name === "ol")) {
+      const subType = child.name === "ol" ? "numbered" : "bullet";
+      const subItems = recognizeListItems(child, ctx, rec);
+      const subData = { type: subType, attributes: {}, items: subItems };
+      const precedingElements = collectPrecedingElements(node, child, rec);
+      if (precedingElements.length > 0) {
+        return listItemElements([
+          ...precedingElements,
+          { element: "list", data: subData }
+        ]);
+      }
+      return listItemSubList(subData);
+    }
+  }
+  const elements = rec(node);
+  return listItemElements(elements);
+}
+function collectPrecedingElements(parent, stopAt, rec) {
+  const elements = [];
+  for (const child of parent.childNodes) {
+    if (child === stopAt)
+      break;
+    if (isTag3(child)) {
+      if (child.name !== "ul" && child.name !== "ol") {
+        elements.push(...rec(child));
+      }
+    } else if (child.type === "text") {
+      const data = child.data.trim();
+      if (data) {
+        elements.push({ element: "text", data: child.data });
+      }
+    }
+  }
+  return elements;
+}
+function recognizeDefinitionList(node, _ctx, rec) {
+  const items = [];
+  let currentKey = [];
+  let currentKeyString = "";
+  for (const child of node.childNodes) {
+    if (!isTag3(child))
+      continue;
+    if (child.name === "dt") {
+      currentKey = rec(child);
+      currentKeyString = extractText(child);
+    } else if (child.name === "dd") {
+      const value = rec(child);
+      items.push({
+        key_string: currentKeyString,
+        key: currentKey,
+        value
+      });
+      currentKey = [];
+      currentKeyString = "";
+    }
+  }
+  return { element: "definition-list", data: items };
+}
+function extractText(node) {
+  let result = "";
+  for (const child of node.childNodes) {
+    if (child.type === "text") {
+      result += child.data;
+    } else if (isTag3(child)) {
+      result += extractText(child);
+    }
+  }
+  return result;
+}
+
+// packages/decompiler/src/html2ast/table.ts
+import { isTag as isTag4 } from "domhandler";
+function recognizeTable(node, _ctx, rec) {
+  const rows = [];
+  const rowContainers = findRowContainers(node);
+  for (const container2 of rowContainers) {
+    for (const child of container2.childNodes) {
+      if (!isTag4(child) || child.name !== "tr")
+        continue;
+      rows.push(recognizeRow(child, rec));
+    }
+  }
+  const data = {
+    attributes: {},
+    rows
+  };
+  return { element: "table", data };
+}
+function findRowContainers(table) {
+  const containers = [];
+  for (const child of table.childNodes) {
+    if (!isTag4(child))
+      continue;
+    if (child.name === "tbody" || child.name === "thead" || child.name === "tfoot") {
+      containers.push(child);
+    } else if (child.name === "tr") {
+      containers.push(table);
+      return containers;
+    }
+  }
+  if (containers.length === 0)
+    containers.push(table);
+  return containers;
+}
+function recognizeRow(node, rec) {
+  const cells = [];
+  for (const child of node.childNodes) {
+    if (!isTag4(child))
+      continue;
+    if (child.name === "td" || child.name === "th") {
+      cells.push(recognizeCell(child, rec));
+    }
+  }
+  return { attributes: {}, cells };
+}
+function recognizeCell(node, rec) {
+  const header = node.name === "th";
+  const colspanStr = node.attribs.colspan;
+  const columnSpan = colspanStr ? parseInt(colspanStr, 10) : 1;
+  const style = node.attribs.style ?? "";
+  const alignMatch = style.match(/text-align:\s*(left|right|center|justify)/);
+  const align = alignMatch ? alignMatch[1] : null;
+  const elements = rec(node);
+  return {
+    header,
+    "column-span": columnSpan,
+    align,
+    attributes: {},
+    elements
+  };
+}
+
+// packages/decompiler/src/html2ast/code.ts
+import { isTag as isTag5 } from "domhandler";
+function recognizeCodeBlock(node) {
+  const data = extractCodeBlockData(node);
+  return { element: "code", data };
+}
+function extractCodeBlockData(node) {
+  const hlMain = findByClass(node, "hl-main");
+  if (hlMain) {
+    const pre2 = findTag(hlMain, "pre");
+    const contents = pre2 ? extractPlainText(pre2) : "";
+    return { contents, language: null, name: null };
+  }
+  const pre = findTag(node, "pre");
+  if (pre) {
+    const code = findTag(pre, "code");
+    const contents = code ? extractPlainText(code) : extractPlainText(pre);
+    return { contents, language: null, name: null };
+  }
+  return { contents: "", language: null, name: null };
+}
+function findByClass(node, className) {
+  for (const child of node.childNodes) {
+    if (!isTag5(child))
+      continue;
+    if ((child.attribs.class ?? "").includes(className))
+      return child;
+    const found = findByClass(child, className);
+    if (found)
+      return found;
+  }
+  return null;
+}
+function findTag(node, tagName) {
+  for (const child of node.childNodes) {
+    if (isTag5(child) && child.name === tagName)
+      return child;
+  }
+  return null;
+}
+function extractPlainText(node) {
+  let result = "";
+  for (const child of node.childNodes) {
+    if (child.type === "text") {
+      result += child.data;
+    } else if (isTag5(child)) {
+      result += extractPlainText(child);
+    }
+  }
+  return result;
+}
+
+// packages/decompiler/src/html2ast/collapsible.ts
+import { isTag as isTag6 } from "domhandler";
+function recognizeCollapsible(node, _ctx, rec) {
+  let showText = null;
+  let hideText = null;
+  let startOpen = false;
+  let showTop = true;
+  let showBottom = false;
+  let contentElements = [];
+  const folded = findByClass2(node, "collapsible-block-folded");
+  const unfolded = findByClass2(node, "collapsible-block-unfolded");
+  if (folded) {
+    const style = folded.attribs.style ?? "";
+    startOpen = style.includes("display:none") || style.includes("display: none");
+    const linkText = extractLinkText(folded);
+    if (linkText) {
+      showText = cleanCollapsibleLabel(linkText);
+    }
+  }
+  if (unfolded) {
+    const content = findByClass2(unfolded, "collapsible-block-content");
+    if (content) {
+      contentElements = rec(content);
+    }
+    const linkText = extractLinkText(unfolded);
+    if (linkText) {
+      hideText = cleanCollapsibleLabel(linkText);
+    }
+    const unfoldedLinks = findAllByClass(unfolded, "collapsible-block-unfolded-link");
+    if (unfoldedLinks.length === 2) {
+      showTop = true;
+      showBottom = true;
+    } else if (unfoldedLinks.length === 1) {
+      const link2 = unfoldedLinks[0];
+      const contentDiv = findByClass2(unfolded, "collapsible-block-content");
+      if (contentDiv) {
+        const linkIndex = getChildIndex(unfolded, link2);
+        const contentIndex = getChildIndex(unfolded, contentDiv);
+        showTop = linkIndex < contentIndex;
+        showBottom = linkIndex > contentIndex;
+      }
+    }
+  }
+  const isDefaultShow = showText === null || showText === "+ show block";
+  const isDefaultHide = hideText === null || hideText === "- hide block";
+  const data = {
+    elements: contentElements,
+    attributes: {},
+    "start-open": startOpen,
+    "show-text": isDefaultShow ? null : showText,
+    "hide-text": isDefaultHide ? null : hideText,
+    "show-top": showTop,
+    "show-bottom": showBottom
+  };
+  return { element: "collapsible", data };
+}
+function cleanCollapsibleLabel(text2) {
+  return text2.replace(/\u00a0/g, " ").replace(/^[+–-]\s*/, "").replace(/\s+/g, " ").trim();
+}
+function extractLinkText(node) {
+  const link2 = findByClass2(node, "collapsible-block-link");
+  if (!link2)
+    return null;
+  return getTextContent2(link2);
+}
+function getTextContent2(node) {
+  let result = "";
+  for (const child of node.childNodes) {
+    if (child.type === "text") {
+      result += child.data;
+    } else if (isTag6(child)) {
+      result += getTextContent2(child);
+    }
+  }
+  return result;
+}
+function findByClass2(node, className) {
+  for (const child of node.childNodes) {
+    if (!isTag6(child))
+      continue;
+    const classes = (child.attribs.class ?? "").split(/\s+/);
+    if (classes.includes(className))
+      return child;
+    const found = findByClass2(child, className);
+    if (found)
+      return found;
+  }
+  return null;
+}
+function findAllByClass(node, className) {
+  const results = [];
+  for (const child of node.childNodes) {
+    if (!isTag6(child))
+      continue;
+    const classes = (child.attribs.class ?? "").split(/\s+/);
+    if (classes.includes(className))
+      results.push(child);
+  }
+  return results;
+}
+function getChildIndex(parent, child) {
+  let index = 0;
+  for (const c of parent.childNodes) {
+    if (c === child)
+      return index;
+    if (isTag6(c))
+      index++;
+  }
+  return -1;
+}
+
+// packages/decompiler/src/html2ast/tab-view.ts
+import { isTag as isTag7 } from "domhandler";
+function recognizeTabView(node, _ctx, rec) {
+  const labels = [];
+  const tabs = [];
+  const nav = findByClass3(node, "yui-nav");
+  if (nav) {
+    for (const li of nav.childNodes) {
+      if (!isTag7(li) || li.name !== "li")
+        continue;
+      const em = findDescendantTag(li, "em");
+      if (em) {
+        labels.push(getTextContent3(em));
+      }
+    }
+  }
+  const content = findByClass3(node, "yui-content");
+  if (content) {
+    let tabIndex = 0;
+    for (const child of content.childNodes) {
+      if (!isTag7(child) || child.name !== "div")
+        continue;
+      const label = labels[tabIndex] ?? `Tab ${tabIndex + 1}`;
+      const elements = rec(child);
+      tabs.push({ label, elements });
+      tabIndex++;
+    }
+  }
+  return { element: "tab-view", data: tabs };
+}
+function findByClass3(node, className) {
+  for (const child of node.childNodes) {
+    if (!isTag7(child))
+      continue;
+    const classes = (child.attribs.class ?? "").split(/\s+/);
+    if (classes.includes(className))
+      return child;
+    const found = findByClass3(child, className);
+    if (found)
+      return found;
+  }
+  return null;
+}
+function findDescendantTag(node, tagName) {
+  for (const child of node.childNodes) {
+    if (isTag7(child)) {
+      if (child.name === tagName)
+        return child;
+      const found = findDescendantTag(child, tagName);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+}
+function getTextContent3(node) {
+  let result = "";
+  for (const child of node.childNodes) {
+    if (child.type === "text") {
+      result += child.data;
+    } else if (isTag7(child)) {
+      result += getTextContent3(child);
+    }
+  }
+  return result;
+}
+
+// packages/decompiler/src/html2ast/footnote.ts
+import { isTag as isTag8 } from "domhandler";
+function recognizeFootnoteRef(node, _ctx) {
+  const link2 = findDescendantTag2(node, "a");
+  const refText = link2 ? getTextContent4(link2) : "1";
+  const refNum = parseInt(refText, 10) || 1;
+  return { element: "footnote-ref", data: refNum };
+}
+function recognizeFootnotesFooter(node, ctx, rec) {
+  for (const child of node.childNodes) {
+    if (!isTag8(child))
+      continue;
+    const classes = (child.attribs.class ?? "").split(/\s+/);
+    if (!classes.includes("footnote-footer"))
+      continue;
+    const id = child.attribs.id ?? "";
+    const match = id.match(/footnote-(\d+)/);
+    const num = match ? parseInt(match[1], 10) : 0;
+    if (num === 0)
+      continue;
+    const content = extractFootnoteContent(child, rec);
+    ctx.footnoteContents.set(num, content);
+  }
+  return [{ element: "footnote-block", data: { title: null } }];
+}
+function extractFootnoteContent(node, rec) {
+  const elements = [];
+  let pastLink = false;
+  let pastDotSpace = false;
+  for (const child of node.childNodes) {
+    if (!pastLink) {
+      if (isTag8(child) && child.name === "a") {
+        pastLink = true;
+        continue;
+      }
+      continue;
+    }
+    if (!pastDotSpace) {
+      if (child.type === "text") {
+        const data = child.data.replace(/^\.\s*/, "");
+        if (data) {
+          elements.push({ element: "text", data });
+        }
+        pastDotSpace = true;
+        continue;
+      }
+    }
+    if (isTag8(child)) {
+      elements.push(...rec(child));
+    } else if (child.type === "text") {
+      const data = child.data;
+      if (data.trim()) {
+        elements.push({ element: "text", data });
+      }
+    }
+  }
+  return elements;
+}
+function findDescendantTag2(node, tagName) {
+  for (const child of node.childNodes) {
+    if (isTag8(child)) {
+      if (child.name === tagName)
+        return child;
+      const found = findDescendantTag2(child, tagName);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+}
+function getTextContent4(node) {
+  let result = "";
+  for (const child of node.childNodes) {
+    if (child.type === "text") {
+      result += child.data;
+    } else if (isTag8(child)) {
+      result += getTextContent4(child);
+    }
+  }
+  return result;
+}
+
+// packages/decompiler/src/html2ast/math.ts
+import { isTag as isTag9 } from "domhandler";
+function recognizeMathBlock(node) {
+  const source = findMathSource(node);
+  const name = node.attribs["data-name"] ?? null;
+  const data = {
+    name,
+    "latex-source": source
+  };
+  return { element: "math", data };
+}
+function recognizeMathInline(node) {
+  const source = findMathSource(node);
+  const data = {
+    "latex-source": source
+  };
+  return { element: "math-inline", data };
+}
+function findMathSource(node) {
+  for (const child of node.childNodes) {
+    if (!isTag9(child))
+      continue;
+    if (child.name === "code" && (child.attribs.class ?? "").includes("math-source")) {
+      return getTextContent5(child);
+    }
+  }
+  return "";
+}
+function getTextContent5(node) {
+  let result = "";
+  for (const child of node.childNodes) {
+    if (child.type === "text") {
+      result += child.data;
+    } else if (isTag9(child)) {
+      result += getTextContent5(child);
+    }
+  }
+  return result;
+}
+
+// packages/decompiler/src/html2ast/misc.ts
+import { isTag as isTag10 } from "domhandler";
+function recognizeColor(node, _ctx, rec) {
+  const style = node.attribs.style ?? "";
+  const match = style.match(/color:\s*([^;]+)/);
+  const color = match ? match[1].trim() : "inherit";
+  const elements = rec(node);
+  const data = { color, elements };
+  return { element: "color", data };
+}
+function recognizeClearFloat(node) {
+  const style = node.attribs.style ?? "";
+  if (!style.includes("clear:") && !style.includes("clear :"))
+    return null;
+  let direction = "both";
+  if (style.includes("clear:left") || style.includes("clear: left")) {
+    direction = "left";
+  } else if (style.includes("clear:right") || style.includes("clear: right")) {
+    direction = "right";
+  }
+  return { element: "clear-float", data: direction };
+}
+function recognizeEmbed(node) {
+  const className = node.attribs.class ?? "";
+  if (className.includes("embed-youtube")) {
+    const iframe = findDescendantTag3(node, "iframe");
+    if (!iframe)
+      return null;
+    const src = iframe.attribs.src ?? "";
+    const match = src.match(/youtube\.com\/embed\/([a-zA-Z0-9_-]+)/);
+    if (!match)
+      return null;
+    const data = { embed: "youtube", data: { "video-id": match[1] } };
+    return { element: "embed", data };
+  }
+  if (className.includes("embed-vimeo")) {
+    const iframe = findDescendantTag3(node, "iframe");
+    if (!iframe)
+      return null;
+    const src = iframe.attribs.src ?? "";
+    const match = src.match(/vimeo\.com\/video\/([a-zA-Z0-9_-]+)/);
+    if (!match)
+      return null;
+    const data = { embed: "vimeo", data: { "video-id": match[1] } };
+    return { element: "embed", data };
+  }
+  return null;
+}
+function recognizeIframe(node) {
+  const url = node.attribs.src ?? "";
+  const attrs = {};
+  const allowedAttrs = ["width", "height", "scrolling", "frameborder", "class", "style"];
+  for (const attr of allowedAttrs) {
+    if (node.attribs[attr]) {
+      attrs[attr] = node.attribs[attr];
+    }
+  }
+  const data = { url, attributes: attrs };
+  return { element: "iframe", data };
+}
+function recognizeStyle(node) {
+  const content = getTextContent6(node);
+  return { element: "style", data: content };
+}
+function findDescendantTag3(node, tagName) {
+  for (const child of node.childNodes) {
+    if (isTag10(child)) {
+      if (child.name === tagName)
+        return child;
+      const found = findDescendantTag3(child, tagName);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+}
+function getTextContent6(node) {
+  let result = "";
+  for (const child of node.childNodes) {
+    if (child.type === "text") {
+      result += child.data;
+    } else if (isTag10(child)) {
+      result += getTextContent6(child);
+    }
+  }
+  return result;
+}
+
+// packages/decompiler/src/html2ast/recognizer.ts
+function recognizeNode(node, ctx) {
+  if (isText(node)) {
+    const data = node.data;
+    if (/^\s*$/.test(data)) {
+      if (/[ \u00a0]/.test(data)) {
+        return [recognizeText(" ")];
+      }
+      return [];
+    }
+    return [recognizeText(data)];
+  }
+  if (!isTag11(node))
+    return [];
+  return recognizeElement(node, ctx);
+}
+function recognizeElement(node, ctx) {
+  const rec = (n) => recognizeChildren(n, ctx);
+  const className = node.attribs.class ?? "";
+  switch (node.name) {
+    case "p": {
+      const iframe = findDirectChild(node, "iframe");
+      if (iframe)
+        return [recognizeIframe(iframe)];
+      return [recognizeParagraph(node, rec)];
+    }
+    case "br":
+      return [recognizeLineBreak()];
+    case "hr":
+      return [recognizeHorizontalRule()];
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return [recognizeHeading(node, ctx, rec)];
+    case "strong":
+    case "b":
+      return [recognizeInlineFormat(node, "bold", rec)];
+    case "em":
+    case "i":
+      return [recognizeInlineFormat(node, "italics", rec)];
+    case "sup":
+      if (className.includes("footnoteref")) {
+        return [recognizeFootnoteRef(node, ctx)];
+      }
+      return [recognizeInlineFormat(node, "superscript", rec)];
+    case "sub":
+      return [recognizeInlineFormat(node, "subscript", rec)];
+    case "tt":
+      return [recognizeInlineFormat(node, "monospace", rec)];
+    case "mark":
+      return [recognizeInlineFormat(node, "mark", rec)];
+    case "ins":
+      return [recognizeInlineFormat(node, "insertion", rec)];
+    case "del":
+      return [recognizeInlineFormat(node, "deletion", rec)];
+    case "ruby":
+      return [recognizeInlineFormat(node, "ruby", rec)];
+    case "rt":
+      return [recognizeInlineFormat(node, "ruby-text", rec)];
+    case "span":
+      return recognizeSpanDispatch(node, ctx, rec);
+    case "a":
+      return recognizeLink(node, ctx, rec);
+    case "img":
+      return [recognizeImage(node)];
+    case "blockquote":
+      return [recognizeBlockquote(node, rec)];
+    case "div":
+      return recognizeDivDispatch(node, ctx, rec);
+    case "ul":
+    case "ol":
+      return [recognizeList(node, ctx, rec)];
+    case "dl":
+      return [recognizeDefinitionList(node, ctx, rec)];
+    case "table":
+      return [recognizeTable(node, ctx, rec)];
+    case "iframe":
+      return [recognizeIframe(node)];
+    case "style":
+      return [recognizeStyle(node)];
+    default:
+      return recognizeChildren(node, ctx);
+  }
+}
+function recognizeSpanDispatch(node, ctx, rec) {
+  const className = node.attribs.class ?? "";
+  const style = node.attribs.style ?? "";
+  if (className.includes("math-inline")) {
+    return [recognizeMathInline(node)];
+  }
+  if (hasOnlyStyleProperty(style, "color")) {
+    return [recognizeColor(node, ctx, rec)];
+  }
+  const result = recognizeSpanContainer(node, rec);
+  if (result)
+    return [result];
+  return rec(node);
+}
+function recognizeDivDispatch(node, ctx, rec) {
+  const className = node.attribs.class ?? "";
+  const style = node.attribs.style ?? "";
+  if (className === "code" || className.startsWith("code ")) {
+    return [recognizeCodeBlock(node)];
+  }
+  if (className.includes("collapsible-block") && !className.includes("collapsible-block-")) {
+    return [recognizeCollapsible(node, ctx, rec)];
+  }
+  if (className.includes("yui-navset")) {
+    return [recognizeTabView(node, ctx, rec)];
+  }
+  if (className.includes("image-container")) {
+    const img = recognizeImageContainer(node);
+    if (img)
+      return [img];
+  }
+  if (className.includes("footnotes-footer")) {
+    return recognizeFootnotesFooter(node, ctx, rec);
+  }
+  if (className.includes("math-block")) {
+    return [recognizeMathBlock(node)];
+  }
+  if (className.includes("embed-")) {
+    const embed = recognizeEmbed(node);
+    if (embed)
+      return [embed];
+  }
+  if (style.includes("clear:") || style.includes("clear :")) {
+    const cf = recognizeClearFloat(node);
+    if (cf)
+      return [cf];
+  }
+  const result = recognizeDiv(node, rec);
+  if (result)
+    return [result];
+  return recognizeChildren(node, ctx);
+}
+function findDirectChild(node, tagName) {
+  for (const child of node.childNodes) {
+    if (isTag11(child) && child.name === tagName)
+      return child;
+  }
+  return null;
+}
+function recognizeChildren(node, ctx) {
+  const elements = [];
+  for (const child of node.childNodes) {
+    elements.push(...recognizeNode(child, ctx));
+  }
+  return elements;
+}
+
+// packages/decompiler/src/html2ast/index.ts
+function htmlToAst(html, options) {
+  const document = parseDocument(html, { decodeEntities: true });
+  const ctx = new DecompileContext(options);
+  const elements = document.childNodes.flatMap((node) => recognizeNode(node, ctx));
+  const tree = { elements };
+  if (ctx.footnoteContents.size > 0) {
+    const footnotes = [];
+    for (const [index, content] of ctx.footnoteContents) {
+      footnotes[index - 1] = content;
+    }
+    tree.footnotes = footnotes;
+  }
+  return tree;
+}
+
+// packages/decompiler/src/serializer/context.ts
+class SerializeContext {
+  newline;
+  forceLineBreakSyntax = false;
+  insideBlockquote = false;
+  inParagraph = false;
+  buffer = [];
+  atLineStart = true;
+  _pendingBlankLine = "none";
+  constructor(options = {}) {
+    this.newline = options.newline ?? `
+`;
+  }
+  requestBlankLine() {
+    this._pendingBlankLine = "block";
+  }
+  requestParagraphBlankLine() {
+    if (this._pendingBlankLine === "none") {
+      this._pendingBlankLine = "paragraph";
+    }
+  }
+  flushPendingBlankLine() {
+    if (this._pendingBlankLine !== "none") {
+      this.buffer.push(this.newline);
+      this._pendingBlankLine = "none";
+    }
+  }
+  clearPendingBlankLine() {
+    this._pendingBlankLine = "none";
+  }
+  get hasPendingBlankLine() {
+    return this._pendingBlankLine !== "none";
+  }
+  push(text2) {
+    this.flushPendingBlankLine();
+    this.buffer.push(text2);
+    this.atLineStart = text2.endsWith(this.newline);
+  }
+  pushBlockLine(text2) {
+    if (this._pendingBlankLine === "block") {
+      this.flushPendingBlankLine();
+    } else {
+      this.clearPendingBlankLine();
+    }
+    this.buffer.push(text2 + this.newline);
+    this.atLineStart = true;
+  }
+  pushLine(text2) {
+    this.push(text2 + this.newline);
+  }
+  pushBlankLine() {
+    this.push(this.newline);
+  }
+  isAtLineStart() {
+    return this.atLineStart;
+  }
+  getOutput() {
+    return this.buffer.join("");
+  }
+  getBlockInnerOutput() {
+    let output = this.getOutput();
+    const nl = this.newline;
+    while (output.endsWith(nl + nl)) {
+      output = output.slice(0, -nl.length);
+    }
+    return output;
+  }
+}
+
+// packages/decompiler/src/serializer/text.ts
+var UNICODE_TO_SOURCE = [
+  ["«", "<<"],
+  ["»", ">>"],
+  ["—", "--"]
+];
+function serializeText(ctx, data) {
+  let text2 = data;
+  for (const [unicode, source] of UNICODE_TO_SOURCE) {
+    text2 = text2.replaceAll(unicode, source);
+  }
+  ctx.push(text2);
+}
+function serializeRaw(ctx, data) {
+  ctx.push(`@@${data}@@`);
+}
+function serializeLineBreak(ctx) {
+  if (ctx.isAtLineStart() || ctx.forceLineBreakSyntax) {
+    ctx.push(" _" + ctx.newline);
+  } else {
+    ctx.push(ctx.newline);
+  }
+}
+function serializeHorizontalRule(ctx) {
+  ctx.pushBlockLine("----");
+  ctx.requestBlankLine();
+}
+function serializeContentSeparator(ctx) {
+  ctx.pushBlockLine("====");
+}
+function serializeEmail(ctx, data) {
+  ctx.push(data);
+}
+
+// packages/decompiler/src/serializer/container.ts
+import { isHeaderType, isAlignType, isStringContainerType } from "@wdprlib/ast";
+function serializeContainer(ctx, data) {
+  const { type, elements, attributes } = data;
+  if (isHeaderType(type)) {
+    serializeHeading(ctx, type.header.level, type.header["has-toc"], elements);
+    return;
+  }
+  if (isAlignType(type)) {
+    serializeAlignment(ctx, type.align, elements);
+    return;
+  }
+  if (isStringContainerType(type)) {
+    serializeStringContainer(ctx, type, elements, attributes);
+    return;
+  }
+  const typeStr = type;
+  switch (typeStr) {
+    case "mark":
+    case "insertion":
+    case "deletion":
+      serializeSpanLike(ctx, typeStr, elements, attributes);
+      return;
+    case "ruby":
+      serializeElements(ctx, elements);
+      return;
+    case "ruby-text":
+      serializeElements(ctx, elements);
+      return;
+    default:
+      serializeElements(ctx, elements);
+  }
+}
+function serializeHeading(ctx, level, hasToc, elements) {
+  const prefix = "+".repeat(level);
+  const tocMarker = hasToc ? "" : "*";
+  ctx.pushBlockLine(prefix + tocMarker + " " + serializeInline(ctx, elements));
+  ctx.requestBlankLine();
+}
+function serializeAlignment(ctx, align, elements) {
+  const tag = alignTag(align);
+  ctx.pushBlockLine(`[[${tag}]]`);
+  const inner = serializeBlockInner(ctx, elements);
+  ctx.push(inner);
+  ctx.pushBlockLine(`[[/${tag}]]`);
+  ctx.requestBlankLine();
+}
+function alignTag(align) {
+  switch (align) {
+    case "center":
+      return "=";
+    case "right":
+      return ">";
+    case "left":
+      return "<";
+    case "justify":
+      return "==";
+  }
+}
+function serializeStringContainer(ctx, type, elements, attributes) {
+  switch (type) {
+    case "paragraph": {
+      const style = attributes.style ?? "";
+      const prevInParagraph = ctx.inParagraph;
+      ctx.inParagraph = true;
+      if (style === "text-align: center;") {
+        ctx.pushBlockLine("= " + serializeInline(ctx, elements));
+        ctx.requestParagraphBlankLine();
+      } else {
+        serializeElements(ctx, elements);
+        ctx.push(ctx.newline);
+        ctx.requestParagraphBlankLine();
+      }
+      ctx.inParagraph = prevInParagraph;
+      break;
+    }
+    case "bold":
+      ctx.push("**");
+      serializeElements(ctx, elements);
+      ctx.push("**");
+      break;
+    case "italics":
+      ctx.push("//");
+      serializeElements(ctx, elements);
+      ctx.push("//");
+      break;
+    case "underline":
+      ctx.push("__");
+      serializeElements(ctx, elements);
+      ctx.push("__");
+      break;
+    case "strikethrough":
+      ctx.push("--");
+      serializeElements(ctx, elements);
+      ctx.push("--");
+      break;
+    case "superscript":
+      ctx.push("^^");
+      serializeElements(ctx, elements);
+      ctx.push("^^");
+      break;
+    case "subscript":
+      ctx.push(",,");
+      serializeElements(ctx, elements);
+      ctx.push(",,");
+      break;
+    case "monospace":
+      ctx.push("{{");
+      serializeElements(ctx, elements);
+      ctx.push("}}");
+      break;
+    case "span":
+      if (!ctx.inParagraph) {
+        serializeBlockSpan(ctx, elements, attributes);
+      } else {
+        serializeSpanLike(ctx, "span", elements, attributes);
+      }
+      break;
+    case "div":
+      serializeDivContainer(ctx, elements, attributes);
+      break;
+    case "blockquote":
+      serializeBlockquote(ctx, elements);
+      break;
+    case "size":
+      serializeSizeContainer(ctx, elements, attributes);
+      break;
+    default:
+      serializeElements(ctx, elements);
+  }
+}
+function serializeSpanLike(ctx, type, elements, attributes) {
+  const attrs = { ...attributes };
+  if (type !== "span") {
+    attrs.class = type;
+  }
+  const attrStr = formatAttributes(attrs);
+  ctx.push(`[[span${attrStr}]]`);
+  serializeElements(ctx, elements);
+  ctx.push("[[/span]]");
+}
+function serializeBlockSpan(ctx, elements, attributes) {
+  const attrStr = formatAttributes(attributes);
+  const innerCtx = new SerializeContext({ newline: ctx.newline });
+  innerCtx.inParagraph = true;
+  serializeElements(innerCtx, elements);
+  const content = innerCtx.getOutput().replace(/\n$/, "");
+  ctx.pushBlockLine(`[[span_${attrStr}]]${content}[[/span]]`);
+  ctx.requestParagraphBlankLine();
+}
+function serializeDivContainer(ctx, elements, attributes) {
+  const attrStr = formatAttributes(attributes);
+  const isParagraphStrip = elements.length > 0 && (isInlineTextElement(elements[0]) || isInlineTextElement(elements[elements.length - 1]));
+  const openTag = isParagraphStrip ? "div_" : "div";
+  ctx.pushBlockLine(`[[${openTag}${attrStr}]]`);
+  if (isParagraphStrip) {
+    const inner = serializeDivStripInner(ctx, elements);
+    ctx.push(inner);
+  } else {
+    const inner = serializeBlockInner(ctx, elements);
+    ctx.push(inner);
+  }
+  ctx.pushBlockLine("[[/div]]");
+  ctx.requestBlankLine();
+}
+function serializeDivStripInner(parentCtx, elements) {
+  const innerCtx = new SerializeContext({ newline: parentCtx.newline });
+  let i = 0;
+  while (i < elements.length) {
+    const el = elements[i];
+    if (isBlockLevelElement(el)) {
+      serializeElement(innerCtx, el);
+      i++;
+    } else {
+      while (i < elements.length && !isBlockLevelElement(elements[i])) {
+        serializeElement(innerCtx, elements[i]);
+        i++;
+      }
+      innerCtx.push(innerCtx.newline);
+      innerCtx.requestParagraphBlankLine();
+    }
+  }
+  return innerCtx.getBlockInnerOutput();
+}
+function isBlockLevelElement(el) {
+  switch (el.element) {
+    case "container": {
+      const type = el.data?.type;
+      if (typeof type === "object")
+        return true;
+      if (typeof type === "string") {
+        return type === "paragraph" || type === "div" || type === "blockquote";
+      }
+      return false;
+    }
+    case "list":
+    case "definition-list":
+    case "table":
+    case "horizontal-rule":
+    case "clear-float":
+    case "code":
+    case "collapsible":
+    case "tab-view":
+    case "footnote-block":
+    case "style":
+    case "embed":
+    case "embed-block":
+    case "iframe":
+    case "content-separator":
+    case "math":
+    case "bibliography-block":
+      return true;
+    default:
+      return false;
+  }
+}
+function isInlineTextElement(el) {
+  switch (el.element) {
+    case "text":
+    case "line-break":
+    case "line-breaks":
+    case "raw":
+    case "variable":
+    case "email":
+    case "link":
+    case "anchor":
+    case "anchor-name":
+    case "footnote":
+    case "footnote-ref":
+    case "bibliography-cite":
+    case "user":
+    case "date":
+    case "color":
+    case "math-inline":
+    case "equation-reference":
+    case "expr":
+      return true;
+    case "container": {
+      const type = el.data?.type;
+      if (typeof type === "string") {
+        switch (type) {
+          case "bold":
+          case "italics":
+          case "underline":
+          case "strikethrough":
+          case "superscript":
+          case "subscript":
+          case "monospace":
+          case "span":
+          case "size":
+            return true;
+        }
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+function serializeBlockquote(ctx, elements) {
+  const innerCtx = new SerializeContext({ newline: ctx.newline });
+  innerCtx.insideBlockquote = true;
+  serializeElements(innerCtx, elements);
+  const inner = innerCtx.getBlockInnerOutput();
+  const lines = inner.split(ctx.newline);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (i === lines.length - 1 && line === "")
+      break;
+    if (line.startsWith(">")) {
+      ctx.pushBlockLine(`>${line}`);
+    } else if (line === "") {
+      ctx.pushBlockLine("> ");
+    } else {
+      ctx.pushBlockLine(`> ${line}`);
+    }
+  }
+  if (!ctx.insideBlockquote) {
+    ctx.requestBlankLine();
+  }
+}
+function serializeSizeContainer(ctx, elements, attributes) {
+  const style = attributes.style ?? "";
+  const match = style.match(/font-size:\s*([^;]+)/);
+  const size = match ? match[1].trim() : "1em";
+  ctx.push(`[[size ${size}]]`);
+  serializeElements(ctx, elements);
+  ctx.push("[[/size]]");
+}
+function serializeBlockInner(parentCtx, elements) {
+  const innerCtx = new SerializeContext({ newline: parentCtx.newline });
+  serializeElements(innerCtx, elements);
+  return innerCtx.getBlockInnerOutput();
+}
+function serializeInline(parentCtx, elements) {
+  const innerCtx = new SerializeContext({ newline: parentCtx.newline });
+  serializeElements(innerCtx, elements);
+  return innerCtx.getOutput().replace(/\n$/, "");
+}
+function formatAttributes(attributes) {
+  const entries = Object.entries(attributes).filter(([k]) => !k.startsWith("_"));
+  if (entries.length === 0)
+    return "";
+  return " " + entries.map(([k, v]) => {
+    if (k === "id" && v.startsWith("u-")) {
+      return `${k}="${v.slice(2)}"`;
+    }
+    return `${k}="${v}"`;
+  }).join(" ");
+}
+
+// packages/decompiler/src/serializer/link.ts
+function serializeLink(ctx, data) {
+  const { type, link: location, label, target, extra } = data;
+  switch (type) {
+    case "anchor": {
+      const labelText = extractLabelText(label);
+      ctx.push(`[# ${labelText}]`);
+      break;
+    }
+    case "page": {
+      const pageName = typeof location === "string" ? location : location.site ? `${location.site}:${location.page}` : location.page;
+      const targetSuffix = target === "new-tab" ? "*" : "";
+      const extraSuffix = extra ?? "";
+      const labelText = extractLabelText(label);
+      if (label === "page" || labelText === pageName) {
+        ctx.push(`[[[${pageName}${extraSuffix}${targetSuffix}]]]`);
+      } else {
+        ctx.push(`[[[${pageName}${extraSuffix}${targetSuffix} | ${labelText}]]]`);
+      }
+      break;
+    }
+    case "direct": {
+      const url = typeof location === "string" ? location : "";
+      const labelText = extractLabelText(label);
+      const targetPrefix = target === "new-tab" ? "*" : "";
+      if (labelIsUrl(label, url)) {
+        ctx.push(`[${targetPrefix}${url}]`);
+      } else {
+        ctx.push(`[${targetPrefix}${url} ${labelText}]`);
+      }
+      break;
+    }
+    default: {
+      const labelText = extractLabelText(label);
+      ctx.push(labelText || (typeof location === "string" ? location : ""));
+    }
+  }
+}
+function serializeAnchorName(ctx, name) {
+  ctx.push(`[[# ${name}]]`);
+}
+function extractLabelText(label) {
+  if (label === "page")
+    return "";
+  if ("text" in label)
+    return label.text;
+  if ("url" in label)
+    return label.url ?? "";
+  return "";
+}
+function labelIsUrl(label, url) {
+  if (label === "page")
+    return false;
+  if ("url" in label)
+    return true;
+  if ("text" in label)
+    return label.text === url;
+  return false;
+}
+
+// packages/decompiler/src/serializer/image.ts
+function serializeImage(ctx, data) {
+  const source = formatImageSource(data.source);
+  const attrs = [];
+  let alignPrefix = "";
+  if (data.alignment) {
+    const { align, float: isFloat } = data.alignment;
+    if (isFloat) {
+      switch (align) {
+        case "left":
+          alignPrefix = "f<";
+          break;
+        case "right":
+          alignPrefix = "f>";
+          break;
+        case "center":
+          alignPrefix = "f=";
+          break;
+      }
+    } else {
+      switch (align) {
+        case "left":
+          alignPrefix = "<";
+          break;
+        case "right":
+          alignPrefix = ">";
+          break;
+        case "center":
+          alignPrefix = "=";
+          break;
+      }
+    }
+  }
+  if (data.link) {
+    const link2 = typeof data.link === "string" ? data.link : data.link.page;
+    attrs.push(`link="${link2}"`);
+  }
+  for (const [key, value] of Object.entries(data.attributes)) {
+    if (key === "class" && value === "image")
+      continue;
+    attrs.push(`${key}="${value}"`);
+  }
+  const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+  ctx.push(`[[${alignPrefix}image ${source}${attrStr}]]`);
+}
+function formatImageSource(source) {
+  switch (source.type) {
+    case "url":
+      return source.data;
+    case "file1":
+      return source.data.file;
+    case "file2":
+      return `${source.data.page}/${source.data.file}`;
+    case "file3":
+      return `${source.data.site}:${source.data.page}/${source.data.file}`;
+  }
+}
+
+// packages/decompiler/src/serializer/list.ts
+function serializeList(ctx, data, depth = 0) {
+  const marker = data.type === "numbered" ? "#" : "*";
+  const prefix = " ".repeat(depth) + marker;
+  const prevForce = ctx.forceLineBreakSyntax;
+  ctx.forceLineBreakSyntax = true;
+  for (const item of data.items) {
+    if (item["item-type"] === "sub-list") {
+      serializeList(ctx, item.data, depth + 1);
+    } else {
+      ctx.push(`${prefix} `);
+      serializeElements(ctx, item.elements);
+      ctx.push(ctx.newline);
+    }
+  }
+  ctx.forceLineBreakSyntax = prevForce;
+  if (depth === 0) {
+    ctx.requestBlankLine();
+  }
+}
+function serializeDefinitionList(ctx, items) {
+  const prevForce = ctx.forceLineBreakSyntax;
+  ctx.forceLineBreakSyntax = true;
+  for (const item of items) {
+    ctx.push(": ");
+    serializeElements(ctx, item.key);
+    ctx.push(" : ");
+    serializeElements(ctx, item.value);
+    ctx.push(ctx.newline);
+  }
+  ctx.forceLineBreakSyntax = prevForce;
+  ctx.requestBlankLine();
+}
+
+// packages/decompiler/src/serializer/table.ts
+function serializeTable(ctx, data) {
+  for (const row of data.rows) {
+    for (const cell of row.cells) {
+      let prefix = "||";
+      for (let i = 1;i < cell["column-span"]; i++) {
+        prefix += "||";
+      }
+      if (cell.header) {
+        prefix += "~";
+      } else if (cell.align === "center") {
+        prefix += "=";
+      } else if (cell.align === "right") {
+        prefix += ">";
+      } else if (cell.align === "left") {
+        prefix += "<";
+      }
+      const innerCtx = new SerializeContext({ newline: ctx.newline });
+      serializeElements(innerCtx, cell.elements);
+      const content = innerCtx.getOutput().replace(/\n$/, "");
+      ctx.push(`${prefix} ${content} `);
+    }
+    ctx.pushLine("||");
+  }
+  ctx.requestBlankLine();
+}
+
+// packages/decompiler/src/serializer/code.ts
+function serializeCode(ctx, data) {
+  const attrs = [];
+  if (data.language) {
+    attrs.push(`type="${data.language}"`);
+  }
+  if (data.name) {
+    attrs.push(`name="${data.name}"`);
+  }
+  const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+  ctx.pushBlockLine(`[[code${attrStr}]]`);
+  if (data.contents.length > 0) {
+    ctx.push(data.contents);
+    if (!data.contents.endsWith(`
+`)) {
+      ctx.push(ctx.newline);
+    }
+  }
+  ctx.pushBlockLine("[[/code]]");
+  ctx.requestBlankLine();
+}
+
+// packages/decompiler/src/serializer/collapsible.ts
+function serializeCollapsible(ctx, data) {
+  const attrs = [];
+  if (data["show-text"]) {
+    attrs.push(`show="${data["show-text"]}"`);
+  }
+  if (data["hide-text"]) {
+    attrs.push(`hide="${data["hide-text"]}"`);
+  }
+  if (data["start-open"]) {
+    attrs.push(`folded="no"`);
+  }
+  if (!data["show-top"] && !data["show-bottom"]) {
+    attrs.push(`hideLocation="neither"`);
+  } else if (!data["show-top"] && data["show-bottom"]) {
+    attrs.push(`hideLocation="bottom"`);
+  } else if (data["show-top"] && data["show-bottom"]) {
+    attrs.push(`hideLocation="both"`);
+  }
+  const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+  ctx.pushBlockLine(`[[collapsible${attrStr}]]`);
+  const innerCtx = new SerializeContext({ newline: ctx.newline });
+  serializeElements(innerCtx, data.elements);
+  ctx.push(innerCtx.getBlockInnerOutput());
+  ctx.pushBlockLine("[[/collapsible]]");
+  ctx.requestBlankLine();
+}
+
+// packages/decompiler/src/serializer/tab-view.ts
+function serializeTabView(ctx, tabs) {
+  ctx.pushBlockLine("[[tabview]]");
+  for (const tab of tabs) {
+    ctx.pushBlockLine(`[[tab ${tab.label}]]`);
+    const innerCtx = new SerializeContext({ newline: ctx.newline });
+    serializeElements(innerCtx, tab.elements);
+    ctx.push(innerCtx.getBlockInnerOutput());
+    ctx.pushBlockLine("[[/tab]]");
+  }
+  ctx.pushBlockLine("[[/tabview]]");
+  ctx.requestBlankLine();
+}
+
+// packages/decompiler/src/serializer/footnote.ts
+function serializeFootnoteInline(ctx, index, footnotes) {
+  const content = footnotes?.[index];
+  if (content && content.length > 0) {
+    serializeFootnoteContent(ctx, content);
+  } else {
+    ctx.push("[[footnote]][[/footnote]]");
+  }
+}
+function serializeFootnoteRef(ctx, refNum, footnotes) {
+  const content = footnotes?.[refNum - 1];
+  if (content && content.length > 0) {
+    serializeFootnoteContent(ctx, content);
+  } else {
+    ctx.push("[[footnote]][[/footnote]]");
+  }
+}
+function serializeFootnoteContent(ctx, content) {
+  const hasParagraph = content.some((el) => el.element === "container" && el.data?.type === "paragraph");
+  if (hasParagraph) {
+    const innerCtx = new SerializeContext({ newline: ctx.newline });
+    let seenParagraph = false;
+    for (const el of content) {
+      if (el.element === "container" && el.data?.type === "paragraph" && !seenParagraph) {
+        seenParagraph = true;
+        innerCtx.push(innerCtx.newline);
+        innerCtx.pushBlankLine();
+      }
+      serializeElement(innerCtx, el);
+    }
+    const inner = innerCtx.getBlockInnerOutput();
+    ctx.push("[[footnote]]" + ctx.newline);
+    ctx.push(inner);
+    if (!inner.endsWith(ctx.newline)) {
+      ctx.push(ctx.newline);
+    }
+    ctx.push("[[/footnote]]");
+  } else {
+    const innerCtx = new SerializeContext({ newline: ctx.newline });
+    serializeElements(innerCtx, content);
+    const inner = innerCtx.getBlockInnerOutput();
+    if (inner.includes(ctx.newline)) {
+      ctx.push("[[footnote]]" + ctx.newline);
+      ctx.push(inner);
+      if (!inner.endsWith(ctx.newline)) {
+        ctx.push(ctx.newline);
+      }
+      ctx.push("[[/footnote]]");
+    } else {
+      ctx.push(`[[footnote]]${inner}[[/footnote]]`);
+    }
+  }
+}
+function serializeFootnoteBlock(ctx, data, isLastElement) {
+  if (!data.title && !data.hide && isLastElement)
+    return;
+  const attrs = [];
+  if (data.hide)
+    attrs.push('hide="true"');
+  if (data.title)
+    attrs.push(`title="${data.title}"`);
+  const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+  if (data.hide || data.title) {
+    ctx.flushPendingBlankLine();
+  }
+  ctx.pushBlockLine(`[[footnoteblock${attrStr}]]`);
+  ctx.requestBlankLine();
+}
+
+// packages/decompiler/src/serializer/math.ts
+function serializeMath(ctx, data) {
+  const attrs = [];
+  if (data.name) {
+    attrs.push(data.name);
+  }
+  const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+  if (!data["latex-source"].includes(`
+`)) {
+    ctx.pushBlockLine(`[[math${attrStr}]] ${data["latex-source"]} [[/math]]`);
+  } else {
+    ctx.pushBlockLine(`[[math${attrStr}]]`);
+    ctx.push(data["latex-source"]);
+    if (!data["latex-source"].endsWith(`
+`)) {
+      ctx.push(ctx.newline);
+    }
+    ctx.pushBlockLine("[[/math]]");
+  }
+  ctx.requestBlankLine();
+}
+function serializeMathInline(ctx, data) {
+  ctx.push(`[[$ ${data["latex-source"]} $]]`);
+}
+
+// packages/decompiler/src/serializer/misc.ts
+function serializeColor(ctx, data) {
+  ctx.push(`##${data.color}|`);
+  serializeElements(ctx, data.elements);
+  ctx.push("##");
+}
+function serializeClearFloat(ctx, data) {
+  switch (data) {
+    case "left":
+      ctx.pushBlockLine("~~~~<");
+      break;
+    case "right":
+      ctx.pushBlockLine("~~~~>");
+      break;
+    case "both":
+      ctx.pushBlockLine("~~~~");
+      break;
+  }
+  ctx.requestBlankLine();
+}
+function serializeEmbed(ctx, data) {
+  switch (data.embed) {
+    case "youtube":
+      ctx.pushBlockLine(`[[embedvideo youtube ${data.data["video-id"]}]]`);
+      break;
+    case "vimeo":
+      ctx.pushBlockLine(`[[embedvideo vimeo ${data.data["video-id"]}]]`);
+      break;
+    case "github-gist":
+      ctx.pushBlockLine(`[[embedvideo github-gist ${data.data.username} ${data.data.hash}]]`);
+      break;
+    case "gitlab-snippet":
+      ctx.pushBlockLine(`[[embedvideo gitlab-snippet ${data.data["snippet-id"]}]]`);
+      break;
+  }
+  ctx.requestBlankLine();
+}
+function serializeEmbedBlock(ctx, data) {
+  ctx.pushBlockLine("[[embed]]");
+  ctx.push(data.contents);
+  if (!data.contents.endsWith(`
+`)) {
+    ctx.push(ctx.newline);
+  }
+  ctx.pushBlockLine("[[/embed]]");
+  ctx.requestBlankLine();
+}
+function serializeIframe(ctx, data) {
+  const attrs = [];
+  for (const [key, value] of Object.entries(data.attributes)) {
+    attrs.push(`${key}="${value}"`);
+  }
+  const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+  ctx.pushBlockLine(`[[iframe ${data.url}${attrStr}]]`);
+  ctx.requestBlankLine();
+}
+function serializeStyle(ctx, data) {
+  ctx.pushBlockLine("[[module CSS]]");
+  ctx.push(data);
+  if (!data.endsWith(`
+`)) {
+    ctx.push(ctx.newline);
+  }
+  ctx.pushBlockLine("[[/module]]");
+  ctx.requestBlankLine();
+}
+function serializeAnchor(ctx, data) {
+  const attrs = [];
+  for (const [key, value] of Object.entries(data.attributes)) {
+    if (key === "id" && value.startsWith("u-")) {
+      attrs.push(`${key}="${value.slice(2)}"`);
+    } else {
+      attrs.push(`${key}="${value}"`);
+    }
+  }
+  const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+  ctx.push(`[[a${attrStr}]]`);
+  serializeElements(ctx, data.elements);
+  ctx.push("[[/a]]");
+}
+function serializeBibliographyCite(ctx, data) {
+  ctx.push(`((bibcite ${data.label}))`);
+}
+function serializeBibliographyBlock(ctx, data) {
+  ctx.flushPendingBlankLine();
+  ctx.pushBlockLine("[[bibliography]]");
+  for (const entry of data.entries) {
+    ctx.push(": ");
+    serializeElements(ctx, entry.key);
+    ctx.push(" : ");
+    serializeElements(ctx, entry.value);
+    ctx.push(ctx.newline);
+  }
+  ctx.pushBlockLine("[[/bibliography]]");
+  ctx.requestBlankLine();
+}
+function serializeEquationRef(ctx, name) {
+  ctx.push(`[[eref ${name}]]`);
+}
+
+// packages/decompiler/src/serializer/serialize-element.ts
+var currentTree;
+var footnoteCounter = 0;
+function setCurrentTree(tree) {
+  currentTree = tree;
+  footnoteCounter = 0;
+}
+function serializeElement(ctx, element) {
+  switch (element.element) {
+    case "text":
+      serializeText(ctx, element.data);
+      break;
+    case "raw":
+      serializeRaw(ctx, element.data);
+      break;
+    case "email":
+      serializeEmail(ctx, element.data);
+      break;
+    case "container":
+      serializeContainer(ctx, element.data);
+      break;
+    case "line-break":
+      serializeLineBreak(ctx);
+      break;
+    case "horizontal-rule":
+      serializeHorizontalRule(ctx);
+      break;
+    case "content-separator":
+      serializeContentSeparator(ctx);
+      break;
+    case "link":
+      serializeLink(ctx, element.data);
+      break;
+    case "anchor":
+      serializeAnchor(ctx, element.data);
+      break;
+    case "anchor-name":
+      serializeAnchorName(ctx, element.data);
+      break;
+    case "image":
+      serializeImage(ctx, element.data);
+      break;
+    case "list":
+      serializeList(ctx, element.data);
+      break;
+    case "definition-list":
+      serializeDefinitionList(ctx, element.data);
+      break;
+    case "table":
+      serializeTable(ctx, element.data);
+      break;
+    case "code":
+      serializeCode(ctx, element.data);
+      break;
+    case "collapsible":
+      serializeCollapsible(ctx, element.data);
+      break;
+    case "tab-view":
+      serializeTabView(ctx, element.data);
+      break;
+    case "footnote":
+      serializeFootnoteInline(ctx, footnoteCounter, currentTree?.footnotes);
+      footnoteCounter++;
+      break;
+    case "footnote-ref":
+      serializeFootnoteRef(ctx, element.data, currentTree?.footnotes);
+      break;
+    case "footnote-block": {
+      const isLast = element._isLastElement;
+      serializeFootnoteBlock(ctx, element.data, isLast);
+      break;
+    }
+    case "math":
+      serializeMath(ctx, element.data);
+      break;
+    case "math-inline":
+      serializeMathInline(ctx, element.data);
+      break;
+    case "equation-reference":
+      serializeEquationRef(ctx, element.data);
+      break;
+    case "color":
+      serializeColor(ctx, element.data);
+      break;
+    case "clear-float":
+      serializeClearFloat(ctx, element.data);
+      break;
+    case "embed":
+      serializeEmbed(ctx, element.data);
+      break;
+    case "embed-block":
+      serializeEmbedBlock(ctx, element.data);
+      break;
+    case "iframe":
+      serializeIframe(ctx, element.data);
+      break;
+    case "style":
+      serializeStyle(ctx, element.data);
+      break;
+    case "bibliography-cite":
+      serializeBibliographyCite(ctx, element.data);
+      break;
+    case "bibliography-block":
+      serializeBibliographyBlock(ctx, element.data);
+      break;
+    default:
+      break;
+  }
+}
+function serializeElements(ctx, elements) {
+  for (let i = 0;i < elements.length; i++) {
+    const el = elements[i];
+    if (el.element === "footnote-block" && i === elements.length - 1) {
+      el._isLastElement = true;
+    }
+    serializeElement(ctx, el);
+  }
+}
+
+// packages/decompiler/src/serializer/index.ts
+function serialize(tree, options) {
+  const ctx = new SerializeContext(options);
+  setCurrentTree(tree);
+  serializeElements(ctx, tree.elements);
+  let output = ctx.getOutput();
+  const nl = ctx.newline;
+  const nlEsc = nl.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+  output = output.replace(new RegExp(`(${nlEsc}){3,}`, "g"), nl + nl);
+  output = output.replace(new RegExp(`(${nlEsc})+$`), nl);
+  return output;
+}
+
+// packages/decompiler/src/index.ts
+function decompile(html, options) {
+  const tree = htmlToAst(html, options);
+  return serialize(tree);
+}
+export {
+  serialize,
+  htmlToAst,
+  decompile
+};