@settlemint/sdk-cli/dist/cli.js

Command-line interface for SettleMint SDK, providing development tools and project management capabilities

#!/usr/bin/env node
import { createRequire } from "node:module";
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
  target = mod != null ? __create(__getProtoOf(mod)) : {};
  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
  for (let key of __getOwnPropNames(mod))
    if (!__hasOwnProp.call(to, key))
      __defProp(to, key, {
        get: () => mod[key],
        enumerable: true
      });
  return to;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, {
      get: all[name],
      enumerable: true,
      configurable: true,
      set: (newValue) => all[name] = () => newValue
    });
};
var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
var __require = /* @__PURE__ */ createRequire(import.meta.url);

// ../../node_modules/console-table-printer/dist/src/utils/colored-console-line.js
var require_colored_console_line = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.DEFAULT_COLOR_MAP = undefined;
  exports.DEFAULT_COLOR_MAP = {
    red: "\x1B[31m",
    green: "\x1B[32m",
    yellow: "\x1B[33m",
    blue: "\x1B[34m",
    magenta: "\x1B[35m",
    cyan: "\x1B[36m",
    white: "\x1B[37m",
    white_bold: "\x1B[01m",
    reset: "\x1B[0m"
  };

  class ColoredConsoleLine {
    constructor(colorMap = exports.DEFAULT_COLOR_MAP) {
      this.text = "";
      this.colorMap = colorMap;
    }
    addCharsWithColor(color, text) {
      const colorAnsi = this.colorMap[color];
      this.text += colorAnsi !== undefined ? `${colorAnsi}${text}${this.colorMap.reset}` : text;
    }
    renderConsole() {
      return this.text;
    }
  }
  exports.default = ColoredConsoleLine;
});

// ../../node_modules/console-table-printer/dist/src/utils/table-constants.js
var require_table_constants = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.DEFAULT_HEADER_ALIGNMENT = exports.DEFAULT_ROW_ALIGNMENT = exports.DEFAULT_HEADER_FONT_COLOR = exports.DEFAULT_ROW_FONT_COLOR = exports.COLORS = exports.ALIGNMENTS = exports.DEFAULT_TABLE_STYLE = exports.DEFAULT_ROW_SEPARATOR = exports.DEFAULT_COLUMN_LEN = undefined;
  exports.DEFAULT_COLUMN_LEN = 20;
  exports.DEFAULT_ROW_SEPARATOR = false;
  exports.DEFAULT_TABLE_STYLE = {
    headerTop: {
      left: "┌",
      mid: "┬",
      right: "┐",
      other: "─"
    },
    headerBottom: {
      left: "├",
      mid: "┼",
      right: "┤",
      other: "─"
    },
    tableBottom: {
      left: "└",
      mid: "┴",
      right: "┘",
      other: "─"
    },
    vertical: "│",
    rowSeparator: {
      left: "├",
      mid: "┼",
      right: "┤",
      other: "─"
    }
  };
  exports.ALIGNMENTS = ["right", "left", "center"];
  exports.COLORS = [
    "red",
    "green",
    "yellow",
    "white",
    "blue",
    "magenta",
    "cyan",
    "white_bold",
    "reset"
  ];
  exports.DEFAULT_ROW_FONT_COLOR = "white";
  exports.DEFAULT_HEADER_FONT_COLOR = "white_bold";
  exports.DEFAULT_ROW_ALIGNMENT = "right";
  exports.DEFAULT_HEADER_ALIGNMENT = "center";
});

// ../../node_modules/console-table-printer/dist/src/internalTable/input-converter.js
var require_input_converter = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.rawColumnToInternalColumn = exports.objIfExists = undefined;
  var table_constants_1 = require_table_constants();
  var objIfExists = (key, val) => {
    if (!val) {
      return {};
    }
    return {
      [key]: val
    };
  };
  exports.objIfExists = objIfExists;
  var rawColumnToInternalColumn = (column) => {
    var _a;
    return Object.assign(Object.assign(Object.assign(Object.assign({ name: column.name, title: (_a = column.title) !== null && _a !== undefined ? _a : column.name }, (0, exports.objIfExists)("color", column.color)), (0, exports.objIfExists)("maxLen", column.maxLen)), (0, exports.objIfExists)("minLen", column.minLen)), { alignment: column.alignment || table_constants_1.DEFAULT_ROW_ALIGNMENT });
  };
  exports.rawColumnToInternalColumn = rawColumnToInternalColumn;
});

