webforai 1.5.0 → 1.5.1

package/dist/cjs/cli/bin.js

@@ -0,0 +1,34 @@
+"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_handlers = require("./commands/handlers");
+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").argument("[source]", "URL or path to process").argument("[outputPath]", "Path to output file or directory").option("--mode <mode>", `Processing mode (${import_constants.MODES.join(", ")})`).option("--loader <loader>", `Loader to use (${import_constants.LOADERS.join(", ")})`).option("--baseUrl <baseUrl>", "Base URL for relative links").option("-o, --stdout", "output to stdout").option("-d, --debug", "output extra debugging information").on("option:debug", () => {
+  process.env.DEBUG = "true";
+}).action(import_handlers.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/handlers/index.js

@@ -0,0 +1,84 @@
+"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 handlers_exports = {};
+__export(handlers_exports, {
+  webforaiCommand: () => webforaiCommand
+});
+module.exports = __toCommonJS(handlers_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_prompts = require("@clack/prompts");
+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, initialOutputPath, options) => {
+  const sourcePath = initialPath ?? await (0, import_inputSourcePath.inputSourcePath)();
+  if (options.debug) {
+    console.debug(`sourcePath: ${sourcePath}`);
+  }
+  const loader = (0, import_utils.isUrl)(sourcePath) ? { type: "web", loader: options.loader ?? await (0, import_selectLoader.selectLoader)() } : { type: "local", loader: null };
+  if (options.debug) {
+    console.debug(`loader: ${loader}`);
+  }
+  const outputPath = initialOutputPath ?? await (0, import_inputOutputPath.inputOutputPath)(sourcePath);
+  if (options.debug) {
+    console.debug(`outputPath: ${outputPath}`);
+  }
+  const mode = options.mode ?? await (0, import_selectExtractMode.selectExtractMode)();
+  if (options.debug) {
+    console.debug(`mode: ${mode}`);
+  }
+  const content = await (0, import_loadHtml.loadHtml)(sourcePath, loader);
+  if (options.debug) {
+    console.debug(`content: ${content}`);
+  }
+  const markdown = (0, import_html_to_markdown.htmlToMarkdown)(content, {
+    baseUrl: (0, import_utils.isUrl)(sourcePath) ? sourcePath : options.baseUrl,
+    ...mode === "ai" ? aiModeOptions : readabilityModeOptions
+  });
+  if (options.debug) {
+    console.debug(`markdown: ${markdown}`);
+  }
+  const directory = import_node_path.default.dirname(outputPath);
+  if (!import_node_fs.default.existsSync(directory)) {
+    import_node_fs.default.mkdirSync(directory, { recursive: true });
+  }
+  import_node_fs.default.writeFileSync(outputPath, markdown);
+  (0, import_prompts.outro)("Markdown conversion is complete!");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  webforaiCommand
+});

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

@@ -0,0 +1,127 @@
+"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_prompts = require("@clack/prompts");
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_zx = require("zx");
+const loadHtml = async (sourcePath, loader) => {
+  const loadSpinner = (0, import_prompts.spinner)();
+  try {
+    switch (loader.type) {
+      case "local":
+        return await loadLocalHtml(sourcePath, loadSpinner);
+      case "web":
+        switch (loader.loader) {
+          case "fetch":
+            return await loadFetchHtml(sourcePath, loadSpinner);
+          case "playwright":
+            return await loadPlaywrightHtml(sourcePath, loadSpinner);
+          default:
+            throw new Error("Invalid loader");
+        }
+      default:
+        throw new Error("Invalid loader type");
+    }
+  } catch (error) {
+    loadSpinner.stop(import_picocolors.default.red("Content loading failed!"));
+    console.error(error);
+    process.exit(1);
+  }
+};
+const loadLocalHtml = async (sourcePath, loadSpinner) => {
+  loadSpinner.start("Retrieving content.");
+  try {
+    await import_promises.default.access(sourcePath);
+  } catch {
+    throw new Error("The file does not exist");
+  }
+  const stats = await import_promises.default.stat(sourcePath);
+  if (!stats.isFile()) {
+    throw new Error("The source must be a file");
+  }
+  const content = await import_promises.default.readFile(sourcePath, "utf-8");
+  loadSpinner.stop("Content retrieval is complete!");
+  return content;
+};
+const loadFetchHtml = async (sourcePath, loadSpinner) => {
+  loadSpinner.start("Downloading content.");
+  const { loadHtml: loadHtml2 } = await import("../../../loaders/fetch");
+  const content = await loadHtml2(sourcePath);
+  loadSpinner.stop("Content download is complete!");
+  return content;
+};
+const loadPlaywrightHtml = async (sourcePath, loadSpinner) => {
+  const launchSpinner = (0, import_prompts.spinner)();
+  launchSpinner.start("Launching playwright.");
+  const playwright = await import("playwright");
+  let browser;
+  try {
+    browser = await playwright.chromium.launch();
+    launchSpinner.stop("Playwright launched!");
+  } catch (error) {
+    await handlePlaywrightLaunchError(error);
+    browser = await playwright.chromium.launch();
+  }
+  loadSpinner.start("Loading content.");
+  const { loadHtml: loadHtml2 } = await import("../../../loaders/playwright");
+  const content = await loadHtml2(sourcePath, browser);
+  loadSpinner.stop("Content download is complete!");
+  await browser.close();
+  return content;
+};
+const handlePlaywrightLaunchError = async (error) => {
+  if (!error.message.includes("npx playwright install")) {
+    throw error;
+  }
+  const isInstall = await (0, import_prompts.confirm)({
+    message: "To continue, you will need to download a browser. Do you wish to continue?"
+  });
+  if (!isInstall) {
+    (0, import_prompts.cancel)("End of process.");
+    process.exit(1);
+  }
+  const installDepsSpinner = (0, import_prompts.spinner)();
+  installDepsSpinner.start("Installing browser dependencies.");
+  try {
+    await import_zx.$`npx playwright install`;
+    installDepsSpinner.stop("Browser dependencies installed!");
+  } catch (error2) {
+    installDepsSpinner.stop(import_picocolors.default.red("Browser dependencies failed to install!"));
+    throw error2;
+  }
+};
+// 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/{utils/bin-utils.js → cli/utils.js}

