webforai 2.1.1 → 4.0.0

package/dist/cjs/platform/client.js

@@ -0,0 +1,204 @@
+"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 client_exports = {};
+__export(client_exports, {
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  createPlatformClient: () => createPlatformClient
+});
+module.exports = __toCommonJS(client_exports);
+var import_error = require("./error");
+var import_fetch = require("./fetch");
+var import_types = require("./types");
+const DEFAULT_BASE_URL = "https://platform.webforai.dev";
+const TERMINAL_STATES = /* @__PURE__ */ new Set(["completed", "failed"]);
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(signal.reason instanceof Error ? signal.reason : new Error("aborted"));
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(signal?.reason instanceof Error ? signal.reason : new Error("aborted"));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+const parseRetryAfter = (body, response) => {
+  const fromBody = body?.error?.retryAfter;
+  if (typeof fromBody === "number") {
+    return fromBody;
+  }
+  const header = Number(response.headers.get("retry-after"));
+  return Number.isFinite(header) && header > 0 ? header : void 0;
+};
+const dashboardHint = (status, dashboardUrl) => {
+  if (status === 401) {
+    return `create or check API keys at ${dashboardUrl}`;
+  }
+  if (status === 402) {
+    return `manage billing, credits and the spend cap at ${dashboardUrl}`;
+  }
+  return void 0;
+};
+const toApiError = (response, body, dashboardUrl) => {
+  const envelope = body;
+  const code = typeof envelope?.error?.code === "string" ? envelope.error.code : "invalid_response";
+  let message = typeof envelope?.error?.message === "string" ? envelope.error.message : `unexpected response (HTTP ${response.status})`;
+  const hint = code === "invalid_response" ? void 0 : dashboardHint(response.status, dashboardUrl);
+  if (hint && !message.includes("/dashboard")) {
+    message = `${message} (${hint})`;
+  }
+  return new import_error.PlatformApiError(code, message, response.status, parseRetryAfter(body, response));
+};
+const createPlatformClient = (options = {}) => {
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const dashboardUrl = `${baseUrl}/dashboard`;
+  const fetchImpl = (0, import_fetch.resolveFetch)(options.fetch);
+  const request = async (path, init) => {
+    const headers = { accept: "application/json" };
+    if (init.body !== void 0) {
+      headers["content-type"] = "application/json";
+    }
+    if (init.auth) {
+      if (!options.apiKey) {
+        throw new import_error.PlatformApiError(
+          "missing_api_key",
+          `This endpoint needs an API key: pass \`apiKey\` to createPlatformClient (create one at ${dashboardUrl}; 1,000 free credits/month).`,
+          0
+        );
+      }
+      headers.authorization = `Bearer ${options.apiKey}`;
+    }
+    const response = await fetchImpl(`${baseUrl}${path}`, {
+      method: init.method,
+      headers,
+      body: init.body === void 0 ? void 0 : JSON.stringify(init.body),
+      ...init.signal ? { signal: init.signal } : {}
+    });
+    const body = await response.json().catch(() => void 0);
+    if (!response.ok) {
+      throw toApiError(response, body, dashboardUrl);
+    }
+    if (body === void 0) {
+      throw new import_error.PlatformApiError("invalid_response", "response body is not JSON", response.status);
+    }
+    return body;
+  };
+  const getJob = (jobId, signal) => request(`/v1/jobs/${encodeURIComponent(jobId)}`, { method: "GET", auth: true, signal });
+  const getJobResults = (jobId, opts) => {
+    const query = opts?.cursor ? `?cursor=${encodeURIComponent(opts.cursor)}` : "";
+    return request(`/v1/jobs/${encodeURIComponent(jobId)}/results${query}`, { method: "GET", auth: true });
+  };
+  const resolveStored = async (resultUrl) => {
+    const response = await fetchImpl(resultUrl, { method: "GET" });
+    if (!response.ok) {
+      throw new import_error.PlatformApiError(
+        "artifact_fetch_failed",
+        `stored result fetch failed (HTTP ${response.status}) \u2014 result URLs expire after ~24h`,
+        response.status
+      );
+    }
+    return await response.json();
+  };
+  const getJobOrBackOff = async (jobId, signal, interval) => {
+    try {
+      return await getJob(jobId, signal);
+    } catch (error) {
+      if (!(error instanceof import_error.PlatformApiError && error.status === 429)) {
+        throw error;
+      }
+      await sleep(error.retryAfter !== void 0 ? error.retryAfter * 1e3 : interval, signal);
+      return void 0;
+    }
+  };
+  return {
+    scrape: (opts) => request("/v1/scrape", { method: "POST", body: opts, auth: true }),
+    scrapeAsync: (opts) => request("/v1/scrape", { method: "POST", body: { ...opts, async: true }, auth: true }),
+    batch: (opts) => request("/v1/batch", { method: "POST", body: opts, auth: true }),
+    crawl: (opts) => request("/v1/crawl", { method: "POST", body: opts, auth: true }),
+    getJob,
+    getJobResults,
+    waitForJob: async (jobId, opts = {}) => {
+      const interval = opts.pollIntervalMs ?? 2e3;
+      const timeout = opts.timeoutMs ?? 10 * 60 * 1e3;
+      if (!Number.isFinite(interval) || interval < 0 || interval > 2147483647) {
+        throw new RangeError("pollIntervalMs must be between 0 and 2147483647");
+      }
+      if (!Number.isFinite(timeout) || timeout <= 0 || timeout > 2147483647) {
+        throw new RangeError("timeoutMs must be greater than 0 and at most 2147483647");
+      }
+      opts.signal?.throwIfAborted();
+      const controller = new AbortController();
+      const { signal } = controller;
+      const onAbort = () => controller.abort(opts.signal?.reason);
+      opts.signal?.addEventListener("abort", onAbort, { once: true });
+      const timer = setTimeout(
+        () => controller.abort(new import_error.PlatformApiError("poll_timeout", `job ${jobId} did not finish within ${timeout}ms`, 0)),
+        timeout
+      );
+      let rejectOnAbort = () => {
+      };
+      const aborted = new Promise((_resolve, reject) => {
+        rejectOnAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", rejectOnAbort, { once: true });
+      });
+      const poll = async () => {
+        for (; ; ) {
+          signal.throwIfAborted();
+          const status = await getJobOrBackOff(jobId, signal, interval);
+          signal.throwIfAborted();
+          if (status === void 0) {
+            continue;
+          }
+          opts.onStatus?.(status);
+          if (TERMINAL_STATES.has(status.status)) {
+            return status;
+          }
+          await sleep(interval, signal);
+        }
+      };
+      try {
+        return await Promise.race([poll(), aborted]);
+      } finally {
+        clearTimeout(timer);
+        opts.signal?.removeEventListener("abort", onAbort);
+        signal.removeEventListener("abort", rejectOnAbort);
+      }
+    },
+    jobResults: async function* (jobId) {
+      let cursor;
+      do {
+        const page = await getJobResults(jobId, { cursor });
+        for (const item of page.results) {
+          yield (0, import_types.isStoredPageStub)(item) ? await resolveStored(item.resultUrl) : item;
+        }
+        cursor = page.cursor;
+      } while (cursor);
+    },
+    demoScrape: (opts) => request("/v1/demo/scrape", { method: "POST", body: opts, auth: false })
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_BASE_URL,
+  createPlatformClient
+});