// ../../node_modules/simple-wcswidth/dist/src/non-spacing-chars.js
var require_non_spacing_chars = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  var combining = [
    { first: 768, last: 879 },
    { first: 1155, last: 1158 },
    { first: 1160, last: 1161 },
    { first: 1425, last: 1469 },
    { first: 1471, last: 1471 },
    { first: 1473, last: 1474 },
    { first: 1476, last: 1477 },
    { first: 1479, last: 1479 },
    { first: 1536, last: 1539 },
    { first: 1552, last: 1557 },
    { first: 1611, last: 1630 },
    { first: 1648, last: 1648 },
    { first: 1750, last: 1764 },
    { first: 1767, last: 1768 },
    { first: 1770, last: 1773 },
    { first: 1807, last: 1807 },
    { first: 1809, last: 1809 },
    { first: 1840, last: 1866 },
    { first: 1958, last: 1968 },
    { first: 2027, last: 2035 },
    { first: 2305, last: 2306 },
    { first: 2364, last: 2364 },
    { first: 2369, last: 2376 },
    { first: 2381, last: 2381 },
    { first: 2385, last: 2388 },
    { first: 2402, last: 2403 },
    { first: 2433, last: 2433 },
    { first: 2492, last: 2492 },
    { first: 2497, last: 2500 },
    { first: 2509, last: 2509 },
    { first: 2530, last: 2531 },
    { first: 2561, last: 2562 },
    { first: 2620, last: 2620 },
    { first: 2625, last: 2626 },
    { first: 2631, last: 2632 },
    { first: 2635, last: 2637 },
    { first: 2672, last: 2673 },
    { first: 2689, last: 2690 },
    { first: 2748, last: 2748 },
    { first: 2753, last: 2757 },
    { first: 2759, last: 2760 },
    { first: 2765, last: 2765 },
    { first: 2786, last: 2787 },
    { first: 2817, last: 2817 },
    { first: 2876, last: 2876 },
    { first: 2879, last: 2879 },
    { first: 2881, last: 2883 },
    { first: 2893, last: 2893 },
    { first: 2902, last: 2902 },
    { first: 2946, last: 2946 },
    { first: 3008, last: 3008 },
    { first: 3021, last: 3021 },
    { first: 3134, last: 3136 },
    { first: 3142, last: 3144 },
    { first: 3146, last: 3149 },
    { first: 3157, last: 3158 },
    { first: 3260, last: 3260 },
    { first: 3263, last: 3263 },
    { first: 3270, last: 3270 },
    { first: 3276, last: 3277 },
    { first: 3298, last: 3299 },
    { first: 3393, last: 3395 },
    { first: 3405, last: 3405 },
    { first: 3530, last: 3530 },
    { first: 3538, last: 3540 },
    { first: 3542, last: 3542 },
    { first: 3633, last: 3633 },
    { first: 3636, last: 3642 },
    { first: 3655, last: 3662 },
    { first: 3761, last: 3761 },
    { first: 3764, last: 3769 },
    { first: 3771, last: 3772 },
    { first: 3784, last: 3789 },
    { first: 3864, last: 3865 },
    { first: 3893, last: 3893 },
    { first: 3895, last: 3895 },
    { first: 3897, last: 3897 },
    { first: 3953, last: 3966 },
    { first: 3968, last: 3972 },
    { first: 3974, last: 3975 },
    { first: 3984, last: 3991 },
    { first: 3993, last: 4028 },
    { first: 4038, last: 4038 },
    { first: 4141, last: 4144 },
    { first: 4146, last: 4146 },
    { first: 4150, last: 4151 },
    { first: 4153, last: 4153 },
    { first: 4184, last: 4185 },
    { first: 4448, last: 4607 },
    { first: 4959, last: 4959 },
    { first: 5906, last: 5908 },
    { first: 5938, last: 5940 },
    { first: 5970, last: 5971 },
    { first: 6002, last: 6003 },
    { first: 6068, last: 6069 },
    { first: 6071, last: 6077 },
    { first: 6086, last: 6086 },
    { first: 6089, last: 6099 },
    { first: 6109, last: 6109 },
    { first: 6155, last: 6157 },
    { first: 6313, last: 6313 },
    { first: 6432, last: 6434 },
    { first: 6439, last: 6440 },
    { first: 6450, last: 6450 },
    { first: 6457, last: 6459 },
    { first: 6679, last: 6680 },
    { first: 6912, last: 6915 },
    { first: 6964, last: 6964 },
    { first: 6966, last: 6970 },
    { first: 6972, last: 6972 },
    { first: 6978, last: 6978 },
    { first: 7019, last: 7027 },
    { first: 7616, last: 7626 },
    { first: 7678, last: 7679 },
    { first: 8203, last: 8207 },
    { first: 8234, last: 8238 },
    { first: 8288, last: 8291 },
    { first: 8298, last: 8303 },
    { first: 8400, last: 8431 },
    { first: 12330, last: 12335 },
    { first: 12441, last: 12442 },
    { first: 43014, last: 43014 },
    { first: 43019, last: 43019 },
    { first: 43045, last: 43046 },
    { first: 64286, last: 64286 },
    { first: 65024, last: 65039 },
    { first: 65056, last: 65059 },
    { first: 65279, last: 65279 },
    { first: 65529, last: 65531 },
    { first: 68097, last: 68099 },
    { first: 68101, last: 68102 },
    { first: 68108, last: 68111 },
    { first: 68152, last: 68154 },
    { first: 68159, last: 68159 },
    { first: 119143, last: 119145 },
    { first: 119155, last: 119170 },
    { first: 119173, last: 119179 },
    { first: 119210, last: 119213 },
    { first: 119362, last: 119364 },
    { first: 917505, last: 917505 },
    { first: 917536, last: 917631 },
    { first: 917760, last: 917999 }
  ];
  exports.default = combining;
});

// ../../node_modules/simple-wcswidth/dist/src/binary-search.js
var require_binary_search = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  var bisearch = (ucs, table, tableSize) => {
    let min = 0;
    let mid;
    let max = tableSize;
    if (ucs < table[0].first || ucs > table[max].last)
      return 0;
    while (max >= min) {
      mid = Math.floor((min + max) / 2);
      if (ucs > table[mid].last) {
        min = mid + 1;
      } else if (ucs < table[mid].first) {
        max = mid - 1;
      } else {
        return 1;
      }
    }
    return 0;
  };
  exports.default = bisearch;
});

