@rsdoctor/utils 0.0.0-next-20240620044732

package/dist/cjs/common/time.js

@@ -0,0 +1,91 @@
+"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 time_exports = {};
+__export(time_exports, {
+  formatCosts: () => formatCosts,
+  getCurrentTimestamp: () => getCurrentTimestamp,
+  getUnit: () => getUnit,
+  toFixedDigits: () => toFixedDigits
+});
+module.exports = __toCommonJS(time_exports);
+var import_process = require("process");
+function toFixedDigits(num, digits = 2) {
+  if (digits === 0) {
+    return Math.floor(num);
+  }
+  return +num.toFixed(digits);
+}
+function getUnit(num, type) {
+  let unit;
+  if (type === "m") {
+    unit = num > 1 ? "mins" : "min";
+  } else {
+    unit = num > 1 ? "hours" : "hour";
+  }
+  return unit;
+}
+function formatCosts(costs) {
+  costs = Number(costs);
+  if (costs >= 1e3) {
+    const sec = costs / 1e3;
+    if (sec >= 60) {
+      let mins = sec / 60;
+      if (mins >= 60) {
+        const hours = toFixedDigits(mins / 60, 0);
+        const restMins = toFixedDigits(mins % 60, 1);
+        const hUnit = getUnit(hours, "h");
+        if (restMins > 0) {
+          return `${hours}${hUnit} ${restMins}${getUnit(restMins, "m")}`;
+        }
+        return `${hours}${hUnit}`;
+      }
+      mins = toFixedDigits(mins, 0);
+      const mUnit = getUnit(mins, "m");
+      const restSec = toFixedDigits(sec % 60, 0);
+      if (restSec > 0) {
+        return `${mins}${mUnit} ${restSec}s`;
+      }
+      return `${mins}${mUnit}`;
+    }
+    return `${toFixedDigits(sec, 1)}s`;
+  }
+  if (costs >= 10) {
+    return `${+toFixedDigits(costs, 0)}ms`;
+  }
+  if (costs >= 1) {
+    return `${+toFixedDigits(costs, 1)}ms`;
+  }
+  let r = +toFixedDigits(costs, 2);
+  if (r === 0) {
+    r = +toFixedDigits(costs, 3);
+  }
+  return `${r}ms`;
+}
+function getCurrentTimestamp(start, startHRTime) {
+  const endHRTime = (0, import_process.hrtime)(startHRTime);
+  const end = start + endHRTime[0] * 1e3 + (process.env.VITEST ? Math.round(endHRTime[1] / 1e6) : endHRTime[1] / 1e6);
+  return end;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatCosts,
+  getCurrentTimestamp,
+  getUnit,
+  toFixedDigits
+});

package/dist/cjs/common/url.js

@@ -0,0 +1,46 @@
+"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 url_exports = {};
+__export(url_exports, {
+  isFilePath: () => isFilePath,
+  isRemoteUrl: () => isRemoteUrl,
+  isUrl: () => isUrl
+});
+module.exports = __toCommonJS(url_exports);
+var import_path = require("path");
+function isUrl(uri) {
+  return /^https?:\/\//.test(uri);
+}
+function isFilePath(uri) {
+  return (0, import_path.isAbsolute)(uri);
+}
+function isRemoteUrl(uri) {
+  if (typeof uri === "string") {
+    if (isUrl(uri) || isFilePath(uri)) {
+      return true;
+    }
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isFilePath,
+  isRemoteUrl,
+  isUrl
+});

package/dist/cjs/error/error.js