package/dist/cjs/platform/error.js

@@ -0,0 +1,36 @@
+"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 error_exports = {};
+__export(error_exports, {
+  PlatformApiError: () => PlatformApiError
+});
+module.exports = __toCommonJS(error_exports);
+class PlatformApiError extends Error {
+  constructor(code, message, status, retryAfter) {
+    super(message);
+    this.name = "PlatformApiError";
+    this.code = code;
+    this.status = status;
+    this.retryAfter = retryAfter;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlatformApiError
+});

package/dist/cjs/platform/fetch.js

@@ -0,0 +1,37 @@
+"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 fetch_exports = {};
+__export(fetch_exports, {
+  resolveFetch: () => resolveFetch
+});
+module.exports = __toCommonJS(fetch_exports);
+const resolveFetch = (custom) => {
+  if (custom) {
+    return custom;
+  }
+  const globalFetch = globalThis.fetch;
+  if (typeof globalFetch !== "function") {
+    throw new Error("No global fetch in this runtime \u2014 pass a fetch implementation to createPlatformClient({ fetch })");
+  }
+  return globalFetch.bind(globalThis);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveFetch
+});

package/dist/cjs/platform/index.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 platform_exports = {};
+__export(platform_exports, {
+  CRAWL_SITEMAP_MODES: () => import_types.CRAWL_SITEMAP_MODES,
+  DEFAULT_BASE_URL: () => import_client.DEFAULT_BASE_URL,
+  ENGINES: () => import_types.ENGINES,
+  PlatformApiError: () => import_error.PlatformApiError,
+  REGIONS: () => import_types.REGIONS,
+  REQUESTED_ENGINES: () => import_types.REQUESTED_ENGINES,
+  createPlatformClient: () => import_client.createPlatformClient,
+  isStoredPageStub: () => import_types.isStoredPageStub
+});
+module.exports = __toCommonJS(platform_exports);
+var import_client = require("./client");
+var import_error = require("./error");
+var import_types = require("./types");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CRAWL_SITEMAP_MODES,
+  DEFAULT_BASE_URL,
+  ENGINES,
+  PlatformApiError,
+  REGIONS,
+  REQUESTED_ENGINES,
+  createPlatformClient,
+  isStoredPageStub
+});