// ../../node_modules/simple-wcswidth/dist/src/wcwidth.js
var require_wcwidth = __commonJS((exports) => {
  var __importDefault = exports && exports.__importDefault || function(mod) {
    return mod && mod.__esModule ? mod : { default: mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  var non_spacing_chars_1 = __importDefault(require_non_spacing_chars());
  var binary_search_1 = __importDefault(require_binary_search());
  var mk_wcwidth = (ucs) => {
    if (ucs === 0) {
      return 0;
    }
    if (ucs < 32 || ucs >= 127 && ucs < 160) {
      return -1;
    }
    if (binary_search_1.default(ucs, non_spacing_chars_1.default, non_spacing_chars_1.default.length - 1)) {
      return 0;
    }
    return 1 + Number(ucs >= 4352 && (ucs <= 4447 || ucs === 9001 || ucs === 9002 || ucs >= 11904 && ucs <= 42191 && ucs !== 12351 || ucs >= 44032 && ucs <= 55203 || ucs >= 63744 && ucs <= 64255 || ucs >= 65040 && ucs <= 65049 || ucs >= 65072 && ucs <= 65135 || ucs >= 65280 && ucs <= 65376 || ucs >= 65504 && ucs <= 65510 || ucs >= 131072 && ucs <= 196605 || ucs >= 196608 && ucs <= 262141));
  };
  exports.default = mk_wcwidth;
});

// ../../node_modules/simple-wcswidth/dist/src/wcswidth.js
var require_wcswidth = __commonJS((exports) => {
  var __importDefault = exports && exports.__importDefault || function(mod) {
    return mod && mod.__esModule ? mod : { default: mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  var wcwidth_1 = __importDefault(require_wcwidth());
  var mk_wcswidth = (pwcs) => {
    let width = 0;
    for (let i = 0;i < pwcs.length; i++) {
      const charCode = pwcs.charCodeAt(i);
      const w = wcwidth_1.default(charCode);
      if (w < 0) {
        return -1;
      }
      width += w;
    }
    return width;
  };
  exports.default = mk_wcswidth;
});

// ../../node_modules/simple-wcswidth/dist/index.js
var require_dist = __commonJS((exports) => {
  var __importDefault = exports && exports.__importDefault || function(mod) {
    return mod && mod.__esModule ? mod : { default: mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.wcswidth = exports.wcwidth = undefined;
  var wcswidth_1 = __importDefault(require_wcswidth());
  exports.wcswidth = wcswidth_1.default;
  var wcwidth_1 = __importDefault(require_wcwidth());
  exports.wcwidth = wcwidth_1.default;
});

// ../../node_modules/console-table-printer/dist/src/utils/console-utils.js
var require_console_utils = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.findWidthInConsole = exports.stripAnsi = undefined;
  var simple_wcswidth_1 = require_dist();
  var colorRegex = /\x1b\[\d{1,3}(;\d{1,3})*m/g;
  var stripAnsi = (str) => str.replace(colorRegex, "");
  exports.stripAnsi = stripAnsi;
  var findWidthInConsole = (str, charLength) => {
    let strLen = 0;
    str = (0, exports.stripAnsi)(str);
    if (charLength) {
      Object.entries(charLength).forEach(([key, value]) => {
        let regex = new RegExp(key, "g");
        strLen += (str.match(regex) || []).length * value;
        str = str.replace(key, "");
      });
    }
    strLen += (0, simple_wcswidth_1.wcswidth)(str);
    return strLen;
  };
  exports.findWidthInConsole = findWidthInConsole;
});

// ../../node_modules/console-table-printer/dist/src/utils/string-utils.js
var require_string_utils = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.biggestWordInSentence = exports.textWithPadding = exports.splitTextIntoTextsOfMinLen = undefined;
  var console_utils_1 = require_console_utils();
  var splitTextIntoTextsOfMinLen = (inpStr, width, charLength) => {
    const ret = [];
    const lines = inpStr.split(/[\n\r]/);
    lines.forEach((line) => {
      const spaceSeparatedStrings = line.split(" ");
      let now = [];
      let cnt = 0;
      spaceSeparatedStrings.forEach((strWithoutSpace) => {
        const consoleWidth = (0, console_utils_1.findWidthInConsole)(strWithoutSpace, charLength);
        if (cnt + consoleWidth <= width) {
          cnt += consoleWidth + 1;
          now.push(strWithoutSpace);
        } else {
          if (now.length > 0)
            ret.push(now.join(" "));
          now = [strWithoutSpace];
          cnt = consoleWidth + 1;
        }
      });
      ret.push(now.join(" "));
    });
    return ret;
  };
  exports.splitTextIntoTextsOfMinLen = splitTextIntoTextsOfMinLen;
  var textWithPadding = (text, alignment, columnLen, charLength) => {
    const curTextSize = (0, console_utils_1.findWidthInConsole)(text, charLength);
    const leftPadding = Math.floor((columnLen - curTextSize) / 2);
    const rightPadding = columnLen - leftPadding - curTextSize;
    if (columnLen < curTextSize) {
      const splittedLines = (0, exports.splitTextIntoTextsOfMinLen)(text, columnLen);
      if (splittedLines.length === 1) {
        return text;
      }
      return splittedLines.map((singleLine) => (0, exports.textWithPadding)(singleLine, alignment, columnLen, charLength)).join(`
`);
    }
    switch (alignment) {
      case "left":
        return text.concat(" ".repeat(columnLen - curTextSize));
      case "center":
        return " ".repeat(leftPadding).concat(text).concat(" ".repeat(rightPadding));
      case "right":
      default:
        return " ".repeat(columnLen - curTextSize).concat(text);
    }
  };
  exports.textWithPadding = textWithPadding;
  var biggestWordInSentence = (inpStr, charLength) => inpStr.split(" ").reduce((a, b) => Math.max(a, (0, console_utils_1.findWidthInConsole)(b, charLength)), 0);
  exports.biggestWordInSentence = biggestWordInSentence;
});

// ../../node_modules/console-table-printer/dist/src/utils/table-helpers.js
var require_table_helpers = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getWidthLimitedColumnsArray = exports.createHeaderAsRow = exports.renderTableHorizontalBorders = exports.findLenOfColumn = exports.createRow = exports.createColumFromComputedColumn = exports.createColumFromOnlyName = exports.createTableHorizontalBorders = exports.convertRawRowOptionsToStandard = exports.cellText = undefined;
  var input_converter_1 = require_input_converter();
  var console_utils_1 = require_console_utils();
  var string_utils_1 = require_string_utils();
  var table_constants_1 = require_table_constants();
  var max = (a, b) => Math.max(a, b);
  var cellText = (text) => text === undefined || text === null ? "" : `${text}`;
  exports.cellText = cellText;
  var convertRawRowOptionsToStandard = (options) => {
    if (options) {
      return {
        color: options.color,
        separator: options.separator || table_constants_1.DEFAULT_ROW_SEPARATOR
      };
    }
    return;
  };
  exports.convertRawRowOptionsToStandard = convertRawRowOptionsToStandard;
  var createTableHorizontalBorders = ({ left, mid, right, other }, column_lengths) => {
    let ret = left;
    column_lengths.forEach((len) => {
      ret += other.repeat(len + 2);
      ret += mid;
    });
    ret = ret.slice(0, -mid.length);
    ret += right;
    return ret;
  };
  exports.createTableHorizontalBorders = createTableHorizontalBorders;
  var createColumFromOnlyName = (name) => ({
    name,
    title: name
  });
  exports.createColumFromOnlyName = createColumFromOnlyName;
  var createColumFromComputedColumn = (column) => {
    var _a;
    return Object.assign(Object.assign(Object.assign(Object.assign({ name: column.name, title: (_a = column.title) !== null && _a !== undefined ? _a : column.name }, (0, input_converter_1.objIfExists)("color", column.color)), (0, input_converter_1.objIfExists)("maxLen", column.maxLen)), (0, input_converter_1.objIfExists)("minLen", column.minLen)), { alignment: column.alignment || table_constants_1.DEFAULT_ROW_ALIGNMENT });
  };
  exports.createColumFromComputedColumn = createColumFromComputedColumn;
  var createRow = (color, text, separator) => ({
    color,
    separator,
    text
  });
  exports.createRow = createRow;
  var findLenOfColumn = (column, rows, charLength) => {
    const columnId = column.name;
    const columnTitle = column.title;
    let length = max(0, (column === null || column === undefined ? undefined : column.minLen) || 0);
    if (column.maxLen) {
      length = max(length, max(column.maxLen, (0, string_utils_1.biggestWordInSentence)(columnTitle, charLength)));
      length = rows.reduce((acc, row) => max(acc, (0, string_utils_1.biggestWordInSentence)((0, exports.cellText)(row.text[columnId]), charLength)), length);
      return length;
    }
    length = max(length, (0, console_utils_1.findWidthInConsole)(columnTitle, charLength));
    rows.forEach((row) => {
      length = max(length, (0, console_utils_1.findWidthInConsole)((0, exports.cellText)(row.text[columnId]), charLength));
    });
    return length;
  };
  exports.findLenOfColumn = findLenOfColumn;
  var renderTableHorizontalBorders = (style, column_lengths) => {
    const str = (0, exports.createTableHorizontalBorders)(style, column_lengths);
    return str;
  };
  exports.renderTableHorizontalBorders = renderTableHorizontalBorders;
  var createHeaderAsRow = (createRowFn, columns) => {
    const headerColor = table_constants_1.DEFAULT_HEADER_FONT_COLOR;
    const row = createRowFn(headerColor, {}, false);
    columns.forEach((column) => {
      row.text[column.name] = column.title;
    });
    return row;
  };
  exports.createHeaderAsRow = createHeaderAsRow;
  var getWidthLimitedColumnsArray = (columns, row, charLength) => {
    const ret = {};
    columns.forEach((column) => {
      ret[column.name] = (0, string_utils_1.splitTextIntoTextsOfMinLen)((0, exports.cellText)(row.text[column.name]), column.length || table_constants_1.DEFAULT_COLUMN_LEN, charLength);
    });
    return ret;
  };
  exports.getWidthLimitedColumnsArray = getWidthLimitedColumnsArray;
});

// ../../node_modules/console-table-printer/dist/src/internalTable/table-pre-processors.js
var require_table_pre_processors = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.preProcessRows = exports.preProcessColumns = undefined;
  var table_helpers_1 = require_table_helpers();
  var createComputedColumnsIfNecessary = (table) => {
    if (table.computedColumns.length) {
      table.computedColumns.forEach((computedColumn) => {
        table.addColumn(computedColumn);
        table.rows.forEach((row) => {
          row.text[computedColumn.name] = computedColumn.function(row.text);
        });
      });
    }
  };
  var disableColumnsIfNecessary = (table) => {
    if (table.enabledColumns.length) {
      table.columns = table.columns.filter((col) => table.enabledColumns.includes(col.name));
    }
  };
  var enableColumnsIfNecessary = (table) => {
    if (table.disabledColumns.length) {
      table.columns = table.columns.filter((col) => !table.disabledColumns.includes(col.name));
    }
  };
  var findColumnWidth = (table) => {
    table.columns.forEach((column) => {
      column.length = (0, table_helpers_1.findLenOfColumn)(column, table.rows, table.charLength);
    });
  };
  var preProcessColumns = (table) => {
    createComputedColumnsIfNecessary(table);
    enableColumnsIfNecessary(table);
    disableColumnsIfNecessary(table);
    findColumnWidth(table);
  };
  exports.preProcessColumns = preProcessColumns;
  var preProcessRows = (table) => {
    const newRows = table.rows.filter((r) => table.filterFunction(r.text)).sort((r1, r2) => table.sortFunction(r1.text, r2.text));
    table.rows = newRows;
  };
  exports.preProcessRows = preProcessRows;
});

