webforai 1.5.0 → 1.6.0

package/dist/cjs/cli/bin.js

@@ -0,0 +1,33 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_prompts = require("@clack/prompts");
+var import_commander = require("commander");
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_package = __toESM(require("../../package.json"), 1);
+var import_webforai = require("./commands/webforai");
+var import_constants = require("./constants");
+import_commander.program.name("webforai").description("CLI tool for ultra-precise HTML to Markdown conversion").version(import_package.default.version, "-v, --version", "output the current version");
+import_commander.program.argument("[source]", "URL or path to process").option("-o, --output <output>", "Path to output file or directory").option("-m, --mode <mode>", `Processing mode (${import_constants.MODES.join(", ")})`).option("-l, --loader <loader>", `Loader to use (${import_constants.LOADERS.join(", ")})`).option("-d, --debug", "output extra debugging information").action(import_webforai.webforaiCommand);
+(0, import_prompts.intro)(import_picocolors.default.inverse(`webforai CLI version ${import_package.default.version}`));
+import_commander.program.parse();

package/dist/cjs/cli/commands/webforai/index.js

@@ -0,0 +1,86 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webforai_exports = {};
+__export(webforai_exports, {
+  webforaiCommand: () => webforaiCommand
+});
+module.exports = __toCommonJS(webforai_exports);
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_prompts = require("@clack/prompts");
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_package = __toESM(require("../../../../package.json"), 1);
+var import_html_to_markdown = require("../../../html-to-markdown");
+var import_inputOutputPath = require("../../helpers/inputOutputPath");
+var import_inputSourcePath = require("../../helpers/inputSourcePath");
+var import_selectExtractMode = require("../../helpers/selectExtractMode");
+var import_selectLoader = require("../../helpers/selectLoader");
+var import_utils = require("../../utils");
+var import_loadHtml = require("./loadHtml");
+const aiModeOptions = { linkAsText: true, tableAsText: true, hideImage: true };
+const readabilityModeOptions = { linkAsText: false, tableAsText: false, hideImage: false };
+const webforaiCommand = async (initialPath, options) => {
+  (0, import_prompts.intro)(import_picocolors.default.bold(import_picocolors.default.green(`webforai CLI version ${import_package.default.version}`)));
+  const sourcePath = initialPath ?? await (0, import_inputSourcePath.inputSourcePath)();
+  options.debug && console.debug(`sourcePath: ${sourcePath}`);
+  const loader = (0, import_utils.isUrl)(sourcePath) ? options.loader ?? await (0, import_selectLoader.selectLoader)() : "local";
+  options.debug && console.debug(`loader: ${loader}`);
+  const outputPath = options.output ?? await (0, import_inputOutputPath.inputOutputPath)(sourcePath);
+  options.debug && console.debug(`outputPath: ${outputPath}`);
+  const mode = options.mode ?? await (0, import_selectExtractMode.selectExtractMode)();
+  options.debug && console.debug(`mode: ${mode}`);
+  let html;
+  const s = (0, import_prompts.spinner)();
+  try {
+    s.start("Loading content...");
+    html = await (0, import_loadHtml.loadHtml)(sourcePath, loader, { debug: options.debug });
+    s.stop(import_picocolors.default.green("Content loaded!"));
+  } catch (error) {
+    s.stop(import_picocolors.default.red("Content loading failed!"));
+    console.error(error);
+    process.exit(1);
+  }
+  options.debug && console.debug(`html: ${html}`);
+  const markdown = (0, import_html_to_markdown.htmlToMarkdown)(html, {
+    baseUrl: (0, import_utils.isUrl)(sourcePath) ? sourcePath : void 0,
+    ...mode === "ai" ? aiModeOptions : readabilityModeOptions
+  });
+  options.debug && console.debug(`markdown: ${markdown}`);
+  const directory = import_node_path.default.dirname(outputPath);
+  const isDirectoryExists = await import_promises.default.stat(directory).then((stat) => stat.isDirectory());
+  if (!isDirectoryExists) {
+    await import_promises.default.mkdir(directory, { recursive: true });
+  }
+  await import_promises.default.writeFile(outputPath, markdown);
+  (0, import_prompts.outro)(import_picocolors.default.green(`${import_picocolors.default.bold("Done!")} Markdown saved to ${outputPath}`));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  webforaiCommand
+});

