@jayfong/x-utils 1.0.0-202510061015 → 3.3.0

package/crawler.js

@@ -1,332 +0,0 @@
-import { xr } from "@jayfong/x-request";
-import { parse as parseHTML } from "node-html-parser";
-import {
-  EventBus,
-  castArray,
-  cloneDeepFast,
-  escape,
-  get,
-  isRegExp,
-  isUrl,
-  keysStrict,
-  memoize,
-  omitStrict
-} from "vtils";
-import { v } from "vtils/vae";
-import { XOcr } from "./ocr.js";
-import { XPuppeteer } from "./puppeteer.js";
-class XCrawler extends EventBus {
-  constructor(config) {
-    super();
-    this.config = config;
-    this.schemaMap = config.schema(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 ? "" : isUrl(url) ? url : new URL(
-      url.startsWith(".") || url.startsWith("/") ? url : `/${url}`,
-      pageUrl
-    ).toString();
-  }
-  async fetchUrlHeadless(pageUrl, url, options) {
-    const text = await 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 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 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 parseHTML(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 XOcr.recognize(
-          this.normalizeUrl(pageUrl, imgUrl)
-        );
-        imgDoc.replaceWith(`<div>${escape(ocrText)} </div>`);
-      }
-    }
-  }
-  findNextById = memoize((id) => {
-    const findNextById = (nexts) => {
-      for (const next of 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(
-        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" ? get(field, next.field) : castArray(await next.field(field));
-      for (const nextField of nextFields) {
-        const newData = cloneDeepFast(data);
-        if (next.extract) {
-          const fieldKeys = 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" ? 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 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) : castArray(
-        await next.element(el, {
-          index,
-          root: rootElement
-        })
-      );
-      const nextParamsList = [];
-      let nextElIndex = 0;
-      for (const nextEl of nextEls) {
-        const newData = cloneDeepFast(data);
-        if (next.extract) {
-          const fieldKeys = 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) : 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(
-            castArray(next.next).map(async (nextItem) => {
-              nextItem = cloneDeepFast(
-                typeof nextItem === "string" ? this.findNextById(nextItem) : nextItem
-              );
-              if (nextItem.url) {
-                nextItem._url = 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],
-                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
-    );
-  }
-}
-export {
-  XCrawler
-};

package/csv.d.ts

@@ -1,14 +0,0 @@
-export type XCsvParseOptions = {
-    arrayFieldNames?: string[];
-    arrayDelimiter?: string;
-    objectFieldNames?: string[];
-    booleanFieldNames?: string[];
-    dateFieldNames?: string[];
-};
-export type XCsvStringifyOptions = XCsvParseOptions;
-export declare class XCsv {
-    static parse<T>(value: string, options?: XCsvParseOptions): Promise<T[]>;
-    static stringify(value: any[], options?: XCsvStringifyOptions): Promise<string>;
-    static read<T>(file: string, options?: XCsvParseOptions): Promise<T[]>;
-    static write(file: string, value: any, options?: XCsvStringifyOptions): Promise<void>;
-}

package/csv.js

@@ -1,67 +0,0 @@
-import * as csv from "csv";
-import * as fs from "node:fs";
-import { mapValues } from "vtils";
-import { formatDate } from "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 ? 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) => 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 ? 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));
-  }
-}
-export {
-  XCsv
-};

package/data_set.d.ts

@@ -1,22 +0,0 @@
-import { OmitStrict } from 'vtils/types';
-import { VaeObjectSchemaShapeOf, v } from 'vtils/vae';
-export type XDataSetOptions<T extends Record<string, any>, K extends keyof T> = {
-    storeFile: string;
-    dataSchema: (_: typeof v) => VaeObjectSchemaShapeOf<T>;
-    dataKey: K;
-    csvArrayDelimiter?: string;
-    autoWriteInterval?: number;
-    noAutoWrite?: boolean;
-};
-export declare class XDataSet<T extends Record<string, any>, K extends keyof T> {
-    private options;
-    private storeType;
-    private dataShapeSchema;
-    private dataSchema;
-    private csvOptions;
-    currentMap: Record<T[K], OmitStrict<T, K>>;
-    get current(): T[];
-    constructor(options: XDataSetOptions<T, K>);
-    read(): Promise<T[]>;
-    write(dataSet?: T[]): Promise<void>;
-}

package/data_set.js

@@ -1,85 +0,0 @@
-import { asyncExitHook } from "exit-hook";
-import fs from "fs-extra";
-import * as path from "node:path";
-import { keyBy, keysStrict, pickStrict } from "vtils";
-import { v } from "vtils/vae";
-import { XCsv } from "./csv.js";
-import { XJson } from "./json.js";
-import { XYaml } from "./yaml.js";
-class XDataSet {
-  constructor(options) {
-    this.options = options;
-    this.storeType = options.storeFile.endsWith(".csv") ? "csv" : options.storeFile.endsWith(".yaml") || options.storeFile.endsWith(".yml") ? "yaml" : "json";
-    this.dataShapeSchema = options.dataSchema(v);
-    this.dataSchema = v.object(this.dataShapeSchema);
-    this.csvOptions = {
-      arrayDelimiter: options.csvArrayDelimiter,
-      arrayFieldNames: keysStrict(this.dataShapeSchema).filter(
-        (key) => this.dataShapeSchema[key].options.type === "array"
-      ),
-      objectFieldNames: keysStrict(this.dataShapeSchema).filter(
-        (key) => this.dataShapeSchema[key].options.type === "object"
-      ),
-      booleanFieldNames: keysStrict(this.dataShapeSchema).filter(
-        (key) => this.dataShapeSchema[key].options.type === "boolean"
-      ),
-      dateFieldNames: keysStrict(this.dataShapeSchema).filter(
-        (key) => this.dataShapeSchema[key].options.type === "date"
-      )
-    };
-    if (!options.noAutoWrite) {
-      const timer = setInterval(() => {
-        this.write();
-      }, options.autoWriteInterval || 5e3);
-      asyncExitHook(
-        async () => {
-          clearInterval(timer);
-          await this.write();
-        },
-        {
-          wait: 1e4
-        }
-      );
-    }
-  }
-  storeType;
-  dataShapeSchema;
-  dataSchema;
-  csvOptions;
-  currentMap;
-  get current() {
-    const orderedDataFieldNames = keysStrict(this.dataShapeSchema);
-    const dataSet = keysStrict(this.currentMap).map((dataKeyValue) => {
-      const data = {
-        ...this.currentMap[dataKeyValue],
-        [this.options.dataKey]: dataKeyValue
-      };
-      return this.dataSchema.cast(
-        pickStrict(data, orderedDataFieldNames)
-      );
-    });
-    return dataSet;
-  }
-  async read() {
-    let dataSet = [];
-    try {
-      dataSet = await (this.storeType === "csv" ? XCsv.read(this.options.storeFile, this.csvOptions) : this.storeType === "yaml" ? XYaml.read(this.options.storeFile) : XJson.read(this.options.storeFile));
-    } catch {
-    }
-    dataSet = dataSet.map((data) => this.dataSchema.cast(data));
-    this.currentMap = keyBy(
-      dataSet,
-      (data) => data[this.options.dataKey]
-    );
-    return dataSet;
-  }
-  async write(dataSet = this.current) {
-    console.log(`\u{1F4A5} \u5199\u5165 ${this.options.storeFile}`);
-    await fs.ensureDir(path.dirname(this.options.storeFile));
-    await (this.storeType === "csv" ? XCsv.write(this.options.storeFile, dataSet, this.csvOptions) : this.storeType === "yaml" ? XYaml.write(this.options.storeFile, dataSet) : XJson.write(this.options.storeFile, dataSet));
-    console.log(`\u2705 \u5199\u5165 ${this.options.storeFile}`);
-  }
-}
-export {
-  XDataSet
-};

package/env.d.ts

@@ -1,6 +0,0 @@
-export declare class XEnv {
-    private static getEnvVarsFromFile;
-    static getEnvVar<T>(name: string, mode?: string): Promise<T | undefined>;
-    static getEnvVars(mode?: string): Promise<Record<string, any>>;
-    static extendProcessEnv(mode?: string): Promise<void>;
-}

package/env.js

@@ -1,52 +0,0 @@
-import dotenv from "dotenv";
-import { isPlainObject, memoize } from "vtils";
-import { XFs } from "./fs.js";
-import { XPath } from "./path.js";
-import { XYaml } from "./yaml.js";
-class XEnv {
-  static getEnvVarsFromFile = memoize(
-    async function get(mode = "", local = false) {
-      const envVars = mode ? await XEnv.getEnvVarsFromFile("") : {};
-      const baseName = local ? `.env${mode ? `.${mode}` : ""}.local` : `.env${mode ? `.${mode}` : ""}`;
-      const envYmlFile = XPath.join(process.cwd(), `${baseName}.yml`);
-      const envYamlFile = XPath.join(process.cwd(), `${baseName}.yaml`);
-      const dotenvFile = XPath.join(process.cwd(), baseName);
-      if (await XFs.pathExists(envYmlFile)) {
-        Object.assign(envVars, await XYaml.read(envYmlFile));
-      } else if (await XFs.pathExists(envYamlFile)) {
-        Object.assign(envVars, await XYaml.read(envYamlFile));
-      } else if (await XFs.pathExists(dotenvFile)) {
-        const dotenvContent = await XFs.readFile(dotenvFile, "utf-8");
-        Object.assign(envVars, await dotenv.parse(dotenvContent));
-      }
-      if (!local) {
-        const localEnvVars = await XEnv.getEnvVarsFromFile(mode, true);
-        Object.assign(envVars, localEnvVars);
-      }
-      return envVars;
-    },
-    (mode, local) => `${mode}_${local}`
-  );
-  static async getEnvVar(name, mode = process.env.X_ENV_MODE || "") {
-    if (process.env[name] != null) {
-      return process.env[name];
-    }
-    const envVars = await XEnv.getEnvVarsFromFile(mode);
-    return isPlainObject(envVars) ? envVars[name] ?? void 0 : void 0;
-  }
-  static async getEnvVars(mode = process.env.X_ENV_MODE || "") {
-    const envVars = await XEnv.getEnvVarsFromFile(mode);
-    return isPlainObject(envVars) ? envVars : {};
-  }
-  static async extendProcessEnv(mode = process.env.X_ENV_MODE || "") {
-    const envVars = await XEnv.getEnvVarsFromFile(mode);
-    if (isPlainObject(envVars)) {
-      Object.keys(envVars).forEach((env) => {
-        process.env[env] = envVars[env];
-      });
-    }
-  }
-}
-export {
-  XEnv
-};

package/fs.d.ts

@@ -1,23 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import fs from 'fs-extra';
-import { NeedleOptions } from 'needle';
-import { Readable } from 'node:stream';
-export type XFsExtraImageInfo = {
-    /** 图片宽度(单位: 像素) */
-    width: number;
-    /** 图片高度(单位: 像素) */
-    height: number;
-    /** 图片类型: jpg, png... */
-    type: string;
-    /** 图片 Mime 类型: image/jpg, image/png... */
-    mime: string;
-};
-export declare const XFs: typeof fs & {
-    getMimeType(extOrName: string): string;
-    getExtension(typeOrName: string): string;
-    toBuffer(file: Buffer | Readable): Promise<Buffer>;
-    toText(file: Buffer | Readable): Promise<string>;
-    toMaskImage(file: Buffer | Readable): Promise<Buffer>;
-    getImageInfo(urlOrStreamOrBuffer: string | Buffer | Readable, options?: NeedleOptions): Promise<XFsExtraImageInfo | null>;
-};

package/fs.js

@@ -1,56 +0,0 @@
-import fs from "fs-extra";
-import mime from "mime";
-import probeImageSize from "probe-image-size";
-const XFsExtra = {
-  getMimeType(extOrName) {
-    return mime.getType(extOrName) || "application/octet-stream";
-  },
-  getExtension(typeOrName) {
-    if (typeOrName.includes(".")) {
-      return typeOrName.split(".").pop();
-    }
-    return mime.getExtension(typeOrName) || "";
-  },
-  async toBuffer(file) {
-    if (Buffer.isBuffer(file)) {
-      return file;
-    }
-    const chunks = [];
-    for await (const chunk of file) {
-      chunks.push(chunk);
-    }
-    const buffer = Buffer.concat(chunks);
-    return buffer;
-  },
-  async toText(file) {
-    const buffer = Buffer.isBuffer(file) ? file : await XFsExtra.toBuffer(file);
-    return buffer.toString("utf-8");
-  },
-  async toMaskImage(file) {
-    const buffers = [
-      // PNG 文件头
-      // https://zh.wikipedia.org/wiki/PNG
-      Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
-      await XFsExtra.toBuffer(file)
-    ];
-    return Buffer.concat(buffers);
-  },
-  async getImageInfo(urlOrStreamOrBuffer, options) {
-    return typeof urlOrStreamOrBuffer === "string" ? probeImageSize(urlOrStreamOrBuffer, {
-      rejectUnauthorized: false,
-      ...options,
-      headers: {
-        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/7.0.17(0x17001126) NetType/WIFI Language/zh_CN",
-        Referer: urlOrStreamOrBuffer,
-        ...options?.headers
-      }
-    }) : Buffer.isBuffer(urlOrStreamOrBuffer) ? probeImageSize.sync(urlOrStreamOrBuffer) : probeImageSize(urlOrStreamOrBuffer, true);
-  }
-};
-const XFs = {
-  ...fs,
-  ...XFsExtra
-};
-export {
-  XFs
-};

package/html.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="node" />
-import { ParagraphChild } from 'docx';
-export { HTMLElement as XHtmlElement, NodeType as XHtmlNodeType, } from 'node-html-parser';
-export declare class XHtml {
-    static parse(html: string): import("node-html-parser").HTMLElement;
-    static toDocxParagraphChildren(html: string, fetchImage: (url: string) => Promise<Buffer>): Promise<ParagraphChild[]>;
-}