// ../../node_modules/console-table-printer/dist/src/internalTable/internal-table-printer.js
var require_internal_table_printer = __commonJS((exports) => {
  var __importDefault = exports && exports.__importDefault || function(mod) {
    return mod && mod.__esModule ? mod : { default: mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.printSimpleTable = exports.renderSimpleTable = exports.renderTable = undefined;
  var colored_console_line_1 = __importDefault(require_colored_console_line());
  var string_utils_1 = require_string_utils();
  var table_constants_1 = require_table_constants();
  var table_helpers_1 = require_table_helpers();
  var internal_table_1 = __importDefault(require_internal_table());
  var table_pre_processors_1 = require_table_pre_processors();
  var renderOneLine = (tableStyle, columns, currentLineIndex, widthLimitedColumnsArray, isHeader, row, colorMap, charLength) => {
    const line = new colored_console_line_1.default(colorMap);
    line.addCharsWithColor("", tableStyle.vertical);
    columns.forEach((column) => {
      const thisLineHasText = currentLineIndex < widthLimitedColumnsArray[column.name].length;
      const textForThisLine = thisLineHasText ? (0, table_helpers_1.cellText)(widthLimitedColumnsArray[column.name][currentLineIndex]) : "";
      line.addCharsWithColor(table_constants_1.DEFAULT_ROW_FONT_COLOR, " ");
      line.addCharsWithColor(isHeader && table_constants_1.DEFAULT_HEADER_FONT_COLOR || column.color || row.color, (0, string_utils_1.textWithPadding)(textForThisLine, column.alignment || table_constants_1.DEFAULT_ROW_ALIGNMENT, column.length || table_constants_1.DEFAULT_COLUMN_LEN, charLength));
      line.addCharsWithColor("", ` ${tableStyle.vertical}`);
    });
    return line.renderConsole();
  };
  var renderWidthLimitedLines = (tableStyle, columns, row, colorMap, isHeader, charLength) => {
    const widthLimitedColumnsArray = (0, table_helpers_1.getWidthLimitedColumnsArray)(columns, row, charLength);
    const totalLines = Object.values(widthLimitedColumnsArray).reduce((a, b) => Math.max(a, b.length), 0);
    const ret = [];
    for (let currentLineIndex = 0;currentLineIndex < totalLines; currentLineIndex += 1) {
      const singleLine = renderOneLine(tableStyle, columns, currentLineIndex, widthLimitedColumnsArray, isHeader, row, colorMap, charLength);
      ret.push(singleLine);
    }
    return ret;
  };
  var renderRow = (table, row) => {
    let ret = [];
    ret = ret.concat(renderWidthLimitedLines(table.tableStyle, table.columns, row, table.colorMap, undefined, table.charLength));
    return ret;
  };
  var renderTableTitle = (table) => {
    const ret = [];
    if (table.title === undefined) {
      return ret;
    }
    const getTableWidth = () => {
      const reducer = (accumulator, currentValue) => accumulator + currentValue + 2 + 1;
      return table.columns.map((m) => m.length || table_constants_1.DEFAULT_COLUMN_LEN).reduce(reducer, 1);
    };
    const titleWithPadding = (0, string_utils_1.textWithPadding)(table.title, table_constants_1.DEFAULT_HEADER_ALIGNMENT, getTableWidth());
    const styledText = new colored_console_line_1.default(table.colorMap);
    styledText.addCharsWithColor(table_constants_1.DEFAULT_HEADER_FONT_COLOR, titleWithPadding);
    ret.push(styledText.renderConsole());
    return ret;
  };
  var renderTableHeaders = (table) => {
    let ret = [];
    ret.push((0, table_helpers_1.renderTableHorizontalBorders)(table.tableStyle.headerTop, table.columns.map((m) => m.length || table_constants_1.DEFAULT_COLUMN_LEN)));
    const row = (0, table_helpers_1.createHeaderAsRow)(table_helpers_1.createRow, table.columns);
    ret = ret.concat(renderWidthLimitedLines(table.tableStyle, table.columns, row, table.colorMap, true));
    ret.push((0, table_helpers_1.renderTableHorizontalBorders)(table.tableStyle.headerBottom, table.columns.map((m) => m.length || table_constants_1.DEFAULT_COLUMN_LEN)));
    return ret;
  };
  var renderTableEnding = (table) => {
    const ret = [];
    ret.push((0, table_helpers_1.renderTableHorizontalBorders)(table.tableStyle.tableBottom, table.columns.map((m) => m.length || table_constants_1.DEFAULT_COLUMN_LEN)));
    return ret;
  };
  var renderRowSeparator = (table, row) => {
    const ret = [];
    const lastRowIndex = table.rows.length - 1;
    const currentRowIndex = table.rows.indexOf(row);
    if (currentRowIndex !== lastRowIndex && row.separator) {
      ret.push((0, table_helpers_1.renderTableHorizontalBorders)(table.tableStyle.rowSeparator, table.columns.map((m) => m.length || table_constants_1.DEFAULT_COLUMN_LEN)));
    }
    return ret;
  };
  var renderTable = (table) => {
    (0, table_pre_processors_1.preProcessColumns)(table);
    (0, table_pre_processors_1.preProcessRows)(table);
    const ret = [];
    renderTableTitle(table).forEach((row) => ret.push(row));
    renderTableHeaders(table).forEach((row) => ret.push(row));
    table.rows.forEach((row) => {
      renderRow(table, row).forEach((row_) => ret.push(row_));
      renderRowSeparator(table, row).forEach((row_) => ret.push(row_));
    });
    renderTableEnding(table).forEach((row) => ret.push(row));
    return ret.join(`
`);
  };
  exports.renderTable = renderTable;
  var renderSimpleTable = (rows) => {
    const table = new internal_table_1.default;
    table.addRows(rows);
    return (0, exports.renderTable)(table);
  };
  exports.renderSimpleTable = renderSimpleTable;
  var printSimpleTable = (rows) => {
    console.log((0, exports.renderSimpleTable)(rows));
  };
  exports.printSimpleTable = printSimpleTable;
});

// ../../node_modules/console-table-printer/dist/src/internalTable/internal-table.js
var require_internal_table = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  var colored_console_line_1 = require_colored_console_line();
  var table_constants_1 = require_table_constants();
  var table_helpers_1 = require_table_helpers();
  var input_converter_1 = require_input_converter();
  var internal_table_printer_1 = require_internal_table_printer();
  var DEFAULT_ROW_SORT_FUNC = () => 0;
  var DEFAULT_ROW_FILTER_FUNC = () => true;

  class TableInternal {
    initSimple(columns) {
      this.columns = columns.map((column) => ({
        name: column,
        title: column,
        alignment: table_constants_1.DEFAULT_ROW_ALIGNMENT
      }));
    }
    initDetailed(options) {
      var _a;
      this.title = (options === null || options === undefined ? undefined : options.title) || this.title;
      this.tableStyle = (options === null || options === undefined ? undefined : options.style) || this.tableStyle;
      this.sortFunction = (options === null || options === undefined ? undefined : options.sort) || this.sortFunction;
      this.filterFunction = (options === null || options === undefined ? undefined : options.filter) || this.filterFunction;
      this.enabledColumns = (options === null || options === undefined ? undefined : options.enabledColumns) || this.enabledColumns;
      this.disabledColumns = (options === null || options === undefined ? undefined : options.disabledColumns) || this.disabledColumns;
      this.computedColumns = (options === null || options === undefined ? undefined : options.computedColumns) || this.computedColumns;
      this.columns = ((_a = options === null || options === undefined ? undefined : options.columns) === null || _a === undefined ? undefined : _a.map(input_converter_1.rawColumnToInternalColumn)) || this.columns;
      this.rowSeparator = (options === null || options === undefined ? undefined : options.rowSeparator) || this.rowSeparator;
      this.charLength = (options === null || options === undefined ? undefined : options.charLength) || this.charLength;
      if (options === null || options === undefined ? undefined : options.shouldDisableColors) {
        this.colorMap = {};
      } else if (options === null || options === undefined ? undefined : options.colorMap) {
        this.colorMap = Object.assign(Object.assign({}, this.colorMap), options.colorMap);
      }
      if (options.rows !== undefined) {
        this.addRows(options.rows);
      }
    }
    constructor(options) {
      this.rows = [];
      this.columns = [];
      this.title = undefined;
      this.tableStyle = table_constants_1.DEFAULT_TABLE_STYLE;
      this.filterFunction = DEFAULT_ROW_FILTER_FUNC;
      this.sortFunction = DEFAULT_ROW_SORT_FUNC;
      this.enabledColumns = [];
      this.disabledColumns = [];
      this.computedColumns = [];
      this.rowSeparator = table_constants_1.DEFAULT_ROW_SEPARATOR;
      this.colorMap = colored_console_line_1.DEFAULT_COLOR_MAP;
      this.charLength = {};
      if (options instanceof Array) {
        this.initSimple(options);
      } else if (typeof options === "object") {
        this.initDetailed(options);
      }
    }
    createColumnFromRow(text) {
      const colNames = this.columns.map((col) => col.name);
      Object.keys(text).forEach((key) => {
        if (!colNames.includes(key)) {
          this.columns.push((0, table_helpers_1.createColumFromOnlyName)(key));
        }
      });
    }
    addColumn(textOrObj) {
      if (typeof textOrObj === "string") {
        this.columns.push((0, table_helpers_1.createColumFromOnlyName)(textOrObj));
      } else {
        this.columns.push((0, table_helpers_1.createColumFromComputedColumn)(textOrObj));
      }
    }
    addColumns(toBeInsertedColumns) {
      toBeInsertedColumns.forEach((toBeInsertedColumn) => {
        this.addColumn(toBeInsertedColumn);
      });
    }
    addRow(text, options) {
      this.createColumnFromRow(text);
      this.rows.push((0, table_helpers_1.createRow)((options === null || options === undefined ? undefined : options.color) || table_constants_1.DEFAULT_ROW_FONT_COLOR, text, (options === null || options === undefined ? undefined : options.separator) !== undefined ? options === null || options === undefined ? undefined : options.separator : this.rowSeparator));
    }
    addRows(toBeInsertedRows, options) {
      toBeInsertedRows.forEach((toBeInsertedRow) => {
        this.addRow(toBeInsertedRow, options);
      });
    }
    renderTable() {
      return (0, internal_table_printer_1.renderTable)(this);
    }
  }
  exports.default = TableInternal;
});