@@ -0,0 +1,236 @@
+"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 error_exports = {};
+__export(error_exports, {
+  DevToolError: () => DevToolError
+});
+module.exports = __toCommonJS(error_exports);
+var import_code_frame = require("@babel/code-frame");
+var import_types = require("@rsdoctor/types");
+var import_chalk = require("chalk");
+var import_deep_eql = __toESM(require("deep-eql"));
+var import_lodash = require("lodash");
+var import_strip_ansi = __toESM(require("strip-ansi"));
+var import_transform = require("./transform");
+var import_utils = require("./utils");
+let id = 1;
+class DevToolError extends Error {
+  constructor(title, message, opts) {
+    super(message);
+    this._controller = {
+      noStack: true,
+      noColor: false
+    };
+    this.id = id++;
+    this.title = title;
+    this.code = opts?.code;
+    this.hint = opts?.hint;
+    this.stack = opts?.stack;
+    this.detail = opts?.detail;
+    this.fixData = opts?.fixData;
+    this.category = opts?.category;
+    this.referenceUrl = opts?.referenceUrl;
+    this._level = opts?.level ? (0, import_utils.toLevel)(opts.level) : import_types.Err.ErrorLevel.Error;
+    this._codeFrame = opts?.codeFrame;
+    this.setControllerOption(opts?.controller ?? {});
+  }
+  static from(err, opt) {
+    if (err instanceof DevToolError) {
+      return err;
+    }
+    return (0, import_transform.transform)(err, opt);
+  }
+  get level() {
+    return import_types.Err.ErrorLevel[this._level];
+  }
+  get path() {
+    return this._codeFrame?.filePath;
+  }
+  set path(file) {
+    if (!file) {
+      return;
+    }
+    if (this._codeFrame) {
+      this._codeFrame.filePath = file;
+      return;
+    }
+    this._codeFrame = {
+      filePath: file
+    };
+  }
+  get codeFrame() {
+    return this._codeFrame;
+  }
+  printCodeFrame(print) {
+    const msgs = [];
+    const { _codeFrame: codeFrameOpt, _controller: controller } = this;
+    if (!codeFrameOpt) {
+      return msgs;
+    }
+    if ("start" in codeFrameOpt && codeFrameOpt.start) {
+      const { filePath, start } = codeFrameOpt;
+      msgs.push(
+        `
+ ${print.red(print.bold("File: "))}${print.bold(filePath)}:${start.line}${start.column ? `:${start.column}` : ""}`
+      );
+      if ("fileContent" in codeFrameOpt) {
+        const { end, fileContent } = codeFrameOpt;
+        msgs.push(
+          (0, import_code_frame.codeFrameColumns)(
+            fileContent,
+            {
+              start,
+              end
+            },
+            {
+              highlightCode: !controller.noColor
+            }
+          )
+        );
+      } else if ("lineText" in codeFrameOpt) {
+        const { length, lineText } = codeFrameOpt;
+        let lineCodeFrame = (0, import_code_frame.codeFrameColumns)(
+          lineText,
+          {
+            start: {
+              line: 1,
+              column: start.column
+            },
+            end: {
+              line: 1,
+              column: (0, import_lodash.isNil)(start.column) || (0, import_lodash.isNil)(length) ? void 0 : start.column + length
+            }
+          },
+          {
+            highlightCode: !controller.noColor
+          }
+        );
+        if (start.line > 1) {
+          lineCodeFrame = lineCodeFrame.replace(" 1 |", ` ${start.line} |`);
+          if (start.line >= 10) {
+            lineCodeFrame = (0, import_utils.insertSpace)(
+              lineCodeFrame,
+              2,
+              String(start.line).length - 1
+            );
+          }
+        }
+        msgs.push(lineCodeFrame);
+      }
+    } else {
+      msgs.push(
+        `
+ ${print.red(print.bold("File: "))}${print.bold(
+          codeFrameOpt.filePath
+        )}
+`
+      );
+    }
+    return msgs;
+  }
+  toString() {
+    const msgs = [];
+    const {
+      code,
+      title,
+      message,
+      hint,
+      referenceUrl,
+      _controller: controller
+    } = this;
+    const print = controller.noColor ? new import_chalk.Instance({ level: 0 }) : new import_chalk.Instance({ level: 3 });
+    const mainColorPrint = this._level === import_types.Err.ErrorLevel.Error ? print.red : print.yellow;
+    const codeText = code ? `${mainColorPrint.blue(code)}:` : "";
+    msgs.push(
+      mainColorPrint.bold(
+        `[${codeText}${this.level}:${title.toUpperCase()}] `
+      ) + message
+    );
+    msgs.push(...this.printCodeFrame(print));
+    if (hint || referenceUrl) {
+      msgs.push("");
+    }
+    if (hint) {
+      msgs.push(` ${print.blue(`HINT: ${hint}`)}`);
+    }
+    if (referenceUrl) {
+      msgs.push(print.magenta.bold(` See: ${referenceUrl}`));
+    }
+    if (!controller.noStack && this.stack) {
+      msgs.push(print.red.bold(` Error Stack:
+${this.stack}
+`));
+    }
+    return msgs.join("\n");
+  }
+  toData() {
+    return {
+      ...this.detail,
+      id: this.id,
+      category: this.category,
+      description: (0, import_strip_ansi.default)(this.detail?.description ?? this.message),
+      title: this.title.toUpperCase(),
+      code: this.code,
+      level: this.level.toLowerCase()
+    };
+  }
+  toError() {
+    const error = new Error();
+    error.message = this.toString();
+    error.name = this.name;
+    error.stack = this.stack;
+    return error;
+  }
+  /**
+   * for json stringify
+   */
+  toJSON() {
+    return {
+      message: this.toString(),
+      name: this.name,
+      stack: this.stack
+    };
+  }
+  setControllerOption(opt) {
+    this._controller = {
+      noStack: opt.noStack ?? this._controller.noStack ?? true,
+      noColor: opt.noColor ?? this._controller.noColor ?? false
+    };
+  }
+  setCodeFrame(opt) {
+    this._codeFrame = opt;
+  }
+  isSame(error) {
+    return this.code === error.code && this.message === error.message && this.hint === error.hint && this.level === error.level && this.title === error.title && this.referenceUrl === error.referenceUrl && this.code === error.code && (0, import_deep_eql.default)(this.codeFrame, error.codeFrame);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevToolError
+});

