@shopify/create-app 3.58.2 → 3.59.0

package/dist/chunk-P4TVG45N.js

@@ -0,0 +1,900 @@
+import {
+  require_merge2,
+  require_out
+} from "./chunk-ZPB26OWQ.js";
+import {
+  __commonJS,
+  __require,
+  init_cjs_shims
+} from "./chunk-M63RTPGR.js";
+
+// ../../node_modules/.pnpm/slash@3.0.0/node_modules/slash/index.js
+var require_slash = __commonJS({
+  "../../node_modules/.pnpm/slash@3.0.0/node_modules/slash/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    module.exports = (path) => {
+      const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+      const hasNonAscii = /[^\u0000-\u0080]+/.test(path);
+      if (isExtendedLengthPath || hasNonAscii) {
+        return path;
+      }
+      return path.replace(/\\/g, "/");
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/array-union@2.1.0/node_modules/array-union/index.js
+var require_array_union = __commonJS({
+  "../../node_modules/.pnpm/array-union@2.1.0/node_modules/array-union/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    module.exports = (...arguments_) => {
+      return [...new Set([].concat(...arguments_))];
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/path-type@4.0.0/node_modules/path-type/index.js
+var require_path_type = __commonJS({
+  "../../node_modules/.pnpm/path-type@4.0.0/node_modules/path-type/index.js"(exports) {
+    "use strict";
+    init_cjs_shims();
+    var { promisify } = __require("util");
+    var fs = __require("fs");
+    async function isType(fsStatType, statsMethodName, filePath) {
+      if (typeof filePath !== "string") {
+        throw new TypeError(`Expected a string, got ${typeof filePath}`);
+      }
+      try {
+        const stats = await promisify(fs[fsStatType])(filePath);
+        return stats[statsMethodName]();
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return false;
+        }
+        throw error;
+      }
+    }
+    function isTypeSync(fsStatType, statsMethodName, filePath) {
+      if (typeof filePath !== "string") {
+        throw new TypeError(`Expected a string, got ${typeof filePath}`);
+      }
+      try {
+        return fs[fsStatType](filePath)[statsMethodName]();
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return false;
+        }
+        throw error;
+      }
+    }
+    exports.isFile = isType.bind(null, "stat", "isFile");
+    exports.isDirectory = isType.bind(null, "stat", "isDirectory");
+    exports.isSymlink = isType.bind(null, "lstat", "isSymbolicLink");
+    exports.isFileSync = isTypeSync.bind(null, "statSync", "isFile");
+    exports.isDirectorySync = isTypeSync.bind(null, "statSync", "isDirectory");
+    exports.isSymlinkSync = isTypeSync.bind(null, "lstatSync", "isSymbolicLink");
+  }
+});
+
+// ../../node_modules/.pnpm/dir-glob@3.0.1/node_modules/dir-glob/index.js
+var require_dir_glob = __commonJS({
+  "../../node_modules/.pnpm/dir-glob@3.0.1/node_modules/dir-glob/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    var path = __require("path");
+    var pathType = require_path_type();
+    var getExtensions = (extensions) => extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0];
+    var getPath = (filepath, cwd) => {
+      const pth = filepath[0] === "!" ? filepath.slice(1) : filepath;
+      return path.isAbsolute(pth) ? pth : path.join(cwd, pth);
+    };
+    var addExtensions = (file, extensions) => {
+      if (path.extname(file)) {
+        return `**/${file}`;
+      }
+      return `**/${file}.${getExtensions(extensions)}`;
+    };
+    var getGlob = (directory, options) => {
+      if (options.files && !Array.isArray(options.files)) {
+        throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``);
+      }
+      if (options.extensions && !Array.isArray(options.extensions)) {
+        throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
+      }
+      if (options.files && options.extensions) {
+        return options.files.map((x) => path.posix.join(directory, addExtensions(x, options.extensions)));
+      }
+      if (options.files) {
+        return options.files.map((x) => path.posix.join(directory, `**/${x}`));
+      }
+      if (options.extensions) {
+        return [path.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
+      }
+      return [path.posix.join(directory, "**")];
+    };
+    module.exports = async (input, options) => {
+      options = {
+        cwd: process.cwd(),
+        ...options
+      };
+      if (typeof options.cwd !== "string") {
+        throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+      }
+      const globs = await Promise.all([].concat(input).map(async (x) => {
+        const isDirectory = await pathType.isDirectory(getPath(x, options.cwd));
+        return isDirectory ? getGlob(x, options) : x;
+      }));
+      return [].concat.apply([], globs);
+    };
+    module.exports.sync = (input, options) => {
+      options = {
+        cwd: process.cwd(),
+        ...options
+      };
+      if (typeof options.cwd !== "string") {
+        throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+      }
+      const globs = [].concat(input).map((x) => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x);
+      return [].concat.apply([], globs);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/ignore@5.2.4/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "../../node_modules/.pnpm/ignore@5.2.4/node_modules/ignore/index.js"(exports, module) {
+    init_cjs_shims();
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    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 = /^\.*\/|^\.+$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => Object.defineProperty(object, key, { 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 = [
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a \ ) -> (a  )
+        /\\?\s+$/,
+        (match) => match.indexOf("\\") === 0 ? SPACE : EMPTY
+      ],
+      // replace (\ ) with ' '
+      [
+        /\\\s/g,
+        () => 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}(?=$|\\/$)`
+      ],
+      // trailing wildcard
+      [
+        /(\^|\\\/)?\\\*$/,
+        (_, p1) => {
+          const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+          return `${prefix}(?=$|\\/$)`;
+        }
+      ]
+    ];
+    var regexCache = /* @__PURE__ */ Object.create(null);
+    var makeRegex = (pattern, ignoreCase) => {
+      let source = regexCache[pattern];
+      if (!source) {
+        source = REPLACERS.reduce(
+          (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+          pattern
+        );
+        regexCache[pattern] = source;
+      }
+      return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+    };
+    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);
+    var IgnoreRule = class {
+      constructor(origin, pattern, negative, regex) {
+        this.origin = origin;
+        this.pattern = pattern;
+        this.negative = negative;
+        this.regex = regex;
+      }
+    };
+    var createRule = (pattern, ignoreCase) => {
+      const origin = pattern;
+      let negative = false;
+      if (pattern.indexOf("!") === 0) {
+        negative = true;
+        pattern = pattern.substr(1);
+      }
+      pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regex = makeRegex(pattern, ignoreCase);
+      return new IgnoreRule(
+        origin,
+        pattern,
+        negative,
+        regex
+      );
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path, originalPath, doThrow) => {
+      if (!isString(path)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = [];
+        this._ignoreCase = ignoreCase;
+        this._allowRelativePaths = allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      _addPattern(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules);
+          this._added = true;
+          return;
+        }
+        if (checkPattern(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._addPattern, this);
+        if (this._added) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      //          |           ignored : unignored
+      // negative |   0:0   |   0:1   |   1:0   |   1:1
+      // -------- | ------- | ------- | ------- | --------
+      //     0    |  TEST   |  TEST   |  SKIP   |    X
+      //     1    |  TESTIF |  SKIP   |  TEST   |    X
+      // - SKIP: always skip
+      // - TEST: always test
+      // - TESTIF: only test if checkUnignored
+      // - X: that never happen
+      // @param {boolean} whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // @returns {TestResult} true if a file is ignored
+      _testOne(path, checkUnignored) {
+        let ignored = false;
+        let unignored = false;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule.regex.test(path);
+          if (matched) {
+            ignored = !negative;
+            unignored = negative;
+          }
+        });
+        return {
+          ignored,
+          unignored
+        };
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path,
+          originalPath,
+          this._allowRelativePaths ? RETURN_FALSE : throwError
+        );
+        return this._t(path, cache, checkUnignored, slices);
+      }
+      _t(path, cache, checkUnignored, slices) {
+        if (path in cache) {
+          return cache[path];
+        }
+        if (!slices) {
+          slices = path.split(SLASH);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path] = this._testOne(path, checkUnignored);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path] = parent.ignored ? parent : this._testOne(path, checkUnignored);
+      }
+      ignores(path) {
+        return this._test(path, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path) => !this.ignores(path);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path) {
+        return this._test(path, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+    factory.isPathValid = isPathValid;
+    factory.default = factory;
+    module.exports = factory;
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
+    ) {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/gitignore.js
+var require_gitignore = __commonJS({
+  "../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/gitignore.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    var { promisify } = __require("util");
+    var fs = __require("fs");
+    var path = __require("path");
+    var fastGlob = require_out();
+    var gitIgnore = require_ignore();
+    var slash = require_slash();
+    var DEFAULT_IGNORE = [
+      "**/node_modules/**",
+      "**/flow-typed/**",
+      "**/coverage/**",
+      "**/.git"
+    ];
+    var readFileP = promisify(fs.readFile);
+    var mapGitIgnorePatternTo = (base) => (ignore) => {
+      if (ignore.startsWith("!")) {
+        return "!" + path.posix.join(base, ignore.slice(1));
+      }
+      return path.posix.join(base, ignore);
+    };
+    var parseGitIgnore = (content, options) => {
+      const base = slash(path.relative(options.cwd, path.dirname(options.fileName)));
+      return content.split(/\r?\n/).filter(Boolean).filter((line) => !line.startsWith("#")).map(mapGitIgnorePatternTo(base));
+    };
+    var reduceIgnore = (files) => {
+      const ignores = gitIgnore();
+      for (const file of files) {
+        ignores.add(parseGitIgnore(file.content, {
+          cwd: file.cwd,
+          fileName: file.filePath
+        }));
+      }
+      return ignores;
+    };
+    var ensureAbsolutePathForCwd = (cwd, p) => {
+      cwd = slash(cwd);
+      if (path.isAbsolute(p)) {
+        if (slash(p).startsWith(cwd)) {
+          return p;
+        }
+        throw new Error(`Path ${p} is not in cwd ${cwd}`);
+      }
+      return path.join(cwd, p);
+    };
+    var getIsIgnoredPredecate = (ignores, cwd) => {
+      return (p) => ignores.ignores(slash(path.relative(cwd, ensureAbsolutePathForCwd(cwd, p.path || p))));
+    };
+    var getFile = async (file, cwd) => {
+      const filePath = path.join(cwd, file);
+      const content = await readFileP(filePath, "utf8");
+      return {
+        cwd,
+        filePath,
+        content
+      };
+    };
+    var getFileSync = (file, cwd) => {
+      const filePath = path.join(cwd, file);
+      const content = fs.readFileSync(filePath, "utf8");
+      return {
+        cwd,
+        filePath,
+        content
+      };
+    };
+    var normalizeOptions = ({
+      ignore = [],
+      cwd = slash(process.cwd())
+    } = {}) => {
+      return { ignore, cwd };
+    };
+    module.exports = async (options) => {
+      options = normalizeOptions(options);
+      const paths = await fastGlob("**/.gitignore", {
+        ignore: DEFAULT_IGNORE.concat(options.ignore),
+        cwd: options.cwd
+      });
+      const files = await Promise.all(paths.map((file) => getFile(file, options.cwd)));
+      const ignores = reduceIgnore(files);
+      return getIsIgnoredPredecate(ignores, options.cwd);
+    };
+    module.exports.sync = (options) => {
+      options = normalizeOptions(options);
+      const paths = fastGlob.sync("**/.gitignore", {
+        ignore: DEFAULT_IGNORE.concat(options.ignore),
+        cwd: options.cwd
+      });
+      const files = paths.map((file) => getFileSync(file, options.cwd));
+      const ignores = reduceIgnore(files);
+      return getIsIgnoredPredecate(ignores, options.cwd);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/stream-utils.js
+var require_stream_utils = __commonJS({
+  "../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/stream-utils.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    var { Transform } = __require("stream");
+    var ObjectTransform = class extends Transform {
+      constructor() {
+        super({
+          objectMode: true
+        });
+      }
+    };
+    var FilterStream = class extends ObjectTransform {
+      constructor(filter) {
+        super();
+        this._filter = filter;
+      }
+      _transform(data, encoding, callback) {
+        if (this._filter(data)) {
+          this.push(data);
+        }
+        callback();
+      }
+    };
+    var UniqueStream = class extends ObjectTransform {
+      constructor() {
+        super();
+        this._pushed = /* @__PURE__ */ new Set();
+      }
+      _transform(data, encoding, callback) {
+        if (!this._pushed.has(data)) {
+          this.push(data);
+          this._pushed.add(data);
+        }
+        callback();
+      }
+    };
+    module.exports = {
+      FilterStream,
+      UniqueStream
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/index.js
+var require_globby = __commonJS({
+  "../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    var fs = __require("fs");
+    var arrayUnion = require_array_union();
+    var merge2 = require_merge2();
+    var fastGlob = require_out();
+    var dirGlob = require_dir_glob();
+    var gitignore = require_gitignore();
+    var { FilterStream, UniqueStream } = require_stream_utils();
+    var DEFAULT_FILTER = () => false;
+    var isNegative = (pattern) => pattern[0] === "!";
+    var assertPatternsInput = (patterns) => {
+      if (!patterns.every((pattern) => typeof pattern === "string")) {
+        throw new TypeError("Patterns must be a string or an array of strings");
+      }
+    };
+    var checkCwdOption = (options = {}) => {
+      if (!options.cwd) {
+        return;
+      }
+      let stat;
+      try {
+        stat = fs.statSync(options.cwd);
+      } catch {
+        return;
+      }
+      if (!stat.isDirectory()) {
+        throw new Error("The `cwd` option must be a path to a directory");
+      }
+    };
+    var getPathString = (p) => p.stats instanceof fs.Stats ? p.path : p;
+    var generateGlobTasks = (patterns, taskOptions) => {
+      patterns = arrayUnion([].concat(patterns));
+      assertPatternsInput(patterns);
+      checkCwdOption(taskOptions);
+      const globTasks = [];
+      taskOptions = {
+        ignore: [],
+        expandDirectories: true,
+        ...taskOptions
+      };
+      for (const [index, pattern] of patterns.entries()) {
+        if (isNegative(pattern)) {
+          continue;
+        }
+        const ignore = patterns.slice(index).filter((pattern2) => isNegative(pattern2)).map((pattern2) => pattern2.slice(1));
+        const options = {
+          ...taskOptions,
+          ignore: taskOptions.ignore.concat(ignore)
+        };
+        globTasks.push({ pattern, options });
+      }
+      return globTasks;
+    };
+    var globDirs = (task, fn) => {
+      let options = {};
+      if (task.options.cwd) {
+        options.cwd = task.options.cwd;
+      }
+      if (Array.isArray(task.options.expandDirectories)) {
+        options = {
+          ...options,
+          files: task.options.expandDirectories
+        };
+      } else if (typeof task.options.expandDirectories === "object") {
+        options = {
+          ...options,
+          ...task.options.expandDirectories
+        };
+      }
+      return fn(task.pattern, options);
+    };
+    var getPattern = (task, fn) => task.options.expandDirectories ? globDirs(task, fn) : [task.pattern];
+    var getFilterSync = (options) => {
+      return options && options.gitignore ? gitignore.sync({ cwd: options.cwd, ignore: options.ignore }) : DEFAULT_FILTER;
+    };
+    var globToTask = (task) => (glob) => {
+      const { options } = task;
+      if (options.ignore && Array.isArray(options.ignore) && options.expandDirectories) {
+        options.ignore = dirGlob.sync(options.ignore);
+      }
+      return {
+        pattern: glob,
+        options
+      };
+    };
+    module.exports = async (patterns, options) => {
+      const globTasks = generateGlobTasks(patterns, options);
+      const getFilter = async () => {
+        return options && options.gitignore ? gitignore({ cwd: options.cwd, ignore: options.ignore }) : DEFAULT_FILTER;
+      };
+      const getTasks = async () => {
+        const tasks2 = await Promise.all(globTasks.map(async (task) => {
+          const globs = await getPattern(task, dirGlob);
+          return Promise.all(globs.map(globToTask(task)));
+        }));
+        return arrayUnion(...tasks2);
+      };
+      const [filter, tasks] = await Promise.all([getFilter(), getTasks()]);
+      const paths = await Promise.all(tasks.map((task) => fastGlob(task.pattern, task.options)));
+      return arrayUnion(...paths).filter((path_) => !filter(getPathString(path_)));
+    };
+    module.exports.sync = (patterns, options) => {
+      const globTasks = generateGlobTasks(patterns, options);
+      const tasks = [];
+      for (const task of globTasks) {
+        const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
+        tasks.push(...newTask);
+      }
+      const filter = getFilterSync(options);
+      let matches = [];
+      for (const task of tasks) {
+        matches = arrayUnion(matches, fastGlob.sync(task.pattern, task.options));
+      }
+      return matches.filter((path_) => !filter(path_));
+    };
+    module.exports.stream = (patterns, options) => {
+      const globTasks = generateGlobTasks(patterns, options);
+      const tasks = [];
+      for (const task of globTasks) {
+        const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
+        tasks.push(...newTask);
+      }
+      const filter = getFilterSync(options);
+      const filterStream = new FilterStream((p) => !filter(p));
+      const uniqueStream = new UniqueStream();
+      return merge2(tasks.map((task) => fastGlob.stream(task.pattern, task.options))).pipe(filterStream).pipe(uniqueStream);
+    };
+    module.exports.generateGlobTasks = generateGlobTasks;
+    module.exports.hasMagic = (patterns, options) => [].concat(patterns).some((pattern) => fastGlob.isDynamicPattern(pattern, options));
+    module.exports.gitignore = gitignore;
+  }
+});
+
+// ../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js
+var require_indent_string = __commonJS({
+  "../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    module.exports = (string, count = 1, options) => {
+      options = {
+        indent: " ",
+        includeEmptyLines: false,
+        ...options
+      };
+      if (typeof string !== "string") {
+        throw new TypeError(
+          `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
+        );
+      }
+      if (typeof count !== "number") {
+        throw new TypeError(
+          `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
+        );
+      }
+      if (typeof options.indent !== "string") {
+        throw new TypeError(
+          `Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
+        );
+      }
+      if (count === 0) {
+        return string;
+      }
+      const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+      return string.replace(regex, options.indent.repeat(count));
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+  "../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    module.exports = balanced;
+    function balanced(a, b, str) {
+      if (a instanceof RegExp)
+        a = maybeMatch(a, str);
+      if (b instanceof RegExp)
+        b = maybeMatch(b, str);
+      var r = range(a, b, str);
+      return r && {
+        start: r[0],
+        end: r[1],
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + a.length, r[1]),
+        post: str.slice(r[1] + b.length)
+      };
+    }
+    function maybeMatch(reg, str) {
+      var m = str.match(reg);
+      return m ? m[0] : null;
+    }
+    balanced.range = range;
+    function range(a, b, str) {
+      var begs, beg, left, right, result;
+      var ai = str.indexOf(a);
+      var bi = str.indexOf(b, ai + 1);
+      var i = ai;
+      if (ai >= 0 && bi > 0) {
+        if (a === b) {
+          return [ai, bi];
+        }
+        begs = [];
+        left = str.length;
+        while (i >= 0 && !result) {
+          if (i == ai) {
+            begs.push(i);
+            ai = str.indexOf(a, i + 1);
+          } else if (begs.length == 1) {
+            result = [begs.pop(), bi];
+          } else {
+            beg = begs.pop();
+            if (beg < left) {
+              left = beg;
+              right = bi;
+            }
+            bi = str.indexOf(b, i + 1);
+          }
+          i = ai < bi && ai >= 0 ? ai : bi;
+        }
+        if (begs.length) {
+          result = [left, right];
+        }
+      }
+      return result;
+    }
+  }
+});
+
+export {
+  require_indent_string,
+  require_balanced_match,
+  require_slash,
+  require_globby
+};