package/dist/cjs/cli/commands/webforai/loadHtml.js

@@ -0,0 +1,93 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loadHtml_exports = {};
+__export(loadHtml_exports, {
+  loadHtml: () => loadHtml
+});
+module.exports = __toCommonJS(loadHtml_exports);
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_playwright_core = require("playwright-core");
+var import_package = __toESM(require("playwright-core/package.json"), 1);
+var import_fetch = require("../../../loaders/fetch");
+var import_playwright = require("../../../loaders/playwright");
+const checkPlaywrightAvailable = async () => {
+  const path = import_playwright_core.chromium.executablePath();
+  const isAvailable = await import_promises.default.access(path).catch(() => false);
+  return !!isAvailable;
+};
+const loadHtml = async (sourcePath, loader, options) => {
+  if (loader === "local") {
+    options.debug && console.debug(`Loading HTML from local file: ${sourcePath}`);
+    const content = await import_promises.default.readFile(sourcePath, "utf-8");
+    options.debug && console.debug(`HTML loaded: ${content.slice(0, 100)}`);
+    return content;
+  }
+  if (loader === "fetch") {
+    options.debug && console.debug(`Loading HTML from URL: ${sourcePath}`);
+    const content = await (0, import_fetch.loadHtml)(sourcePath);
+    options.debug && console.debug(`HTML loaded: ${content.slice(0, 100)}`);
+    return content;
+  }
+  if (loader === "playwright") {
+    options.debug && console.debug(`Loading HTML from playwright: ${sourcePath}`);
+    const isPlaywrightAvailable = await checkPlaywrightAvailable();
+    options.debug && console.debug(`Playwright available: ${isPlaywrightAvailable}`);
+    if (!isPlaywrightAvailable) {
+      const message = [
+        "To use playwright loader, you need to install playwright.",
+        "You can install it by running:",
+        "",
+        `	${import_picocolors.default.bold(`npx playwright@${import_package.default.version} install chromium`)}	`,
+        "",
+        "Hint1: If you get warning like this:",
+        "WARNING: It looks like you are running 'npx playwright install' without first installing your project's dependencies. ",
+        `${import_picocolors.default.bold("Ignore this warning.")}`,
+        "",
+        "Hint2: If you get message like this:",
+        "Host system is missing dependencies to run browsers.",
+        "You should install dependencies by running:",
+        "",
+        `	${import_picocolors.default.bold(`sudo npx playwright@${import_package.default.version} install-deps`)}	`,
+        "",
+        import_picocolors.default.gray("Note: Good luck with that.")
+      ];
+      console.info(message.join("\n"));
+      throw new Error("Playwright is not available");
+    }
+    const content = await (0, import_playwright.loadHtml)(sourcePath);
+    options.debug && console.debug(`HTML loaded: ${content.slice(0, 100)}`);
+    return content;
+  }
+  throw new Error(`Unsupported loader: ${loader}`);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadHtml
+});

package/dist/cjs/cli/constants.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_PATH: () => DEFAULT_PATH,
+  LOADERS: () => LOADERS,
+  MODES: () => MODES
+});
+module.exports = __toCommonJS(constants_exports);
+const DEFAULT_PATH = "https://example.com";
+const LOADERS = ["fetch", "playwright"];
+const MODES = ["default", "ai"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PATH,
+  LOADERS,
+  MODES
+});

package/dist/cjs/cli/helpers/assertContinue.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var assertContinue_exports = {};
+__export(assertContinue_exports, {
+  assertContinue: () => assertContinue
+});
+module.exports = __toCommonJS(assertContinue_exports);
+var import_prompts = require("@clack/prompts");
+function assertContinue(message, cancelMessage = "Canceled.") {
+  if ((0, import_prompts.isCancel)(message)) {
+    (0, import_prompts.cancel)(cancelMessage);
+    process.exit(1);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertContinue
+});

package/dist/cjs/cli/helpers/inputOutputPath.js

