@jayfong/x-utils 1.0.0-202407012223

package/_cjs/ai.js

@@ -0,0 +1,80 @@
+"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 ai_exports = {};
+__export(ai_exports, {
+  CozeAiProvider: () => CozeAiProvider,
+  XAi: () => XAi
+});
+module.exports = __toCommonJS(ai_exports);
+var import_vtils = require("vtils");
+var import_puppeteer = require("./puppeteer.js");
+class AiProvider {
+}
+class CozeAiProvider extends AiProvider {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  xp;
+  page;
+  async prepare() {
+    this.xp = new import_puppeteer.XPuppeteer();
+    await this.xp.connectSystemBrowser();
+    this.page = await this.xp.openPage(this.options.botUrl);
+  }
+  async ask(question) {
+    const page = this.page;
+    await page.evaluate(
+      () => document.querySelector("textarea:not([placeholder])").parentElement.parentElement.previousElementSibling.firstElementChild.click()
+    );
+    await (0, import_vtils.wait)(300);
+    await this.page.type("textarea:not([placeholder])", question);
+    await (0, import_vtils.wait)(500);
+    await this.page.keyboard.press("Enter");
+    await (0, import_vtils.wait)(1e3);
+    await (0, import_vtils.loopUntil)(
+      () => page.$$eval(
+        "button",
+        (els) => !els.find((el) => el.textContent.includes("Stop Responding"))?.parentElement.getBoundingClientRect().height
+      ),
+      {
+        retryDelay: 300
+      }
+    );
+    await (0, import_vtils.wait)(300);
+    const code = await page.$$eval(
+      'div[class^="code-area"]',
+      (els) => els.pop().querySelector('[class^="content"]').textContent
+    );
+    return code;
+  }
+}
+class XAi {
+  constructor(options) {
+    this.options = options;
+    this.provider = options.provider;
+  }
+  provider;
+  prepare = (0, import_vtils.memoize)(() => this.provider.prepare());
+  async ask(question) {
+    await this.prepare();
+    const answer = await this.provider.ask(question);
+    return answer;
+  }
+}

package/_cjs/cli.js

@@ -0,0 +1,51 @@
+"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 cli_exports = {};
+__export(cli_exports, {
+  XCli: () => XCli
+});
+module.exports = __toCommonJS(cli_exports);
+var import_cli_table3 = __toESM(require("cli-table3"), 1);
+var import_inquirer = __toESM(require("inquirer"), 1);
+class XCli {
+  static async prompt(options) {
+    const { x } = await import_inquirer.default.prompt({
+      name: "x",
+      message: options.message,
+      type: options.type,
+      default: options.default
+    });
+    return x;
+  }
+  static table(data) {
+    const table = new import_cli_table3.default();
+    table.push(...data);
+    return table.toString();
+  }
+}

package/_cjs/clipboard.js

@@ -0,0 +1,65 @@
+"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 clipboard_exports = {};
+__export(clipboard_exports, {
+  XClipboard: () => XClipboard
+});
+module.exports = __toCommonJS(clipboard_exports);
+var import_clipboardy = __toESM(require("clipboardy"), 1);
+var import_cmd = require("./cmd.js");
+class XClipboard {
+  static async readText() {
+    return import_clipboardy.default.read();
+  }
+  static async readHtml() {
+    const hex = await import_cmd.XCmd.exec(
+      // 读取剪切板为 HTML
+      // https://stackoverflow.com/questions/2545289/getting-rtf-data-out-of-mac-os-x-pasteboard-clipboard
+      // https://stackoverflow.com/a/17217886
+      `osascript -e "the clipboard as \xABclass HTML\xBB"`
+    );
+    const html = Buffer.from(
+      hex.substring(10, hex.length - 1),
+      "hex"
+    ).toString();
+    return html;
+  }
+  static async writeText(text) {
+    await import_clipboardy.default.write(text);
+  }
+  static async writeHtml(html) {
+    const hex = Buffer.from(html).toString("hex");
+    await import_cmd.XCmd.exec(
+      // 设置剪切板为 HTML
+      // https://stackoverflow.com/questions/11085654/apple-script-how-can-i-copy-html-content-to-the-clipboard
+      // https://stackoverflow.com/a/11089226
+      `osascript -e "set the clipboard to \xABdata HTML${hex}\xBB"`
+    );
+  }
+}