// ../../node_modules/console-table-printer/dist/src/console-table-printer.js
var require_console_table_printer = __commonJS((exports) => {
  var __importDefault = exports && exports.__importDefault || function(mod) {
    return mod && mod.__esModule ? mod : { default: mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  var internal_table_1 = __importDefault(require_internal_table());
  var table_helpers_1 = require_table_helpers();

  class Table {
    constructor(options) {
      this.table = new internal_table_1.default(options);
    }
    addColumn(column) {
      this.table.addColumn(column);
      return this;
    }
    addColumns(columns) {
      this.table.addColumns(columns);
      return this;
    }
    addRow(text, rowOptions) {
      this.table.addRow(text, (0, table_helpers_1.convertRawRowOptionsToStandard)(rowOptions));
      return this;
    }
    addRows(toBeInsertedRows, rowOptions) {
      this.table.addRows(toBeInsertedRows, (0, table_helpers_1.convertRawRowOptionsToStandard)(rowOptions));
      return this;
    }
    printTable() {
      const tableRendered = this.table.renderTable();
      console.log(tableRendered);
    }
    render() {
      return this.table.renderTable();
    }
  }
  exports.default = Table;
});

// ../../node_modules/console-table-printer/dist/index.js
var require_dist2 = __commonJS((exports) => {
  var __importDefault = exports && exports.__importDefault || function(mod) {
    return mod && mod.__esModule ? mod : { default: mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.renderTable = exports.printTable = exports.Table = undefined;
  var console_table_printer_1 = __importDefault(require_console_table_printer());
  exports.Table = console_table_printer_1.default;
  var internal_table_printer_1 = require_internal_table_printer();
  Object.defineProperty(exports, "printTable", { enumerable: true, get: function() {
    return internal_table_printer_1.printSimpleTable;
  } });
  Object.defineProperty(exports, "renderTable", { enumerable: true, get: function() {
    return internal_table_printer_1.renderSimpleTable;
  } });
});

// ../../node_modules/@dotenvx/dotenvx/package.json
var require_package = __commonJS((exports, module) => {
  module.exports = {
    version: "1.39.1",
    name: "@dotenvx/dotenvx",
    description: "a better dotenv–from the creator of `dotenv`",
    author: "@motdotla",
    keywords: [
      "dotenv",
      "env"
    ],
    homepage: "https://github.com/dotenvx/dotenvx",
    repository: {
      type: "git",
      url: "git+https://github.com/dotenvx/dotenvx.git"
    },
    license: "BSD-3-Clause",
    files: [
      "src/**/*",
      "CHANGELOG.md"
    ],
    main: "src/lib/main.js",
    types: "src/lib/main.d.ts",
    exports: {
      ".": {
        types: "./src/lib/main.d.ts",
        require: "./src/lib/main.js",
        default: "./src/lib/main.js"
      },
      "./config": "./src/lib/config.js",
      "./config.js": "./src/lib/config.js",
      "./package.json": "./package.json"
    },
    bin: {
      dotenvx: "./src/cli/dotenvx.js",
      "git-dotenvx": "./src/cli/dotenvx.js"
    },
    scripts: {
      standard: "standard",
      "standard:fix": "standard --fix",
      test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
      "test-coverage": "tap run --show-full-coverage --timeout=60000",
      testshell: "bash shellspec",
      prerelease: "npm test && npm run testshell",
      release: "standard-version"
    },
    funding: "https://dotenvx.com",
    dependencies: {
      commander: "^11.1.0",
      dotenv: "^16.4.5",
      eciesjs: "^0.4.10",
      execa: "^5.1.1",
      fdir: "^6.2.0",
      ignore: "^5.3.0",
      "object-treeify": "1.1.33",
      picomatch: "^4.0.2",
      which: "^4.0.0"
    },
    devDependencies: {
      "@yao-pkg/pkg": "^5.14.2",
      "capture-console": "^1.0.2",
      esbuild: "^0.24.0",
      proxyquire: "^2.1.3",
      sinon: "^14.0.1",
      standard: "^17.1.0",
      "standard-version": "^9.5.0",
      tap: "^21.0.1"
    },
    publishConfig: {
      access: "public",
      provenance: true
    }
  };
});

// ../../node_modules/@dotenvx/dotenvx/src/lib/helpers/packageJson.js
var require_packageJson = __commonJS((exports, module) => {
  var { name, version, description } = require_package();
  module.exports = { name, version, description };
});

// ../../node_modules/@dotenvx/dotenvx/src/lib/helpers/colorDepth.js
var require_colorDepth = __commonJS((exports, module) => {
  var { WriteStream } = __require("tty");
  var getColorDepth = () => {
    try {
      return WriteStream.prototype.getColorDepth();
    } catch (error) {
      const term = process.env.TERM;
      if (term && (term.includes("256color") || term.includes("xterm"))) {
        return 8;
      }
      return 4;
    }
  };
  module.exports = { getColorDepth };
});

// ../../node_modules/@dotenvx/dotenvx/src/shared/colors.js
var require_colors = __commonJS((exports, module) => {
  var depth = require_colorDepth();
  var colors16 = new Map([
    ["blue", 34],
    ["gray", 37],
    ["green", 32],
    ["olive", 33],
    ["orangered", 31],
    ["plum", 35],
    ["red", 31],
    ["electricblue", 36],
    ["dodgerblue", 36]
  ]);
  var colors256 = new Map([
    ["blue", 21],
    ["gray", 244],
    ["green", 34],
    ["olive", 142],
    ["orangered", 202],
    ["plum", 182],
    ["red", 196],
    ["electricblue", 45],
    ["dodgerblue", 33]
  ]);
  function getColor(color) {
    const colorDepth = depth.getColorDepth();
    if (!colors256.has(color)) {
      throw new Error(`Invalid color ${color}`);
    }
    if (colorDepth >= 8) {
      const code = colors256.get(color);
      return (message) => `\x1B[38;5;${code}m${message}\x1B[39m`;
    }
    if (colorDepth >= 4) {
      const code = colors16.get(color);
      return (message) => `\x1B[${code}m${message}\x1B[39m`;
    }
    return (message) => message;
  }
  function bold2(message) {
    if (depth.getColorDepth() >= 4) {
      return `\x1B[1m${message}\x1B[22m`;
    }
    return message;
  }
  module.exports = {
    getColor,
    bold: bold2
  };
});

// ../../node_modules/@dotenvx/dotenvx/src/shared/logger.js
var require_logger = __commonJS((exports, module) => {
  var packageJson = require_packageJson();
  var { getColor, bold: bold2 } = require_colors();
  var levels = {
    error: 0,
    errorv: 0,
    errornocolor: 0,
    warn: 1,
    success: 2,
    successv: 2,
    info: 2,
    help: 2,
    blank: 2,
    verbose: 4,
    debug: 5,
    silly: 6
  };
  var error = (m) => bold2(getColor("red")(m));
  var warn = getColor("orangered");
  var success = getColor("green");
  var successv = getColor("olive");
  var help = getColor("dodgerblue");
  var verbose = getColor("plum");
  var debug = getColor("plum");
  var currentLevel = levels.info;
  function log(level, message) {
    if (levels[level] === undefined) {
      throw new Error(`MISSING_LOG_LEVEL: '${level}'. implement in logger.`);
    }
    if (levels[level] <= currentLevel) {
      const formattedMessage = formatMessage(level, message);
      console.log(formattedMessage);
    }
  }
  function formatMessage(level, message) {
    const formattedMessage = typeof message === "object" ? JSON.stringify(message) : message;
    switch (level.toLowerCase()) {
      case "error":
        return error(formattedMessage);
      case "errorv":
        return error(`[dotenvx@${packageJson.version}] ${formattedMessage}`);
      case "errornocolor":
        return formattedMessage;
      case "warn":
        return warn(formattedMessage);
      case "success":
        return success(formattedMessage);
      case "successv":
        return successv(`[dotenvx@${packageJson.version}] ${formattedMessage}`);
      case "info":
        return formattedMessage;
      case "help":
        return help(formattedMessage);
      case "verbose":
        return verbose(formattedMessage);
      case "debug":
        return debug(formattedMessage);
      case "blank":
        return formattedMessage;
    }
  }
  var logger = {
    level: "info",
    error: (msg) => log("error", msg),
    errorv: (msg) => log("errorv", msg),
    errornocolor: (msg) => log("errornocolor", msg),
    warn: (msg) => log("warn", msg),
    success: (msg) => log("success", msg),
    successv: (msg) => log("successv", msg),
    info: (msg) => log("info", msg),
    help: (msg) => log("help", msg),
    verbose: (msg) => log("verbose", msg),
    debug: (msg) => log("debug", msg),
    blank: (msg) => log("blank", msg),
    setLevel: (level) => {
      if (levels[level] !== undefined) {
        currentLevel = levels[level];
        logger.level = level;
      }
    }
  };
  function setLogLevel(options) {
    const logLevel = options.debug ? "debug" : options.verbose ? "verbose" : options.quiet ? "error" : options.logLevel;
    if (!logLevel)
      return;
    logger.setLevel(logLevel);
    if (!options.quiet || options.quiet && logLevel !== "error") {
      logger.debug(`Setting log level to ${logLevel}`);
    }
  }
  module.exports = {
    logger,
    getColor,
    setLogLevel,
    levels
  };
});

// ../../node_modules/fdir/dist/utils.js
var require_utils = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.normalizePath = exports.convertSlashes = exports.cleanPath = undefined;
  var path_1 = __require("path");
  function cleanPath(path) {
    let normalized = (0, path_1.normalize)(path);
    if (normalized.length > 1 && normalized[normalized.length - 1] === path_1.sep)
      normalized = normalized.substring(0, normalized.length - 1);
    return normalized;
  }
  exports.cleanPath = cleanPath;
  var SLASHES_REGEX = /[\\/]/g;
  function convertSlashes(path, separator) {
    return path.replace(SLASHES_REGEX, separator);
  }
  exports.convertSlashes = convertSlashes;
  function normalizePath(path, options) {
    const { resolvePaths, normalizePath: normalizePath2, pathSeparator } = options;
    const pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
    if (resolvePaths)
      path = (0, path_1.resolve)(path);
    if (normalizePath2 || pathNeedsCleaning)
      path = cleanPath(path);
    if (path === ".")
      return "";
    const needsSeperator = path[path.length - 1] !== pathSeparator;
    return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
  }
  exports.normalizePath = normalizePath;
});

// ../../node_modules/fdir/dist/api/functions/join-path.js
var require_join_path = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.build = exports.joinDirectoryPath = exports.joinPathWithBasePath = undefined;
  var path_1 = __require("path");
  var utils_1 = require_utils();
  function joinPathWithBasePath(filename, directoryPath) {
    return directoryPath + filename;
  }
  exports.joinPathWithBasePath = joinPathWithBasePath;
  function joinPathWithRelativePath(root, options) {
    return function(filename, directoryPath) {
      const sameRoot = directoryPath.startsWith(root);
      if (sameRoot)
        return directoryPath.replace(root, "") + filename;
      else
        return (0, utils_1.convertSlashes)((0, path_1.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
    };
  }
  function joinPath(filename) {
    return filename;
  }
  function joinDirectoryPath(filename, directoryPath, separator) {
    return directoryPath + filename + separator;
  }
  exports.joinDirectoryPath = joinDirectoryPath;
  function build(root, options) {
    const { relativePaths, includeBasePath } = options;
    return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
  }
  exports.build = build;
});

// ../../node_modules/fdir/dist/api/functions/push-directory.js
var require_push_directory = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.build = undefined;
  function pushDirectoryWithRelativePath(root) {
    return function(directoryPath, paths) {
      paths.push(directoryPath.substring(root.length) || ".");
    };
  }
  function pushDirectoryFilterWithRelativePath(root) {
    return function(directoryPath, paths, filters) {
      const relativePath = directoryPath.substring(root.length) || ".";
      if (filters.every((filter) => filter(relativePath, true))) {
        paths.push(relativePath);
      }
    };
  }
  var pushDirectory = (directoryPath, paths) => {
    paths.push(directoryPath || ".");
  };
  var pushDirectoryFilter = (directoryPath, paths, filters) => {
    const path = directoryPath || ".";
    if (filters.every((filter) => filter(path, true))) {
      paths.push(path);
    }
  };
  var empty = () => {};
  function build(root, options) {
    const { includeDirs, filters, relativePaths } = options;
    if (!includeDirs)
      return empty;
    if (relativePaths)
      return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
    return filters && filters.length ? pushDirectoryFilter : pushDirectory;
  }
  exports.build = build;
});

