formatferry 1.0.33 → 1.0.35

package/README.md

@@ -103,6 +103,8 @@ formatferry [options]
 | `-o, --output <path>` | Output file path (defaults to stdout) |
 | `-f, --format <format>` | Markdown format (default: `github`) |
 | `--url <url>` | Fetch and convert a web article (requires API key) |
+
+`--url` asks the proxy for the page HTML and converts it locally, so `--format` chooses the Markdown flavour exactly as it does for a local file. The proxy also offers the finished Markdown directly: `POST /v1/extract` with `{ "format": "markdown" }` (see the root README).
 | `--batch <glob>` | Batch convert files matching a glob pattern (Premium) |
 | `--output-dir <dir>` | Output directory for batch mode |
 | `--strict` | Exit with code 1 if the conversion produced any warnings (including advisory ones) |

package/dist/index.js

@@ -948,14 +948,14 @@ var require_Node = __commonJS({
       this._nextSibling = this._previousSibling = this;
       this._index = void 0;
     }
-    var ELEMENT_NODE = Node2.ELEMENT_NODE = 1;
+    var ELEMENT_NODE2 = Node2.ELEMENT_NODE = 1;
     var ATTRIBUTE_NODE = Node2.ATTRIBUTE_NODE = 2;
     var TEXT_NODE = Node2.TEXT_NODE = 3;
     var CDATA_SECTION_NODE = Node2.CDATA_SECTION_NODE = 4;
     var ENTITY_REFERENCE_NODE = Node2.ENTITY_REFERENCE_NODE = 5;
     var ENTITY_NODE = Node2.ENTITY_NODE = 6;
     var PROCESSING_INSTRUCTION_NODE = Node2.PROCESSING_INSTRUCTION_NODE = 7;
-    var COMMENT_NODE = Node2.COMMENT_NODE = 8;
+    var COMMENT_NODE2 = Node2.COMMENT_NODE = 8;
     var DOCUMENT_NODE = Node2.DOCUMENT_NODE = 9;
     var DOCUMENT_TYPE_NODE = Node2.DOCUMENT_TYPE_NODE = 10;
     var DOCUMENT_FRAGMENT_NODE = Node2.DOCUMENT_FRAGMENT_NODE = 11;
@@ -973,7 +973,7 @@ var require_Node = __commonJS({
       // we'll come back to this later.
       baseURI: { get: utils2.nyi },
       parentElement: { get: function() {
-        return this.parentNode && this.parentNode.nodeType === ELEMENT_NODE ? this.parentNode : null;
+        return this.parentNode && this.parentNode.nodeType === ELEMENT_NODE2 ? this.parentNode : null;
       } },
       hasChildNodes: { value: utils2.shouldOverride },
       firstChild: { get: utils2.shouldOverride },
@@ -1034,7 +1034,7 @@ var require_Node = __commonJS({
         switch (parent.nodeType) {
           case DOCUMENT_NODE:
           case DOCUMENT_FRAGMENT_NODE:
-          case ELEMENT_NODE:
+          case ELEMENT_NODE2:
             break;
           default:
             utils2.HierarchyRequestError();
@@ -1046,10 +1046,10 @@ var require_Node = __commonJS({
         switch (node.nodeType) {
           case DOCUMENT_FRAGMENT_NODE:
           case DOCUMENT_TYPE_NODE:
-          case ELEMENT_NODE:
+          case ELEMENT_NODE2:
           case TEXT_NODE:
           case PROCESSING_INSTRUCTION_NODE:
-          case COMMENT_NODE:
+          case COMMENT_NODE2:
             break;
           default:
             utils2.HierarchyRequestError();
@@ -1062,7 +1062,7 @@ var require_Node = __commonJS({
             case DOCUMENT_FRAGMENT_NODE:
               if (node._countChildrenOfType(TEXT_NODE) > 0)
                 utils2.HierarchyRequestError();
-              switch (node._countChildrenOfType(ELEMENT_NODE)) {
+              switch (node._countChildrenOfType(ELEMENT_NODE2)) {
                 case 0:
                   break;
                 case 1:
@@ -1074,12 +1074,12 @@ var require_Node = __commonJS({
                         utils2.HierarchyRequestError();
                     }
                   }
-                  i = parent._countChildrenOfType(ELEMENT_NODE);
+                  i = parent._countChildrenOfType(ELEMENT_NODE2);
                   if (isPreinsert) {
                     if (i > 0)
                       utils2.HierarchyRequestError();
                   } else {
-                    if (i > 1 || i === 1 && child.nodeType !== ELEMENT_NODE)
+                    if (i > 1 || i === 1 && child.nodeType !== ELEMENT_NODE2)
                       utils2.HierarchyRequestError();
                   }
                   break;
@@ -1087,7 +1087,7 @@ var require_Node = __commonJS({
                   utils2.HierarchyRequestError();
               }
               break;
-            case ELEMENT_NODE:
+            case ELEMENT_NODE2:
               if (child !== null) {
                 if (isPreinsert && child.nodeType === DOCUMENT_TYPE_NODE)
                   utils2.HierarchyRequestError();
@@ -1096,23 +1096,23 @@ var require_Node = __commonJS({
                     utils2.HierarchyRequestError();
                 }
               }
-              i = parent._countChildrenOfType(ELEMENT_NODE);
+              i = parent._countChildrenOfType(ELEMENT_NODE2);
               if (isPreinsert) {
                 if (i > 0)
                   utils2.HierarchyRequestError();
               } else {
-                if (i > 1 || i === 1 && child.nodeType !== ELEMENT_NODE)
+                if (i > 1 || i === 1 && child.nodeType !== ELEMENT_NODE2)
                   utils2.HierarchyRequestError();
               }
               break;
             case DOCUMENT_TYPE_NODE:
               if (child === null) {
-                if (parent._countChildrenOfType(ELEMENT_NODE))
+                if (parent._countChildrenOfType(ELEMENT_NODE2))
                   utils2.HierarchyRequestError();
               } else {
                 for (kid = parent.firstChild; kid !== null; kid = kid.nextSibling) {
                   if (kid === child) break;
-                  if (kid.nodeType === ELEMENT_NODE)
+                  if (kid.nodeType === ELEMENT_NODE2)
                     utils2.HierarchyRequestError();
                 }
               }
@@ -1229,7 +1229,7 @@ var require_Node = __commonJS({
         var e;
         if (ns === "" || ns === null || ns === void 0) return null;
         switch (this.nodeType) {
-          case ELEMENT_NODE:
+          case ELEMENT_NODE2:
             return this._lookupNamespacePrefix(ns, this);
           case DOCUMENT_NODE:
             e = this.documentElement;
@@ -1253,7 +1253,7 @@ var require_Node = __commonJS({
         }
         var e;
         switch (this.nodeType) {
-          case ELEMENT_NODE:
+          case ELEMENT_NODE2:
             return utils2.shouldOverride();
           case DOCUMENT_NODE:
             e = this.documentElement;
@@ -1511,14 +1511,14 @@ var require_Node = __commonJS({
       },
       // mirror node type properties in the prototype, so they are present
       // in instances of Node (and subclasses)
-      ELEMENT_NODE: { value: ELEMENT_NODE },
+      ELEMENT_NODE: { value: ELEMENT_NODE2 },
       ATTRIBUTE_NODE: { value: ATTRIBUTE_NODE },
       TEXT_NODE: { value: TEXT_NODE },
       CDATA_SECTION_NODE: { value: CDATA_SECTION_NODE },
       ENTITY_REFERENCE_NODE: { value: ENTITY_REFERENCE_NODE },
       ENTITY_NODE: { value: ENTITY_NODE },
       PROCESSING_INSTRUCTION_NODE: { value: PROCESSING_INSTRUCTION_NODE },
-      COMMENT_NODE: { value: COMMENT_NODE },
+      COMMENT_NODE: { value: COMMENT_NODE2 },
       DOCUMENT_NODE: { value: DOCUMENT_NODE },
       DOCUMENT_TYPE_NODE: { value: DOCUMENT_TYPE_NODE },
       DOCUMENT_FRAGMENT_NODE: { value: DOCUMENT_FRAGMENT_NODE },
@@ -58046,20 +58046,29 @@ var InputSanitizer = class {
     this.purifyConfig = this.createPurifyConfig();
   }
   /**
-   * Sanitize HTML content to prevent XSS attacks
+   * Like sanitizeHTML, but a sanitiser failure is thrown instead of being
+   * turned into an empty string. Use it wherever an empty result would be
+   * read as "the page had no content" (the ConversionEngine on an injected
+   * DOM: the Worker's server-side Markdown and the CLI), so a failure is
+   * reported as a failure (#170).
    */
-  sanitizeHTML(html) {
+  sanitizeHTMLOrThrow(html) {
     if (!html || typeof html !== "string") {
       return "";
     }
+    return this.domEnv.DOMPurify.sanitize(html, {
+      ALLOWED_TAGS: this.purifyConfig.ALLOWED_TAGS,
+      ALLOWED_ATTR: this.purifyConfig.ALLOWED_ATTR,
+      FORBID_TAGS: this.purifyConfig.FORBID_TAGS,
+      FORBID_ATTR: this.purifyConfig.FORBID_ATTR
+    });
+  }
+  /**
+   * Sanitize HTML content to prevent XSS attacks
+   */
+  sanitizeHTML(html) {
     try {
-      const sanitized = this.domEnv.DOMPurify.sanitize(html, {
-        ALLOWED_TAGS: this.purifyConfig.ALLOWED_TAGS,
-        ALLOWED_ATTR: this.purifyConfig.ALLOWED_ATTR,
-        FORBID_TAGS: this.purifyConfig.FORBID_TAGS,
-        FORBID_ATTR: this.purifyConfig.FORBID_ATTR
-      });
-      return sanitized;
+      return this.sanitizeHTMLOrThrow(html);
     } catch (error) {
       console.warn("HTML sanitization failed:", error);
       return "";
@@ -58196,6 +58205,7 @@ var InputSanitizer = class {
       ALLOWED_TAGS: [
         "p",
         "br",
+        "hr",
         "div",
         "span",
         "h1",
@@ -58246,6 +58256,7 @@ var InputSanitizer = class {
           ALLOWED_TAGS: [
             "p",
             "br",
+            "hr",
             "div",
             "span",
             "h1",
@@ -58312,7 +58323,11 @@ var InputSanitizer = class {
     return { ...this.config };
   }
 };
-var defaultSanitizer = new InputSanitizer();
+var defaultSanitizerInstance;
+function getDefaultSanitizer() {
+  defaultSanitizerInstance ??= new InputSanitizer();
+  return defaultSanitizerInstance;
+}
 function normalizeSlackHTML(html, domParser) {
   if (!html || !html.includes("indent=")) return html;
   const doc = (domParser ?? new globalThis.DOMParser()).parseFromString(html, "text/html");
@@ -58343,7 +58358,7 @@ function normalizeSlackHTML(html, domParser) {
     }
     return root;
   };
-  const isListEl = (n) => n.nodeType === Node.ELEMENT_NODE && (n.nodeName === "UL" || n.nodeName === "OL");
+  const isListEl = (n) => n.nodeType === 1 && (n.nodeName === "UL" || n.nodeName === "OL");
   const snapshot = Array.from(body.childNodes);
   let runStart = -1;
   const flushRun = (endIdx) => {
@@ -58377,7 +58392,7 @@ function sanitizeHTML(html, config) {
     const sanitizer = new InputSanitizer(config);
     return sanitizer.sanitizeHTML(html);
   }
-  return defaultSanitizer.sanitizeHTML(html);
+  return getDefaultSanitizer().sanitizeHTML(html);
 }
 var PANEL_EMOJI = {
   info: "\u2139\uFE0F Info:",
@@ -58463,11 +58478,11 @@ function normalizeAtlassianTables(doc) {
   }
 }
 function stripUnrecognizedMacros(node) {
-  const ELEMENT_NODE = 1;
+  const ELEMENT_NODE2 = 1;
   let i = 0;
   while (i < node.childNodes.length) {
     const child = node.childNodes[i];
-    if (child.nodeType === ELEMENT_NODE) {
+    if (child.nodeType === ELEMENT_NODE2) {
       const el = child;
       const tagName = el.tagName.toLowerCase();
       if (tagName.startsWith("ac:") || tagName.startsWith("ri:")) {
@@ -58682,11 +58697,11 @@ function processConfluenceList(list, service, depth) {
 function processConfluenceListItem(item, service, depth) {
   let content = "";
   const TEXT_NODE = 3;
-  const ELEMENT_NODE = 1;
+  const ELEMENT_NODE2 = 1;
   Array.from(item.childNodes).forEach((child) => {
     if (child.nodeType === TEXT_NODE) {
       content += child.textContent || "";
-    } else if (child.nodeType === ELEMENT_NODE) {
+    } else if (child.nodeType === ELEMENT_NODE2) {
       const el = child;
       if (el.nodeName === "UL" || el.nodeName === "OL") {
         content += "\n" + processConfluenceList(el, service, depth + 1);
@@ -58904,8 +58919,46 @@ var ConversionEngine = class {
   rmarkdownService;
   slackService;
   confluenceService;
-  constructor() {
+  dom;
+  domSanitizer;
+  constructor(options = {}) {
+    this.dom = options.dom;
     this.initializeServices();
+    if (this.dom) {
+      for (const service of [
+        this.githubService,
+        this.commonmarkService,
+        this.customService,
+        this.discordService,
+        this.redditService,
+        this.rmarkdownService,
+        this.slackService,
+        this.confluenceService
+      ]) {
+        this.parseWithInjectedDom(service, this.dom);
+      }
+    }
+  }
+  /**
+   * Make `service.turndown(html)` parse with the injected DOM. Turndown parses
+   * a string by wrapping it in `<x-turndown id="turndown-root">` and handing
+   * that element to its converter; this does the same with `dom.DOMParser` and
+   * passes the element, which Turndown accepts in place of a string. Covers
+   * the nested `service.turndown(el.outerHTML)` calls in the list rules too.
+   */
+  parseWithInjectedDom(service, dom) {
+    const turndown = service.turndown.bind(service);
+    service.turndown = (input) => {
+      if (typeof input !== "string") return turndown(input);
+      const doc = new dom.DOMParser().parseFromString(
+        '<x-turndown id="turndown-root">' + input + "</x-turndown>",
+        "text/html"
+      );
+      const root = doc.getElementById("turndown-root");
+      root?.normalize();
+      if (!root) throw new Error("Injected DOM did not produce the turndown root element");
+      return turndown(root);
+    };
   }
   initializeServices() {
     this.githubService = new import_turndown2.default({
@@ -58962,6 +59015,37 @@ var ConversionEngine = class {
     this.confluenceService = createConfluenceService(deps);
     this.addSlideMarkerRules(this.slackService);
     this.addSlideMarkerRules(this.confluenceService);
+    [
+      this.githubService,
+      this.commonmarkService,
+      this.customService,
+      this.discordService,
+      this.redditService,
+      this.rmarkdownService,
+      this.slackService,
+      this.confluenceService
+    ].forEach((service) => this.addGoogleDocsWrapperRule(service));
+  }
+  /**
+   * Google Docs wraps every copied selection in
+   * <b style="font-weight:normal" id="docs-internal-guid-...">. Treating that
+   * as bold puts a stray pair of bold markers around the whole document, so a
+   * <b>/<strong> whose inline style explicitly sets a non-bold weight is
+   * rendered as its plain content.
+   */
+  addGoogleDocsWrapperRule(service) {
+    service.addRule("googleDocsNonBoldWrapper", {
+      filter: (node) => {
+        if (node.nodeName !== "B" && node.nodeName !== "STRONG") return false;
+        const style = (node.getAttribute("style") || "").toLowerCase();
+        const matches = [...style.matchAll(/font-weight\s*:\s*([a-z0-9]+)/g)];
+        if (matches.length === 0) return false;
+        const weight = matches[matches.length - 1][1];
+        if (weight === "normal" || weight === "lighter") return true;
+        return /^\d+$/.test(weight) && parseInt(weight, 10) < 600;
+      },
+      replacement: (content) => content
+    });
   }
   /**
    * Create Discord-optimized Turndown service
@@ -59017,8 +59101,8 @@ ${plainText}
         return node.nodeName === "INPUT" && node.type === "checkbox";
       },
       replacement: (_content, node) => {
-        const checked = node.checked;
-        return checked ? "\u2611 " : "\u2610 ";
+        const checked = node.checked || node.hasAttribute("checked");
+        return (checked ? "\u2611" : "\u2610") + this.checkboxSpacer(node);
       }
     });
     return service;
@@ -59046,9 +59130,9 @@ ${plainText}
    * Converts Unicode checkboxes to [x] and [ ]
    */
   normalizeGitHubCheckboxes(markdown) {
-    let result = markdown;
-    result = result.replace(/^([-*]\s+)[☑✓✔■⬛]/gm, "$1[x]");
-    result = result.replace(/^([-*]\s+)[☐✗✘□⬜]/gm, "$1[ ]");
+    let result = markdown.replace(/^([ \t]*(?:[-*+]|\d+[.)])[ \t]+)\\\[([ xX])\\\]/gm, "$1[$2]");
+    result = result.replace(/^([ \t]*(?:[-*+]|\d+[.)])[ \t]+)[☑✓✔■⬛]/gm, "$1[x]");
+    result = result.replace(/^([ \t]*(?:[-*+]|\d+[.)])[ \t]+)[☐✗✘□⬜]/gm, "$1[ ]");
     return result;
   }
   /**
@@ -59056,10 +59140,10 @@ ${plainText}
    * Converts [x], [ ], and other checkbox patterns to emoji
    */
   normalizeDiscordCheckboxes(markdown) {
-    let result = markdown.replace(/^([-*]\s+)\[x\]/gmi, "$1\u2611");
-    result = result.replace(/^([-*]\s+)[✓✔■⬛]/gm, "$1\u2611");
-    result = result.replace(/^([-*]\s+)\[\s?\]/gm, "$1\u2610");
-    result = result.replace(/^([-*]\s+)[✗✘□⬜]/gm, "$1\u2610");
+    let result = markdown.replace(/^([ \t]*(?:[-*+]|\d+[.)])[ \t]+)\\?\[x\\?\]/gmi, "$1\u2611");
+    result = result.replace(/^([ \t]*(?:[-*+]|\d+[.)])[ \t]+)[✓✔■⬛]/gm, "$1\u2611");
+    result = result.replace(/^([ \t]*(?:[-*+]|\d+[.)])[ \t]+)\\?\[\s?\\?\]/gm, "$1\u2610");
+    result = result.replace(/^([ \t]*(?:[-*+]|\d+[.)])[ \t]+)[✗✘□⬜]/gm, "$1\u2610");
     return result;
   }
   /**
@@ -59298,8 +59382,9 @@ ${plainText}
     return lines.join("\n");
   }
   flattenTables(html) {
-    if (typeof DOMParser === "undefined") return html;
-    const parser = new DOMParser();
+    const Parser = this.dom?.DOMParser ?? (typeof DOMParser === "undefined" ? void 0 : DOMParser);
+    if (!Parser) return html;
+    const parser = new Parser();
     const doc = parser.parseFromString(`<div>${html}</div>`, "text/html");
     Array.from(doc.querySelectorAll("table")).forEach((table) => {
       const replacement = doc.createElement("div");
@@ -59459,10 +59544,11 @@ ${plainText}
     });
   }
   renderTableCell(cell) {
+    const ELEMENT_NODE2 = 1;
     const blocks = [];
     let inlineBuffer = "";
     cell.childNodes.forEach((child) => {
-      if (child.nodeType === Node.ELEMENT_NODE && this.isTableCellBlock(child)) {
+      if (child.nodeType === ELEMENT_NODE2 && this.isTableCellBlock(child)) {
         if (inlineBuffer.trim()) {
           blocks.push(inlineBuffer.trim());
           inlineBuffer = "";
@@ -59486,8 +59572,10 @@ ${plainText}
     return this.renderInlineNode(element).trim();
   }
   renderInlineNode(node) {
-    if (node.nodeType === Node.TEXT_NODE) return node.textContent || "";
-    if (node.nodeType !== Node.ELEMENT_NODE) return "";
+    const TEXT_NODE = 3;
+    const ELEMENT_NODE2 = 1;
+    if (node.nodeType === TEXT_NODE) return node.textContent || "";
+    if (node.nodeType !== ELEMENT_NODE2) return "";
     const element = node;
     const content = Array.from(element.childNodes).map((child) => this.renderInlineNode(child)).join("");
     const trimmed = content.trim();
@@ -59525,6 +59613,11 @@ ${plainText}
   escapeTableCell(content) {
     return content.replace(/\|/g, "\\|").replace(/\s*<br>\s*/g, "<br>").trim();
   }
+  /** A space after a checkbox marker unless the label text already starts with one. */
+  checkboxSpacer(node) {
+    const next = node.nextSibling;
+    return next && /^\s/.test(next.textContent || "") ? "" : " ";
+  }
   addTaskListRules(service) {
     service.addRule("gfmTaskListCheckbox", {
       filter: (node) => {
@@ -59532,7 +59625,7 @@ ${plainText}
       },
       replacement: (_content, node) => {
         const checked = node.checked || node.hasAttribute("checked");
-        return checked ? "[x] " : "[ ] ";
+        return (checked ? "[x]" : "[ ]") + this.checkboxSpacer(node);
       }
     });
   }
@@ -59598,60 +59691,78 @@ ${plainText}
     service.addRule("enhancedList", {
       filter: ["ul", "ol"],
       replacement: (content, node) => {
-        const listType = node?.nodeName.toLowerCase();
         const items = Array.from(node.children).filter(
           (child) => child.nodeName.toLowerCase() === "li"
         );
         if (items.length === 0) return content;
-        let markdown = "\n";
-        const isOrdered = listType === "ol";
-        const marker = isOrdered ? "1." : service.options.bulletListMarker || "-";
-        items.forEach((item, index) => {
-          const itemContent = this.processListItem(item, service);
-          const actualMarker = isOrdered ? `${index + 1}.` : marker;
-          markdown += `${actualMarker} ${itemContent}
-`;
-        });
-        return markdown + "\n";
-      }
-    });
-  }
-  processListItem(item, service, depth = 0) {
-    let content = "";
-    const TEXT_NODE = 3;
-    const ELEMENT_NODE = 1;
-    Array.from(item.childNodes).forEach((child) => {
-      if (child.nodeType === TEXT_NODE) {
-        content += child.textContent || "";
-      } else if (child.nodeType === ELEMENT_NODE) {
-        const element = child;
-        if (element.nodeName.toLowerCase() === "ul" || element.nodeName.toLowerCase() === "ol") {
-          const nestedContent = this.processNestedList(element, service, depth + 1);
-          content += "\n" + nestedContent;
-        } else {
-          content += service.turndown(element.outerHTML);
-        }
+        return "\n" + this.renderList(node, service) + "\n";
       }
     });
-    return content.trim();
   }
-  processNestedList(list, service, depth) {
+  /**
+   * Render a list with markers at column 0. Continuation lines of each item
+   * (extra paragraphs, nested lists) are indented to the item's content
+   * column (marker width + 1), which is what CommonMark/GFM require for them
+   * to stay inside the item: 2 spaces under "- ", 3 under "1. ", 4 under "10. ".
+   */
+  renderList(list, service) {
     const items = Array.from(list.children).filter(
       (child) => child.nodeName.toLowerCase() === "li"
     );
-    if (items.length === 0) return "";
-    let markdown = "";
     const isOrdered = list.nodeName.toLowerCase() === "ol";
-    const indent = "  ".repeat(depth);
-    const marker = isOrdered ? "1." : service.options.bulletListMarker || "-";
+    const bullet = service.options.bulletListMarker || "-";
+    let markdown = "";
     items.forEach((item, index) => {
-      const itemContent = this.processListItem(item, service, depth);
-      const actualMarker = isOrdered ? `${index + 1}.` : marker;
-      markdown += `${indent}${actualMarker} ${itemContent}
+      const marker = isOrdered ? `${index + 1}.` : bullet;
+      const indent = " ".repeat(marker.length + 1);
+      const body = this.processListItem(item, service);
+      const lines = body.split("\n");
+      const indented = lines.map((line, i) => i === 0 || line === "" ? line : indent + line).join("\n");
+      markdown += `${marker} ${indented}
 `;
     });
     return markdown;
   }
+  /**
+   * Render one list item's content relative to its own content column.
+   * Inline runs and block children are converted together, so whitespace
+   * between sibling spans survives (Google Docs emits one span per run) and
+   * multiple paragraphs stay separated.
+   */
+  processListItem(item, service) {
+    const parts = [];
+    const ELEMENT_NODE2 = 1;
+    const doc = item.ownerDocument;
+    let buffer = doc.createElement("div");
+    const flush = () => {
+      if (buffer.childNodes.length > 0) {
+        const md = service.turndown(buffer).trim();
+        if (md) parts.push(md);
+      }
+      buffer = doc.createElement("div");
+    };
+    Array.from(item.childNodes).forEach((child) => {
+      const name = child.nodeType === ELEMENT_NODE2 ? child.nodeName.toLowerCase() : "";
+      if (name === "ul" || name === "ol") {
+        flush();
+        const nested = this.renderList(child, service).replace(/\n+$/, "");
+        if (nested) parts.push(nested);
+      } else {
+        buffer.appendChild(child.cloneNode(true));
+      }
+    });
+    flush();
+    let content = "";
+    parts.forEach((part, i) => {
+      if (i === 0) {
+        content = part;
+        return;
+      }
+      const isList = /^(?:[-*+]|\d+\.) /.test(part);
+      content += (isList ? "\n" : "\n\n") + part;
+    });
+    return content;
+  }
   addSlideMarkerRules(service) {
     service.addRule("pptxSlideMarker", {
       filter: (node) => node.nodeName === "DIV" && node.hasAttribute("data-slide-marker"),
@@ -59764,6 +59875,10 @@ ${plainText}
     };
   }
   sanitize(html) {
+    if (this.dom) {
+      this.domSanitizer ??= new InputSanitizer({ level: "moderate" }, this.dom);
+      return this.domSanitizer.sanitizeHTMLOrThrow(html);
+    }
     return sanitizeHTML(html, {
       level: "moderate"
       // Use moderate level for conversion
@@ -63205,7 +63320,7 @@ var PptxAdapter = class {
 };
 var pptxAdapter = new PptxAdapter();
 
-// ../../src/shared/readability-processor.ts
+// ../../src/shared/readability-core.ts
 var import_readability = __toESM(require_readability(), 1);
 var LinkedomProvider = class {
   createDocument(html) {
@@ -63503,6 +63618,118 @@ function buildCachedProvider(config, lastValidated) {
   return new CachedEntitlementProvider(cachedState);
 }
 
+// ../../src/shared/linkedom-sanitizer.ts
+var FORBID_CONTENTS = /* @__PURE__ */ new Set([
+  "annotation-xml",
+  "audio",
+  "colgroup",
+  "desc",
+  "foreignobject",
+  "head",
+  "iframe",
+  "math",
+  "mi",
+  "mn",
+  "mo",
+  "ms",
+  "mtext",
+  "noembed",
+  "noframes",
+  "noscript",
+  "plaintext",
+  "script",
+  "selectedcontent",
+  "style",
+  "svg",
+  "template",
+  "thead",
+  "title",
+  "video",
+  "xmp"
+]);
+var DATA_URI_TAGS = /* @__PURE__ */ new Set(["audio", "video", "img", "source", "image", "track"]);
+var URI_SAFE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "alt",
+  "class",
+  "for",
+  "id",
+  "label",
+  "name",
+  "pattern",
+  "placeholder",
+  "role",
+  "summary",
+  "title",
+  "value",
+  "style",
+  "xmlns"
+]);
+var IS_ALLOWED_URI = /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
+var ATTR_WHITESPACE = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
+var ELEMENT_NODE = 1;
+var COMMENT_NODE = 8;
+function toSet(list) {
+  return new Set((list ?? []).map((s) => s.toLowerCase()));
+}
+function attrAllowed(name, allowed, wildcards) {
+  return allowed.has(name) || wildcards.some((prefix) => name.startsWith(prefix));
+}
+function isSafeValue(tag, name, value) {
+  if (URI_SAFE_ATTRIBUTES.has(name) || !value) return true;
+  if (IS_ALLOWED_URI.test(value.replace(ATTR_WHITESPACE, ""))) return true;
+  return (name === "src" || name === "href" || name === "xlink:href") && value.startsWith("data:") && DATA_URI_TAGS.has(tag);
+}
+function sanitizeWithLinkedom(html, config, parse) {
+  if (!html) return "";
+  const allowedTags = toSet(config.ALLOWED_TAGS);
+  const forbidTags = toSet(config.FORBID_TAGS);
+  const allowedAttrList = (config.ALLOWED_ATTR ?? []).map((s) => s.toLowerCase());
+  const allowedAttrs = new Set(allowedAttrList.filter((a) => !a.endsWith("*")));
+  const attrWildcards = allowedAttrList.filter((a) => a.endsWith("*")).map((a) => a.slice(0, -1));
+  const forbidAttrs = toSet(config.FORBID_ATTR);
+  const doc = parse(`<!DOCTYPE html><html><head></head><body>${html}</body></html>`);
+  const body = doc.body;
+  if (!body) return "";
+  const toUnwrap = [];
+  const stack = [body];
+  while (stack.length > 0) {
+    const parent = stack.pop();
+    for (const child of Array.from(parent.childNodes)) {
+      if (child.nodeType === COMMENT_NODE) {
+        parent.removeChild(child);
+        continue;
+      }
+      if (child.nodeType !== ELEMENT_NODE) continue;
+      const el = child;
+      const tag = el.nodeName.toLowerCase();
+      if (!allowedTags.has(tag) || forbidTags.has(tag)) {
+        if (FORBID_CONTENTS.has(tag)) {
+          parent.removeChild(el);
+        } else {
+          toUnwrap.push(el);
+          stack.push(el);
+        }
+        continue;
+      }
+      for (const attr of Array.from(el.attributes)) {
+        const name = attr.name.toLowerCase();
+        if (name.startsWith("on") || forbidAttrs.has(name) || !attrAllowed(name, allowedAttrs, attrWildcards) || !isSafeValue(tag, name, attr.value)) {
+          el.removeAttribute(attr.name);
+        }
+      }
+      stack.push(el);
+    }
+  }
+  for (let i = toUnwrap.length - 1; i >= 0; i--) {
+    const el = toUnwrap[i];
+    const parent = el.parentNode;
+    if (!parent) continue;
+    while (el.firstChild) parent.insertBefore(el.firstChild, el);
+    parent.removeChild(el);
+  }
+  return body.innerHTML;
+}
+
 // ../../src/shared/token-estimator.ts
 var CJK_REGEX3 = /[\u4e00-\u9fff\u3400-\u4dbf\u3000-\u303f\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g;
 var MAX_INPUT_LENGTH = 1e6;
@@ -64052,6 +64279,18 @@ async function binaryToMarkdown(buffer, type, format) {
     }
   }
 }
+function linkedomDomEnvironment() {
+  const parseHTML2 = globalThis.__FF_parseHTML;
+  if (!parseHTML2) throw new Error("The CLI shim must be loaded before converting a URL");
+  const parseDocument = (html) => parseHTML2(html).document;
+  const { window: window3 } = parseHTML2("<!DOCTYPE html><html><head></head><body></body></html>");
+  return {
+    DOMParser: window3.DOMParser,
+    DOMPurify: {
+      sanitize: (html, config) => sanitizeWithLinkedom(html, config ?? {}, parseDocument)
+    }
+  };
+}
 var DEFAULT_PROXY_URL = "https://formatferry.vibingfun.com";
 async function urlToMarkdown(url, apiKey, format, proxyBaseUrl = process.env.FORMATFERRY_PROXY_URL ?? DEFAULT_PROXY_URL) {
   const extractEndpoint = `${proxyBaseUrl}/v1/extract`;
@@ -64063,7 +64302,9 @@ async function urlToMarkdown(url, apiKey, format, proxyBaseUrl = process.env.FOR
         "Content-Type": "application/json",
         "X-API-Key": apiKey
       },
-      body: JSON.stringify({ url })
+      // Readability and the chosen flavour run locally, so ask for the page's
+      // HTML (the API's default is Markdown).
+      body: JSON.stringify({ url, format: "html" })
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -64074,18 +64315,19 @@ async function urlToMarkdown(url, apiKey, format, proxyBaseUrl = process.env.FOR
   if (!response.ok) {
     let errorMessage = `Proxy returned ${response.status}`;
     try {
-      const body = await response.json();
-      errorMessage = body.error ?? body.message ?? errorMessage;
+      const body2 = await response.json();
+      errorMessage = body2.error ?? body2.message ?? errorMessage;
     } catch {
     }
     process.stderr.write(`Error: ${errorMessage}
 `);
     process.exit(1);
   }
-  const { html } = await response.json();
+  const body = await response.json();
+  const html = body.content ?? body.html ?? "";
   const domProvider = new LinkedomProvider();
   const article = extractArticle(html, domProvider);
-  const engine = new ConversionEngine();
+  const engine = new ConversionEngine({ dom: linkedomDomEnvironment() });
   const result = await engine.convert(article.content, {
     format,
     preserveTables: true,
@@ -64589,8 +64831,8 @@ import { readFileSync as readFileSync5 } from "fs";
 import { resolve, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 var getVersion = () => {
-  if ("1.0.33") {
-    return "1.0.33";
+  if ("1.0.35") {
+    return "1.0.35";
   }
   try {
     const __dirname2 = dirname3(fileURLToPath(import.meta.url));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "formatferry",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "description": "Format Ferry CLI — Convert HTML, DOCX, PDF, XLSX, CSV, JSON, XML, PPTX to Markdown",
   "keywords": [
     "markdown",