package/_cjs/cmd.js

@@ -0,0 +1,42 @@
+"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 cmd_exports = {};
+__export(cmd_exports, {
+  XCmd: () => XCmd
+});
+module.exports = __toCommonJS(cmd_exports);
+var import_execa = require("execa");
+class XCmd {
+  static execDivider = "clrue91c60000e6rl7w03b40p";
+  static async exec(command, options) {
+    const { stdout } = await (0, import_execa.execa)(
+      "zsh",
+      [
+        "-c",
+        `
+          echo ${XCmd.execDivider}
+          ${command}
+          echo ${XCmd.execDivider}
+        `
+      ],
+      options
+    );
+    return stdout.split(XCmd.execDivider)[1].trim();
+  }
+}

package/_cjs/crawler.js

@@ -0,0 +1,341 @@
+"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 crawler_exports = {};
+__export(crawler_exports, {
+  XCrawler: () => XCrawler
+});
+module.exports = __toCommonJS(crawler_exports);
+var import_x_request = require("@jayfong/x-request");
+var import_node_html_parser = require("node-html-parser");
+var import_vtils = require("vtils");
+var import_vae = require("vtils/vae");
+var import_ocr = require("./ocr.js");
+var import_puppeteer = require("./puppeteer.js");
+class XCrawler extends import_vtils.EventBus {
+  constructor(config) {
+    super();
+    this.config = config;
+    this.schemaMap = config.schema(import_vae.v);
+    if (config.listen) {
+      this.on("newData", (newData) => {
+        config.listen(newData);
+      });
+    }
+  }
+  schemaMap;
+  id = Date.now().toString(36);
+  normalizeUrl(pageUrl, url) {
+    url = url.trim();
+    return !url ? "" : (0, import_vtils.isUrl)(url) ? url : new URL(
+      url.startsWith(".") || url.startsWith("/") ? url : `/${url}`,
+      pageUrl
+    ).toString();
+  }
+  async fetchUrlHeadless(pageUrl, url, options) {
+    const text = await import_puppeteer.XPuppeteer.getPageHtml(this.normalizeUrl(pageUrl, url), {
+      headful: false,
+      proxy: this.config.proxy,
+      blockAssets: true,
+      instanceId: this.id,
+      ...options
+    });
+    return text;
+  }
+  async fetchUrlHeadful(pageUrl, url, options) {
+    const text = await import_puppeteer.XPuppeteer.getPageHtml(this.normalizeUrl(pageUrl, url), {
+      headful: true,
+      proxy: this.config.proxy,
+      blockAssets: true,
+      instanceId: this.id,
+      ...options
+    });
+    return text;
+  }
+  async fetchUrlRequest(pageUrl, url) {
+    const absoluteUrl = this.normalizeUrl(pageUrl, url);
+    const { data: text } = await import_x_request.xr.getText({
+      url: absoluteUrl,
+      autoReferer: true,
+      proxyUrl: this.config.proxy
+    });
+    return text;
+  }
+  async fetchUrl(pageUrl, url, engine, options) {
+    const text = engine === "headless" ? await this.fetchUrlHeadless(pageUrl, url, options) : engine === "headful" ? await this.fetchUrlHeadful(pageUrl, url, options) : await this.fetchUrlRequest(pageUrl, url);
+    return text;
+  }
+  async fetchUrlAsHTMLElement(pageUrl, url, engine, options) {
+    const text = await this.fetchUrl(pageUrl, url, engine, options);
+    return (0, import_node_html_parser.parse)(text);
+  }
+  async fetchUrlAsJSON(pageUrl, url, engine) {
+    const text = await this.fetchUrl(pageUrl, url, engine);
+    return JSON.parse(text);
+  }
+  async ocr(pageUrl, el) {
+    const imgDocs = el.querySelectorAll("img");
+    for (const imgDoc of imgDocs) {
+      const imgUrl = imgDoc.getAttribute("src");
+      if (imgUrl) {
+        const ocrText = await import_ocr.XOcr.recognize(
+          this.normalizeUrl(pageUrl, imgUrl)
+        );
+        imgDoc.replaceWith(`<div>${(0, import_vtils.escape)(ocrText)} </div>`);
+      }
+    }
+  }
+  findNextById = (0, import_vtils.memoize)((id) => {
+    const findNextById = (nexts) => {
+      for (const next of (0, import_vtils.castArray)(nexts)) {
+        if (typeof next !== "string") {
+          if (next.id === id) {
+            return next;
+          }
+          if (next.next) {
+            const _next = findNextById(next.next);
+            if (_next) {
+              return _next;
+            }
+          }
+        }
+      }
+    };
+    return this.config.next && findNextById(this.config.next);
+  });
+  pageUrlCache = /* @__PURE__ */ new Set();
+  async next(pageUrl, contentType, engine, elOrField, data, next, index, rootElement) {
+    if (next.filter && !await next.filter(data)) {
+      return;
+    }
+    contentType = next.contentType || contentType;
+    engine = next.engine || engine;
+    if (contentType === "json") {
+      const field = elOrField;
+      const nextFields = next.url ? await Promise.all(
+        (0, import_vtils.castArray)(
+          typeof next.url === "function" ? await next.url(data) : data[next.url]
+        ).map((url) => this.fetchUrlAsJSON(pageUrl, url, engine))
+      ) : !next.field || next.field === "." ? [field] : typeof next.field === "string" ? (0, import_vtils.get)(field, next.field) : (0, import_vtils.castArray)(await next.field(field));
+      for (const nextField of nextFields) {
+        const newData = (0, import_vtils.cloneDeepFast)(data);
+        if (next.extract) {
+          const fieldKeys = (0, import_vtils.keysStrict)(next.extract);
+          for (const fieldKey of fieldKeys) {
+            const fieldConfig = typeof next.extract[fieldKey] === "string" || typeof next.extract[fieldKey] === "function" || Array.isArray(next.extract[fieldKey]) ? { select: next.extract[fieldKey] } : next.extract[fieldKey];
+            let fieldValue = !fieldConfig.select || fieldConfig.select === "." ? nextField : typeof fieldConfig.select === "string" ? (0, import_vtils.get)(nextField, fieldConfig.select) : Array.isArray(fieldConfig.select) ? "TODO" : "TODO";
+            if (fieldValue != null) {
+              fieldValue = fieldConfig.transform ? await fieldConfig.transform(fieldValue) : fieldValue;
+              const fieldSchema = this.schemaMap[fieldKey];
+              fieldValue = fieldSchema.cast(fieldValue);
+              newData[fieldKey] = fieldValue;
+            }
+          }
+        }
+        if (next.next) {
+          for (const nextItem of (0, import_vtils.castArray)(next.next)) {
+            await this.next(
+              pageUrl,
+              contentType,
+              engine,
+              nextField,
+              newData,
+              typeof nextItem === "string" ? this.findNextById(nextItem) : nextItem,
+              0,
+              rootElement
+            );
+          }
+        } else {
+          this.emit("newData", newData);
+        }
+      }
+    } else {
+      const el = elOrField;
+      const nextEls = next.url ? await Promise.all(
+        next._url.map(
+          (fullUrl) => this.fetchUrlAsHTMLElement(
+            pageUrl,
+            fullUrl,
+            engine,
+            next.engineOptions
+          )
+        )
+      ) : !next.element || next.element === "." ? [el] : typeof next.element === "string" ? el.querySelectorAll(next.element) : (0, import_vtils.castArray)(
+        await next.element(el, {
+          index,
+          root: rootElement
+        })
+      );
+      const nextParamsList = [];
+      let nextElIndex = 0;
+      for (const nextEl of nextEls) {
+        const newData = (0, import_vtils.cloneDeepFast)(data);
+        if (next.extract) {
+          const fieldKeys = (0, import_vtils.keysStrict)(next.extract);
+          for (const fieldKey of fieldKeys) {
+            const fieldConfig = typeof next.extract[fieldKey] === "string" || typeof next.extract[fieldKey] === "function" || Array.isArray(next.extract[fieldKey]) ? { select: next.extract[fieldKey] } : next.extract[fieldKey];
+            const fieldEl = !fieldConfig.select || fieldConfig.select === "." ? nextEl : typeof fieldConfig.select === "string" ? nextEl.querySelector(fieldConfig.select) : Array.isArray(fieldConfig.select) ? nextEl.querySelectorAll(fieldConfig.select[0]).find((item) => {
+              const filter = fieldConfig.select[1];
+              return typeof filter === "string" ? item.text.includes(filter) : (0, import_vtils.isRegExp)(filter) ? filter.test(item.text) : filter(item);
+            }) : await fieldConfig.select(nextEl);
+            if (fieldEl != null) {
+              let fieldText = "";
+              if (typeof fieldEl === "string") {
+                fieldText = fieldEl.trim();
+              } else {
+                if (fieldConfig.ocr) {
+                  await this.ocr(pageUrl, fieldEl);
+                }
+                switch (fieldConfig.extract) {
+                  case "getHTML":
+                    fieldText = fieldEl.outerHTML;
+                    break;
+                  case "getFirstImageUrl":
+                    fieldText = this.normalizeUrl(
+                      pageUrl,
+                      fieldEl.getAttribute("src") || fieldEl.querySelector("img")?.getAttribute("src") || ""
+                    );
+                    break;
+                  case "getFirstLinkUrl":
+                    fieldText = this.normalizeUrl(
+                      pageUrl,
+                      fieldEl.getAttribute("href") || fieldEl.querySelector("a")?.getAttribute("href") || ""
+                    );
+                    break;
+                  default:
+                    fieldText = fieldEl.text.trim();
+                    break;
+                }
+              }
+              let fieldValue = fieldConfig.transform ? await fieldConfig.transform(fieldText) : fieldText;
+              const fieldSchema = this.schemaMap[fieldKey];
+              if (fieldSchema.options.type !== "array") {
+                fieldValue = fieldSchema.cast(fieldValue);
+              } else {
+                fieldValue = fieldSchema.cast([
+                  ...newData[fieldKey] || [],
+                  fieldValue
+                ]);
+              }
+              newData[fieldKey] = fieldValue;
+            }
+          }
+        }
+        if (next.next) {
+          const nexts = await Promise.all(
+            (0, import_vtils.castArray)(next.next).map(async (nextItem) => {
+              nextItem = (0, import_vtils.cloneDeepFast)(
+                typeof nextItem === "string" ? this.findNextById(nextItem) : nextItem
+              );
+              if (nextItem.url) {
+                nextItem._url = (0, import_vtils.castArray)(
+                  typeof nextItem.url === "function" ? await nextItem.url({
+                    data: newData,
+                    el: nextEl
+                  }) : newData[nextItem.url]
+                ).map((url) => this.normalizeUrl(pageUrl, url)).filter((fullUrl) => !this.pageUrlCache.has(fullUrl)).map((fullUrl) => {
+                  this.pageUrlCache.add(fullUrl);
+                  return fullUrl;
+                });
+              }
+              return nextItem;
+            })
+          );
+          let i = 0;
+          for (const nextItem of nexts) {
+            nextParamsList.push([
+              nextItem.url && nextItem._url[i] || pageUrl,
+              contentType,
+              engine,
+              nextEl,
+              newData,
+              nextItem,
+              nextElIndex,
+              rootElement
+            ]);
+            i++;
+          }
+        } else {
+          this.emit("newData", newData);
+        }
+        nextElIndex++;
+      }
+      for (const nextParams of nextParamsList) {
+        await this.next(...nextParams);
+        if (next.nextPageUrl) {
+          const nextPageUrl = await next.nextPageUrl({
+            data: nextParams[4],
+            el: nextParams[3],
+            url: nextParams[0]
+          });
+          if (nextPageUrl) {
+            const nextPageAbsoluteUrl = this.normalizeUrl(
+              nextParams[0],
+              nextPageUrl
+            );
+            if (nextPageAbsoluteUrl !== nextParams[0]) {
+              const nextPageElement = await this.fetchUrlAsHTMLElement(
+                nextPageAbsoluteUrl,
+                nextPageAbsoluteUrl,
+                engine,
+                this.config.engineOptions
+              );
+              await this.next(
+                nextPageAbsoluteUrl,
+                contentType,
+                engine,
+                nextPageElement,
+                nextParams[4],
+                (0, import_vtils.omitStrict)(next, ["url"]),
+                index,
+                rootElement
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  async start() {
+    const initialContentType = this.config.contentType || "html";
+    const initialEngine = this.config.engine || "request";
+    const rootElement = initialContentType === "json" ? await this.fetchUrlAsJSON(
+      this.config.entry,
+      this.config.entry,
+      initialEngine
+    ) : await this.fetchUrlAsHTMLElement(
+      this.config.entry,
+      this.config.entry,
+      initialEngine,
+      this.config.engineOptions
+    );
+    await this.next(
+      this.config.entry,
+      initialContentType,
+      initialEngine,
+      rootElement,
+      {},
+      {
+        extract: this.config.extract,
+        next: this.config.next
+      },
+      0,
+      rootElement
+    );
+  }
+}

package/_cjs/csv.js

@@ -0,0 +1,97 @@
+"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 csv_exports = {};
+__export(csv_exports, {
+  XCsv: () => XCsv
+});
+module.exports = __toCommonJS(csv_exports);
+var csv = __toESM(require("csv"), 1);
+var fs = __toESM(require("node:fs"), 1);
+var import_vtils = require("vtils");
+var import_date = require("vtils/date");
+class XCsv {
+  static async parse(value, options = {}) {
+    const res = [];
+    for await (const item of csv.parse(value, {
+      columns: true
+    })) {
+      res.push(
+        options.objectFieldNames?.length || options.booleanFieldNames?.length || options.dateFieldNames?.length || options.arrayFieldNames?.length && options.arrayDelimiter ? (0, import_vtils.mapValues)(item, (v, k) => {
+          if (options.arrayFieldNames.includes(k)) {
+            return v.split(options.arrayDelimiter).filter(Boolean);
+          }
+          if (options.objectFieldNames?.includes(k)) {
+            return v ? JSON.parse(v) : {};
+          }
+          if (options.booleanFieldNames?.includes(k)) {
+            return v ? v === 1 : void 0;
+          }
+          if (options.dateFieldNames?.includes(k)) {
+            return v ? new Date(v) : void 0;
+          }
+          return v;
+        }) : item
+      );
+    }
+    return res;
+  }
+  static async stringify(value, options = {}) {
+    let res = "";
+    for await (const line of csv.stringify(
+      options.objectFieldNames?.length || options.booleanFieldNames?.length || options.dateFieldNames?.length || options.arrayFieldNames?.length && options.arrayDelimiter ? value.map(
+        (item) => (0, import_vtils.mapValues)(item, (v, k) => {
+          if (options.arrayFieldNames.includes(k)) {
+            return v ? v.join(options.arrayDelimiter) : "";
+          }
+          if (options.objectFieldNames?.includes(k)) {
+            return JSON.stringify(v || {});
+          }
+          if (options.booleanFieldNames?.includes(k)) {
+            return v ? "1" : "0";
+          }
+          if (options.dateFieldNames?.includes(k)) {
+            return v ? (0, import_date.formatDate)(v, "yyyy-mm-dd hh:ii:ss") : v;
+          }
+          return v;
+        })
+      ) : value,
+      { header: true }
+    )) {
+      res += line;
+    }
+    return res;
+  }
+  static async read(file, options = {}) {
+    const value = await fs.promises.readFile(file, "utf8");
+    return XCsv.parse(value, options);
+  }
+  static async write(file, value, options = {}) {
+    await fs.promises.writeFile(file, await XCsv.stringify(value, options));
+  }
+}