package/dist/cjs/error/index.js

@@ -0,0 +1,31 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_exports = {};
+__export(error_exports, {
+  printErrors: () => import_utils.printErrors
+});
+module.exports = __toCommonJS(error_exports);
+__reExport(error_exports, require("./error"), module.exports);
+var import_utils = require("./utils");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  printErrors,
+  ...require("./error")
+});

package/dist/cjs/error/transform.js

@@ -0,0 +1,175 @@
+"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 transform_exports = {};
+__export(transform_exports, {
+  transform: () => transform
+});
+module.exports = __toCommonJS(transform_exports);
+var import_strip_ansi = __toESM(require("strip-ansi"));
+var import_types = require("@rsdoctor/types");
+var import_error = require("./error");
+function isEsbuildError(err) {
+  return "pluginName" in err && "text" in err && "location" in err;
+}
+function isBabelError(err) {
+  return "code" in err && "reasonCode" in err;
+}
+function isDiagnosticError(err) {
+  return "severity" in err && "title" in err;
+}
+function parseBabelErrorMessage(input) {
+  const lines = (0, import_strip_ansi.default)(input).split("\n");
+  const filePath = lines[0].replace(/^([^:]+):.*/, "$1");
+  const message = lines[0].replace(/.*: (.*) \(\d+:\d+\)*/, "$1");
+  const lineText = lines.find((line) => line.startsWith("> "))?.replace(/> \d+ \| /, "") ?? "";
+  return {
+    message,
+    filePath,
+    lineText
+  };
+}
+function clearMessage(str) {
+  return (0, import_strip_ansi.default)(str).replace(/.*: (.*)\n\n[\s\S]*/g, "$1");
+}
+function clearStack(str) {
+  return str.slice(str.indexOf("  at")).replace(/\s*at(.*) \((.*)\)/g, "$1\n$2\n");
+}
+function transformEsbuildError(err, opt) {
+  if (isEsbuildError(err)) {
+    const errorCode = opt?.code ?? "ESBUILD_ERROR";
+    const speedyError = typeof err.detail === "object" ? import_error.DevToolError.from(err.detail) : new import_error.DevToolError(errorCode, clearMessage(err.text), {
+      ...opt,
+      hint: err.location?.suggestion,
+      codeFrame: {
+        filePath: err.text.split(":")[0]
+      }
+    });
+    if (err.location) {
+      speedyError.setCodeFrame({
+        filePath: err.location.file,
+        lineText: err.location.lineText,
+        length: err.location.length,
+        start: {
+          line: err.location.line,
+          column: err.location.column + 1
+        }
+      });
+    }
+    return speedyError;
+  }
+}
+function transformBabelError(err, opt) {
+  if (isBabelError(err)) {
+    const errorCode = opt?.code ?? err.code ?? "BABEL";
+    const title = err.reasonCode;
+    const errorParsed = parseBabelErrorMessage(err.message);
+    const speedyError = new import_error.DevToolError(title, errorParsed.message, {
+      ...opt,
+      code: errorCode,
+      stack: err.stack && clearStack(err.stack)
+    });
+    if (err.loc) {
+      speedyError.setCodeFrame({
+        ...errorParsed,
+        start: {
+          line: err.loc.line,
+          column: err.loc.column + 1
+        }
+      });
+    }
+    return speedyError;
+  }
+}
+function transformNormalError(err, opt) {
+  if (err instanceof Error) {
+    const stacks = [];
+    const filePath = stacks?.[0]?.getFileName?.();
+    return new import_error.DevToolError(err.name, clearMessage(err.message), {
+      ...opt,
+      codeFrame: filePath ? { filePath } : void 0,
+      stack: err.stack && clearStack(err.stack)
+    });
+  }
+}
+function transformErrorLike(err, opt) {
+  const isErrorLike = err && typeof err === "object" && err.message;
+  if (isErrorLike) {
+    const stacks = [];
+    const filePath = stacks?.[0]?.getFileName?.();
+    return new import_error.DevToolError(
+      err.name || "UNKNOWN_ERROR",
+      clearMessage(err.message),
+      {
+        ...opt,
+        codeFrame: filePath ? { filePath } : void 0,
+        stack: err.stack && clearStack(err.stack)
+      }
+    );
+  }
+}
+function transformDiagnostic(err, opt) {
+  if (isDiagnosticError(err)) {
+    return new import_error.DevToolError(err.title, err.message, {
+      ...err,
+      ...opt,
+      hint: err.suggestions?.description,
+      fixData: err.suggestions?.fixData,
+      codeFrame: err.document ? {
+        filePath: err.document.path,
+        fileContent: err.document.content,
+        start: err.document.range.start,
+        end: err.document.range.end
+      } : void 0,
+      level: import_types.Linter.Severity[err.severity]
+    });
+  }
+}
+function defaultError(err, opt) {
+  return new import_error.DevToolError("UNKNOWN_ERROR", JSON.stringify(err), opt);
+}
+function transform(err, opt) {
+  const transformers = [
+    transformEsbuildError,
+    transformBabelError,
+    transformDiagnostic,
+    transformNormalError,
+    transformErrorLike
+  ];
+  for (const fn of transformers) {
+    const result = fn(err, opt);
+    if (result) {
+      return result;
+    }
+  }
+  return defaultError(err, opt);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transform
+});