@@ -0,0 +1,89 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inputOutputPath_exports = {};
+__export(inputOutputPath_exports, {
+  inputOutputPath: () => inputOutputPath
+});
+module.exports = __toCommonJS(inputOutputPath_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_prompts = require("@clack/prompts");
+var import_utils = require("../utils");
+var import_assertContinue = require("./assertContinue");
+const inputOutputPath = async (sourcePath) => {
+  const outputPath = await (0, import_prompts.text)({
+    message: "Enter the output file path:",
+    placeholder: "output.md",
+    initialValue: (0, import_utils.sourcePathToOutputPath)(sourcePath),
+    validate: (value) => {
+      if (value.trim() === "") {
+        return "Output path is required";
+      }
+      if (import_node_fs.default.existsSync(value) && import_node_fs.default.statSync(value).isDirectory()) {
+        return "No directory can be specified.";
+      }
+      if (!import_node_fs.default.existsSync(value) && value.endsWith("/")) {
+        return "No directory can be specified.";
+      }
+    }
+  });
+  (0, import_assertContinue.assertContinue)(outputPath);
+  if (!import_node_fs.default.existsSync(outputPath)) {
+    return outputPath;
+  }
+  const isOutputFileOverwrite = await (0, import_prompts.confirm)({
+    message: "The file already exists. Overwrite?",
+    initialValue: false
+  });
+  (0, import_assertContinue.assertContinue)(isOutputFileOverwrite);
+  if (isOutputFileOverwrite) {
+    return outputPath;
+  }
+  const escapedOutputPath = await (0, import_prompts.text)({
+    message: "Enter the output file path:",
+    placeholder: "output.md",
+    initialValue: (0, import_utils.getNextAvailableFilePath)(outputPath),
+    validate: (value) => {
+      if (value.trim() === "") {
+        return "Output path is required";
+      }
+      if (import_node_fs.default.existsSync(value)) {
+        return "The file already exists";
+      }
+      if (!import_node_fs.default.existsSync(value) && value.endsWith("/")) {
+        return "No directory can be specified.";
+      }
+    }
+  });
+  (0, import_assertContinue.assertContinue)(escapedOutputPath);
+  return escapedOutputPath;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inputOutputPath
+});

package/dist/cjs/cli/helpers/inputSourcePath.js

@@ -0,0 +1,64 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inputSourcePath_exports = {};
+__export(inputSourcePath_exports, {
+  inputSourcePath: () => inputSourcePath
+});
+module.exports = __toCommonJS(inputSourcePath_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_prompts = require("@clack/prompts");
+var import_constants = require("../constants");
+var import_utils = require("../utils");
+var import_assertContinue = require("./assertContinue");
+const inputSourcePath = async () => {
+  const result = await (0, import_prompts.text)({
+    message: "Enter the URL or html path to be converted to markdown:",
+    placeholder: import_constants.DEFAULT_PATH,
+    initialValue: "",
+    validate: (value) => {
+      if (value.trim() === "") {
+        return "Source is required";
+      }
+      if (!(0, import_utils.isUrl)(value)) {
+        if (!import_node_fs.default.existsSync(value)) {
+          return "It appears that you are specifying a local file, but the file cannot be found. hint: when specifying a url, start with http or https.";
+        }
+        if (import_node_fs.default.statSync(value).isDirectory()) {
+          return "You are specifying a local file, but you cannot specify a directory. hint: when specifying a url, start with http or https.";
+        }
+      }
+    }
+  });
+  (0, import_assertContinue.assertContinue)(result);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inputSourcePath
+});

package/dist/cjs/cli/helpers/selectExtractMode.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var selectExtractMode_exports = {};
+__export(selectExtractMode_exports, {
+  selectExtractMode: () => selectExtractMode
+});
+module.exports = __toCommonJS(selectExtractMode_exports);
+var import_prompts = require("@clack/prompts");
+var import_constants = require("../constants");
+var import_assertContinue = require("./assertContinue");
+const selectExtractMode = async () => {
+  const result = await (0, import_prompts.select)({
+    message: "Select processing mode:",
+    options: import_constants.MODES.map((mode) => ({ value: mode, label: mode })),
+    initialValue: import_constants.MODES[0]
+  });
+  (0, import_assertContinue.assertContinue)(result);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  selectExtractMode
+});

