meodp 0.0.1

package/dist/shared/meodp.6ae77875.cjs

@@ -0,0 +1,862 @@
+'use strict';
+
+const consola = require('consola');
+const PQueue = require('p-queue');
+const utils = require('consola/utils');
+const playwright = require('playwright');
+const path = require('node:path');
+const process = require('node:process');
+const dateFns = require('date-fns');
+const fs = require('fs-extra');
+const stripAnsi = require('strip-ansi');
+const winston = require('winston');
+const transports = require('winston/lib/winston/transports');
+const cliProgress = require('cli-progress');
+const Options = require('cli-progress/lib/options');
+const _defaultFormatBar = require('cli-progress/lib/format-bar');
+const _defaultFormatTime = require('cli-progress/lib/format-time');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const consola__default = /*#__PURE__*/_interopDefaultCompat(consola);
+const PQueue__default = /*#__PURE__*/_interopDefaultCompat(PQueue);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const stripAnsi__default = /*#__PURE__*/_interopDefaultCompat(stripAnsi);
+const winston__default = /*#__PURE__*/_interopDefaultCompat(winston);
+const transports__default = /*#__PURE__*/_interopDefaultCompat(transports);
+const cliProgress__default = /*#__PURE__*/_interopDefaultCompat(cliProgress);
+const Options__default = /*#__PURE__*/_interopDefaultCompat(Options);
+const _defaultFormatBar__default = /*#__PURE__*/_interopDefaultCompat(_defaultFormatBar);
+const _defaultFormatTime__default = /*#__PURE__*/_interopDefaultCompat(_defaultFormatTime);
+
+const siteUrlMap = /* @__PURE__ */ new Map();
+const PQueueMap = /* @__PURE__ */ new Map();
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+function logUrlItemInfo(urlItem) {
+  consola__default.info("urlItem", urlItem);
+}
+const _LocalLog = class _LocalLog {
+  constructor(options = {}) {
+    _LocalLog.options = options;
+    _LocalLog.nameRule = options.nameRule || "url";
+    _LocalLog.init(options);
+  }
+  /**
+   * @desc init ensure dir
+   */
+  static async init(options) {
+    const cwd = options?.cwd || process__default.cwd();
+    _LocalLog.rootLogFolder = path__default.resolve(cwd, "logs/meodp");
+    fs__default.ensureDirSync(this.rootLogFolder);
+    if (_LocalLog.nameRule === "timestamp") {
+      const now = dateFns.formatDate(/* @__PURE__ */ new Date(), "yyyy-MM-dd-HH-mm-ss");
+      this.logFolder = path__default.resolve(this.rootLogFolder, now);
+    } else {
+      this.logFolder = path__default.resolve(this.rootLogFolder);
+    }
+    fs__default.ensureDirSync(this.logFolder);
+    this.siteLogFolder = path__default.resolve(this.logFolder, "site");
+    fs__default.ensureDirSync(this.siteLogFolder);
+    this.linkLogFile = path__default.resolve(this.logFolder, "link.log");
+  }
+  /**
+   * @desc clean log
+   */
+  static async clean() {
+    await fs__default.remove(this.rootLogFolder);
+  }
+  static async log(filePath, ...args) {
+    const now = dateFns.formatDate(/* @__PURE__ */ new Date(), "yyyy-MM-dd HH:mm:ss");
+    const content = stripAnsi__default(`${[now, ...args].join(" ")}
+`);
+    await fs__default.appendFile(filePath, content);
+  }
+  /**
+   * @desc append log
+   */
+  static async SiteLog(urlItem, ...args) {
+    const logName = (urlItem.name || urlItem.url).replace("https://", "").replace("http://", "").replace(/\//g, "-");
+    const logPath = path__default.resolve(this.logFolder, urlItem.type, `${logName}.log`);
+    await _LocalLog.log(logPath, ...args);
+  }
+  /**
+   * console link log
+   */
+  static async linkLog(...args) {
+    await _LocalLog.log(this.linkLogFile, ...args);
+  }
+  static async logByType(urlItem, ...args) {
+    switch (urlItem.type) {
+      case "site":
+        this.SiteLog(urlItem, ...args);
+        break;
+      case "link":
+        this.linkLog(...args);
+        break;
+    }
+  }
+  /**
+   * @desc create log
+   */
+  static createLog(urlItem) {
+    return (...args) => {
+      _LocalLog.logByType(urlItem, ...args);
+    };
+  }
+};
+/**
+ * 日志根目录
+ */
+__publicField$1(_LocalLog, "rootLogFolder");
+/**
+ * rootLogFolder + yyyy-MM-dd-HH-mm-ss
+ */
+__publicField$1(_LocalLog, "logFolder");
+/**
+ * rootLogFolder + site
+ */
+__publicField$1(_LocalLog, "siteLogFolder");
+/**
+ * link.log
+ */
+__publicField$1(_LocalLog, "linkLogFile");
+/**
+ * 日志命名规则
+ * - timestamp: yyyy-MM-dd-HH-mm-ss 每次都会建立一个以时间戳命名的文件夹
+ * - url: url 在同一个文件夹下
+ */
+__publicField$1(_LocalLog, "nameRule");
+__publicField$1(_LocalLog, "options");
+let LocalLog = _LocalLog;
+const localLog = new LocalLog();
+
+const RAW_SYMBOLS = {
+  block: "\u2503",
+  start: "\u25D0",
+  pointer: "\u276F",
+  uncheck: "\u25CC",
+  success: "\u2714",
+  info: "\u2139",
+  warn: "\u26A0",
+  error: "\u2716",
+  line: "\u2502",
+  end: "\u2514"
+};
+const COLORFUL_SYMBOLS = {
+  block: utils.colors.bold(utils.colors.dim(RAW_SYMBOLS.block)),
+  start: utils.colors.magenta(RAW_SYMBOLS.start),
+  uncheck: utils.colors.gray(RAW_SYMBOLS.uncheck),
+  pointer: utils.colors.cyan(RAW_SYMBOLS.pointer),
+  success: utils.colors.green(RAW_SYMBOLS.success),
+  info: utils.colors.blue(RAW_SYMBOLS.info),
+  warn: utils.colors.yellow(RAW_SYMBOLS.warn),
+  error: utils.colors.red(RAW_SYMBOLS.error),
+  line: utils.colors.dim(RAW_SYMBOLS.line)
+};
+
+const formatter = (options, params, payload) => {
+  const { value, total } = params;
+  const formatTime = options.formatTime || _defaultFormatTime__default;
+  const formatBar = options.formatBar || _defaultFormatBar__default;
+  const bar = formatBar(params.progress, options);
+  const stopTime = params.stopTime || Date.now();
+  const elapsedTime = Math.round((stopTime - params.startTime) / 1e3);
+  const duration_formatted = formatTime(elapsedTime, options, 1);
+  consola__default.debug(duration_formatted);
+  if (!payload.type) {
+    options = Object.assign({}, options, cliProgress__default.Presets.rect);
+    Options__default.assignDerivedOptions(options);
+    const bar2 = formatBar(params.progress, options);
+    const { site } = payload;
+    const url = payload.url || "";
+    return `${bar2} ${value}/${total} | ${utils.colors.yellow(site || "MEODP Item")} | ${utils.colors.cyan(url || "URL")}`;
+  } else {
+    const { error_count, emoji, url, type } = payload;
+    const errorInfo = error_count ? `\u274C${error_count} ` : "";
+    return `${bar} \u2705${utils.colors.green(value)}/${total} ${errorInfo}| ${duration_formatted} | ${emoji} ${utils.colors.yellow(type)} | ${utils.colors.cyan(url)}`;
+  }
+};
+const multiBar = new cliProgress__default.MultiBar({
+  hideCursor: true,
+  // format: '{bar} {percentage}% | ✅{value}/{total} ❌{error_count} | {duration_formatted} | {name}',
+  format: formatter,
+  barsize: 20,
+  autopadding: true,
+  barCompleteChar: "\u2588",
+  barIncompleteChar: "\u2591",
+  // important! redraw everything to avoid "empty" completed bars
+  forceRedraw: true
+}, cliProgress__default.Presets.rect);
+const progressBarMap = /* @__PURE__ */ new Map();
+
+function formatArgs(args) {
+  return args.join(" ");
+}
+function getFormattedDataFromResponse(res) {
+  const statusCode = res?.status();
+  const statusText = res?.statusText();
+  const statusInfo = statusText ? `${statusCode?.toString()} ${statusText}` : statusCode?.toString();
+  const req = res.request();
+  const duration = req.timing().responseEnd - req.timing().requestStart;
+  const durationText = utils.colors.dim(`\u2502${utils.colors.blue(`${duration.toString().padStart(4, " ")}${utils.colors.white("ms")}`)} \u2502`);
+  return {
+    duration,
+    durationText,
+    statusCode,
+    statusText,
+    statusInfo,
+    linkText: utils.colors.dim(res.url())
+  };
+}
+
+function registerPageEvents(page, urlItem) {
+  const urlMap = /* @__PURE__ */ new Map();
+  const log = LocalLog.createLog(urlItem);
+  let respondNum = 0;
+  const curBar = progressBarMap.get("CURRENT");
+  page.on("request", (request) => {
+    if (urlMap.size === 0) {
+      curBar?.start(1, 0);
+    }
+    const requestUrl = request.url();
+    if (MEODP.isIgnoredLink(requestUrl)) {
+      urlMap.set(requestUrl, {
+        ignored: true,
+        request
+      });
+      return;
+    }
+    if (requestUrl && !urlMap.has(requestUrl)) {
+      urlMap.set(requestUrl, {
+        request
+      });
+    }
+    curBar?.setTotal(urlMap.size);
+  });
+  page.on("response", (response) => {
+    const request = response.request();
+    const item = urlMap.get(response.url());
+    if (!item || item.ignored) {
+      return;
+    }
+    urlMap.set(response.url(), {
+      request,
+      response
+    });
+    const urlInfo = urlMap.get(response.url());
+    if (!urlInfo)
+      return;
+    if (urlInfo.response)
+      return;
+    respondNum += 1;
+    const {
+      durationText,
+      statusInfo,
+      linkText
+    } = getFormattedDataFromResponse(response);
+    const info = `  [${statusInfo}] ${durationText} ${linkText}`;
+    if (response.status() >= 400) {
+      MEODP.logger.error(info);
+    } else {
+      MEODP.logger.info(info);
+    }
+    log(urlItem.type === "link" ? info.trim() : info);
+    curBar?.update(respondNum, {
+      site: urlItem.url,
+      url: response.url()
+    });
+  });
+  page.on("requestfailed", (request) => {
+    const url = request.url();
+    const urlInfo = urlMap.get(url);
+    if (!urlInfo?.ignored) {
+      urlMap.set(url, {
+        request,
+        failed: true
+      });
+    }
+  });
+  return urlMap;
+}
+
+function isLink(url) {
+  if (url) {
+    return url.startsWith("http") || url.startsWith("/");
+  } else {
+    return false;
+  }
+}
+
+function parseUrlMap(urlMap) {
+  const successCount = Array.from(urlMap.values()).filter(
+    (value) => value.response && value.response.status() && value.response.status() < 400
+  ).length;
+  const timeoutCount = Array.from(urlMap.values()).filter((value) => !value.response && !value.ignored).length;
+  const timeoutTxt = timeoutCount ? utils.colors.redBright(utils.colors.redBright(`(\u{1F6AB} ${timeoutCount} Timeout)`)) : "";
+  const failedCount = Array.from(urlMap.values()).filter((value) => {
+    return value.failed || value.response && value.response?.status() > 400;
+  }).length;
+  const ignoredCount = Array.from(urlMap.values()).filter((value) => value.ignored).length;
+  const success = {
+    count: successCount,
+    text: `${COLORFUL_SYMBOLS.success} ${utils.colors.green(`${successCount} OK`)}`
+  };
+  const timeout = {
+    count: timeoutCount,
+    text: timeoutTxt
+  };
+  const failedTxt = `${COLORFUL_SYMBOLS.error} ${failedCount} Failed`;
+  const failed = {
+    count: failedCount,
+    text: `${failedCount ? utils.colors.red(failedTxt) : utils.colors.dim(failedTxt)}`
+  };
+  const ignored = {
+    count: ignoredCount,
+    text: utils.colors.dim(`\u{1F47B} ${ignoredCount} Ignored`)
+  };
+  const total = {
+    count: urlMap.size,
+    text: `${urlMap.size} Total Requests`
+  };
+  return {
+    success,
+    failed,
+    /**
+     * Ignored links, controlled by `ignoreLinks` and `ignoreExtensions`
+     */
+    ignored,
+    timeout,
+    total
+  };
+}
+
+const emojiMap = {
+  site: "\u{1F3E0}",
+  link: "\u{1F517}",
+  sitemap: "\u{1F4C4}"
+};
+function getMEODPUrlItemInfo(urlItem) {
+  const type = typeof urlItem === "string" ? "link" : urlItem.type;
+  const url = typeof urlItem === "string" ? urlItem : urlItem.url;
+  const emoji = emojiMap[type] || "\u{1F517}";
+  return {
+    type,
+    url,
+    emoji
+  };
+}
+
+function createMEODPLogger() {
+  return {
+    _log: (...args) => {
+      const allLogPath = path__default.resolve(MEODP.logFolder, "all.log");
+      LocalLog.log(allLogPath, stripAnsi__default(args.join(" ")));
+    },
+    log: (...args) => {
+      const content = formatArgs(args);
+      consola__default.log(content);
+      MEODP.logger._log(content);
+    },
+    inner: (...args) => {
+      const content = formatArgs(args);
+      consola__default.log(COLORFUL_SYMBOLS.line, "  ", content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.line, "  ", content);
+    },
+    start: (...args) => {
+      const content = formatArgs(args);
+      consola__default.start(content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.start, content);
+    },
+    success: (...args) => {
+      const content = formatArgs(args);
+      consola__default.success(content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.success, content);
+    },
+    info: (...args) => {
+      const content = formatArgs(args);
+      consola__default.info(content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.info, content);
+    },
+    warn: (...args) => {
+      const content = formatArgs(args);
+      consola__default.warn(content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.warn, content);
+    },
+    error: (...args) => {
+      const content = formatArgs(args);
+      consola__default.log(COLORFUL_SYMBOLS.error, content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.error, content);
+      MEODP.wLogger.error(content);
+    }
+  };
+}
+
+function createWinstonLogger() {
+  const allLogPath = path__default.resolve(MEODP.logFolder, "all.log");
+  const errorLogPath = path__default.resolve(MEODP.logFolder, "error.log");
+  const customFormats = [
+    winston__default.format.timestamp({
+      format: "YYYY-MM-DD HH:mm:ss"
+    })
+    // winston.format.colorize(),
+    // winston.format.errors({ stack: true }),
+    // winston.format.json(),
+    // winston.format.simple(),
+    // winston.format.uncolorize(),
+  ];
+  customFormats.push(
+    winston__default.format.printf(({ level, message, timestamp, service }) => {
+      const content = [
+        timestamp,
+        `[${service}]`,
+        level.toUpperCase(),
+        message
+      ];
+      return content.join(" ");
+    })
+  );
+  const customTransports = [
+    new transports__default.File({
+      filename: errorLogPath,
+      level: "error"
+    }),
+    new transports__default.File({
+      filename: allLogPath
+      // level: 'info',
+    })
+  ];
+  return winston__default.createLogger({
+    level: "info",
+    format: winston__default.format.combine(...customFormats),
+    defaultMeta: { service: "MEODP" },
+    transports: customTransports,
+    exitOnError: false
+  });
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _MEODP = class _MEODP {
+  constructor(config) {
+    _MEODP.config = config;
+  }
+  static async init(config) {
+    _MEODP.config = config;
+    if (config.clean) {
+      console.log();
+      consola__default.start("Cleaning history log...");
+      await LocalLog.clean();
+      consola__default.success("Clean history log.");
+      console.log();
+    }
+    await LocalLog.init();
+    _MEODP.logFolder = LocalLog.logFolder || path__default.resolve(process__default.cwd(), "logs/meodp");
+    _MEODP.wLogger = createWinstonLogger();
+  }
+  /**
+   * filter link by ignoreLinks
+   */
+  static isIgnoredLink(link) {
+    const isIgnoredLinks = _MEODP.config.ignoreLinks?.some((ignoreLink) => {
+      if (ignoreLink instanceof RegExp) {
+        return ignoreLink.test(link);
+      } else if (link.startsWith(ignoreLink)) {
+        return true;
+      }
+      return false;
+    });
+    const isIgnoredExtensions = _MEODP.config.ignoreExtensions?.some((ext) => link.endsWith(ext));
+    return isIgnoredLinks || isIgnoredExtensions;
+  }
+  /**
+   * @desc 是否为外链
+   */
+  static isExternalLink(url, urlItem) {
+    return url.startsWith("http") && !url.startsWith(urlItem.url);
+  }
+  /**
+   * @desc 通用日志
+   * - 本地日志
+   * - winston 日志
+   */
+  static log(urlItem, ...args) {
+    _MEODP.logger.info(args);
+    LocalLog.logByType(urlItem, args.join(" "));
+  }
+};
+/**
+ * global config
+ */
+__publicField(_MEODP, "config");
+__publicField(_MEODP, "configFile");
+/**
+ * browser instance by playwright
+ */
+__publicField(_MEODP, "browser");
+/**
+ * log folder
+ * logs/meodp/
+ */
+__publicField(_MEODP, "logFolder");
+__publicField(_MEODP, "logger", createMEODPLogger());
+__publicField(_MEODP, "wLogger");
+let MEODP = _MEODP;
+
+async function getBrowser() {
+  if (!MEODP.browser) {
+    MEODP.browser = await playwright.chromium.launch({
+      // 15s
+      timeout: 15e3
+    });
+  }
+  return MEODP.browser;
+}
+
+async function getSiteLinks(page, options) {
+  const links = await page.$$eval("a", (elements) => {
+    return elements.map((element) => element.getAttribute("href")).filter(Boolean);
+  });
+  const filterLinks = links.map((link) => {
+    if (!isLink(link)) {
+      return false;
+    }
+    const isExternalLink = MEODP.isExternalLink(link, options.urlItem);
+    if (!isExternalLink) {
+      {
+        const url = new URL(link, page.url());
+        url.search = "";
+        return url.toString();
+      }
+    } else {
+      return link;
+    }
+  }).filter(Boolean);
+  return filterLinks;
+}
+async function checkUrlNomoduleAssets(page) {
+  const legacyScripts = await page.$$eval("script", (elements) => {
+    return elements.filter((element) => element.getAttribute("nomodule") && element.getAttribute("src")).map((el) => el.getAttribute("src"));
+  }).catch((e) => {
+    consola__default.error(e);
+  }) || [];
+  if (!legacyScripts.length)
+    return true;
+  const browser = await getBrowser();
+  const context = await browser.newContext();
+  const loadPromises = legacyScripts.map((nomoduleUrl) => {
+    return (async () => {
+      if (!nomoduleUrl) {
+        return;
+      }
+      const startTime = Date.now();
+      const newPage = await context.newPage();
+      const response = await newPage.goto(nomoduleUrl);
+      if (!response) {
+        return;
+      }
+      const {
+        statusCode,
+        statusInfo,
+        linkText
+      } = getFormattedDataFromResponse(response);
+      const duration = Date.now() - startTime;
+      const durationTxt = utils.colors.dim(`\u2502${utils.colors.blue(`${duration.toString().padStart(4, " ")}${utils.colors.white("ms")}`)} \u2502`);
+      if (statusCode >= 400) {
+        MEODP.logger.inner(" ", COLORFUL_SYMBOLS.error, utils.colors.red(statusInfo), durationTxt, linkText);
+      } else {
+        MEODP.logger.inner(" ", COLORFUL_SYMBOLS.success, utils.colors.green(statusInfo), durationTxt, linkText);
+      }
+      await newPage.close();
+      return statusCode ? statusCode < 400 : false;
+    })();
+  });
+  const results = await Promise.all(loadPromises);
+  return results.every((result) => result);
+}
+async function checkSiteUrl(url, options) {
+  const browser = await getBrowser();
+  const page = await browser.newPage();
+  const bar = progressBarMap.get(options.urlItem.url);
+  const startTime = Date.now();
+  const isExternalLink = MEODP.isExternalLink(url, options.urlItem);
+  const log = LocalLog.createLog(options.urlItem);
+  if (!MEODP.config.checkExternalLinks && isExternalLink) {
+    let res = null;
+    try {
+      res = await page.goto(url, {
+        waitUntil: "load"
+      });
+    } catch (e) {
+      MEODP.logger.error(e);
+    }
+    if (!res)
+      return;
+    const statusCode = res?.status() || 0;
+    const checkStatus = statusCode < 400 ? "passed" : "failed";
+    siteUrlMap.set(url, {
+      response: res,
+      statusCode,
+      checkStatus
+    });
+    MEODP.logger.log(COLORFUL_SYMBOLS.line, "  ", utils.colors.green(`[${statusCode}]`), utils.colors.cyan(url), utils.colors.dim(`(in ${((Date.now() - startTime) / 1e3).toFixed(2)}s)`));
+    return;
+  }
+  const urlMap = registerPageEvents(page, options.urlItem);
+  try {
+    const res = await page.goto(url, {
+      waitUntil: "networkidle"
+    });
+    const statusCode = res?.status() || 0;
+    siteUrlMap.set(url, {
+      response: res,
+      statusCode,
+      checkStatus: "goto"
+    });
+    const { success, failed, total, ignored, timeout } = parseUrlMap(urlMap);
+    const duration = (Date.now() - startTime) / 1e3;
+    const statusText = res?.statusText();
+    const logInfo = [
+      COLORFUL_SYMBOLS.line,
+      "  ",
+      utils.colors.green(`[${statusCode}${statusText ? ` ${statusText}` : ""}]`),
+      utils.colors.cyan(url),
+      utils.colors.dim(`(in ${duration}s)`),
+      total.text,
+      success.text,
+      failed.text,
+      timeout.text,
+      ignored.text
+    ];
+    MEODP.logger.log(...logInfo);
+    log(...logInfo);
+    log();
+    if (MEODP.config.log?.type === "progress") {
+      bar?.update(success.count, {
+        value: utils.colors.green(success.count),
+        error_count: failed.count ? utils.colors.red(failed.count) : 0
+      });
+    } else {
+    }
+  } catch (e) {
+    MEODP.logger.error(e);
+  }
+  for (const [url2, info] of urlMap) {
+    if (!info.response && !info.ignored) {
+      MEODP.logger.log(COLORFUL_SYMBOLS.line, "    ", COLORFUL_SYMBOLS.error, `Timeout: ${utils.colors.underline(url2)}`);
+    }
+  }
+  let noModuleAssetsPassed = true;
+  if (options.checkNoModule) {
+    noModuleAssetsPassed = await checkUrlNomoduleAssets(page);
+  }
+  const urlMapValues = Array.from(urlMap.values());
+  const siteUrlItem = siteUrlMap.get(url);
+  if (siteUrlItem) {
+    if (urlMapValues.every((value) => value.response?.status() && value.response?.status() < 400) && noModuleAssetsPassed) {
+      siteUrlItem.checkStatus = "passed";
+      const successCount = Array.from(siteUrlMap.values()).filter((value) => value.checkStatus === "passed").length;
+      bar?.update(successCount);
+    } else {
+      siteUrlItem.checkStatus = "failed";
+    }
+  }
+  if (!isExternalLink) {
+    const queue = PQueueMap.get(url);
+    if (queue) {
+      const links = await getSiteLinks(page, options);
+      for (const link of links) {
+        if (!siteUrlMap.has(link)) {
+          siteUrlMap.set(link, {
+            statusCode: 0,
+            checkStatus: "pending"
+          });
+          bar?.setTotal(siteUrlMap.size);
+          const url2 = new URL(link, page.url()).href;
+          await queue.add(async () => {
+            await checkSiteUrl(url2, options);
+          });
+        }
+      }
+    }
+  }
+  await page.close();
+}
+async function checkSite(props) {
+  const { url } = props;
+  const queue = new PQueue__default({
+    concurrency: MEODP.config.concurrency
+  });
+  PQueueMap.set(url, queue);
+  const bar = progressBarMap.get(url);
+  const browser = await getBrowser();
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  const homeUrl = url;
+  siteUrlMap.set(homeUrl, {
+    statusCode: 0,
+    checkStatus: "pending"
+  });
+  bar?.setTotal(siteUrlMap.size);
+  await checkSiteUrl(homeUrl, {
+    urlItem: props,
+    checkNoModule: true
+  });
+  await queue.onIdle();
+  await page.close();
+  await context.close();
+}
+
+async function checkLink(urlItem) {
+  const browser = await getBrowser();
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  const startTime = Date.now();
+  const { url } = urlItem;
+  const bar = progressBarMap.get(url);
+  const urlMap = registerPageEvents(page, urlItem);
+  const res = await page.goto(url, {
+    waitUntil: "networkidle"
+  });
+  const isHtml = res?.headers()["content-type"].includes("text/html");
+  if (isHtml) {
+    const { success, failed, total, ignored, timeout } = parseUrlMap(urlMap);
+    const duration = (Date.now() - startTime) / 1e3;
+    const statusCode = res?.status() || 0;
+    const statusText = res?.statusText();
+    const logInfo = [
+      COLORFUL_SYMBOLS.line,
+      "  ",
+      utils.colors.green(`[${statusCode}${statusText ? ` ${statusText}` : ""}]`),
+      utils.colors.cyan(url),
+      total.text,
+      utils.colors.dim(`(in ${duration}s)`),
+      success.text,
+      failed.text,
+      timeout.text,
+      ignored.text
+    ];
+    MEODP.logger.log(...logInfo);
+    bar?.setTotal(urlMap.size);
+    bar?.update(success.count);
+  } else {
+    bar?.update(1);
+  }
+  await checkUrlNomoduleAssets(page);
+  await page.close();
+  await context.close();
+}
+
+async function checkMEODPUrl(meodpUrl) {
+  if (typeof meodpUrl === "string") {
+    meodpUrl = {
+      type: "link",
+      url: meodpUrl
+    };
+  }
+  const { type, url, emoji } = getMEODPUrlItemInfo(meodpUrl);
+  MEODP.logger.log();
+  MEODP.logger.start(`${emoji} ${utils.colors.yellow(`[${type}]`)} ${utils.colors.cyan(url)}`);
+  const startTime = Date.now();
+  if (typeof meodpUrl === "object") {
+    switch (meodpUrl.type) {
+      case "site":
+        await checkSite(meodpUrl);
+        break;
+      case "link":
+        await checkLink(meodpUrl);
+        break;
+    }
+  }
+  const duration = Date.now() - startTime;
+  const bar = progressBarMap.get(meodpUrl.url);
+  bar?.stop();
+  MEODP.logger.success(`Done in ${duration / 1e3}s.`);
+}
+
+const defaultMEODPConfig = {
+  urls: [],
+  concurrency: 10,
+  log: {
+    type: "raw",
+    file: true
+  }
+};
+function defineConfig(config) {
+  return config;
+}
+async function runByConfig(config) {
+  const { urls, debug } = config;
+  consola__default.level = debug ? 5 : 3;
+  const queue = new PQueue__default({
+    concurrency: config.concurrency
+  });
+  if (config.log?.type === "progress") {
+    for (const urlItem of urls) {
+      const { type, url, emoji } = getMEODPUrlItemInfo(urlItem);
+      const bar = multiBar.create(1, 0, {
+        emoji,
+        url,
+        type,
+        error_count: 0
+      });
+      progressBarMap.set(url, bar);
+    }
+    const curBar = multiBar.create(1, 0, {
+      name: "CURRENT"
+    });
+    progressBarMap.set("CURRENT", curBar);
+  }
+  const browser = await getBrowser();
+  for (const urlItem of urls) {
+    await queue.add(async () => {
+      await checkMEODPUrl(urlItem);
+    });
+  }
+  await queue.onIdle();
+  if (config.log?.type === "progress") {
+    multiBar.stop();
+  }
+  await browser.close();
+  consola__default.debug("browser closed");
+  return true;
+}
+
+exports.LocalLog = LocalLog;
+exports.MEODP = MEODP;
+exports.PQueueMap = PQueueMap;
+exports.checkLink = checkLink;
+exports.checkMEODPUrl = checkMEODPUrl;
+exports.checkSite = checkSite;
+exports.checkSiteUrl = checkSiteUrl;
+exports.checkUrlNomoduleAssets = checkUrlNomoduleAssets;
+exports.createMEODPLogger = createMEODPLogger;
+exports.createWinstonLogger = createWinstonLogger;
+exports.defaultMEODPConfig = defaultMEODPConfig;
+exports.defineConfig = defineConfig;
+exports.emojiMap = emojiMap;
+exports.formatArgs = formatArgs;
+exports.getBrowser = getBrowser;
+exports.getFormattedDataFromResponse = getFormattedDataFromResponse;
+exports.getMEODPUrlItemInfo = getMEODPUrlItemInfo;
+exports.getSiteLinks = getSiteLinks;
+exports.isLink = isLink;
+exports.localLog = localLog;
+exports.logUrlItemInfo = logUrlItemInfo;
+exports.multiBar = multiBar;
+exports.parseUrlMap = parseUrlMap;
+exports.progressBarMap = progressBarMap;
+exports.registerPageEvents = registerPageEvents;
+exports.runByConfig = runByConfig;
+exports.siteUrlMap = siteUrlMap;