package/dist/cjs/platform/types.js

@@ -0,0 +1,40 @@
+"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 types_exports = {};
+__export(types_exports, {
+  CRAWL_SITEMAP_MODES: () => CRAWL_SITEMAP_MODES,
+  ENGINES: () => ENGINES,
+  REGIONS: () => REGIONS,
+  REQUESTED_ENGINES: () => REQUESTED_ENGINES,
+  isStoredPageStub: () => isStoredPageStub
+});
+module.exports = __toCommonJS(types_exports);
+const ENGINES = ["fetch", "browser", "proxy-fetch", "proxy-browser"];
+const REQUESTED_ENGINES = [...ENGINES, "auto"];
+const REGIONS = ["auto", "jp"];
+const CRAWL_SITEMAP_MODES = ["skip", "include", "only"];
+const isStoredPageStub = (item) => item.status === "ok" && "resultUrl" in item;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CRAWL_SITEMAP_MODES,
+  ENGINES,
+  REGIONS,
+  REQUESTED_ENGINES,
+  isStoredPageStub
+});

package/dist/cjs/utils/hast-fast.js

@@ -0,0 +1,284 @@
+"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 hast_fast_exports = {};
+__export(hast_fast_exports, {
+  MetricsCollector: () => MetricsCollector,
+  asRoot: () => asRoot,
+  classList: () => classList,
+  cloneHast: () => cloneHast,
+  collectElements: () => collectElements,
+  findElement: () => findElement,
+  hasProperty: () => hasProperty,
+  isElement: () => isElement,
+  isParent: () => isParent,
+  isTruthyAttribute: () => isTruthyAttribute,
+  matchString: () => matchString,
+  numericProperty: () => numericProperty,
+  property: () => property,
+  pruneInPlace: () => pruneInPlace,
+  stringProperty: () => stringProperty,
+  walk: () => walk
+});
+module.exports = __toCommonJS(hast_fast_exports);
+const EMPTY_METRICS = { text: 0, link: 0, commas: 0, paragraphs: 0, elements: 0 };
+const COMMA_REGEX = /[,、，،]/g;
+const PARAGRAPH_LIKE = /* @__PURE__ */ new Set(["p", "pre", "li", "blockquote", "figcaption", "dd", "dt"]);
+const NON_PROSE_TAGS = /* @__PURE__ */ new Set(["script", "style", "noscript", "template", "svg", "math", "iframe", "object"]);
+const isElement = (node) => typeof node === "object" && node !== null && node.type === "element";
+const isParent = (node) => typeof node === "object" && node !== null && Array.isArray(node.children);
+const classList = (element) => {
+  const className = element.properties?.className;
+  if (Array.isArray(className)) {
+    return className;
+  }
+  if (typeof className === "string") {
+    return className.split(/\s+/).filter(Boolean);
+  }
+  return [];
+};
+const matchString = (element) => {
+  const id = element.properties?.id;
+  const classes = classList(element);
+  if (!id && classes.length === 0) {
+    return element.tagName;
+  }
+  return `${element.tagName} ${typeof id === "string" ? id : ""} ${classes.join(" ")}`;
+};
+class MetricsCollector {
+  #cache = /* @__PURE__ */ new WeakMap();
+  metrics(node) {
+    if (node.type === "text") {
+      const value = node.value;
+      if (value.trim().length === 0) {
+        return EMPTY_METRICS;
+      }
+      return {
+        text: value.length,
+        link: 0,
+        commas: (value.match(COMMA_REGEX) ?? []).length,
+        paragraphs: 0,
+        elements: 0
+      };
+    }
+    if (!isParent(node)) {
+      return EMPTY_METRICS;
+    }
+    const cached = this.#cache.get(node);
+    if (cached) {
+      return cached;
+    }
+    if (isElement(node) && NON_PROSE_TAGS.has(node.tagName)) {
+      this.#cache.set(node, EMPTY_METRICS);
+      return EMPTY_METRICS;
+    }
+    let text = 0;
+    let link = 0;
+    let commas = 0;
+    let paragraphs = 0;
+    let elements = 0;
+    for (const child of node.children) {
+      const childMetrics = this.metrics(child);
+      text += childMetrics.text;
+      link += childMetrics.link;
+      commas += childMetrics.commas;
+      paragraphs += childMetrics.paragraphs;
+      elements += childMetrics.elements;
+      if (isElement(child)) {
+        elements += 1;
+        if (PARAGRAPH_LIKE.has(child.tagName)) {
+          paragraphs += 1;
+        }
+      }
+    }
+    if (isElement(node) && node.tagName === "a") {
+      link = text;
+    }
+    const metrics = { text, link, commas, paragraphs, elements };
+    this.#cache.set(node, metrics);
+    return metrics;
+  }
+  textLength(node) {
+    return this.metrics(node).text;
+  }
+  /** Fraction of a subtree's text that is link anchor text. `0` for empty subtrees. */
+  linkDensity(node) {
+    const { text, link } = this.metrics(node);
+    if (text === 0) {
+      return 0;
+    }
+    return Math.min(1, link / text);
+  }
+}
+const pruneInPlace = (tree, keep) => {
+  if (!isParent(tree)) {
+    return tree;
+  }
+  const stack = [tree];
+  while (stack.length > 0) {
+    const parent = stack.pop();
+    const children = parent.children;
+    let write = 0;
+    for (let read = 0; read < children.length; read++) {
+      const child = children[read];
+      if (!keep(child)) {
+        continue;
+      }
+      children[write++] = child;
+      if (isParent(child)) {
+        stack.push(child);
+      }
+    }
+    children.length = write;
+  }
+  return tree;
+};
+const walk = (tree, visit) => {
+  const stack = [{ node: tree, parent: void 0 }];
+  while (stack.length > 0) {
+    const { node, parent } = stack.pop();
+    if (visit(node, parent) === false) {
+      continue;
+    }
+    if (isParent(node)) {
+      for (let i = node.children.length - 1; i >= 0; i--) {
+        stack.push({ node: node.children[i], parent: node });
+      }
+    }
+  }
+};
+const collectElements = (tree, predicate) => {
+  const found = [];
+  walk(tree, (node) => {
+    if (isElement(node) && predicate(node)) {
+      found.push(node);
+    }
+  });
+  return found;
+};
+const findElement = (tree, predicate) => {
+  let found;
+  walk(tree, (node) => {
+    if (found) {
+      return false;
+    }
+    if (isElement(node) && predicate(node)) {
+      found = node;
+      return false;
+    }
+  });
+  return found;
+};
+const cloneHast = (tree) => {
+  try {
+    return structuredClone(tree);
+  } catch {
+    return manualClone(tree);
+  }
+};
+const manualClone = (node) => {
+  if (Array.isArray(node)) {
+    return node.map(manualClone);
+  }
+  if (typeof node !== "object" || node === null) {
+    return node;
+  }
+  const copy = {};
+  for (const [key, value] of Object.entries(node)) {
+    copy[key] = manualClone(value);
+  }
+  return copy;
+};
+const asRoot = (nodes) => {
+  if (Array.isArray(nodes)) {
+    return { type: "root", children: nodes };
+  }
+  return nodes;
+};
+const property = (element, key) => {
+  const properties = element.properties;
+  if (!properties) {
+    return void 0;
+  }
+  const direct = properties[key];
+  if (direct !== void 0) {
+    return direct;
+  }
+  if (!(key.includes("-") || key.includes(":"))) {
+    return void 0;
+  }
+  return properties[camelCaseAttribute(key)];
+};
+const camelCaseAttribute = (key) => key.replace(/[-:]([a-z])/g, (_, character) => character.toUpperCase());
+const numericProperty = (element, key) => {
+  const raw = property(element, key);
+  if (typeof raw === "number") {
+    return Number.isFinite(raw) ? raw : void 0;
+  }
+  if (typeof raw === "string" && raw.length > 0) {
+    const parsed = Number.parseFloat(raw);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+};
+const stringProperty = (element, key) => {
+  const raw = property(element, key);
+  if (typeof raw === "string") {
+    return raw;
+  }
+  if (Array.isArray(raw)) {
+    return raw.join(" ");
+  }
+  if (raw === true) {
+    return "";
+  }
+  return void 0;
+};
+const hasProperty = (element, key) => property(element, key) !== void 0;
+const isTruthyAttribute = (element, key) => {
+  const raw = property(element, key);
+  if (raw === void 0 || raw === null || raw === false) {
+    return false;
+  }
+  if (raw === true) {
+    return true;
+  }
+  if (typeof raw === "string") {
+    return raw.toLowerCase() !== "false";
+  }
+  return true;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MetricsCollector,
+  asRoot,
+  classList,
+  cloneHast,
+  collectElements,
+  findElement,
+  hasProperty,
+  isElement,
+  isParent,
+  isTruthyAttribute,
+  matchString,
+  numericProperty,
+  property,
+  pruneInPlace,
+  stringProperty,
+  walk
+});

package/dist/constants.js

@@ -1,6 +1,6 @@
 // src/constants.ts
-import { takumiExtractor } from "./extractors/presets/takumi.js";
-var DEFAULT_EXTRACTORS = [takumiExtractor];
+import { autoExtractor } from "./extractors/presets/auto.js";
+var DEFAULT_EXTRACTORS = [autoExtractor];
 export {
   DEFAULT_EXTRACTORS
 };