@mtnts/contract-client 0.0.6 → 0.0.7

package/dist/cli.cjs

@@ -0,0 +1,2210 @@
+#!/usr/bin/env node
+"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 __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js"(exports2, module2) {
+    "use strict";
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0;
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => {
+      Object.defineProperty(object, key, { value });
+      return value;
+    };
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // Remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // Replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
+      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+      pattern
+    );
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+    var IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        );
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    };
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let negative = false;
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
+        negative = true;
+        body = body.substr(1);
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path7, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule[mode].test(path7);
+          if (!matched) {
+            return;
+          }
+          ignored = !negative;
+          unignored = negative;
+          matchedRule = negative ? UNDEFINED : rule;
+        });
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path7, originalPath, doThrow) => {
+      if (!isString(path7)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path7) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path7)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path7 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path7,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path7, cache, checkUnignored, slices);
+      }
+      checkIgnore(path7) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path7)) {
+          return this.test(path7);
+        }
+        const slices = path7.split(SLASH).filter(Boolean);
+        slices.pop();
+        if (slices.length) {
+          const parent = this._t(
+            slices.join(SLASH) + SLASH,
+            this._testCache,
+            true,
+            slices
+          );
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path7, false, MODE_CHECK_IGNORE);
+      }
+      _t(path7, cache, checkUnignored, slices) {
+        if (path7 in cache) {
+          return cache[path7];
+        }
+        if (!slices) {
+          slices = path7.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path7] = this._rules.test(path7, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path7] = parent.ignored ? parent : this._rules.test(path7, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path7) {
+        return this._test(path7, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path7) => !this.ignores(path7);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path7) {
+        return this._test(path7, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path7) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module2.exports = factory;
+    factory.default = factory;
+    module2.exports.isPathValid = isPathValid;
+    define(module2.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
+// src/cli/index.ts
+var cli_exports = {};
+__export(cli_exports, {
+  generateBlockchainTypes: () => generateBlockchainTypes
+});
+module.exports = __toCommonJS(cli_exports);
+
+// node_modules/.pnpm/globby@16.2.0/node_modules/globby/index.js
+var import_node_process2 = __toESM(require("process"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_stream2 = require("stream");
+
+// node_modules/.pnpm/@sindresorhus+merge-streams@4.0.0/node_modules/@sindresorhus/merge-streams/index.js
+var import_node_events = require("events");
+var import_node_stream = require("stream");
+var import_promises = require("stream/promises");
+function mergeStreams(streams) {
+  if (!Array.isArray(streams)) {
+    throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
+  }
+  for (const stream of streams) {
+    validateStream(stream);
+  }
+  const objectMode = streams.some(({ readableObjectMode }) => readableObjectMode);
+  const highWaterMark = getHighWaterMark(streams, objectMode);
+  const passThroughStream = new MergedStream({
+    objectMode,
+    writableHighWaterMark: highWaterMark,
+    readableHighWaterMark: highWaterMark
+  });
+  for (const stream of streams) {
+    passThroughStream.add(stream);
+  }
+  return passThroughStream;
+}
+var getHighWaterMark = (streams, objectMode) => {
+  if (streams.length === 0) {
+    return (0, import_node_stream.getDefaultHighWaterMark)(objectMode);
+  }
+  const highWaterMarks = streams.filter(({ readableObjectMode }) => readableObjectMode === objectMode).map(({ readableHighWaterMark }) => readableHighWaterMark);
+  return Math.max(...highWaterMarks);
+};
+var _streams, _ended, _aborted, _onFinished, _unpipeEvent, _streamPromises;
+var MergedStream = class extends import_node_stream.PassThrough {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _streams, /* @__PURE__ */ new Set([]));
+    __privateAdd(this, _ended, /* @__PURE__ */ new Set([]));
+    __privateAdd(this, _aborted, /* @__PURE__ */ new Set([]));
+    __privateAdd(this, _onFinished);
+    __privateAdd(this, _unpipeEvent, /* @__PURE__ */ Symbol("unpipe"));
+    __privateAdd(this, _streamPromises, /* @__PURE__ */ new WeakMap());
+  }
+  add(stream) {
+    validateStream(stream);
+    if (__privateGet(this, _streams).has(stream)) {
+      return;
+    }
+    __privateGet(this, _streams).add(stream);
+    __privateGet(this, _onFinished) ?? __privateSet(this, _onFinished, onMergedStreamFinished(this, __privateGet(this, _streams), __privateGet(this, _unpipeEvent)));
+    const streamPromise = endWhenStreamsDone({
+      passThroughStream: this,
+      stream,
+      streams: __privateGet(this, _streams),
+      ended: __privateGet(this, _ended),
+      aborted: __privateGet(this, _aborted),
+      onFinished: __privateGet(this, _onFinished),
+      unpipeEvent: __privateGet(this, _unpipeEvent)
+    });
+    __privateGet(this, _streamPromises).set(stream, streamPromise);
+    stream.pipe(this, { end: false });
+  }
+  async remove(stream) {
+    validateStream(stream);
+    if (!__privateGet(this, _streams).has(stream)) {
+      return false;
+    }
+    const streamPromise = __privateGet(this, _streamPromises).get(stream);
+    if (streamPromise === void 0) {
+      return false;
+    }
+    __privateGet(this, _streamPromises).delete(stream);
+    stream.unpipe(this);
+    await streamPromise;
+    return true;
+  }
+};
+_streams = new WeakMap();
+_ended = new WeakMap();
+_aborted = new WeakMap();
+_onFinished = new WeakMap();
+_unpipeEvent = new WeakMap();
+_streamPromises = new WeakMap();
+var onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) => {
+  updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
+  const controller = new AbortController();
+  try {
+    await Promise.race([
+      onMergedStreamEnd(passThroughStream, controller),
+      onInputStreamsUnpipe(passThroughStream, streams, unpipeEvent, controller)
+    ]);
+  } finally {
+    controller.abort();
+    updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_COUNT);
+  }
+};
+var onMergedStreamEnd = async (passThroughStream, { signal }) => {
+  try {
+    await (0, import_promises.finished)(passThroughStream, { signal, cleanup: true });
+  } catch (error) {
+    errorOrAbortStream(passThroughStream, error);
+    throw error;
+  }
+};
+var onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, { signal }) => {
+  for await (const [unpipedStream] of (0, import_node_events.on)(passThroughStream, "unpipe", { signal })) {
+    if (streams.has(unpipedStream)) {
+      unpipedStream.emit(unpipeEvent);
+    }
+  }
+};
+var validateStream = (stream) => {
+  if (typeof stream?.pipe !== "function") {
+    throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
+  }
+};
+var endWhenStreamsDone = async ({ passThroughStream, stream, streams, ended, aborted, onFinished, unpipeEvent }) => {
+  updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_PER_STREAM);
+  const controller = new AbortController();
+  try {
+    await Promise.race([
+      afterMergedStreamFinished(onFinished, stream, controller),
+      onInputStreamEnd({
+        passThroughStream,
+        stream,
+        streams,
+        ended,
+        aborted,
+        controller
+      }),
+      onInputStreamUnpipe({
+        stream,
+        streams,
+        ended,
+        aborted,
+        unpipeEvent,
+        controller
+      })
+    ]);
+  } finally {
+    controller.abort();
+    updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
+  }
+  if (streams.size > 0 && streams.size === ended.size + aborted.size) {
+    if (ended.size === 0 && aborted.size > 0) {
+      abortStream(passThroughStream);
+    } else {
+      endStream(passThroughStream);
+    }
+  }
+};
+var afterMergedStreamFinished = async (onFinished, stream, { signal }) => {
+  try {
+    await onFinished;
+    if (!signal.aborted) {
+      abortStream(stream);
+    }
+  } catch (error) {
+    if (!signal.aborted) {
+      errorOrAbortStream(stream, error);
+    }
+  }
+};
+var onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, aborted, controller: { signal } }) => {
+  try {
+    await (0, import_promises.finished)(stream, {
+      signal,
+      cleanup: true,
+      readable: true,
+      writable: false
+    });
+    if (streams.has(stream)) {
+      ended.add(stream);
+    }
+  } catch (error) {
+    if (signal.aborted || !streams.has(stream)) {
+      return;
+    }
+    if (isAbortError(error)) {
+      aborted.add(stream);
+    } else {
+      errorStream(passThroughStream, error);
+    }
+  }
+};
+var onInputStreamUnpipe = async ({ stream, streams, ended, aborted, unpipeEvent, controller: { signal } }) => {
+  await (0, import_node_events.once)(stream, unpipeEvent, { signal });
+  if (!stream.readable) {
+    return (0, import_node_events.once)(signal, "abort", { signal });
+  }
+  streams.delete(stream);
+  ended.delete(stream);
+  aborted.delete(stream);
+};
+var endStream = (stream) => {
+  if (stream.writable) {
+    stream.end();
+  }
+};
+var errorOrAbortStream = (stream, error) => {
+  if (isAbortError(error)) {
+    abortStream(stream);
+  } else {
+    errorStream(stream, error);
+  }
+};
+var isAbortError = (error) => error?.code === "ERR_STREAM_PREMATURE_CLOSE";
+var abortStream = (stream) => {
+  if (stream.readable || stream.writable) {
+    stream.destroy();
+  }
+};
+var errorStream = (stream, error) => {
+  if (!stream.destroyed) {
+    stream.once("error", noop);
+    stream.destroy(error);
+  }
+};
+var noop = () => {
+};
+var updateMaxListeners = (passThroughStream, increment) => {
+  const maxListeners = passThroughStream.getMaxListeners();
+  if (maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY) {
+    passThroughStream.setMaxListeners(maxListeners + increment);
+  }
+};
+var PASSTHROUGH_LISTENERS_COUNT = 2;
+var PASSTHROUGH_LISTENERS_PER_STREAM = 1;
+
+// node_modules/.pnpm/globby@16.2.0/node_modules/globby/index.js
+var import_fast_glob3 = __toESM(require("fast-glob"), 1);
+
+// node_modules/.pnpm/unicorn-magic@0.4.0/node_modules/unicorn-magic/node.js
+var import_node_util = require("util");
+var import_node_child_process = require("child_process");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var execFileOriginal = (0, import_node_util.promisify)(import_node_child_process.execFile);
+function toPath(urlOrPath) {
+  return urlOrPath instanceof URL ? (0, import_node_url.fileURLToPath)(urlOrPath) : urlOrPath;
+}
+var TEN_MEGABYTES_IN_BYTES = 10 * 1024 * 1024;
+
+// node_modules/.pnpm/globby@16.2.0/node_modules/globby/ignore.js
+var import_node_process = __toESM(require("process"), 1);
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
+var import_ignore = __toESM(require_ignore(), 1);
+
+// node_modules/.pnpm/is-path-inside@4.0.0/node_modules/is-path-inside/index.js
+var import_node_path2 = __toESM(require("path"), 1);
+function isPathInside(childPath, parentPath) {
+  const relation = import_node_path2.default.relative(parentPath, childPath);
+  return Boolean(
+    relation && relation !== ".." && !relation.startsWith(`..${import_node_path2.default.sep}`) && relation !== import_node_path2.default.resolve(childPath)
+  );
+}
+
+// node_modules/.pnpm/slash@5.1.0/node_modules/slash/index.js
+function slash(path7) {
+  const isExtendedLengthPath = path7.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path7;
+  }
+  return path7.replace(/\\/g, "/");
+}
+
+// node_modules/.pnpm/globby@16.2.0/node_modules/globby/utilities.js
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_util2 = require("util");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var isNegativePattern = (pattern) => pattern[0] === "!";
+var normalizeAbsolutePatternToRelative = (pattern) => {
+  if (!pattern.startsWith("/")) {
+    return pattern;
+  }
+  const inner = pattern.slice(1);
+  const firstSlashIndex = inner.indexOf("/");
+  const firstSegment = firstSlashIndex > 0 ? inner.slice(0, firstSlashIndex) : inner;
+  if (firstSlashIndex > 0 && !import_fast_glob.default.isDynamicPattern(firstSegment)) {
+    return pattern;
+  }
+  return inner;
+};
+var absolutePrefixesMatch = (positivePrefix, negativePrefix) => negativePrefix === positivePrefix;
+var getStaticAbsolutePathPrefix = (pattern) => {
+  if (!import_node_path3.default.isAbsolute(pattern)) {
+    return void 0;
+  }
+  const staticSegments = [];
+  for (const segment of pattern.split("/")) {
+    if (!segment) {
+      continue;
+    }
+    if (import_fast_glob.default.isDynamicPattern(segment)) {
+      break;
+    }
+    staticSegments.push(segment);
+  }
+  return staticSegments.length === 0 ? void 0 : `/${staticSegments.join("/")}`;
+};
+var normalizeNegativePattern = (pattern, positiveAbsolutePathPrefixes = [], hasRelativePositivePattern = false) => {
+  if (!pattern.startsWith("/")) {
+    return pattern;
+  }
+  const normalizedPattern = normalizeAbsolutePatternToRelative(pattern);
+  if (normalizedPattern !== pattern) {
+    return normalizedPattern;
+  }
+  if (hasRelativePositivePattern) {
+    return pattern.slice(1);
+  }
+  const negativeAbsolutePathPrefix = getStaticAbsolutePathPrefix(pattern);
+  const preserveAsAbsolutePattern = negativeAbsolutePathPrefix !== void 0 && positiveAbsolutePathPrefixes.some((positiveAbsolutePathPrefix) => absolutePrefixesMatch(positiveAbsolutePathPrefix, negativeAbsolutePathPrefix));
+  return preserveAsAbsolutePattern ? pattern : pattern.slice(1);
+};
+var bindFsMethod = (object, methodName) => {
+  const method = object?.[methodName];
+  return typeof method === "function" ? method.bind(object) : void 0;
+};
+var promisifyFsMethod = (object, methodName) => {
+  const method = object?.[methodName];
+  if (typeof method !== "function") {
+    return void 0;
+  }
+  return (0, import_node_util2.promisify)(method.bind(object));
+};
+var normalizeDirectoryPatternForFastGlob = (pattern) => {
+  if (!pattern.endsWith("/")) {
+    return pattern;
+  }
+  const trimmedPattern = pattern.replace(/\/+$/u, "");
+  if (!trimmedPattern) {
+    return "/**";
+  }
+  if (trimmedPattern === "**") {
+    return "**/**";
+  }
+  const hasLeadingSlash = trimmedPattern.startsWith("/");
+  const patternBody = hasLeadingSlash ? trimmedPattern.slice(1) : trimmedPattern;
+  const hasInnerSlash = patternBody.includes("/");
+  const needsRecursivePrefix = !hasLeadingSlash && !hasInnerSlash && !trimmedPattern.startsWith("**/");
+  const recursivePrefix = needsRecursivePrefix ? "**/" : "";
+  return `${recursivePrefix}${trimmedPattern}/**`;
+};
+var getParentDirectoryPrefix = (pattern) => {
+  const normalizedPattern = isNegativePattern(pattern) ? pattern.slice(1) : pattern;
+  const match = normalizedPattern.match(/^(\.\.\/)+/);
+  return match ? match[0] : "";
+};
+var adjustIgnorePatternsForParentDirectories = (patterns, ignorePatterns) => {
+  if (patterns.length === 0 || ignorePatterns.length === 0) {
+    return ignorePatterns;
+  }
+  const parentPrefixes = patterns.map((pattern) => getParentDirectoryPrefix(pattern));
+  const firstPrefix = parentPrefixes[0];
+  if (!firstPrefix) {
+    return ignorePatterns;
+  }
+  const allSamePrefix = parentPrefixes.every((prefix) => prefix === firstPrefix);
+  if (!allSamePrefix) {
+    return ignorePatterns;
+  }
+  return ignorePatterns.map((pattern) => {
+    if (pattern.startsWith("**/") && !pattern.startsWith("../")) {
+      return firstPrefix + pattern;
+    }
+    return pattern;
+  });
+};
+var getAsyncStatMethod = (fsImplementation) => bindFsMethod(fsImplementation?.promises, "stat") ?? bindFsMethod(import_node_fs.default.promises, "stat");
+var getStatSyncMethod = (fsImplementation) => {
+  if (fsImplementation) {
+    return bindFsMethod(fsImplementation, "statSync");
+  }
+  return bindFsMethod(import_node_fs.default, "statSync");
+};
+var pathHasGitDirectory = (stats) => Boolean(stats?.isDirectory?.() || stats?.isFile?.());
+var buildPathChain = (startPath, rootPath) => {
+  const chain = [];
+  let currentPath = startPath;
+  chain.push(currentPath);
+  while (currentPath !== rootPath) {
+    const parentPath = import_node_path3.default.dirname(currentPath);
+    if (parentPath === currentPath) {
+      break;
+    }
+    currentPath = parentPath;
+    chain.push(currentPath);
+  }
+  return chain;
+};
+var findGitRootInChain = async (paths, statMethod) => {
+  for (const directory of paths) {
+    const gitPath = import_node_path3.default.join(directory, ".git");
+    try {
+      const stats = await statMethod(gitPath);
+      if (pathHasGitDirectory(stats)) {
+        return directory;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+};
+var findGitRootSyncUncached = (cwd, fsImplementation) => {
+  const statSyncMethod = getStatSyncMethod(fsImplementation);
+  if (!statSyncMethod) {
+    return void 0;
+  }
+  const currentPath = import_node_path3.default.resolve(cwd);
+  const { root } = import_node_path3.default.parse(currentPath);
+  const chain = buildPathChain(currentPath, root);
+  for (const directory of chain) {
+    const gitPath = import_node_path3.default.join(directory, ".git");
+    try {
+      const stats = statSyncMethod(gitPath);
+      if (pathHasGitDirectory(stats)) {
+        return directory;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+};
+var findGitRootSync = (cwd, fsImplementation) => {
+  if (typeof cwd !== "string") {
+    throw new TypeError("cwd must be a string");
+  }
+  return findGitRootSyncUncached(cwd, fsImplementation);
+};
+var findGitRootAsyncUncached = async (cwd, fsImplementation) => {
+  const statMethod = getAsyncStatMethod(fsImplementation);
+  if (!statMethod) {
+    return findGitRootSync(cwd, fsImplementation);
+  }
+  const currentPath = import_node_path3.default.resolve(cwd);
+  const { root } = import_node_path3.default.parse(currentPath);
+  const chain = buildPathChain(currentPath, root);
+  return findGitRootInChain(chain, statMethod);
+};
+var findGitRoot = async (cwd, fsImplementation) => {
+  if (typeof cwd !== "string") {
+    throw new TypeError("cwd must be a string");
+  }
+  return findGitRootAsyncUncached(cwd, fsImplementation);
+};
+var isWithinGitRoot = (gitRoot, cwd) => {
+  const resolvedGitRoot = import_node_path3.default.resolve(gitRoot);
+  const resolvedCwd = import_node_path3.default.resolve(cwd);
+  return resolvedCwd === resolvedGitRoot || isPathInside(resolvedCwd, resolvedGitRoot);
+};
+var getParentGitignorePaths = (gitRoot, cwd) => {
+  if (gitRoot && typeof gitRoot !== "string") {
+    throw new TypeError("gitRoot must be a string or undefined");
+  }
+  if (typeof cwd !== "string") {
+    throw new TypeError("cwd must be a string");
+  }
+  if (!gitRoot) {
+    return [];
+  }
+  if (!isWithinGitRoot(gitRoot, cwd)) {
+    return [];
+  }
+  const chain = buildPathChain(import_node_path3.default.resolve(cwd), import_node_path3.default.resolve(gitRoot));
+  return [...chain].reverse().map((directory) => import_node_path3.default.join(directory, ".gitignore"));
+};
+var convertPatternsForFastGlob = (patterns, usingGitRoot, normalizeDirectoryPatternForFastGlob2) => {
+  if (usingGitRoot) {
+    return [];
+  }
+  const result = [];
+  let hasNegations = false;
+  for (const pattern of patterns) {
+    if (isNegativePattern(pattern)) {
+      hasNegations = true;
+      break;
+    }
+    result.push(normalizeDirectoryPatternForFastGlob2(pattern));
+  }
+  return hasNegations ? [] : result;
+};
+
+// node_modules/.pnpm/globby@16.2.0/node_modules/globby/ignore.js
+var defaultIgnoredDirectories = [
+  "**/node_modules",
+  "**/flow-typed",
+  "**/coverage",
+  "**/.git"
+];
+var ignoreFilesGlobOptions = {
+  absolute: true,
+  dot: true
+};
+var GITIGNORE_FILES_PATTERN = "**/.gitignore";
+var MAX_INCLUDE_DEPTH = 10;
+var getReadFileMethod = (fsImplementation) => bindFsMethod(fsImplementation?.promises, "readFile") ?? bindFsMethod(import_promises2.default, "readFile") ?? promisifyFsMethod(fsImplementation, "readFile");
+var getReadFileSyncMethod = (fsImplementation) => bindFsMethod(fsImplementation, "readFileSync") ?? bindFsMethod(import_node_fs2.default, "readFileSync");
+var shouldSkipIgnoreFileError = (error, suppressErrors) => {
+  if (!error) {
+    return Boolean(suppressErrors);
+  }
+  if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+    return true;
+  }
+  return Boolean(suppressErrors);
+};
+var createReadError = (kind, filePath, error) => {
+  const prefix = `Failed to read ${kind} at ${filePath}`;
+  if (error instanceof Error) {
+    return new Error(`${prefix}: ${error.message}`, { cause: error });
+  }
+  return new Error(`${prefix}: ${String(error)}`);
+};
+var createIgnoreFileReadError = (filePath, error) => createReadError("ignore file", filePath, error);
+var createGitConfigReadError = (filePath, error) => createReadError("git config", filePath, error);
+var processIgnoreFileCore = (filePath, readMethod, suppressErrors) => {
+  try {
+    const content = readMethod(filePath, "utf8");
+    return { filePath, content };
+  } catch (error) {
+    if (shouldSkipIgnoreFileError(error, suppressErrors)) {
+      return void 0;
+    }
+    throw createIgnoreFileReadError(filePath, error);
+  }
+};
+var readIgnoreFilesSafely = async (paths, readFileMethod, suppressErrors) => {
+  const fileResults = await Promise.all(paths.map(async (filePath) => {
+    try {
+      const content = await readFileMethod(filePath, "utf8");
+      return { filePath, content };
+    } catch (error) {
+      if (shouldSkipIgnoreFileError(error, suppressErrors)) {
+        return void 0;
+      }
+      throw createIgnoreFileReadError(filePath, error);
+    }
+  }));
+  return fileResults.filter(Boolean);
+};
+var readIgnoreFilesSafelySync = (paths, readFileSyncMethod, suppressErrors) => paths.map((filePath) => processIgnoreFileCore(filePath, readFileSyncMethod, suppressErrors)).filter(Boolean);
+var dedupePaths = (paths) => {
+  const seen = /* @__PURE__ */ new Set();
+  return paths.filter((filePath) => {
+    if (seen.has(filePath)) {
+      return false;
+    }
+    seen.add(filePath);
+    return true;
+  });
+};
+var globIgnoreFiles = (globFunction, patterns, normalizedOptions) => globFunction(patterns, {
+  ...normalizedOptions,
+  ...ignoreFilesGlobOptions
+  // Must be last to ensure absolute/dot flags stick
+});
+var getParentIgnorePaths = (gitRoot, normalizedOptions) => gitRoot ? getParentGitignorePaths(gitRoot, normalizedOptions.cwd) : [];
+var combineIgnoreFilePaths = (gitRoot, normalizedOptions, childPaths) => dedupePaths([
+  ...getParentIgnorePaths(gitRoot, normalizedOptions),
+  ...childPaths
+]);
+var buildIgnoreResult = (files, normalizedOptions, gitRoot) => {
+  const baseDir = gitRoot || normalizedOptions.cwd;
+  const patterns = getPatternsFromIgnoreFiles(files, baseDir);
+  const matcher = createIgnoreMatcher(patterns, normalizedOptions.cwd, baseDir);
+  return {
+    patterns,
+    matcher,
+    predicate: (fileOrDirectory) => matcher(fileOrDirectory).ignored,
+    usingGitRoot: Boolean(gitRoot && gitRoot !== normalizedOptions.cwd)
+  };
+};
+var applyBaseToPattern = (pattern, base) => {
+  if (!base) {
+    return pattern;
+  }
+  const isNegative = isNegativePattern(pattern);
+  const cleanPattern = isNegative ? pattern.slice(1) : pattern;
+  const slashIndex = cleanPattern.indexOf("/");
+  const hasNonTrailingSlash = slashIndex !== -1 && slashIndex !== cleanPattern.length - 1;
+  let result;
+  if (!hasNonTrailingSlash) {
+    result = import_node_path4.default.posix.join(base, "**", cleanPattern);
+  } else if (cleanPattern.startsWith("/")) {
+    result = import_node_path4.default.posix.join(base, cleanPattern.slice(1));
+  } else {
+    result = import_node_path4.default.posix.join(base, cleanPattern);
+  }
+  return isNegative ? "!" + result : result;
+};
+var parseIgnoreFile = (file, cwd) => {
+  const base = slash(import_node_path4.default.relative(cwd, import_node_path4.default.dirname(file.filePath)));
+  return file.content.split(/\r?\n/).filter((line) => line && !line.startsWith("#")).map((pattern) => applyBaseToPattern(pattern, base));
+};
+var toRelativePath = (fileOrDirectory, cwd) => {
+  if (import_node_path4.default.isAbsolute(fileOrDirectory)) {
+    const relativePath = import_node_path4.default.relative(cwd, fileOrDirectory);
+    if (relativePath && !isPathInside(fileOrDirectory, cwd)) {
+      return void 0;
+    }
+    return relativePath;
+  }
+  if (fileOrDirectory.startsWith("./")) {
+    return fileOrDirectory.slice(2);
+  }
+  if (fileOrDirectory.startsWith("../")) {
+    return void 0;
+  }
+  return fileOrDirectory;
+};
+var notIgnored = { ignored: false, unignored: false };
+var createIgnoreMatcher = (patterns, cwd, baseDir) => {
+  const ignores = (0, import_ignore.default)().add(patterns);
+  const resolvedCwd = import_node_path4.default.normalize(import_node_path4.default.resolve(cwd));
+  const resolvedBaseDir = import_node_path4.default.normalize(import_node_path4.default.resolve(baseDir));
+  return (fileOrDirectory) => {
+    fileOrDirectory = toPath(fileOrDirectory);
+    const hasTrailingSeparator = /[/\\]$/.test(fileOrDirectory);
+    const normalizedPath = import_node_path4.default.normalize(import_node_path4.default.resolve(fileOrDirectory));
+    if (normalizedPath === resolvedCwd) {
+      return notIgnored;
+    }
+    let relativePath = toRelativePath(fileOrDirectory, resolvedBaseDir);
+    if (relativePath === void 0) {
+      return notIgnored;
+    }
+    if (!relativePath) {
+      return notIgnored;
+    }
+    if (hasTrailingSeparator && !relativePath.endsWith(import_node_path4.default.sep)) {
+      relativePath += import_node_path4.default.sep;
+    }
+    return ignores.test(slash(relativePath));
+  };
+};
+var normalizeOptions = (options = {}) => {
+  const ignoreOption = options.ignore ? Array.isArray(options.ignore) ? options.ignore : [options.ignore] : [];
+  const cwd = toPath(options.cwd) ?? import_node_process.default.cwd();
+  const deep = typeof options.deep === "number" ? Math.max(0, options.deep) + 1 : Number.POSITIVE_INFINITY;
+  return {
+    cwd,
+    suppressErrors: options.suppressErrors ?? false,
+    deep,
+    ignore: [...ignoreOption, ...defaultIgnoredDirectories],
+    followSymbolicLinks: options.followSymbolicLinks ?? true,
+    concurrency: options.concurrency,
+    throwErrorOnBrokenSymbolicLink: options.throwErrorOnBrokenSymbolicLink ?? false,
+    fs: options.fs
+  };
+};
+var unescapeGitQuotedValue = (value) => value.replaceAll(/\\(["\\abfnrtv])/g, (_match, escapedCharacter) => {
+  switch (escapedCharacter) {
+    case "a": {
+      return "\x07";
+    }
+    case "b": {
+      return "\b";
+    }
+    case "f": {
+      return "\f";
+    }
+    case "n": {
+      return "\n";
+    }
+    case "r": {
+      return "\r";
+    }
+    case "t": {
+      return "	";
+    }
+    case "v": {
+      return "\v";
+    }
+    default: {
+      return escapedCharacter;
+    }
+  }
+});
+var parseGitConfigValue = (value) => {
+  const trimmedValue = value.trim();
+  const quotedMatch = trimmedValue.match(/^"((?:[^"\\]|\\.)*)"\s*(?:[#;].*)?$/);
+  if (quotedMatch) {
+    return unescapeGitQuotedValue(quotedMatch[1]);
+  }
+  return trimmedValue.replace(/\s[#;].*$/, "").trim();
+};
+var resolveConfigPath = (filePath, configPath) => {
+  if (configPath.startsWith("~/")) {
+    const homeDirectory = import_node_os.default.homedir();
+    const resolved = import_node_path4.default.join(homeDirectory, configPath.slice(2));
+    if (!isPathInside(resolved, homeDirectory)) {
+      return import_node_path4.default.join(homeDirectory, ".globby-invalid-path-traversal");
+    }
+    return resolved;
+  }
+  if (import_node_path4.default.isAbsolute(configPath)) {
+    return configPath;
+  }
+  return import_node_path4.default.resolve(import_node_path4.default.dirname(filePath), configPath);
+};
+var parseGitConfigSection = (line) => {
+  if (!line.startsWith("[")) {
+    return void 0;
+  }
+  let inQuotes = false;
+  let isEscaped = false;
+  for (let index = 1; index < line.length; index++) {
+    const character = line[index];
+    if (isEscaped) {
+      isEscaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      isEscaped = true;
+      continue;
+    }
+    if (character === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (character === "]" && !inQuotes) {
+      const remainder = line.slice(index + 1).trimStart();
+      if (remainder && !remainder.startsWith("#") && !remainder.startsWith(";")) {
+        return void 0;
+      }
+      return line.slice(1, index).trim();
+    }
+  }
+  return void 0;
+};
+var parseGitConfigEntry = (line) => {
+  const match = line.match(/^([A-Za-z\d-.]+)\s*=\s*(.*)$/);
+  if (!match) {
+    return void 0;
+  }
+  return {
+    key: match[1].toLowerCase(),
+    value: parseGitConfigValue(match[2])
+  };
+};
+var parseIncludeIfCondition = (section) => {
+  if (!section) {
+    return void 0;
+  }
+  const match = section.match(/^includeif\s+"([^"]+)"$/i);
+  return match ? match[1] : void 0;
+};
+var normalizeGitConfigConditionPattern = (pattern, configFilePath) => {
+  if (pattern.startsWith("~/")) {
+    pattern = import_node_path4.default.join(import_node_os.default.homedir(), pattern.slice(2));
+  } else if (pattern.startsWith("./")) {
+    pattern = import_node_path4.default.resolve(import_node_path4.default.dirname(configFilePath), pattern.slice(2));
+  } else if (!import_node_path4.default.isAbsolute(pattern)) {
+    pattern = `**/${pattern}`;
+  }
+  if (pattern.endsWith("/")) {
+    pattern += "**";
+  }
+  return slash(pattern);
+};
+var gitConfigGlobToRegex = (pattern, flags) => {
+  let regex = "";
+  for (let index = 0; index < pattern.length; index++) {
+    const character = pattern[index];
+    const nextCharacter = pattern[index + 1];
+    const nextNextCharacter = pattern[index + 2];
+    if (character === "*" && nextCharacter === "*" && nextNextCharacter === "/") {
+      regex += "(?:.*/)?";
+      index += 2;
+      continue;
+    }
+    if (character === "*" && nextCharacter === "*") {
+      regex += ".*";
+      index += 1;
+      continue;
+    }
+    if (character === "*") {
+      regex += "[^/]*";
+      continue;
+    }
+    if (character === "?") {
+      regex += "[^/]";
+      continue;
+    }
+    if (character === "[") {
+      const closingBracketIndex = pattern.indexOf("]", index + 1);
+      if (closingBracketIndex !== -1) {
+        const bracketContent = pattern.slice(index + 1, closingBracketIndex);
+        if (bracketContent) {
+          const negatedBracketContent = bracketContent[0] === "!" ? `^${bracketContent.slice(1)}` : bracketContent;
+          regex += `[${negatedBracketContent}]`;
+          index = closingBracketIndex;
+          continue;
+        }
+      }
+    }
+    regex += /[|\\{}()[\]^$+?.]/.test(character) ? `\\${character}` : character;
+  }
+  try {
+    return new RegExp(`^${regex}$`, flags);
+  } catch {
+    return /(?!)/;
+  }
+};
+var matchesIncludeIfCondition = (condition, gitDirectory, configFilePath) => {
+  if (!gitDirectory) {
+    return false;
+  }
+  const match = condition.match(/^(gitdir|gitdir\/i):(.*)$/i);
+  if (!match) {
+    return false;
+  }
+  const [, keyword, rawPattern] = match;
+  const pattern = normalizeGitConfigConditionPattern(rawPattern.trim(), configFilePath);
+  const isCaseInsensitive = keyword.toLowerCase() === "gitdir/i";
+  const regularExpression = gitConfigGlobToRegex(pattern, isCaseInsensitive ? "i" : void 0);
+  const normalizedGitDirectory = slash(import_node_path4.default.resolve(gitDirectory));
+  return regularExpression.test(normalizedGitDirectory);
+};
+var shouldIncludeConfigSection = (section, gitDirectory, configFilePath) => {
+  if (section?.toLowerCase() === "include") {
+    return true;
+  }
+  const condition = parseIncludeIfCondition(section);
+  return condition ? matchesIncludeIfCondition(condition, gitDirectory, configFilePath) : false;
+};
+var createExcludesFileValue = (value, declaringFilePath) => ({
+  value,
+  declaringFilePath
+});
+var parseGitConfigForExcludesFile = (content, normalizedPath, gitDirectory) => {
+  let currentSection;
+  let excludesFile;
+  const includePaths = [];
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";")) {
+      continue;
+    }
+    if (trimmed.startsWith("[")) {
+      currentSection = parseGitConfigSection(trimmed);
+      continue;
+    }
+    const entry = parseGitConfigEntry(trimmed);
+    if (!entry) {
+      continue;
+    }
+    if (currentSection?.toLowerCase() === "core" && entry.key === "excludesfile") {
+      excludesFile = createExcludesFileValue(entry.value, normalizedPath);
+      continue;
+    }
+    if (shouldIncludeConfigSection(currentSection, gitDirectory, normalizedPath) && entry.key === "path" && entry.value) {
+      includePaths.push(resolveConfigPath(normalizedPath, entry.value));
+    }
+  }
+  return { excludesFile, includePaths };
+};
+var readGitConfigFile = (normalizedPath, readMethod, suppressErrors) => {
+  try {
+    return readMethod(normalizedPath, "utf8");
+  } catch (error) {
+    if (shouldSkipIgnoreFileError(error, suppressErrors)) {
+      return void 0;
+    }
+    throw createGitConfigReadError(normalizedPath, error);
+  }
+};
+var getExcludesFileFromGitConfigSync = (filePath, readFileSync, gitDirectory, options = {}) => {
+  const { suppressErrors, includeStack = /* @__PURE__ */ new Set(), depth = 0 } = options;
+  const normalizedPath = import_node_path4.default.resolve(filePath);
+  if (includeStack.has(normalizedPath)) {
+    return void 0;
+  }
+  if (depth >= MAX_INCLUDE_DEPTH) {
+    return void 0;
+  }
+  includeStack.add(normalizedPath);
+  const content = readGitConfigFile(normalizedPath, readFileSync, suppressErrors);
+  if (content === void 0) {
+    includeStack.delete(normalizedPath);
+    return void 0;
+  }
+  let { excludesFile, includePaths } = parseGitConfigForExcludesFile(content, normalizedPath, gitDirectory);
+  for (const includePath of includePaths) {
+    const includedExcludesFile = getExcludesFileFromGitConfigSync(includePath, readFileSync, gitDirectory, { suppressErrors, includeStack, depth: depth + 1 });
+    if (includedExcludesFile !== void 0) {
+      excludesFile = includedExcludesFile;
+    }
+  }
+  includeStack.delete(normalizedPath);
+  return excludesFile;
+};
+var getExcludesFileFromGitConfigAsync = async (filePath, readFile, gitDirectory, options = {}) => {
+  const { suppressErrors, includeStack = /* @__PURE__ */ new Set(), depth = 0 } = options;
+  const normalizedPath = import_node_path4.default.resolve(filePath);
+  if (includeStack.has(normalizedPath)) {
+    return void 0;
+  }
+  if (depth >= MAX_INCLUDE_DEPTH) {
+    return void 0;
+  }
+  includeStack.add(normalizedPath);
+  let content;
+  try {
+    content = await readFile(normalizedPath, "utf8");
+  } catch (error) {
+    includeStack.delete(normalizedPath);
+    if (shouldSkipIgnoreFileError(error, suppressErrors)) {
+      return void 0;
+    }
+    throw createGitConfigReadError(normalizedPath, error);
+  }
+  let { excludesFile, includePaths } = parseGitConfigForExcludesFile(content, normalizedPath, gitDirectory);
+  for (const includePath of includePaths) {
+    const includedExcludesFile = await getExcludesFileFromGitConfigAsync(includePath, readFile, gitDirectory, { suppressErrors, includeStack, depth: depth + 1 });
+    if (includedExcludesFile !== void 0) {
+      excludesFile = includedExcludesFile;
+    }
+  }
+  includeStack.delete(normalizedPath);
+  return excludesFile;
+};
+var resolveGitDirectoryFromFile = (gitFilePath, content) => {
+  const match = content.match(/^gitdir:\s*(.+?)\s*$/i);
+  if (!match) {
+    return gitFilePath;
+  }
+  return import_node_path4.default.resolve(import_node_path4.default.dirname(gitFilePath), match[1]);
+};
+var getGitDirectorySync = (gitRoot, readFileSync) => {
+  if (!gitRoot) {
+    return void 0;
+  }
+  const gitFilePath = import_node_path4.default.join(gitRoot, ".git");
+  try {
+    return resolveGitDirectoryFromFile(gitFilePath, readFileSync(gitFilePath, "utf8"));
+  } catch {
+    return gitFilePath;
+  }
+};
+var getGitDirectoryAsync = async (gitRoot, readFile) => {
+  if (!gitRoot) {
+    return void 0;
+  }
+  const gitFilePath = import_node_path4.default.join(gitRoot, ".git");
+  try {
+    return resolveGitDirectoryFromFile(gitFilePath, await readFile(gitFilePath, "utf8"));
+  } catch {
+    return gitFilePath;
+  }
+};
+var getXdgConfigHome = () => import_node_process.default.env.XDG_CONFIG_HOME || import_node_path4.default.join(import_node_os.default.homedir(), ".config");
+var getGitConfigPaths = () => {
+  if ("GIT_CONFIG_GLOBAL" in import_node_process.default.env) {
+    const value = import_node_process.default.env.GIT_CONFIG_GLOBAL;
+    return value ? [value] : [];
+  }
+  return [
+    import_node_path4.default.join(getXdgConfigHome(), "git", "config"),
+    import_node_path4.default.join(import_node_os.default.homedir(), ".gitconfig")
+  ];
+};
+var getDefaultGlobalGitignorePath = () => import_node_path4.default.join(getXdgConfigHome(), "git", "ignore");
+var resolveExcludesFilePath = (excludesFileConfig) => {
+  if (excludesFileConfig?.value === "") {
+    return void 0;
+  }
+  if (excludesFileConfig === void 0) {
+    return getDefaultGlobalGitignorePath();
+  }
+  return resolveConfigPath(excludesFileConfig.declaringFilePath, excludesFileConfig.value);
+};
+var readGlobalGitignoreContent = (filePath, readMethod, suppressErrors) => {
+  try {
+    const content = readMethod(filePath, "utf8");
+    return { filePath, content };
+  } catch (error) {
+    if (shouldSkipIgnoreFileError(error, suppressErrors)) {
+      return void 0;
+    }
+    throw createIgnoreFileReadError(filePath, error);
+  }
+};
+var getGlobalGitignoreFile = (options = {}) => {
+  const cwd = toPath(options.cwd) ?? import_node_process.default.cwd();
+  const readFileSync = getReadFileSyncMethod(options.fs);
+  const gitRoot = findGitRootSync(cwd, options.fs);
+  const gitDirectory = getGitDirectorySync(gitRoot, readFileSync);
+  let excludesFileConfig;
+  for (const gitConfigPath of getGitConfigPaths()) {
+    const value = getExcludesFileFromGitConfigSync(gitConfigPath, readFileSync, gitDirectory, { suppressErrors: options.suppressErrors });
+    if (value !== void 0) {
+      excludesFileConfig = value;
+    }
+  }
+  const filePath = resolveExcludesFilePath(excludesFileConfig);
+  return filePath === void 0 ? void 0 : readGlobalGitignoreContent(filePath, readFileSync, options.suppressErrors);
+};
+var getGlobalGitignoreFileAsync = async (options = {}) => {
+  const cwd = toPath(options.cwd) ?? import_node_process.default.cwd();
+  const readFile = getReadFileMethod(options.fs);
+  const gitRoot = await findGitRoot(cwd, options.fs);
+  const gitDirectory = await getGitDirectoryAsync(gitRoot, readFile);
+  const excludesFileValues = await Promise.all(getGitConfigPaths().map((gitConfigPath) => getExcludesFileFromGitConfigAsync(
+    gitConfigPath,
+    readFile,
+    gitDirectory,
+    { suppressErrors: options.suppressErrors }
+  )));
+  const excludesFileConfig = excludesFileValues.findLast((value) => value !== void 0);
+  const filePath = resolveExcludesFilePath(excludesFileConfig);
+  if (filePath === void 0) {
+    return void 0;
+  }
+  try {
+    const content = await readFile(filePath, "utf8");
+    return { filePath, content };
+  } catch (error) {
+    if (shouldSkipIgnoreFileError(error, options.suppressErrors)) {
+      return void 0;
+    }
+    throw createIgnoreFileReadError(filePath, error);
+  }
+};
+var buildGlobalMatcher = (globalIgnoreFile, cwd, rootDirectory = cwd) => {
+  const patterns = parseIgnoreFile(globalIgnoreFile, import_node_path4.default.dirname(globalIgnoreFile.filePath));
+  return createIgnoreMatcher(patterns, cwd, rootDirectory);
+};
+var collectIgnoreFileArtifactsAsync = async (patterns, options, includeParentIgnoreFiles) => {
+  const normalizedOptions = normalizeOptions(options);
+  const childPaths = await globIgnoreFiles(import_fast_glob2.default, patterns, normalizedOptions);
+  const gitRoot = includeParentIgnoreFiles ? await findGitRoot(normalizedOptions.cwd, normalizedOptions.fs) : void 0;
+  const allPaths = combineIgnoreFilePaths(gitRoot, normalizedOptions, childPaths);
+  const readFileMethod = getReadFileMethod(normalizedOptions.fs);
+  const files = await readIgnoreFilesSafely(allPaths, readFileMethod, normalizedOptions.suppressErrors);
+  return { files, normalizedOptions, gitRoot };
+};
+var collectIgnoreFileArtifactsSync = (patterns, options, includeParentIgnoreFiles) => {
+  const normalizedOptions = normalizeOptions(options);
+  const childPaths = globIgnoreFiles(import_fast_glob2.default.sync, patterns, normalizedOptions);
+  const gitRoot = includeParentIgnoreFiles ? findGitRootSync(normalizedOptions.cwd, normalizedOptions.fs) : void 0;
+  const allPaths = combineIgnoreFilePaths(gitRoot, normalizedOptions, childPaths);
+  const readFileSyncMethod = getReadFileSyncMethod(normalizedOptions.fs);
+  const files = readIgnoreFilesSafelySync(allPaths, readFileSyncMethod, normalizedOptions.suppressErrors);
+  return { files, normalizedOptions, gitRoot };
+};
+var getPatternsFromIgnoreFiles = (files, baseDir) => files.flatMap((file) => parseIgnoreFile(file, baseDir));
+var getIgnorePatternsAndPredicate = async (patterns, options, includeParentIgnoreFiles = false) => {
+  const { files, normalizedOptions, gitRoot } = await collectIgnoreFileArtifactsAsync(
+    patterns,
+    options,
+    includeParentIgnoreFiles
+  );
+  return buildIgnoreResult(files, normalizedOptions, gitRoot);
+};
+var getIgnorePatternsAndPredicateSync = (patterns, options, includeParentIgnoreFiles = false) => {
+  const { files, normalizedOptions, gitRoot } = collectIgnoreFileArtifactsSync(
+    patterns,
+    options,
+    includeParentIgnoreFiles
+  );
+  return buildIgnoreResult(files, normalizedOptions, gitRoot);
+};
+
+// node_modules/.pnpm/globby@16.2.0/node_modules/globby/index.js
+var assertPatternsInput = (patterns) => {
+  if (patterns.some((pattern) => typeof pattern !== "string")) {
+    throw new TypeError("Patterns must be a string or an array of strings");
+  }
+};
+var getStatMethod = (fsImplementation) => {
+  if (fsImplementation) {
+    return bindFsMethod(fsImplementation.promises, "stat") ?? promisifyFsMethod(fsImplementation, "stat");
+  }
+  return bindFsMethod(import_node_fs3.default.promises, "stat");
+};
+var getStatSyncMethod2 = (fsImplementation) => bindFsMethod(fsImplementation, "statSync") ?? bindFsMethod(import_node_fs3.default, "statSync");
+var isDirectory = async (path7, fsImplementation) => {
+  try {
+    const stats = await getStatMethod(fsImplementation)(path7);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+};
+var isDirectorySync = (path7, fsImplementation) => {
+  try {
+    const stats = getStatSyncMethod2(fsImplementation)(path7);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+};
+var normalizePathForDirectoryGlob = (filePath, cwd) => {
+  const path7 = isNegativePattern(filePath) ? filePath.slice(1) : filePath;
+  return import_node_path5.default.isAbsolute(path7) ? path7 : import_node_path5.default.join(cwd, path7);
+};
+var shouldExpandGlobstarDirectory = (pattern) => {
+  const match = pattern?.match(/\*\*\/([^/]+)$/);
+  if (!match) {
+    return false;
+  }
+  const dirname = match[1];
+  const hasWildcards = /[*?[\]{}]/.test(dirname);
+  const hasExtension = import_node_path5.default.extname(dirname) && !dirname.startsWith(".");
+  return !hasWildcards && !hasExtension;
+};
+var getDirectoryGlob = ({ directoryPath, files, extensions }) => {
+  const extensionGlob = extensions?.length > 0 ? `.${extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0]}` : "";
+  return files ? files.map((file) => import_node_path5.default.posix.join(directoryPath, `**/${import_node_path5.default.extname(file) ? file : `${file}${extensionGlob}`}`)) : [import_node_path5.default.posix.join(directoryPath, `**${extensionGlob ? `/*${extensionGlob}` : ""}`)];
+};
+var directoryToGlob = async (directoryPaths, {
+  cwd = import_node_process2.default.cwd(),
+  files,
+  extensions,
+  fs: fsImplementation
+} = {}) => {
+  const globs = await Promise.all(directoryPaths.map(async (directoryPath) => {
+    const checkPattern = isNegativePattern(directoryPath) ? directoryPath.slice(1) : directoryPath;
+    if (shouldExpandGlobstarDirectory(checkPattern)) {
+      return getDirectoryGlob({ directoryPath, files, extensions });
+    }
+    const pathToCheck = normalizePathForDirectoryGlob(directoryPath, cwd);
+    return await isDirectory(pathToCheck, fsImplementation) ? getDirectoryGlob({ directoryPath, files, extensions }) : directoryPath;
+  }));
+  return globs.flat();
+};
+var directoryToGlobSync = (directoryPaths, {
+  cwd = import_node_process2.default.cwd(),
+  files,
+  extensions,
+  fs: fsImplementation
+} = {}) => directoryPaths.flatMap((directoryPath) => {
+  const checkPattern = isNegativePattern(directoryPath) ? directoryPath.slice(1) : directoryPath;
+  if (shouldExpandGlobstarDirectory(checkPattern)) {
+    return getDirectoryGlob({ directoryPath, files, extensions });
+  }
+  const pathToCheck = normalizePathForDirectoryGlob(directoryPath, cwd);
+  return isDirectorySync(pathToCheck, fsImplementation) ? getDirectoryGlob({ directoryPath, files, extensions }) : directoryPath;
+});
+var toPatternsArray = (patterns) => {
+  patterns = [...new Set([patterns].flat())];
+  assertPatternsInput(patterns);
+  return patterns;
+};
+var checkCwdOption = (cwd, fsImplementation = import_node_fs3.default) => {
+  if (!cwd || !fsImplementation.statSync) {
+    return;
+  }
+  let stats;
+  try {
+    stats = fsImplementation.statSync(cwd);
+  } catch {
+    return;
+  }
+  if (!stats.isDirectory()) {
+    throw new Error(`The \`cwd\` option must be a path to a directory, got: ${cwd}`);
+  }
+};
+var normalizeOptions2 = (options = {}) => {
+  const ignore = options.ignore ? Array.isArray(options.ignore) ? options.ignore : [options.ignore] : [];
+  options = {
+    ...options,
+    ignore,
+    expandDirectories: options.expandDirectories ?? true,
+    cwd: toPath(options.cwd)
+  };
+  checkCwdOption(options.cwd, options.fs);
+  return options;
+};
+var normalizeArguments = (function_) => async (patterns, options) => function_(toPatternsArray(patterns), normalizeOptions2(options));
+var normalizeArgumentsSync = (function_) => (patterns, options) => function_(toPatternsArray(patterns), normalizeOptions2(options));
+var getIgnoreFilesPatterns = (options) => {
+  const { ignoreFiles, gitignore } = options;
+  const patterns = ignoreFiles ? toPatternsArray(ignoreFiles) : [];
+  if (gitignore) {
+    patterns.push(GITIGNORE_FILES_PATTERN);
+  }
+  return patterns;
+};
+var isPathIgnored = (matcher, globalMatcher, path7) => {
+  const globalResult = globalMatcher ? globalMatcher(path7) : void 0;
+  const result = matcher ? matcher(path7) : void 0;
+  if (result?.unignored) {
+    return false;
+  }
+  return Boolean(result?.ignored || globalResult?.ignored);
+};
+var hasIgnoredAncestorDirectory = (matcher, globalMatcher, file) => {
+  let currentPath = file;
+  while (true) {
+    const parentDirectory = import_node_path5.default.dirname(currentPath);
+    if (parentDirectory === currentPath) {
+      return false;
+    }
+    if (isPathIgnored(matcher, globalMatcher, `${parentDirectory}${import_node_path5.default.sep}`)) {
+      return true;
+    }
+    currentPath = parentDirectory;
+  }
+};
+var combinePredicate = (matcher, globalMatcher) => {
+  if (!matcher && !globalMatcher) {
+    return false;
+  }
+  return (file) => {
+    const result = matcher ? matcher(file) : void 0;
+    if (result?.unignored) {
+      const globalResult = globalMatcher ? globalMatcher(file) : void 0;
+      return globalResult?.ignored && hasIgnoredAncestorDirectory(matcher, globalMatcher, file);
+    }
+    return isPathIgnored(matcher, globalMatcher, file);
+  };
+};
+var buildIgnoreFilterResult = (options, cwd, { patterns, matcher, usingGitRoot }, globalMatcher, createFilter) => {
+  const finalPredicate = combinePredicate(matcher, globalMatcher);
+  const patternsForFastGlob = convertPatternsForFastGlob(patterns, usingGitRoot, normalizeDirectoryPatternForFastGlob);
+  return {
+    options: {
+      ...options,
+      ignore: [...options.ignore, ...patternsForFastGlob]
+    },
+    filter: createFilter(finalPredicate, cwd, options.fs)
+  };
+};
+var applyIgnoreFilesAndGetFilter = async (options) => {
+  const cwd = options.cwd ?? import_node_process2.default.cwd();
+  const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
+  const globalIgnoreFile = options.globalGitignore ? await getGlobalGitignoreFileAsync(options) : void 0;
+  if (ignoreFilesPatterns.length === 0 && !globalIgnoreFile) {
+    return {
+      options,
+      filter: createFilterFunctionAsync(false, cwd, options.fs)
+    };
+  }
+  const includeParentIgnoreFiles = options.gitignore === true;
+  const ignoreResult = ignoreFilesPatterns.length > 0 ? await getIgnorePatternsAndPredicate(ignoreFilesPatterns, options, includeParentIgnoreFiles) : { patterns: [], matcher: false, usingGitRoot: false };
+  const globalGitRoot = globalIgnoreFile ? await findGitRoot(cwd, options.fs) : void 0;
+  const globalMatcher = globalIgnoreFile ? buildGlobalMatcher(globalIgnoreFile, cwd, globalGitRoot ?? cwd) : void 0;
+  return buildIgnoreFilterResult(options, cwd, ignoreResult, globalMatcher, createFilterFunctionAsync);
+};
+var applyIgnoreFilesAndGetFilterSync = (options) => {
+  const cwd = options.cwd ?? import_node_process2.default.cwd();
+  const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
+  const globalIgnoreFile = options.globalGitignore ? getGlobalGitignoreFile(options) : void 0;
+  if (ignoreFilesPatterns.length === 0 && !globalIgnoreFile) {
+    return {
+      options,
+      filter: createFilterFunction(false, cwd, options.fs)
+    };
+  }
+  const includeParentIgnoreFiles = options.gitignore === true;
+  const ignoreResult = ignoreFilesPatterns.length > 0 ? getIgnorePatternsAndPredicateSync(ignoreFilesPatterns, options, includeParentIgnoreFiles) : { patterns: [], matcher: false, usingGitRoot: false };
+  const globalGitRoot = globalIgnoreFile ? findGitRootSync(cwd, options.fs) : void 0;
+  const globalMatcher = globalIgnoreFile ? buildGlobalMatcher(globalIgnoreFile, cwd, globalGitRoot ?? cwd) : void 0;
+  return buildIgnoreFilterResult(options, cwd, ignoreResult, globalMatcher, createFilterFunction);
+};
+var assertGlobalGitignoreSyncSupport = (options) => {
+  if (options.globalGitignore && options.fs && !options.fs.statSync) {
+    throw new Error("The `globalGitignore` option in `globbySync()` requires `fs.statSync` when a custom `fs` is provided.");
+  }
+};
+var globalGitignoreAsyncStatErrorMessage = "The `globalGitignore` option in `globby()` and `globbyStream()` requires `fs.promises.stat` or `fs.stat` when a custom `fs` is provided.";
+var assertGlobalGitignoreAsyncSupport = (options) => {
+  if (!options.globalGitignore || !options.fs) {
+    return;
+  }
+  if (!options.fs.promises?.stat && !options.fs.stat) {
+    throw new Error(globalGitignoreAsyncStatErrorMessage);
+  }
+};
+var createPathResolver = (cwd) => {
+  const basePath = cwd || import_node_process2.default.cwd();
+  const pathCache = /* @__PURE__ */ new Map();
+  return (pathKey) => {
+    let absolutePath = pathCache.get(pathKey);
+    if (absolutePath === void 0) {
+      if (pathCache.size > 1e4) {
+        pathCache.clear();
+      }
+      absolutePath = import_node_path5.default.isAbsolute(pathKey) ? pathKey : import_node_path5.default.resolve(basePath, pathKey);
+      pathCache.set(pathKey, absolutePath);
+    }
+    return absolutePath;
+  };
+};
+var createAsyncDirectoryCheck = (fsMethod) => {
+  const directoryCache = /* @__PURE__ */ new Map();
+  return async (absolutePath) => {
+    let isDirectory2 = directoryCache.get(absolutePath);
+    if (isDirectory2 !== void 0) {
+      return isDirectory2;
+    }
+    try {
+      const stats = await fsMethod?.(absolutePath);
+      isDirectory2 = Boolean(stats?.isDirectory());
+    } catch {
+      isDirectory2 = false;
+    }
+    if (directoryCache.size > 1e4) {
+      directoryCache.clear();
+    }
+    directoryCache.set(absolutePath, isDirectory2);
+    return isDirectory2;
+  };
+};
+var createDirectoryCheck = (fsMethod) => {
+  const directoryCache = /* @__PURE__ */ new Map();
+  return (absolutePath) => {
+    let isDirectory2 = directoryCache.get(absolutePath);
+    if (isDirectory2 !== void 0) {
+      return isDirectory2;
+    }
+    try {
+      isDirectory2 = Boolean(fsMethod?.(absolutePath)?.isDirectory());
+    } catch {
+      isDirectory2 = false;
+    }
+    if (directoryCache.size > 1e4) {
+      directoryCache.clear();
+    }
+    directoryCache.set(absolutePath, isDirectory2);
+    return isDirectory2;
+  };
+};
+var createFilterFunctionAsync = (isIgnored, cwd, fsImplementation) => {
+  const resolveAbsolutePath = createPathResolver(cwd);
+  const isDirectoryEntry = createAsyncDirectoryCheck(getStatMethod(fsImplementation));
+  return async (fastGlobResult) => {
+    if (!isIgnored) {
+      return true;
+    }
+    const absolutePath = resolveAbsolutePath(import_node_path5.default.normalize(fastGlobResult.path ?? fastGlobResult));
+    if (isIgnored(absolutePath)) {
+      return false;
+    }
+    return !(await isDirectoryEntry(absolutePath) && isIgnored(`${absolutePath}${import_node_path5.default.sep}`));
+  };
+};
+var createFilterFunction = (isIgnored, cwd, fsImplementation) => {
+  const seen = /* @__PURE__ */ new Set();
+  const resolveAbsolutePath = createPathResolver(cwd);
+  const isDirectoryEntry = createDirectoryCheck(getStatSyncMethod2(fsImplementation));
+  return (fastGlobResult) => {
+    const pathKey = import_node_path5.default.normalize(fastGlobResult.path ?? fastGlobResult);
+    if (seen.has(pathKey)) {
+      return false;
+    }
+    if (isIgnored) {
+      const absolutePath = resolveAbsolutePath(pathKey);
+      if (isIgnored(absolutePath)) {
+        return false;
+      }
+      if (isDirectoryEntry(absolutePath) && isIgnored(`${absolutePath}${import_node_path5.default.sep}`)) {
+        return false;
+      }
+    }
+    seen.add(pathKey);
+    return true;
+  };
+};
+var unionFastGlobResults = (results, filter) => results.flat().filter((fastGlobResult) => filter(fastGlobResult));
+var unionFastGlobResultsAsync = async (results, filter) => {
+  results = results.flat();
+  const matches = await Promise.all(results.map((fastGlobResult) => filter(fastGlobResult)));
+  const seen = /* @__PURE__ */ new Set();
+  return results.filter((fastGlobResult, index) => {
+    if (!matches[index]) {
+      return false;
+    }
+    const pathKey = import_node_path5.default.normalize(fastGlobResult.path ?? fastGlobResult);
+    if (seen.has(pathKey)) {
+      return false;
+    }
+    seen.add(pathKey);
+    return true;
+  });
+};
+var convertNegativePatterns = (patterns, options) => {
+  if (patterns.length > 0 && patterns.every((pattern) => isNegativePattern(pattern))) {
+    if (options.expandNegationOnlyPatterns === false) {
+      return [];
+    }
+    patterns = ["**/*", ...patterns];
+  }
+  const positiveAbsolutePathPrefixes = [];
+  let hasRelativePositivePattern = false;
+  const normalizedPatterns = [];
+  for (const pattern of patterns) {
+    if (isNegativePattern(pattern)) {
+      normalizedPatterns.push(`!${normalizeNegativePattern(pattern.slice(1), positiveAbsolutePathPrefixes, hasRelativePositivePattern)}`);
+      continue;
+    }
+    normalizedPatterns.push(pattern);
+    const staticAbsolutePathPrefix = getStaticAbsolutePathPrefix(pattern);
+    if (staticAbsolutePathPrefix === void 0) {
+      hasRelativePositivePattern = true;
+      continue;
+    }
+    positiveAbsolutePathPrefixes.push(staticAbsolutePathPrefix);
+  }
+  patterns = normalizedPatterns;
+  const tasks = [];
+  while (patterns.length > 0) {
+    const index = patterns.findIndex((pattern) => isNegativePattern(pattern));
+    if (index === -1) {
+      tasks.push({ patterns, options });
+      break;
+    }
+    const ignorePattern = patterns[index].slice(1);
+    for (const task of tasks) {
+      task.options.ignore.push(ignorePattern);
+    }
+    if (index !== 0) {
+      tasks.push({
+        patterns: patterns.slice(0, index),
+        options: {
+          ...options,
+          ignore: [
+            ...options.ignore,
+            ignorePattern
+          ]
+        }
+      });
+    }
+    patterns = patterns.slice(index + 1);
+  }
+  return tasks;
+};
+var applyParentDirectoryIgnoreAdjustments = (tasks) => tasks.map((task) => ({
+  patterns: task.patterns,
+  options: {
+    ...task.options,
+    ignore: adjustIgnorePatternsForParentDirectories(task.patterns, task.options.ignore)
+  }
+}));
+var normalizeExpandDirectoriesOption = (options, cwd) => ({
+  ...cwd ? { cwd } : {},
+  ...Array.isArray(options) ? { files: options } : options
+});
+var generateTasks = async (patterns, options) => {
+  const globTasks = convertNegativePatterns(patterns, options);
+  const { cwd, expandDirectories, fs: fsImplementation } = options;
+  if (!expandDirectories) {
+    return applyParentDirectoryIgnoreAdjustments(globTasks);
+  }
+  const directoryToGlobOptions = {
+    ...normalizeExpandDirectoriesOption(expandDirectories, cwd),
+    fs: fsImplementation
+  };
+  return Promise.all(globTasks.map(async (task) => {
+    let { patterns: patterns2, options: options2 } = task;
+    [
+      patterns2,
+      options2.ignore
+    ] = await Promise.all([
+      directoryToGlob(patterns2, directoryToGlobOptions),
+      directoryToGlob(options2.ignore, { cwd, fs: fsImplementation })
+    ]);
+    options2.ignore = adjustIgnorePatternsForParentDirectories(patterns2, options2.ignore);
+    return { patterns: patterns2, options: options2 };
+  }));
+};
+var generateTasksSync = (patterns, options) => {
+  const globTasks = convertNegativePatterns(patterns, options);
+  const { cwd, expandDirectories, fs: fsImplementation } = options;
+  if (!expandDirectories) {
+    return applyParentDirectoryIgnoreAdjustments(globTasks);
+  }
+  const directoryToGlobSyncOptions = {
+    ...normalizeExpandDirectoriesOption(expandDirectories, cwd),
+    fs: fsImplementation
+  };
+  return globTasks.map((task) => {
+    let { patterns: patterns2, options: options2 } = task;
+    patterns2 = directoryToGlobSync(patterns2, directoryToGlobSyncOptions);
+    options2.ignore = directoryToGlobSync(options2.ignore, { cwd, fs: fsImplementation });
+    options2.ignore = adjustIgnorePatternsForParentDirectories(patterns2, options2.ignore);
+    return { patterns: patterns2, options: options2 };
+  });
+};
+var globby = normalizeArguments(async (patterns, options) => {
+  assertGlobalGitignoreAsyncSupport(options);
+  const { options: modifiedOptions, filter } = await applyIgnoreFilesAndGetFilter(options);
+  const tasks = await generateTasks(patterns, modifiedOptions);
+  const results = await Promise.all(tasks.map((task) => (0, import_fast_glob3.default)(task.patterns, task.options)));
+  return unionFastGlobResultsAsync(results, filter);
+});
+var globbySync = normalizeArgumentsSync((patterns, options) => {
+  assertGlobalGitignoreSyncSupport(options);
+  const { options: modifiedOptions, filter } = applyIgnoreFilesAndGetFilterSync(options);
+  const tasks = generateTasksSync(patterns, modifiedOptions);
+  const results = tasks.map((task) => import_fast_glob3.default.sync(task.patterns, task.options));
+  return unionFastGlobResults(results, filter);
+});
+var globbyStream = normalizeArgumentsSync((patterns, options) => {
+  assertGlobalGitignoreAsyncSupport(options);
+  const seen = /* @__PURE__ */ new Set();
+  const stream = import_node_stream2.Readable.from((async function* () {
+    const { options: modifiedOptions, filter } = await applyIgnoreFilesAndGetFilter(options);
+    const tasks = await generateTasks(patterns, modifiedOptions);
+    if (tasks.length === 0) {
+      return;
+    }
+    const streams = tasks.map((task) => import_fast_glob3.default.stream(task.patterns, task.options));
+    for await (const fastGlobResult of mergeStreams(streams)) {
+      const pathKey = import_node_path5.default.normalize(fastGlobResult.path ?? fastGlobResult);
+      if (!seen.has(pathKey) && await filter(fastGlobResult)) {
+        seen.add(pathKey);
+        yield fastGlobResult;
+      }
+    }
+  })());
+  return stream;
+});
+var isDynamicPattern = normalizeArgumentsSync((patterns, options) => patterns.some((pattern) => import_fast_glob3.default.isDynamicPattern(pattern, options)));
+var generateGlobTasks = normalizeArguments(generateTasks);
+var generateGlobTasksSync = normalizeArgumentsSync(generateTasksSync);
+var { convertPathToPattern } = import_fast_glob3.default;
+
+// src/cli/index.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+
+// src/cli/io-to-ts.ts
+var structs = /* @__PURE__ */ new Map();
+function solidityPrimitiveToTs(type) {
+  if (["string", "address"].includes(type) || type.startsWith("byte")) return "string";
+  if (type.startsWith("uint")) return "number";
+  if (type === "bool") return "boolean";
+  throw new Error(`[abiTypeToTsType] Not handle type: ${type}`);
+}
+function normalizeStructName(internalType) {
+  if (!internalType) {
+    return "UnknownStruct";
+  }
+  const rawName = internalType.split(" ")[1] ?? "UnknownStruct";
+  return `BC${rawName.replace("[]", "").replaceAll(".", "")}`;
+}
+function buildTsObjectType(ios, ioType) {
+  if (!ios?.length) {
+    return ioType === "in" ? "null" : "void";
+  }
+  if (ios.length === 1 && ios[0].name === "" && ioType === "out") {
+    return abiTypeToTsType(ios[0], ioType);
+  }
+  const fields = ios.map((item) => `${item.name || '""'}: ${abiTypeToTsType(item, ioType)}`).join("; ");
+  return `{ ${fields} }`;
+}
+function getOrCreateStructType(item, ioType) {
+  const structName = normalizeStructName(item.internalType);
+  if (!structs.has(structName)) {
+    const body = buildTsObjectType(item.components ?? [], ioType);
+    structs.set(structName, `type ${structName} = ${body}`);
+  }
+  return structName;
+}
+function abiTypeToTsType(item, ioType) {
+  const isArray = item.type.endsWith("[]");
+  if (item.type.includes("tuple")) {
+    const structName = getOrCreateStructType(item, ioType);
+    return isArray ? `${structName}[]` : structName;
+  }
+  const baseType = isArray ? item.type.slice(0, -2) : item.type;
+  const tsType = solidityPrimitiveToTs(baseType);
+  return isArray ? `${tsType}[]` : tsType;
+}
+function abiToTs(ios, ioType) {
+  return buildTsObjectType(ios, ioType);
+}
+function getStructString() {
+  return [...structs.values()].join("\n");
+}
+
+// src/cli/utils.ts
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_prettier = __toESM(require("prettier"), 1);
+var import_readline = __toESM(require("readline"), 1);
+function ask(label) {
+  const rl = import_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(label, (answer) => {
+      rl.close();
+      const rs = answer.trim();
+      resolve(rs);
+    });
+  });
+}
+function capitalize(input) {
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}
+function createMethodsName(name) {
+  return `${capitalize(name)}Mehods`;
+}
+function createEventsName(name) {
+  return `${capitalize(name)}Events`;
+}
+function normalizePath(input) {
+  return import_node_path6.default.basename(input, ".abi.json").split(/[-.]/g).join("");
+}
+async function writePrettyFile(fileName, content, outDir) {
+  import_node_fs4.default.mkdirSync(outDir, {
+    recursive: true
+  });
+  const outFile = import_node_path6.default.join(outDir, fileName);
+  const config = await import_prettier.default.resolveConfig(outFile);
+  const formatted = await import_prettier.default.format(content, {
+    ...config,
+    filepath: outFile
+  });
+  import_node_fs4.default.writeFileSync(outFile, formatted, "utf-8");
+}
+var contractsTemplate = ` type HandlerDefinition<Input = unknown, Output = unknown> = [Input, Output];
+
+ type RegistrySchema = Record<string, Record<string, HandlerDefinition<unknown, unknown>>>;
+
+ type RegistryHandlers<TSchema extends RegistrySchema, TOptions = unknown> = {
+  [TGroup in keyof TSchema]: {
+    [TKey in keyof TSchema[TGroup]]: (
+      input: TSchema[TGroup][TKey][0],
+      options?: TOptions,
+    ) => Promise<TSchema[TGroup][TKey][1]>;
+  };
+};
+type ContractOptions = {
+    from?: string
+    to?: string
+    gas?: string | number
+  }
+`;
+
+// src/cli/index.ts
+function createGlobalDeclaration(content) {
+  const finalContent = Array.isArray(content) ? content.join("\n") : content;
+  return ` export {}
+               declare global {
+               ${finalContent}
+               }`;
+}
+function defineMethods(abiName, items) {
+  const content = items.map((item) => {
+    const inputs = abiToTs(item.inputs, "in");
+    const outputs = abiToTs(item.outputs, "out");
+    return `
+${item.name}: [${inputs},${outputs}]`;
+  }).join("");
+  return createGlobalDeclaration(`type ${createMethodsName(abiName)} = {${content}}`);
+}
+function defineEvents(abiName, items) {
+  const content = items.map((item) => {
+    return `
+${item.name}: ${abiToTs(item.inputs, "out")}`;
+  }).join("");
+  return createGlobalDeclaration(`type ${createEventsName(abiName)} = {${content}}`);
+}
+function defineAllContracts(abis) {
+  const content = abis.map(([name]) => {
+    return `
+${name}: ${createMethodsName(name)}`;
+  });
+  const allMehodsString = `type ContractMethods = RegistryHandlers<{${content}}, ContractOptions>`;
+  return createGlobalDeclaration(contractsTemplate + allMehodsString);
+}
+async function generateBlockchainTypes() {
+  const rootPath = process.cwd();
+  const _input = await ask("type relative path: ");
+  const input = _input ? _input + "/" : "";
+  const outDir = import_node_path7.default.resolve(rootPath, `src/${input}@bc-types`);
+  const filePaths = await globby(`src/${input}abis/*.abi.json`, {
+    cwd: rootPath,
+    absolute: true
+  });
+  const abis = filePaths.map((filePath) => [
+    normalizePath(filePath),
+    JSON.parse(import_node_fs5.default.readFileSync(filePath, "utf-8"))
+  ]);
+  abis.forEach(async ([name, abiArray]) => {
+    const dir = import_node_path7.default.resolve(outDir, name);
+    const methods = abiArray.filter((i) => i.type === "function");
+    const events = abiArray.filter((i) => i.type === "event");
+    writePrettyFile(`${name}.methods.d.ts`, defineMethods(name, methods), dir);
+    writePrettyFile(`${name}.events.d.ts`, defineEvents(name, events), dir);
+  });
+  const structsString = createGlobalDeclaration(getStructString());
+  writePrettyFile(`structs.d.ts`, structsString, outDir);
+  writePrettyFile(`contracts.d.ts`, defineAllContracts(abis), outDir);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateBlockchainTypes
+});