// ../../node_modules/fdir/dist/api/functions/push-file.js
var require_push_file = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.build = undefined;
  var pushFileFilterAndCount = (filename, _paths, counts, filters) => {
    if (filters.every((filter) => filter(filename, false)))
      counts.files++;
  };
  var pushFileFilter = (filename, paths, _counts, filters) => {
    if (filters.every((filter) => filter(filename, false)))
      paths.push(filename);
  };
  var pushFileCount = (_filename, _paths, counts, _filters) => {
    counts.files++;
  };
  var pushFile = (filename, paths) => {
    paths.push(filename);
  };
  var empty = () => {};
  function build(options) {
    const { excludeFiles, filters, onlyCounts } = options;
    if (excludeFiles)
      return empty;
    if (filters && filters.length) {
      return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
    } else if (onlyCounts) {
      return pushFileCount;
    } else {
      return pushFile;
    }
  }
  exports.build = build;
});

// ../../node_modules/fdir/dist/api/functions/get-array.js
var require_get_array = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.build = undefined;
  var getArray = (paths) => {
    return paths;
  };
  var getArrayGroup = () => {
    return [""].slice(0, 0);
  };
  function build(options) {
    return options.group ? getArrayGroup : getArray;
  }
  exports.build = build;
});

// ../../node_modules/fdir/dist/api/functions/group-files.js
var require_group_files = __commonJS((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.build = undefined;
  var groupFiles = (groups, directory, files) => {
    groups.push({ directory, files, dir: directory });
  };
  var empty = () => {};
  function build(options) {
    return options.group ? groupFiles : empty;
  }
  exports.build = build;
});