package/dist/cjs/cli/helpers/selectLoader.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var selectLoader_exports = {};
+__export(selectLoader_exports, {
+  selectLoader: () => selectLoader
+});
+module.exports = __toCommonJS(selectLoader_exports);
+var import_prompts = require("@clack/prompts");
+var import_constants = require("../constants");
+var import_assertContinue = require("./assertContinue");
+const loadersHint = {
+  fetch: "Fetch HTML content from the given URL",
+  playwright: "Retrieve HTML content after rendering using Playwright; Playwright must be installed in advance.",
+  puppeteer: "Retrieve HTML content after rendering using Puppeteer; Puppeteer must be installed in advance."
+};
+const selectLoader = async () => {
+  const result = await (0, import_prompts.select)({
+    message: "Select loader:",
+    initialValue: "fetch",
+    options: import_constants.LOADERS.map((mode) => ({ value: mode, label: mode, hint: loadersHint[mode] || "" }))
+  });
+  (0, import_assertContinue.assertContinue)(result);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  selectLoader
+});

package/dist/cjs/cli/utils.js

@@ -0,0 +1,89 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  changeFileExtension: () => changeFileExtension,
+  getNextAvailableFilePath: () => getNextAvailableFilePath,
+  isUrl: () => isUrl,
+  sourcePathToOutputPath: () => sourcePathToOutputPath,
+  urlToFilename: () => urlToFilename
+});
+module.exports = __toCommonJS(utils_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+const isUrl = (maybeUrl) => {
+  try {
+    new URL(maybeUrl);
+    return true;
+  } catch {
+    return false;
+  }
+};
+function changeFileExtension(filePath, newExtension) {
+  const parsed = import_node_path.default.parse(filePath);
+  const ext = newExtension.startsWith(".") ? newExtension : `.${newExtension}`;
+  return import_node_path.default.format({ ...parsed, ext });
+}
+function urlToFilename(url) {
+  try {
+    const urlObj = new URL(url);
+    const hostname = urlObj.hostname.startsWith("www.") ? urlObj.hostname.slice(4) : urlObj.hostname;
+    const domainParts = hostname.split(".").slice(-2).join("-");
+    const pathParts = urlObj.pathname.split("/").filter(Boolean);
+    const relevantPathParts = pathParts.slice(-2).map(decodeURIComponent).join("-");
+    let filename = [domainParts, relevantPathParts].filter(Boolean).join("-");
+    filename = filename.toLowerCase().replace(/[<>:"/\\|?*\x00-\x1F]/g, "").replace(/[\s.]+/g, "-").replace(/^-+|-+$/g, "");
+    return filename || "output";
+  } catch {
+    return "output";
+  }
+}
+const sourcePathToOutputPath = (sourcePath) => isUrl(sourcePath) ? `${urlToFilename(sourcePath)}.md` : changeFileExtension(sourcePath, "md");
+function getNextAvailableFilePath(filePath) {
+  const parsed = import_node_path.default.parse(filePath);
+  const dir = parsed.dir;
+  const ext = parsed.ext;
+  const baseName = parsed.name.replace(/_\d+$/, "");
+  const match = parsed.name.match(/_(\d+)$/);
+  let counter = match ? Number(match[1]) + 1 : 1;
+  let newPath = import_node_path.default.join(dir, `${baseName}_${counter}${ext}`);
+  while (import_node_fs.default.existsSync(newPath)) {
+    counter++;
+    newPath = import_node_path.default.join(dir, `${baseName}_${counter}${ext}`);
+  }
+  return newPath;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  changeFileExtension,
+  getNextAvailableFilePath,
+  isUrl,
+  sourcePathToOutputPath,
+  urlToFilename
+});

package/dist/cjs/extract-hast/index.js

@@ -30,17 +30,18 @@ const PRESET_EXTRACT_HAST = {
   readability: import_readability.readabilityExtractHast
 };
 const DEFAULT_EXTRACT_HAST = ["readability"];
-const extractHast = (hast, extractors = DEFAULT_EXTRACT_HAST) => {
+const extractHast = (params, extractors = DEFAULT_EXTRACT_HAST) => {
+  const { hast, lang } = params;
   const _extractors = Array.isArray(extractors) ? extractors : [extractors];
   const extracted = _extractors.reduce((acc, extractor) => {
     if (extractor === false) {
       return acc;
     }
     if (typeof extractor === "string" && extractor in PRESET_EXTRACT_HAST) {
-      return PRESET_EXTRACT_HAST[extractor](acc);
+      return PRESET_EXTRACT_HAST[extractor]({ hast: acc, lang });
     }
     if (typeof extractor === "function") {
-      return extractor(acc);
+      return extractor({ hast: acc, lang });
     }
     throw new Error(`Invalid extractor: ${extractor}`);
   }, hast) || hast;