meodp 0.0.1

package/dist/shared/meodp.faa3c78c.mjs

@@ -0,0 +1,819 @@
+import consola from 'consola';
+import PQueue from 'p-queue';
+import { colors } from 'consola/utils';
+import { chromium } from 'playwright';
+import path from 'node:path';
+import process from 'node:process';
+import { formatDate } from 'date-fns';
+import fs from 'fs-extra';
+import stripAnsi from 'strip-ansi';
+import winston from 'winston';
+import transports from 'winston/lib/winston/transports';
+import cliProgress from 'cli-progress';
+import Options from 'cli-progress/lib/options';
+import _defaultFormatBar from 'cli-progress/lib/format-bar';
+import _defaultFormatTime from 'cli-progress/lib/format-time';
+
+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.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.cwd();
+    _LocalLog.rootLogFolder = path.resolve(cwd, "logs/meodp");
+    fs.ensureDirSync(this.rootLogFolder);
+    if (_LocalLog.nameRule === "timestamp") {
+      const now = formatDate(/* @__PURE__ */ new Date(), "yyyy-MM-dd-HH-mm-ss");
+      this.logFolder = path.resolve(this.rootLogFolder, now);
+    } else {
+      this.logFolder = path.resolve(this.rootLogFolder);
+    }
+    fs.ensureDirSync(this.logFolder);
+    this.siteLogFolder = path.resolve(this.logFolder, "site");
+    fs.ensureDirSync(this.siteLogFolder);
+    this.linkLogFile = path.resolve(this.logFolder, "link.log");
+  }
+  /**
+   * @desc clean log
+   */
+  static async clean() {
+    await fs.remove(this.rootLogFolder);
+  }
+  static async log(filePath, ...args) {
+    const now = formatDate(/* @__PURE__ */ new Date(), "yyyy-MM-dd HH:mm:ss");
+    const content = stripAnsi(`${[now, ...args].join(" ")}
+`);
+    await fs.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.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: colors.bold(colors.dim(RAW_SYMBOLS.block)),
+  start: colors.magenta(RAW_SYMBOLS.start),
+  uncheck: colors.gray(RAW_SYMBOLS.uncheck),
+  pointer: colors.cyan(RAW_SYMBOLS.pointer),
+  success: colors.green(RAW_SYMBOLS.success),
+  info: colors.blue(RAW_SYMBOLS.info),
+  warn: colors.yellow(RAW_SYMBOLS.warn),
+  error: colors.red(RAW_SYMBOLS.error),
+  line: colors.dim(RAW_SYMBOLS.line)
+};
+
+const formatter = (options, params, payload) => {
+  const { value, total } = params;
+  const formatTime = options.formatTime || _defaultFormatTime;
+  const formatBar = options.formatBar || _defaultFormatBar;
+  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.debug(duration_formatted);
+  if (!payload.type) {
+    options = Object.assign({}, options, cliProgress.Presets.rect);
+    Options.assignDerivedOptions(options);
+    const bar2 = formatBar(params.progress, options);
+    const { site } = payload;
+    const url = payload.url || "";
+    return `${bar2} ${value}/${total} | ${colors.yellow(site || "MEODP Item")} | ${colors.cyan(url || "URL")}`;
+  } else {
+    const { error_count, emoji, url, type } = payload;
+    const errorInfo = error_count ? `\u274C${error_count} ` : "";
+    return `${bar} \u2705${colors.green(value)}/${total} ${errorInfo}| ${duration_formatted} | ${emoji} ${colors.yellow(type)} | ${colors.cyan(url)}`;
+  }
+};
+const multiBar = new cliProgress.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.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 = colors.dim(`\u2502${colors.blue(`${duration.toString().padStart(4, " ")}${colors.white("ms")}`)} \u2502`);
+  return {
+    duration,
+    durationText,
+    statusCode,
+    statusText,
+    statusInfo,
+    linkText: 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 ? colors.redBright(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} ${colors.green(`${successCount} OK`)}`
+  };
+  const timeout = {
+    count: timeoutCount,
+    text: timeoutTxt
+  };
+  const failedTxt = `${COLORFUL_SYMBOLS.error} ${failedCount} Failed`;
+  const failed = {
+    count: failedCount,
+    text: `${failedCount ? colors.red(failedTxt) : colors.dim(failedTxt)}`
+  };
+  const ignored = {
+    count: ignoredCount,
+    text: 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.resolve(MEODP.logFolder, "all.log");
+      LocalLog.log(allLogPath, stripAnsi(args.join(" ")));
+    },
+    log: (...args) => {
+      const content = formatArgs(args);
+      consola.log(content);
+      MEODP.logger._log(content);
+    },
+    inner: (...args) => {
+      const content = formatArgs(args);
+      consola.log(COLORFUL_SYMBOLS.line, "  ", content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.line, "  ", content);
+    },
+    start: (...args) => {
+      const content = formatArgs(args);
+      consola.start(content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.start, content);
+    },
+    success: (...args) => {
+      const content = formatArgs(args);
+      consola.success(content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.success, content);
+    },
+    info: (...args) => {
+      const content = formatArgs(args);
+      consola.info(content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.info, content);
+    },
+    warn: (...args) => {
+      const content = formatArgs(args);
+      consola.warn(content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.warn, content);
+    },
+    error: (...args) => {
+      const content = formatArgs(args);
+      consola.log(COLORFUL_SYMBOLS.error, content);
+      MEODP.logger._log(COLORFUL_SYMBOLS.error, content);
+      MEODP.wLogger.error(content);
+    }
+  };
+}
+
+function createWinstonLogger() {
+  const allLogPath = path.resolve(MEODP.logFolder, "all.log");
+  const errorLogPath = path.resolve(MEODP.logFolder, "error.log");
+  const customFormats = [
+    winston.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.format.printf(({ level, message, timestamp, service }) => {
+      const content = [
+        timestamp,
+        `[${service}]`,
+        level.toUpperCase(),
+        message
+      ];
+      return content.join(" ");
+    })
+  );
+  const customTransports = [
+    new transports.File({
+      filename: errorLogPath,
+      level: "error"
+    }),
+    new transports.File({
+      filename: allLogPath
+      // level: 'info',
+    })
+  ];
+  return winston.createLogger({
+    level: "info",
+    format: winston.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.start("Cleaning history log...");
+      await LocalLog.clean();
+      consola.success("Clean history log.");
+      console.log();
+    }
+    await LocalLog.init();
+    _MEODP.logFolder = LocalLog.logFolder || path.resolve(process.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 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.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 = colors.dim(`\u2502${colors.blue(`${duration.toString().padStart(4, " ")}${colors.white("ms")}`)} \u2502`);
+      if (statusCode >= 400) {
+        MEODP.logger.inner(" ", COLORFUL_SYMBOLS.error, colors.red(statusInfo), durationTxt, linkText);
+      } else {
+        MEODP.logger.inner(" ", COLORFUL_SYMBOLS.success, 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, "  ", colors.green(`[${statusCode}]`), colors.cyan(url), 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,
+      "  ",
+      colors.green(`[${statusCode}${statusText ? ` ${statusText}` : ""}]`),
+      colors.cyan(url),
+      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: colors.green(success.count),
+        error_count: failed.count ? 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: ${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({
+    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,
+      "  ",
+      colors.green(`[${statusCode}${statusText ? ` ${statusText}` : ""}]`),
+      colors.cyan(url),
+      total.text,
+      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} ${colors.yellow(`[${type}]`)} ${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.level = debug ? 5 : 3;
+  const queue = new PQueue({
+    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.debug("browser closed");
+  return true;
+}
+
+export { LocalLog as L, MEODP as M, PQueueMap as P, checkLink as a, getSiteLinks as b, checkMEODPUrl as c, checkUrlNomoduleAssets as d, checkSiteUrl as e, checkSite as f, getBrowser as g, defaultMEODPConfig as h, defineConfig as i, localLog as j, createMEODPLogger as k, logUrlItemInfo as l, createWinstonLogger as m, multiBar as n, registerPageEvents as o, progressBarMap as p, formatArgs as q, runByConfig as r, siteUrlMap as s, getFormattedDataFromResponse as t, isLink as u, parseUrlMap as v, emojiMap as w, getMEODPUrlItemInfo as x };