package/dist/cjs/error/utils.js

@@ -0,0 +1,66 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  insertSpace: () => insertSpace,
+  printErrors: () => printErrors,
+  toLevel: () => toLevel
+});
+module.exports = __toCommonJS(utils_exports);
+var import_types = require("@rsdoctor/types");
+function toLevel(level) {
+  return import_types.Err.ErrorLevel[level];
+}
+function insertSpace(rawLines, line, width) {
+  const lines = rawLines.split("\n");
+  lines[line - 1] = Array(width).fill(" ").join("") + lines[line - 1];
+  return lines.join("\n");
+}
+function printErrors({ errors, warnings }, logLevel = "Error") {
+  const onlyError = logLevel === "Error";
+  if (logLevel === "Silent") {
+    return "";
+  }
+  if (onlyError && errors.length === 0 || !onlyError && errors.length === 0 && warnings.length === 0) {
+    return "";
+  }
+  const msgs = [];
+  if (onlyError) {
+    msgs.push(
+      `Build failed with ${errors.length} error:`,
+      ...errors.map((item) => item.toString()),
+      ""
+    );
+  } else {
+    const title = errors.length === 0 ? `Build succuss with ${warnings.length} warning:` : `Build failed with ${errors.length} error, ${warnings.length} warning:`;
+    msgs.push(
+      title,
+      ...errors.map((item) => item.toString()),
+      ...warnings.map((item) => item.toString()),
+      ""
+    );
+  }
+  return msgs.join("\n\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  insertSpace,
+  printErrors,
+  toLevel
+});

package/dist/cjs/index.js

@@ -0,0 +1,41 @@
+"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 src_exports = {};
+__export(src_exports, {
+  Logger: () => Logger,
+  RuleUtils: () => RuleUtils
+});
+module.exports = __toCommonJS(src_exports);
+var RuleUtils = __toESM(require("./rule-utils"));
+var Logger = __toESM(require("./logger"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger,
+  RuleUtils
+});