@@ -26,50 +26,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var bin_utils_exports = {};
-__export(bin_utils_exports, {
+var utils_exports = {};
+__export(utils_exports, {
   changeFileExtension: () => changeFileExtension,
   getNextAvailableFilePath: () => getNextAvailableFilePath,
   isUrl: () => isUrl,
-  logError: () => logError,
+  sourcePathToOutputPath: () => sourcePathToOutputPath,
   urlToFilename: () => urlToFilename
 });
-module.exports = __toCommonJS(bin_utils_exports);
+module.exports = __toCommonJS(utils_exports);
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
-var import_prompts = require("@clack/prompts");
-function logError(error) {
-  import_prompts.log.error("An error occurred during processing");
-  console.error(error.message);
-}
-function isUrl(str) {
+const isUrl = (maybeUrl) => {
   try {
-    new URL(str);
+    new URL(maybeUrl);
     return true;
   } catch {
     return false;
   }
-}
-function getNextAvailableFilePath(filePath) {
-  const parsedPath = import_node_path.default.parse(filePath);
-  const directory = parsedPath.dir;
-  const fullName = parsedPath.base;
-  const [firstPart, ...restParts] = fullName.split(".");
-  const restName = restParts.length > 0 ? `.${restParts.join(".")}` : "";
-  const baseName = firstPart.replace(/_\d+$/, "");
-  let counter = 1;
-  let nextFilePath = filePath;
-  while (import_node_fs.default.existsSync(nextFilePath)) {
-    const match = firstPart.match(/_(\d+)$/);
-    if (match) {
-      counter = Number.parseInt(match[1], 10) + 1;
-    }
-    const newName = `${baseName}_${counter}${restName}`;
-    nextFilePath = import_node_path.default.join(directory, newName);
-    counter++;
-  }
-  return nextFilePath;
-}
+};
 function changeFileExtension(filePath, newExtension) {
   const parsedPath = filePath.split("/");
   const fileName = parsedPath[parsedPath.length - 1];
@@ -114,11 +89,34 @@ function urlToFilename(url) {
     return "output";
   }
 }
+const sourcePathToOutputPath = (sourcePath) => {
+  return isUrl(sourcePath) ? `${urlToFilename(sourcePath)}.md` : changeFileExtension(sourcePath, "md");
+};
+function getNextAvailableFilePath(filePath) {
+  const parsedPath = import_node_path.default.parse(filePath);
+  const directory = parsedPath.dir;
+  const fullName = parsedPath.base;
+  const [firstPart, ...restParts] = fullName.split(".");
+  const restName = restParts.length > 0 ? `.${restParts.join(".")}` : "";
+  const baseName = firstPart.replace(/_\d+$/, "");
+  let counter = 1;
+  let nextFilePath = filePath;
+  while (import_node_fs.default.existsSync(nextFilePath)) {
+    const match = firstPart.match(/_(\d+)$/);
+    if (match) {
+      counter = Number.parseInt(match[1], 10) + 1;
+    }
+    const newName = `${baseName}_${counter}${restName}`;
+    nextFilePath = import_node_path.default.join(directory, newName);
+    counter++;
+  }
+  return nextFilePath;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   changeFileExtension,
   getNextAvailableFilePath,
   isUrl,
-  logError,
+  sourcePathToOutputPath,
   urlToFilename
 });