// ../../node_modules/fdir/dist/api/functions/resolve-symlink.js
var require_resolve_symlink = __commonJS((exports) => {
  var __importDefault = exports && exports.__importDefault || function(mod) {
    return mod && mod.__esModule ? mod : { default: mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.build = undefined;
  var fs_1 = __importDefault(__require("fs"));
  var path_1 = __require("path");
  var resolveSymlinksAsync = function(path, state, callback) {
    const { queue, options: { suppressErrors } } = state;
    queue.enqueue();
    fs_1.default.realpath(path, (error, resolvedPath) => {
      if (error)
        return queue.dequeue(suppressErrors ? null : error, state);
      fs_1.default.stat(resolvedPath, (error2, stat) => {
        if (error2)
          return queue.dequeue(suppressErrors ? null : error2, state);
        if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
          return queue.dequeue(null, state);
        callback(stat, resolvedPath);
        queue.dequeue(null, state);
      });
    });
  };
  var resolveSymlinks = function(path, state, callback) {
    const { queue, options: { suppressErrors } } = state;
    queue.enqueue();
    try {
      const resolvedPath = fs_1.default.realpathSync(path);
      const stat = fs_1.default.statSync(resolvedPath);
      if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
        return;
      callback(stat, resolvedPath);
    } catch (e) {
      if (!suppressErrors)
        throw e;
    }
  };
  function build(options, isSynchronous) {
    if (!options.resolveSymlinks || options.excludeSymlinks)
      return null;
    return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
  }
  exports.build = build;
  function isRecursive(path, resolved, state) {
    if (state.options.useRealPaths)
      return isRecursiveUsingRealPaths(resolved, state);
    let parent = (0, path_1.dirname)(path);
    let depth = 1;
    while (parent !== state.root && depth < 2) {
      const resolvedPath = state.symlinks.get(parent);
      const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
      if (isSameRoot)
        depth++;
      else
        parent = (0, path_1.dirname)(parent);
    }
    state.symlinks.set(path, resolved);
    return depth > 1;
  }
  function isRecursiveUsingRealPaths(resolved, state) {
    return state.visited.includes(resolved + state.options.pathSeparator);
  }
});

// ../../node_modules/fdir/dist/api/functions/invoke-callback.js
var require_invoke_callback = __commonJS((exports) => {
  Object.defineP