lingo.dev 0.99.3 → 0.99.5

package/build/cli.cjs

@@ -17,14 +17,14 @@ var _ini = require('ini'); var _ini2 = _interopRequireDefault(_ini);
 function getSettings(explicitApiKey) {
   const env = _loadEnv();
   const systemFile = _loadSystemFile();
-  const defaults = _loadDefaults();
+  const defaults2 = _loadDefaults();
   _legacyEnvVarWarning();
   _envVarsInfo();
   return {
     auth: {
-      apiKey: explicitApiKey || env.LINGODOTDEV_API_KEY || _optionalChain([systemFile, 'access', _34 => _34.auth, 'optionalAccess', _35 => _35.apiKey]) || defaults.auth.apiKey,
-      apiUrl: env.LINGODOTDEV_API_URL || _optionalChain([systemFile, 'access', _36 => _36.auth, 'optionalAccess', _37 => _37.apiUrl]) || defaults.auth.apiUrl,
-      webUrl: env.LINGODOTDEV_WEB_URL || _optionalChain([systemFile, 'access', _38 => _38.auth, 'optionalAccess', _39 => _39.webUrl]) || defaults.auth.webUrl
+      apiKey: explicitApiKey || env.LINGODOTDEV_API_KEY || _optionalChain([systemFile, 'access', _34 => _34.auth, 'optionalAccess', _35 => _35.apiKey]) || defaults2.auth.apiKey,
+      apiUrl: env.LINGODOTDEV_API_URL || _optionalChain([systemFile, 'access', _36 => _36.auth, 'optionalAccess', _37 => _37.apiUrl]) || defaults2.auth.apiUrl,
+      webUrl: env.LINGODOTDEV_WEB_URL || _optionalChain([systemFile, 'access', _38 => _38.auth, 'optionalAccess', _39 => _39.webUrl]) || defaults2.auth.webUrl
     },
     llm: {
       openaiApiKey: env.OPENAI_API_KEY || _optionalChain([systemFile, 'access', _40 => _40.llm, 'optionalAccess', _41 => _41.openaiApiKey]),
@@ -189,20 +189,20 @@ function _envVarsInfo() {
 
 // src/cli/utils/errors.ts
 var docLinks = {
-  i18nNotFound: "https://docs.lingo.dev/quickstart#initialization",
-  bucketNotFound: "https://docs.lingo.dev/config#buckets",
-  authError: "https://docs.lingo.dev/auth",
-  localeTargetNotFound: "https://docs.lingo.dev/config#locale",
-  lockFiletNotFound: "https://docs.lingo.dev/config#i18n-lock",
-  failedReplexicaEngine: "https://docs.lingo.dev/",
-  placeHolderFailed: "https://docs.lingo.dev/formats/json",
-  translationFailed: "https://docs.lingo.dev/setup/cli#core-command-i18n",
-  connectionFailed: "https://docs.lingo.dev/",
-  invalidType: "https://docs.lingo.dev/setup/cli#configuration-commands",
-  invalidPathPattern: "https://docs.lingo.dev/config#buckets",
-  androidResouceError: "https://docs.lingo.dev/formats/android",
-  invalidBucketType: "https://docs.lingo.dev/config#buckets",
-  invalidStringDict: "https://docs.lingo.dev/formats/xcode-stringsdict"
+  i18nNotFound: "https://lingo.dev/cli",
+  bucketNotFound: "https://lingo.dev/cli",
+  authError: "https://lingo.dev/cli",
+  localeTargetNotFound: "https://lingo.dev/cli",
+  lockFiletNotFound: "https://lingo.dev/cli",
+  failedReplexicaEngine: "https://lingo.dev/cli",
+  placeHolderFailed: "https://lingo.dev/cli",
+  translationFailed: "https://lingo.dev/cli",
+  connectionFailed: "https://lingo.dev/cli",
+  invalidType: "https://lingo.dev/cli",
+  invalidPathPattern: "https://lingo.dev/cli",
+  androidResouceError: "https://lingo.dev/cli",
+  invalidBucketType: "https://lingo.dev/cli",
+  invalidStringDict: "https://lingo.dev/cli"
 };
 var CLIError = class extends Error {
   
@@ -549,7 +549,7 @@ var _prompts = require('@inquirer/prompts');
 
 // src/cli/utils/find-locale-paths.ts
 
-var _glob = require('glob');
+var _glob2 = require('glob');
 
 
 function findLocaleFiles(bucket) {
@@ -578,20 +578,20 @@ function findLocaleFiles(bucket) {
       return null;
   }
 }
-function findLocaleFilesWithExtension(ext) {
-  const files = _glob.glob.sync(`**/*${ext}`, {
+function findLocaleFilesWithExtension(ext2) {
+  const files = _glob2.glob.sync(`**/*${ext2}`, {
     ignore: ["node_modules/**", "package*.json", "i18n.json", "lingo.json"]
   });
-  const localeFilePattern = new RegExp(`/([a-z]{2}(-[A-Z]{2})?)${ext}$`);
-  const localeDirectoryPattern = new RegExp(`/([a-z]{2}(-[A-Z]{2})?)/[^/]+${ext}$`);
+  const localeFilePattern = new RegExp(`/([a-z]{2}(-[A-Z]{2})?)${ext2}$`);
+  const localeDirectoryPattern = new RegExp(`/([a-z]{2}(-[A-Z]{2})?)/[^/]+${ext2}$`);
   const potentialLocaleFiles = files.filter(
     (file) => localeFilePattern.test(file) || localeDirectoryPattern.test(file)
   );
   const potantialLocaleFilesAndPatterns = potentialLocaleFiles.map((file) => {
     const matchPotentialLocales = Array.from(
-      file.matchAll(new RegExp(`/([a-z]{2}(-[A-Z]{2})?|[^/]+)(?=/|${ext})`, "g"))
+      file.matchAll(new RegExp(`/([a-z]{2}(-[A-Z]{2})?|[^/]+)(?=/|${ext2})`, "g"))
     );
-    const potantialLocales = matchPotentialLocales.map((match) => match[1]);
+    const potantialLocales = matchPotentialLocales.map((match2) => match2[1]);
     return { file, potantialLocales };
   }).map(({ file, potantialLocales }) => {
     for (const locale of potantialLocales) {
@@ -604,12 +604,12 @@ function findLocaleFilesWithExtension(ext) {
     return { file, locale: null };
   }).filter(({ locale }) => locale !== null);
   const localeFilesAndPatterns = potantialLocaleFilesAndPatterns.map(({ file, locale }) => {
-    const pattern = file.replaceAll(new RegExp(`/${locale}${ext}`, "g"), `/[locale]${ext}`).replaceAll(new RegExp(`/${locale}/`, "g"), `/[locale]/`).replaceAll(new RegExp(`/${locale}/`, "g"), `/[locale]/`);
+    const pattern = file.replaceAll(new RegExp(`/${locale}${ext2}`, "g"), `/[locale]${ext2}`).replaceAll(new RegExp(`/${locale}/`, "g"), `/[locale]/`).replaceAll(new RegExp(`/${locale}/`, "g"), `/[locale]/`);
     return { pattern, file };
   });
   const grouppedFilesAndPatterns = _lodash2.default.groupBy(localeFilesAndPatterns, "pattern");
   const patterns = Object.keys(grouppedFilesAndPatterns);
-  const defaultPatterns = [`i18n/[locale]${ext}`];
+  const defaultPatterns = [`i18n/[locale]${ext2}`];
   if (patterns.length > 0) {
     return { patterns, defaultPatterns };
   }
@@ -617,7 +617,7 @@ function findLocaleFilesWithExtension(ext) {
 }
 function findLocaleFilesForFilename(fileName) {
   const pattern = fileName;
-  const localeFiles = _glob.glob.sync(`**/${fileName}`, {
+  const localeFiles = _glob2.glob.sync(`**/${fileName}`, {
     ignore: ["node_modules/**", "package*.json", "i18n.json", "lingo.json"]
   });
   const localeFilesAndPatterns = localeFiles.map((file) => ({
@@ -649,9 +649,9 @@ function ensurePatterns(patterns, source) {
     }
   });
 }
-function getDefaultContent(ext, source) {
+function getDefaultContent(ext2, source) {
   const defaultGreeting = "Hello from Lingo.dev";
-  switch (ext) {
+  switch (ext2) {
     case ".json":
     case ".arb":
       return `{
@@ -711,7 +711,7 @@ function getDefaultContent(ext, source) {
 </dict>
 </plist>`;
     default:
-      throw new Error(`Unsupported file extension: ${ext}`);
+      throw new Error(`Unsupported file extension: ${ext2}`);
   }
 }
 
@@ -764,7 +764,7 @@ async function initCICD(spinner) {
     message: "Would you like to use Lingo.dev in your CI/CD?"
   });
   if (!init) {
-    spinner.warn("CI/CD not initialized. To set it up later, see docs: https://docs.lingo.dev/ci-action/overview");
+    spinner.warn("CI/CD not initialized. To set it up later, see docs: https://lingo.dev/ci");
     return;
   }
   const selectedPlatforms = await _prompts.checkbox.call(void 0, {
@@ -881,9 +881,9 @@ function makeGitlabInitializer(spinner) {
 
 // src/cli/cmd/init.ts
 
-var openUrl = (path16) => {
+var openUrl = (path17) => {
   const settings = getSettings(void 0);
-  _open2.default.call(void 0, `${settings.auth.webUrl}${path16}`, { wait: false });
+  _open2.default.call(void 0, `${settings.auth.webUrl}${path17}`, { wait: false });
 };
 var throwHelpError = (option, value) => {
   if (value === "help") {
@@ -1047,7 +1047,7 @@ var init_default = new (0, _interactivecommander.InteractiveCommand)().command("
   }
   updateGitignore();
   if (!isInteractive) {
-    _ora2.default.call(void 0, ).info("Please see https://docs.lingo.dev/");
+    _ora2.default.call(void 0, ).info("Please see https://lingo.dev/cli");
   }
 });
 
@@ -1199,7 +1199,7 @@ function expandPlaceholderedGlob(_pathPattern, sourceLocale) {
     []
   );
   const sourcePathPattern = pathPattern.replaceAll(/\[locale\]/g, sourceLocale);
-  const sourcePaths = _glob.glob.sync(sourcePathPattern, { follow: true, withFileTypes: true }).filter((file) => file.isFile() || file.isSymbolicLink()).map((file) => file.fullpath()).map((fullpath) => path12.default.relative(process.cwd(), fullpath));
+  const sourcePaths = _glob2.glob.sync(sourcePathPattern, { follow: true, withFileTypes: true }).filter((file) => file.isFile() || file.isSymbolicLink()).map((file) => file.fullpath()).map((fullpath) => path12.default.relative(process.cwd(), fullpath));
   const placeholderedPaths = sourcePaths.map((sourcePath) => {
     const sourcePathChunks = sourcePath.split(path12.default.sep);
     localeSegmentIndexes.forEach((localeSegmentIndex) => {
@@ -1208,9 +1208,9 @@ function expandPlaceholderedGlob(_pathPattern, sourceLocale) {
       const regexp = new RegExp(
         "(" + pathPatternChunk.replaceAll(".", "\\.").replaceAll("*", ".*").replace("[locale]", `)${sourceLocale}(`) + ")"
       );
-      const match = sourcePathChunk.match(regexp);
-      if (match) {
-        const [, prefix, suffix] = match;
+      const match2 = sourcePathChunk.match(regexp);
+      if (match2) {
+        const [, prefix, suffix] = match2;
         const placeholderedSegment = prefix + "[locale]" + suffix;
         sourcePathChunks[localeSegmentIndex] = placeholderedSegment;
       }
@@ -1257,8 +1257,8 @@ var files_default = new (0, _interactivecommander.Command)().command("files").de
           } else if (type.target) {
             result.push(...targetPaths);
           }
-          result.forEach((path16) => {
-            console.log(path16);
+          result.forEach((path17) => {
+            console.log(path17);
           });
         }
       }
@@ -1757,7 +1757,7 @@ function createAndroidLoader() {
             continue;
           }
           const cdataRegex = /<!\[CDATA\[([\s\S]*?)\]\]>/g;
-          value = value.replace(cdataRegex, (match, content) => content);
+          value = value.replace(cdataRegex, (match2, content) => content);
           value = value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/\\'/g, "'");
           result[name] = value;
         }
@@ -2071,9 +2071,9 @@ function createHtmlLoader() {
         const bDepth = b.split("/").length;
         return aDepth - bDepth;
       });
-      paths.forEach((path16) => {
-        const value = data[path16];
-        const [nodePath, attribute] = path16.split("#");
+      paths.forEach((path17) => {
+        const value = data[path17];
+        const [nodePath, attribute] = path17.split("#");
         const [rootTag, ...indices] = nodePath.split("/");
         let parent = rootTag === "head" ? document.head : document.body;
         let current = parent;
@@ -2201,9 +2201,9 @@ function createXcodeStringsLoader() {
       for (const line of lines) {
         const trimmedLine = line.trim();
         if (trimmedLine && !trimmedLine.startsWith("//")) {
-          const match = trimmedLine.match(/^"(.+)"\s*=\s*"(.+)";$/);
-          if (match) {
-            const [, key, value] = match;
+          const match2 = trimmedLine.match(/^"(.+)"\s*=\s*"(.+)";$/);
+          if (match2) {
+            const [, key, value] = match2;
             result[key] = unescapeXcodeString(value);
           }
         }
@@ -3199,18 +3199,18 @@ function createRawDatoValue(parsedDatoValue, originalRawDatoValue, isClean = fal
 }
 function serializeStructuredText(rawStructuredText) {
   return serializeStructuredTextNode(rawStructuredText);
-  function serializeStructuredTextNode(node, path16 = [], acc = {}) {
+  function serializeStructuredTextNode(node, path17 = [], acc = {}) {
     if ("document" in node) {
-      return serializeStructuredTextNode(node.document, [...path16, "document"], acc);
+      return serializeStructuredTextNode(node.document, [...path17, "document"], acc);
     }
     if (!_lodash2.default.isNil(node.value)) {
-      acc[[...path16, "value"].join(".")] = node.value;
+      acc[[...path17, "value"].join(".")] = node.value;
     } else if (_lodash2.default.get(node, "type") === "block") {
-      acc[[...path16, "item"].join(".")] = serializeBlock(node.item);
+      acc[[...path17, "item"].join(".")] = serializeBlock(node.item);
     }
     if (node.children) {
       for (let i = 0; i < node.children.length; i++) {
-        serializeStructuredTextNode(node.children[i], [...path16, i.toString()], acc);
+        serializeStructuredTextNode(node.children[i], [...path17, i.toString()], acc);
       }
     }
     return acc;
@@ -3269,8 +3269,8 @@ function deserializeBlockList(parsedBlockList, originalRawBlockList, isClean = f
 }
 function deserializeStructuredText(parsedStructuredText, originalRawStructuredText) {
   const result = _lodash2.default.cloneDeep(originalRawStructuredText);
-  for (const [path16, value] of _lodash2.default.entries(parsedStructuredText)) {
-    const realPath = _lodash2.default.chain(path16.split(".")).flatMap((s) => !_lodash2.default.isNaN(_lodash2.default.toNumber(s)) ? ["children", s] : s).value();
+  for (const [path17, value] of _lodash2.default.entries(parsedStructuredText)) {
+    const realPath = _lodash2.default.chain(path17.split(".")).flatMap((s) => !_lodash2.default.isNaN(_lodash2.default.toNumber(s)) ? ["children", s] : s).value();
     const deserializedValue = createRawDatoValue(value, _lodash2.default.get(originalRawStructuredText, realPath), true);
     _lodash2.default.set(result, realPath, deserializedValue);
   }
@@ -3370,11 +3370,11 @@ function variableExtractLoader(params) {
           variables: []
         };
         for (let i = 0; i < matches.length; i++) {
-          const match = matches[i];
+          const match2 = matches[i];
           const currentValue = result[key].value;
-          const newValue = _optionalChain([currentValue, 'optionalAccess', _169 => _169.replace, 'call', _170 => _170(match, `{variable:${i}}`)]);
+          const newValue = _optionalChain([currentValue, 'optionalAccess', _169 => _169.replace, 'call', _170 => _170(match2, `{variable:${i}}`)]);
           result[key].value = newValue;
-          result[key].variables[i] = match;
+          result[key].variables[i] = match2;
         }
       }
       return result;
@@ -3485,8 +3485,8 @@ ${currentIndent}}`;
   return result;
 }
 function detectIndentation(jsonStr) {
-  const match = jsonStr.match(/\n(\s+)/);
-  return match ? match[1] : "    ";
+  const match2 = jsonStr.match(/\n(\s+)/);
+  return match2 ? match2[1] : "    ";
 }
 
 // src/cli/loaders/plutil-json-loader.ts
@@ -3584,11 +3584,11 @@ ${JSON.stringify(parsed.i18n, null, 2)}
   });
 }
 function parseVueFile(input2) {
-  const match = input2.match(/^([\s\S]*)<i18n>([\s\S]*)<\/i18n>([\s\S]*)$/);
-  if (!match) {
+  const match2 = input2.match(/^([\s\S]*)<i18n>([\s\S]*)<\/i18n>([\s\S]*)$/);
+  if (!match2) {
     return null;
   }
-  const [, before, jsonString = "{}", after] = match;
+  const [, before, jsonString = "{}", after] = match2;
   let i18n;
   try {
     i18n = JSON.parse(jsonString);
@@ -3656,15 +3656,15 @@ function parseTypeScript(input2) {
 function extractStringsFromDefaultExport(ast) {
   let extracted = {};
   traverse(ast, {
-    ExportDefaultDeclaration(path16) {
-      const { declaration } = path16.node;
+    ExportDefaultDeclaration(path17) {
+      const { declaration } = path17.node;
       const decl = unwrapTSAsExpression(declaration);
       if (t.isObjectExpression(decl)) {
         extracted = objectExpressionToObject(decl);
       } else if (t.isArrayExpression(decl)) {
         extracted = arrayExpressionToArray(decl);
       } else if (t.isIdentifier(decl)) {
-        const binding = path16.scope.bindings[decl.name];
+        const binding = path17.scope.bindings[decl.name];
         if (binding && t.isVariableDeclarator(binding.path.node) && binding.path.node.init) {
           const initRaw = binding.path.node.init;
           const init = initRaw ? unwrapTSAsExpression(initRaw) : initRaw;
@@ -3729,8 +3729,8 @@ function arrayExpressionToArray(arrayExpression) {
 function updateStringsInDefaultExport(ast, data) {
   let modified = false;
   traverse(ast, {
-    ExportDefaultDeclaration(path16) {
-      const { declaration } = path16.node;
+    ExportDefaultDeclaration(path17) {
+      const { declaration } = path17.node;
       const decl = unwrapTSAsExpression(declaration);
       if (t.isObjectExpression(decl)) {
         modified = updateStringsInObjectExpression(decl, data) || modified;
@@ -3739,7 +3739,7 @@ function updateStringsInDefaultExport(ast, data) {
           modified = updateStringsInArrayExpression(decl, data) || modified;
         }
       } else if (t.isIdentifier(decl)) {
-        modified = updateStringsInExportedIdentifier(path16, data) || modified;
+        modified = updateStringsInExportedIdentifier(path17, data) || modified;
       }
     }
   });
@@ -3810,9 +3810,9 @@ function updateStringsInArrayExpression(arrayExpression, incoming) {
   });
   return modified;
 }
-function updateStringsInExportedIdentifier(path16, data) {
-  const exportName = path16.node.declaration.name;
-  const binding = path16.scope.bindings[exportName];
+function updateStringsInExportedIdentifier(path17, data) {
+  const exportName = path17.node.declaration.name;
+  const binding = path17.scope.bindings[exportName];
   if (!binding || !binding.path.node) return false;
   if (t.isVariableDeclarator(binding.path.node) && binding.path.node.init) {
     const initRaw = binding.path.node.init;
@@ -3940,14 +3940,14 @@ function ensureSurroundingImageNewlines(_content) {
     found = false;
     const matches = workingContent.match(imageRegex);
     if (matches) {
-      const match = matches[0];
-      const replacement = match.trim().startsWith(">") ? match : `
+      const match2 = matches[0];
+      const replacement = match2.trim().startsWith(">") ? match2 : `
 
-${match}
+${match2}
 
 `;
-      content = content.replaceAll(match, replacement);
-      workingContent = workingContent.replaceAll(match, "");
+      content = content.replaceAll(match2, replacement);
+      workingContent = workingContent.replaceAll(match2, "");
       found = true;
     }
   } while (found);
@@ -3962,14 +3962,14 @@ function ensureTrailingFenceNewline(_content) {
     found = false;
     const matches = workingContent.match(fenceRegex);
     if (matches) {
-      const match = matches[0];
-      const replacement = match.trim().startsWith(">") ? match : `
+      const match2 = matches[0];
+      const replacement = match2.trim().startsWith(">") ? match2 : `
 
-${match}
+${match2}
 
 `;
-      content = content.replaceAll(match, replacement);
-      workingContent = workingContent.replaceAll(match, "");
+      content = content.replaceAll(match2, replacement);
+      workingContent = workingContent.replaceAll(match2, "");
       found = true;
     }
   } while (found);
@@ -3982,8 +3982,8 @@ function extractCodePlaceholders(content) {
   finalContent = ensureSurroundingImageNewlines(finalContent);
   const codePlaceholders = {};
   const codeBlockMatches = finalContent.matchAll(fenceRegex);
-  for (const match of codeBlockMatches) {
-    const codeBlock = match[0];
+  for (const match2 of codeBlockMatches) {
+    const codeBlock = match2[0];
     const codeBlockHash = md5(codeBlock);
     const placeholder = `---CODE-PLACEHOLDER-${codeBlockHash}---`;
     codePlaceholders[placeholder] = codeBlock;
@@ -3991,8 +3991,8 @@ function extractCodePlaceholders(content) {
     finalContent = finalContent.replace(codeBlock, replacement);
   }
   const inlineCodeMatches = finalContent.matchAll(inlineCodeRegex);
-  for (const match of inlineCodeMatches) {
-    const inlineCode = match[0];
+  for (const match2 of inlineCodeMatches) {
+    const inlineCode = match2[0];
     const inlineCodeHash = md5(inlineCode);
     const placeholder = `---INLINE-CODE-PLACEHOLDER-${inlineCodeHash}---`;
     codePlaceholders[placeholder] = inlineCode;
@@ -4081,8 +4081,8 @@ function extractLockedPatterns(content, patterns = []) {
     try {
       const pattern = new RegExp(patternStr, "gm");
       const matches = Array.from(finalContent.matchAll(pattern));
-      for (const match of matches) {
-        const matchedText = match[0];
+      for (const match2 of matches) {
+        const matchedText = match2[0];
         const matchHash = md5(matchedText);
         const placeholder = `---LOCKED-PATTERN-${matchHash}---`;
         lockedPlaceholders[placeholder] = matchedText;
@@ -4873,7 +4873,7 @@ var i18n_default = new (0, _interactivecommander.Command)().command("i18n").desc
     if (_optionalChain([flags, 'access', _184 => _184.file, 'optionalAccess', _185 => _185.length])) {
       buckets = buckets.map((bucket) => {
         const paths = bucket.paths.filter(
-          (path16) => flags.file.find((file) => _optionalChain([path16, 'access', _186 => _186.pathPattern, 'optionalAccess', _187 => _187.includes, 'call', _188 => _188(file)]))
+          (path17) => flags.file.find((file) => _optionalChain([path17, 'access', _186 => _186.pathPattern, 'optionalAccess', _187 => _187.includes, 'call', _188 => _188(file)]))
         );
         return { ...bucket, paths };
       }).filter((bucket) => bucket.paths.length > 0);
@@ -4886,8 +4886,8 @@ var i18n_default = new (0, _interactivecommander.Command)().command("i18n").desc
         ora.info(`\x1B[36mProcessing only filtered buckets:\x1B[0m`);
         buckets.map((bucket) => {
           ora.info(`  ${bucket.type}:`);
-          bucket.paths.forEach((path16) => {
-            ora.info(`    - ${path16.pathPattern}`);
+          bucket.paths.forEach((path17) => {
+            ora.info(`    - ${path17.pathPattern}`);
           });
         });
       }
@@ -6077,6 +6077,1546 @@ async function plan(input2) {
 
 var _plimit = require('p-limit'); var _plimit2 = _interopRequireDefault(_plimit);
 
+
+// ../../node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
+var balanced = (a, b, str) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
+};
+var maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+};
+var range = (a, b, str) => {
+  let begs, beg, left, right = void 0, result;
+  let ai = str.indexOf(a);
+  let bi = str.indexOf(b, ai + 1);
+  let 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) {
+        const r = begs.pop();
+        if (r !== void 0)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== void 0 && beg < left) {
+          left = beg;
+          right = bi;
+        }
+        bi = str.indexOf(b, i + 1);
+      }
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+    if (begs.length && right !== void 0) {
+      result = [left, right];
+    }
+  }
+  return result;
+};
+
+// ../../node_modules/.pnpm/@isaacs+brace-expansion@5.0.0/node_modules/@isaacs/brace-expansion/dist/esm/index.js
+var escSlash = "\0SLASH" + Math.random() + "\0";
+var escOpen = "\0OPEN" + Math.random() + "\0";
+var escClose = "\0CLOSE" + Math.random() + "\0";
+var escComma = "\0COMMA" + Math.random() + "\0";
+var escPeriod = "\0PERIOD" + Math.random() + "\0";
+var escSlashPattern = new RegExp(escSlash, "g");
+var escOpenPattern = new RegExp(escOpen, "g");
+var escClosePattern = new RegExp(escClose, "g");
+var escCommaPattern = new RegExp(escComma, "g");
+var escPeriodPattern = new RegExp(escPeriod, "g");
+var slashPattern = /\\\\/g;
+var openPattern = /\\{/g;
+var closePattern = /\\}/g;
+var commaPattern = /\\,/g;
+var periodPattern = /\\./g;
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
+  }
+  const parts = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    ;
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  return parts;
+}
+function expand(str) {
+  if (!str) {
+    return [];
+  }
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), true).map(unescapeBraces);
+}
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+function expand_(str, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0; k < post.length; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str);
+      }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== void 0) {
+        n = expand_(n[0], false).map(embrace);
+        if (n.length === 1) {
+          return post.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x; test(i, y); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z3 = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z3 + c.slice(1);
+              } else {
+                c = z3 + c;
+              }
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0; j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], false));
+      }
+    }
+    for (let j = 0; j < N.length; j++) {
+      for (let k = 0; k < post.length; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
+        }
+      }
+    }
+  }
+  return expansions;
+}
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/assert-valid-pattern.js
+var MAX_PATTERN_LENGTH = 1024 * 64;
+var assertValidPattern = (pattern) => {
+  if (typeof pattern !== "string") {
+    throw new TypeError("invalid pattern");
+  }
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new TypeError("pattern is too long");
+  }
+};
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/brace-expressions.js
+var posixClasses = {
+  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
+  "[:alpha:]": ["\\p{L}\\p{Nl}", true],
+  "[:ascii:]": ["\\x00-\\x7f", false],
+  "[:blank:]": ["\\p{Zs}\\t", true],
+  "[:cntrl:]": ["\\p{Cc}", true],
+  "[:digit:]": ["\\p{Nd}", true],
+  "[:graph:]": ["\\p{Z}\\p{C}", true, true],
+  "[:lower:]": ["\\p{Ll}", true],
+  "[:print:]": ["\\p{C}", true],
+  "[:punct:]": ["\\p{P}", true],
+  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
+  "[:upper:]": ["\\p{Lu}", true],
+  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
+  "[:xdigit:]": ["A-Fa-f0-9", false]
+};
+var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var rangesToString = (ranges) => ranges.join("");
+var parseClass = (glob3, position) => {
+  const pos = position;
+  if (glob3.charAt(pos) !== "[") {
+    throw new Error("not in a brace expression");
+  }
+  const ranges = [];
+  const negs = [];
+  let i = pos + 1;
+  let sawStart = false;
+  let uflag = false;
+  let escaping = false;
+  let negate = false;
+  let endPos = pos;
+  let rangeStart = "";
+  WHILE: while (i < glob3.length) {
+    const c = glob3.charAt(i);
+    if ((c === "!" || c === "^") && i === pos + 1) {
+      negate = true;
+      i++;
+      continue;
+    }
+    if (c === "]" && sawStart && !escaping) {
+      endPos = i + 1;
+      break;
+    }
+    sawStart = true;
+    if (c === "\\") {
+      if (!escaping) {
+        escaping = true;
+        i++;
+        continue;
+      }
+    }
+    if (c === "[" && !escaping) {
+      for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+        if (glob3.startsWith(cls, i)) {
+          if (rangeStart) {
+            return ["$.", false, glob3.length - pos, true];
+          }
+          i += cls.length;
+          if (neg)
+            negs.push(unip);
+          else
+            ranges.push(unip);
+          uflag = uflag || u;
+          continue WHILE;
+        }
+      }
+    }
+    escaping = false;
+    if (rangeStart) {
+      if (c > rangeStart) {
+        ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+      } else if (c === rangeStart) {
+        ranges.push(braceEscape(c));
+      }
+      rangeStart = "";
+      i++;
+      continue;
+    }
+    if (glob3.startsWith("-]", i + 1)) {
+      ranges.push(braceEscape(c + "-"));
+      i += 2;
+      continue;
+    }
+    if (glob3.startsWith("-", i + 1)) {
+      rangeStart = c;
+      i += 2;
+      continue;
+    }
+    ranges.push(braceEscape(c));
+    i++;
+  }
+  if (endPos < i) {
+    return ["", false, 0, false];
+  }
+  if (!ranges.length && !negs.length) {
+    return ["$.", false, glob3.length - pos, true];
+  }
+  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
+    const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+    return [regexpEscape(r), false, endPos - pos, false];
+  }
+  const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
+  const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
+  const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
+  return [comb, uflag, endPos - pos, true];
+};
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/unescape.js
+var unescape = (s, { windowsPathsNoEscape = false } = {}) => {
+  return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+};
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/ast.js
+var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
+var isExtglobType = (c) => types.has(c);
+var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
+var startNoDot = "(?!\\.)";
+var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
+var justDots = /* @__PURE__ */ new Set(["..", "."]);
+var reSpecials = new Set("().*{}+?[]^$\\!");
+var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var qmark = "[^/]";
+var star = qmark + "*?";
+var starNoEmpty = qmark + "+?";
+var AST = class _AST {
+  
+  #root;
+  #hasMagic;
+  #uflag = false;
+  #parts = [];
+  #parent;
+  #parentIndex;
+  #negs;
+  #filledNegs = false;
+  #options;
+  #toString;
+  // set to true if it's an extglob with no children
+  // (which really means one child of '')
+  #emptyExt = false;
+  constructor(type, parent, options = {}) {
+    this.type = type;
+    if (type)
+      this.#hasMagic = true;
+    this.#parent = parent;
+    this.#root = this.#parent ? this.#parent.#root : this;
+    this.#options = this.#root === this ? options : this.#root.#options;
+    this.#negs = this.#root === this ? [] : this.#root.#negs;
+    if (type === "!" && !this.#root.#filledNegs)
+      this.#negs.push(this);
+    this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+  }
+  get hasMagic() {
+    if (this.#hasMagic !== void 0)
+      return this.#hasMagic;
+    for (const p of this.#parts) {
+      if (typeof p === "string")
+        continue;
+      if (p.type || p.hasMagic)
+        return this.#hasMagic = true;
+    }
+    return this.#hasMagic;
+  }
+  // reconstructs the pattern
+  toString() {
+    if (this.#toString !== void 0)
+      return this.#toString;
+    if (!this.type) {
+      return this.#toString = this.#parts.map((p) => String(p)).join("");
+    } else {
+      return this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
+    }
+  }
+  #fillNegs() {
+    if (this !== this.#root)
+      throw new Error("should only call on root");
+    if (this.#filledNegs)
+      return this;
+    this.toString();
+    this.#filledNegs = true;
+    let n;
+    while (n = this.#negs.pop()) {
+      if (n.type !== "!")
+        continue;
+      let p = n;
+      let pp = p.#parent;
+      while (pp) {
+        for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
+          for (const part of n.#parts) {
+            if (typeof part === "string") {
+              throw new Error("string part in extglob AST??");
+            }
+            part.copyIn(pp.#parts[i]);
+          }
+        }
+        p = pp;
+        pp = p.#parent;
+      }
+    }
+    return this;
+  }
+  push(...parts) {
+    for (const p of parts) {
+      if (p === "")
+        continue;
+      if (typeof p !== "string" && !(p instanceof _AST && p.#parent === this)) {
+        throw new Error("invalid part: " + p);
+      }
+      this.#parts.push(p);
+    }
+  }
+  toJSON() {
+    const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
+    if (this.isStart() && !this.type)
+      ret.unshift([]);
+    if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && _optionalChain([this, 'access', _208 => _208.#parent, 'optionalAccess', _209 => _209.type]) === "!")) {
+      ret.push({});
+    }
+    return ret;
+  }
+  isStart() {
+    if (this.#root === this)
+      return true;
+    if (!_optionalChain([this, 'access', _210 => _210.#parent, 'optionalAccess', _211 => _211.isStart, 'call', _212 => _212()]))
+      return false;
+    if (this.#parentIndex === 0)
+      return true;
+    const p = this.#parent;
+    for (let i = 0; i < this.#parentIndex; i++) {
+      const pp = p.#parts[i];
+      if (!(pp instanceof _AST && pp.type === "!")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isEnd() {
+    if (this.#root === this)
+      return true;
+    if (_optionalChain([this, 'access', _213 => _213.#parent, 'optionalAccess', _214 => _214.type]) === "!")
+      return true;
+    if (!_optionalChain([this, 'access', _215 => _215.#parent, 'optionalAccess', _216 => _216.isEnd, 'call', _217 => _217()]))
+      return false;
+    if (!this.type)
+      return _optionalChain([this, 'access', _218 => _218.#parent, 'optionalAccess', _219 => _219.isEnd, 'call', _220 => _220()]);
+    const pl = this.#parent ? this.#parent.#parts.length : 0;
+    return this.#parentIndex === pl - 1;
+  }
+  copyIn(part) {
+    if (typeof part === "string")
+      this.push(part);
+    else
+      this.push(part.clone(this));
+  }
+  clone(parent) {
+    const c = new _AST(this.type, parent);
+    for (const p of this.#parts) {
+      c.copyIn(p);
+    }
+    return c;
+  }
+  static #parseAST(str, ast, pos, opt) {
+    let escaping = false;
+    let inBrace = false;
+    let braceStart = -1;
+    let braceNeg = false;
+    if (ast.type === null) {
+      let i2 = pos;
+      let acc2 = "";
+      while (i2 < str.length) {
+        const c = str.charAt(i2++);
+        if (escaping || c === "\\") {
+          escaping = !escaping;
+          acc2 += c;
+          continue;
+        }
+        if (inBrace) {
+          if (i2 === braceStart + 1) {
+            if (c === "^" || c === "!") {
+              braceNeg = true;
+            }
+          } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
+            inBrace = false;
+          }
+          acc2 += c;
+          continue;
+        } else if (c === "[") {
+          inBrace = true;
+          braceStart = i2;
+          braceNeg = false;
+          acc2 += c;
+          continue;
+        }
+        if (!opt.noext && isExtglobType(c) && str.charAt(i2) === "(") {
+          ast.push(acc2);
+          acc2 = "";
+          const ext2 = new _AST(c, ast);
+          i2 = _AST.#parseAST(str, ext2, i2, opt);
+          ast.push(ext2);
+          continue;
+        }
+        acc2 += c;
+      }
+      ast.push(acc2);
+      return i2;
+    }
+    let i = pos + 1;
+    let part = new _AST(null, ast);
+    const parts = [];
+    let acc = "";
+    while (i < str.length) {
+      const c = str.charAt(i++);
+      if (escaping || c === "\\") {
+        escaping = !escaping;
+        acc += c;
+        continue;
+      }
+      if (inBrace) {
+        if (i === braceStart + 1) {
+          if (c === "^" || c === "!") {
+            braceNeg = true;
+          }
+        } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
+          inBrace = false;
+        }
+        acc += c;
+        continue;
+      } else if (c === "[") {
+        inBrace = true;
+        braceStart = i;
+        braceNeg = false;
+        acc += c;
+        continue;
+      }
+      if (isExtglobType(c) && str.charAt(i) === "(") {
+        part.push(acc);
+        acc = "";
+        const ext2 = new _AST(c, part);
+        part.push(ext2);
+        i = _AST.#parseAST(str, ext2, i, opt);
+        continue;
+      }
+      if (c === "|") {
+        part.push(acc);
+        acc = "";
+        parts.push(part);
+        part = new _AST(null, ast);
+        continue;
+      }
+      if (c === ")") {
+        if (acc === "" && ast.#parts.length === 0) {
+          ast.#emptyExt = true;
+        }
+        part.push(acc);
+        acc = "";
+        ast.push(...parts, part);
+        return i;
+      }
+      acc += c;
+    }
+    ast.type = null;
+    ast.#hasMagic = void 0;
+    ast.#parts = [str.substring(pos - 1)];
+    return i;
+  }
+  static fromGlob(pattern, options = {}) {
+    const ast = new _AST(null, void 0, options);
+    _AST.#parseAST(pattern, ast, 0, options);
+    return ast;
+  }
+  // returns the regular expression if there's magic, or the unescaped
+  // string if not.
+  toMMPattern() {
+    if (this !== this.#root)
+      return this.#root.toMMPattern();
+    const glob3 = this.toString();
+    const [re, body, hasMagic, uflag] = this.toRegExpSource();
+    const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob3.toUpperCase() !== glob3.toLowerCase();
+    if (!anyMagic) {
+      return body;
+    }
+    const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
+    return Object.assign(new RegExp(`^${re}$`, flags), {
+      _src: re,
+      _glob: glob3
+    });
+  }
+  get options() {
+    return this.#options;
+  }
+  // returns the string match, the regexp source, whether there's magic
+  // in the regexp (so a regular expression is required) and whether or
+  // not the uflag is needed for the regular expression (for posix classes)
+  // TODO: instead of injecting the start/end at this point, just return
+  // the BODY of the regexp, along with the start/end portions suitable
+  // for binding the start/end in either a joined full-path makeRe context
+  // (where we bind to (^|/), or a standalone matchPart context (where
+  // we bind to ^, and not /).  Otherwise slashes get duped!
+  //
+  // In part-matching mode, the start is:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: ^(?!\.\.?$)
+  // - if dots allowed or not possible: ^
+  // - if dots possible and not allowed: ^(?!\.)
+  // end is:
+  // - if not isEnd(): nothing
+  // - else: $
+  //
+  // In full-path matching mode, we put the slash at the START of the
+  // pattern, so start is:
+  // - if first pattern: same as part-matching mode
+  // - if not isStart(): nothing
+  // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
+  // - if dots allowed or not possible: /
+  // - if dots possible and not allowed: /(?!\.)
+  // end is:
+  // - if last pattern, same as part-matching mode
+  // - else nothing
+  //
+  // Always put the (?:$|/) on negated tails, though, because that has to be
+  // there to bind the end of the negated pattern portion, and it's easier to
+  // just stick it in now rather than try to inject it later in the middle of
+  // the pattern.
+  //
+  // We can just always return the same end, and leave it up to the caller
+  // to know whether it's going to be used joined or in parts.
+  // And, if the start is adjusted slightly, can do the same there:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
+  // - if dots allowed or not possible: (?:/|^)
+  // - if dots possible and not allowed: (?:/|^)(?!\.)
+  //
+  // But it's better to have a simpler binding without a conditional, for
+  // performance, so probably better to return both start options.
+  //
+  // Then the caller just ignores the end if it's not the first pattern,
+  // and the start always gets applied.
+  //
+  // But that's always going to be $ if it's the ending pattern, or nothing,
+  // so the caller can just attach $ at the end of the pattern when building.
+  //
+  // So the todo is:
+  // - better detect what kind of start is needed
+  // - return both flavors of starting pattern
+  // - attach $ at the end of the pattern when creating the actual RegExp
+  //
+  // Ah, but wait, no, that all only applies to the root when the first pattern
+  // is not an extglob. If the first pattern IS an extglob, then we need all
+  // that dot prevention biz to live in the extglob portions, because eg
+  // +(*|.x*) can match .xy but not .yx.
+  //
+  // So, return the two flavors if it's #root and the first child is not an
+  // AST, otherwise leave it to the child AST to handle it, and there,
+  // use the (?:^|/) style of start binding.
+  //
+  // Even simplified further:
+  // - Since the start for a join is eg /(?!\.) and the start for a part
+  // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
+  // or start or whatever) and prepend ^ or / at the Regexp construction.
+  toRegExpSource(allowDot) {
+    const dot = _nullishCoalesce(allowDot, () => ( !!this.#options.dot));
+    if (this.#root === this)
+      this.#fillNegs();
+    if (!this.type) {
+      const noEmpty = this.isStart() && this.isEnd();
+      const src = this.#parts.map((p) => {
+        const [re, _33, hasMagic, uflag] = typeof p === "string" ? _AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+        this.#hasMagic = this.#hasMagic || hasMagic;
+        this.#uflag = this.#uflag || uflag;
+        return re;
+      }).join("");
+      let start2 = "";
+      if (this.isStart()) {
+        if (typeof this.#parts[0] === "string") {
+          const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
+          if (!dotTravAllowed) {
+            const aps = addPatternStart;
+            const needNoTrav = (
+              // dots are allowed, and the pattern starts with [ or .
+              dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
+              src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
+              src.startsWith("\\.\\.") && aps.has(src.charAt(4))
+            );
+            const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+            start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+          }
+        }
+      }
+      let end = "";
+      if (this.isEnd() && this.#root.#filledNegs && _optionalChain([this, 'access', _221 => _221.#parent, 'optionalAccess', _222 => _222.type]) === "!") {
+        end = "(?:$|\\/)";
+      }
+      const final2 = start2 + src + end;
+      return [
+        final2,
+        unescape(src),
+        this.#hasMagic = !!this.#hasMagic,
+        this.#uflag
+      ];
+    }
+    const repeated = this.type === "*" || this.type === "+";
+    const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let body = this.#partsToRegExp(dot);
+    if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
+      const s = this.toString();
+      this.#parts = [s];
+      this.type = null;
+      this.#hasMagic = void 0;
+      return [s, unescape(this.toString()), false, false];
+    }
+    let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
+    if (bodyDotAllowed === body) {
+      bodyDotAllowed = "";
+    }
+    if (bodyDotAllowed) {
+      body = `(?:${body})(?:${bodyDotAllowed})*?`;
+    }
+    let final = "";
+    if (this.type === "!" && this.#emptyExt) {
+      final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
+    } else {
+      const close = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
+      final = start + body + close;
+    }
+    return [
+      final,
+      unescape(body),
+      this.#hasMagic = !!this.#hasMagic,
+      this.#uflag
+    ];
+  }
+  #partsToRegExp(dot) {
+    return this.#parts.map((p) => {
+      if (typeof p === "string") {
+        throw new Error("string type in extglob ast??");
+      }
+      const [re, _33, _hasMagic, uflag] = p.toRegExpSource(dot);
+      this.#uflag = this.#uflag || uflag;
+      return re;
+    }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
+  }
+  static #parseGlob(glob3, hasMagic, noEmpty = false) {
+    let escaping = false;
+    let re = "";
+    let uflag = false;
+    for (let i = 0; i < glob3.length; i++) {
+      const c = glob3.charAt(i);
+      if (escaping) {
+        escaping = false;
+        re += (reSpecials.has(c) ? "\\" : "") + c;
+        continue;
+      }
+      if (c === "\\") {
+        if (i === glob3.length - 1) {
+          re += "\\\\";
+        } else {
+          escaping = true;
+        }
+        continue;
+      }
+      if (c === "[") {
+        const [src, needUflag, consumed, magic] = parseClass(glob3, i);
+        if (consumed) {
+          re += src;
+          uflag = uflag || needUflag;
+          i += consumed - 1;
+          hasMagic = hasMagic || magic;
+          continue;
+        }
+      }
+      if (c === "*") {
+        if (noEmpty && glob3 === "*")
+          re += starNoEmpty;
+        else
+          re += star;
+        hasMagic = true;
+        continue;
+      }
+      if (c === "?") {
+        re += qmark;
+        hasMagic = true;
+        continue;
+      }
+      re += regExpEscape(c);
+    }
+    return [re, unescape(glob3), !!hasMagic, uflag];
+  }
+};
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/escape.js
+var escape = (s, { windowsPathsNoEscape = false } = {}) => {
+  return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
+};
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/index.js
+var minimatch = (p, pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (!options.nocomment && pattern.charAt(0) === "#") {
+    return false;
+  }
+  return new Minimatch(pattern, options).match(p);
+};
+var starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
+var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
+var starDotExtTestNocase = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
+};
+var starDotExtTestNocaseDot = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => f.toLowerCase().endsWith(ext2);
+};
+var starDotStarRE = /^\*+\.\*+$/;
+var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
+var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
+var dotStarRE = /^\.\*+$/;
+var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
+var starRE = /^\*+$/;
+var starTest = (f) => f.length !== 0 && !f.startsWith(".");
+var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
+var qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+var qmarksTestNocase = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTest = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTestNoExt = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && !f.startsWith(".");
+};
+var qmarksTestNoExtDot = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && f !== "." && f !== "..";
+};
+var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+var path15 = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+};
+var sep = defaultPlatform === "win32" ? path15.win32.sep : path15.posix.sep;
+minimatch.sep = sep;
+var GLOBSTAR = Symbol("globstar **");
+minimatch.GLOBSTAR = GLOBSTAR;
+var qmark2 = "[^/]";
+var star2 = qmark2 + "*?";
+var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+var filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
+minimatch.filter = filter;
+var ext = (a, b = {}) => Object.assign({}, a, b);
+var defaults = (def) => {
+  if (!def || typeof def !== "object" || !Object.keys(def).length) {
+    return minimatch;
+  }
+  const orig = minimatch;
+  const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+  return Object.assign(m, {
+    Minimatch: class Minimatch extends orig.Minimatch {
+      constructor(pattern, options = {}) {
+        super(pattern, ext(def, options));
+      }
+      static defaults(options) {
+        return orig.defaults(ext(def, options)).Minimatch;
+      }
+    },
+    AST: class AST extends orig.AST {
+      /* c8 ignore start */
+      constructor(type, parent, options = {}) {
+        super(type, parent, ext(def, options));
+      }
+      /* c8 ignore stop */
+      static fromGlob(pattern, options = {}) {
+        return orig.AST.fromGlob(pattern, ext(def, options));
+      }
+    },
+    unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
+    escape: (s, options = {}) => orig.escape(s, ext(def, options)),
+    filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
+    defaults: (options) => orig.defaults(ext(def, options)),
+    makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
+    braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
+    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+    sep: orig.sep,
+    GLOBSTAR
+  });
+};
+minimatch.defaults = defaults;
+var braceExpand = (pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+    return [pattern];
+  }
+  return expand(pattern);
+};
+minimatch.braceExpand = braceExpand;
+var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
+minimatch.makeRe = makeRe;
+var match = (list, pattern, options = {}) => {
+  const mm = new Minimatch(pattern, options);
+  list = list.filter((f) => mm.match(f));
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern);
+  }
+  return list;
+};
+minimatch.match = match;
+var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var Minimatch = class {
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  constructor(pattern, options = {}) {
+    assertValidPattern(pattern);
+    options = options || {};
+    this.options = options;
+    this.pattern = pattern;
+    this.platform = options.platform || defaultPlatform;
+    this.isWindows = this.platform === "win32";
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+    if (this.windowsPathsNoEscape) {
+      this.pattern = this.pattern.replace(/\\/g, "/");
+    }
+    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
+    this.regexp = null;
+    this.negate = false;
+    this.nonegate = !!options.nonegate;
+    this.comment = false;
+    this.empty = false;
+    this.partial = !!options.partial;
+    this.nocase = !!this.options.nocase;
+    this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
+    this.globSet = [];
+    this.globParts = [];
+    this.set = [];
+    this.make();
+  }
+  hasMagic() {
+    if (this.options.magicalBraces && this.set.length > 1) {
+      return true;
+    }
+    for (const pattern of this.set) {
+      for (const part of pattern) {
+        if (typeof part !== "string")
+          return true;
+      }
+    }
+    return false;
+  }
+  debug(..._33) {
+  }
+  make() {
+    const pattern = this.pattern;
+    const options = this.options;
+    if (!options.nocomment && pattern.charAt(0) === "#") {
+      this.comment = true;
+      return;
+    }
+    if (!pattern) {
+      this.empty = true;
+      return;
+    }
+    this.parseNegate();
+    this.globSet = [...new Set(this.braceExpand())];
+    if (options.debug) {
+      this.debug = (...args) => console.error(...args);
+    }
+    this.debug(this.pattern, this.globSet);
+    const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
+    this.globParts = this.preprocess(rawGlobParts);
+    this.debug(this.pattern, this.globParts);
+    let set = this.globParts.map((s, _33, __) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
+        const isDrive = /^[a-z]:/i.test(s[0]);
+        if (isUNC) {
+          return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
+        } else if (isDrive) {
+          return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
+        }
+      }
+      return s.map((ss) => this.parse(ss));
+    });
+    this.debug(this.pattern, set);
+    this.set = set.filter((s) => s.indexOf(false) === -1);
+    if (this.isWindows) {
+      for (let i = 0; i < this.set.length; i++) {
+        const p = this.set[i];
+        if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
+          p[2] = "?";
+        }
+      }
+    }
+    this.debug(this.pattern, this.set);
+  }
+  // various transforms to equivalent pattern sets that are
+  // faster to process in a filesystem walk.  The goal is to
+  // eliminate what we can, and push all ** patterns as far
+  // to the right as possible, even if it increases the number
+  // of patterns that we have to process.
+  preprocess(globParts) {
+    if (this.options.noglobstar) {
+      for (let i = 0; i < globParts.length; i++) {
+        for (let j = 0; j < globParts[i].length; j++) {
+          if (globParts[i][j] === "**") {
+            globParts[i][j] = "*";
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      globParts = this.firstPhasePreProcess(globParts);
+      globParts = this.secondPhasePreProcess(globParts);
+    } else if (optimizationLevel >= 1) {
+      globParts = this.levelOneOptimize(globParts);
+    } else {
+      globParts = this.adjascentGlobstarOptimize(globParts);
+    }
+    return globParts;
+  }
+  // just get rid of adjascent ** portions
+  adjascentGlobstarOptimize(globParts) {
+    return globParts.map((parts) => {
+      let gs = -1;
+      while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+        let i = gs;
+        while (parts[i + 1] === "**") {
+          i++;
+        }
+        if (i !== gs) {
+          parts.splice(gs, i - gs);
+        }
+      }
+      return parts;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(globParts) {
+    return globParts.map((parts) => {
+      parts = parts.reduce((set, part) => {
+        const prev = set[set.length - 1];
+        if (part === "**" && prev === "**") {
+          return set;
+        }
+        if (part === "..") {
+          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
+            set.pop();
+            return set;
+          }
+        }
+        set.push(part);
+        return set;
+      }, []);
+      return parts.length === 0 ? [""] : parts;
+    });
+  }
+  levelTwoFileOptimize(parts) {
+    if (!Array.isArray(parts)) {
+      parts = this.slashSplit(parts);
+    }
+    let didSomething = false;
+    do {
+      didSomething = false;
+      if (!this.preserveMultipleSlashes) {
+        for (let i = 1; i < parts.length - 1; i++) {
+          const p = parts[i];
+          if (i === 1 && p === "" && parts[0] === "")
+            continue;
+          if (p === "." || p === "") {
+            didSomething = true;
+            parts.splice(i, 1);
+            i--;
+          }
+        }
+        if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+          didSomething = true;
+          parts.pop();
+        }
+      }
+      let dd = 0;
+      while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+        const p = parts[dd - 1];
+        if (p && p !== "." && p !== ".." && p !== "**") {
+          didSomething = true;
+          parts.splice(dd - 1, 2);
+          dd -= 2;
+        }
+      }
+    } while (didSomething);
+    return parts.length === 0 ? [""] : parts;
+  }
+  // First phase: single-pattern processing
+  // <pre> is 1 or more portions
+  // <rest> is 1 or more portions
+  // <p> is any portion other than ., .., '', or **
+  // <e> is . or ''
+  //
+  // **/.. is *brutal* for filesystem walking performance, because
+  // it effectively resets the recursive walk each time it occurs,
+  // and ** cannot be reduced out by a .. pattern part like a regexp
+  // or most strings (other than .., ., and '') can be.
+  //
+  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
+  // <pre>/<e>/<rest> -> <pre>/<rest>
+  // <pre>/<p>/../<rest> -> <pre>/<rest>
+  // **/**/<rest> -> **/<rest>
+  //
+  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
+  // this WOULD be allowed if ** did follow symlinks, or * didn't
+  firstPhasePreProcess(globParts) {
+    let didSomething = false;
+    do {
+      didSomething = false;
+      for (let parts of globParts) {
+        let gs = -1;
+        while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+          let gss = gs;
+          while (parts[gss + 1] === "**") {
+            gss++;
+          }
+          if (gss > gs) {
+            parts.splice(gs + 1, gss - gs);
+          }
+          let next = parts[gs + 1];
+          const p = parts[gs + 2];
+          const p2 = parts[gs + 3];
+          if (next !== "..")
+            continue;
+          if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
+            continue;
+          }
+          didSomething = true;
+          parts.splice(gs, 1);
+          const other = parts.slice(0);
+          other[gs] = "**";
+          globParts.push(other);
+          gs--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let i = 1; i < parts.length - 1; i++) {
+            const p = parts[i];
+            if (i === 1 && p === "" && parts[0] === "")
+              continue;
+            if (p === "." || p === "") {
+              didSomething = true;
+              parts.splice(i, 1);
+              i--;
+            }
+          }
+          if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+            didSomething = true;
+            parts.pop();
+          }
+        }
+        let dd = 0;
+        while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+          const p = parts[dd - 1];
+          if (p && p !== "." && p !== ".." && p !== "**") {
+            didSomething = true;
+            const needDot = dd === 1 && parts[dd + 1] === "**";
+            const splin = needDot ? ["."] : [];
+            parts.splice(dd - 1, 2, ...splin);
+            if (parts.length === 0)
+              parts.push("");
+            dd -= 2;
+          }
+        }
+      }
+    } while (didSomething);
+    return globParts;
+  }
+  // second phase: multi-pattern dedupes
+  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
+  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
+  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
+  //
+  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
+  // ^-- not valid because ** doens't follow symlinks
+  secondPhasePreProcess(globParts) {
+    for (let i = 0; i < globParts.length - 1; i++) {
+      for (let j = i + 1; j < globParts.length; j++) {
+        const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+        if (matched) {
+          globParts[i] = [];
+          globParts[j] = matched;
+          break;
+        }
+      }
+    }
+    return globParts.filter((gs) => gs.length);
+  }
+  partsMatch(a, b, emptyGSMatch = false) {
+    let ai = 0;
+    let bi = 0;
+    let result = [];
+    let which = "";
+    while (ai < a.length && bi < b.length) {
+      if (a[ai] === b[bi]) {
+        result.push(which === "b" ? b[bi] : a[ai]);
+        ai++;
+        bi++;
+      } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
+        result.push(a[ai]);
+        ai++;
+      } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
+        result.push(b[bi]);
+        bi++;
+      } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
+        if (which === "b")
+          return false;
+        which = "a";
+        result.push(a[ai]);
+        ai++;
+        bi++;
+      } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
+        if (which === "a")
+          return false;
+        which = "b";
+        result.push(b[bi]);
+        ai++;
+        bi++;
+      } else {
+        return false;
+      }
+    }
+    return a.length === b.length && result;
+  }
+  parseNegate() {
+    if (this.nonegate)
+      return;
+    const pattern = this.pattern;
+    let negate = false;
+    let negateOffset = 0;
+    for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
+      negate = !negate;
+      negateOffset++;
+    }
+    if (negateOffset)
+      this.pattern = pattern.slice(negateOffset);
+    this.negate = negate;
+  }
+  // set partial to true to test if, for example,
+  // "/a/b" matches the start of "/*/b/*/d"
+  // Partial means, if you run out of file before you run
+  // out of pattern, then that's fine, as long as all
+  // the parts match.
+  matchOne(file, pattern, partial = false) {
+    const options = this.options;
+    if (this.isWindows) {
+      const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
+      const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
+      const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
+      const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
+      const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
+      const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
+      if (typeof fdi === "number" && typeof pdi === "number") {
+        const [fd, pd] = [file[fdi], pattern[pdi]];
+        if (fd.toLowerCase() === pd.toLowerCase()) {
+          pattern[pdi] = fd;
+          if (pdi > fdi) {
+            pattern = pattern.slice(pdi);
+          } else if (fdi > pdi) {
+            file = file.slice(fdi);
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      file = this.levelTwoFileOptimize(file);
+    }
+    this.debug("matchOne", this, { file, pattern });
+    this.debug("matchOne", file.length, pattern.length);
+    for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      var p = pattern[pi];
+      var f = file[fi];
+      this.debug(pattern, p, f);
+      if (p === false) {
+        return false;
+      }
+      if (p === GLOBSTAR) {
+        this.debug("GLOBSTAR", [pattern, p, f]);
+        var fr = fi;
+        var pr = pi + 1;
+        if (pr === pl) {
+          this.debug("** at the end");
+          for (; fi < fl; fi++) {
+            if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
+              return false;
+          }
+          return true;
+        }
+        while (fr < fl) {
+          var swallowee = file[fr];
+          this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
+          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+            this.debug("globstar found match!", fr, fl, swallowee);
+            return true;
+          } else {
+            if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
+              this.debug("dot detected!", file, fr, pattern, pr);
+              break;
+            }
+            this.debug("globstar swallow a segment, and continue");
+            fr++;
+          }
+        }
+        if (partial) {
+          this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
+          if (fr === fl) {
+            return true;
+          }
+        }
+        return false;
+      }
+      let hit;
+      if (typeof p === "string") {
+        hit = f === p;
+        this.debug("string match", p, f, hit);
+      } else {
+        hit = p.test(f);
+        this.debug("pattern match", p, f, hit);
+      }
+      if (!hit)
+        return false;
+    }
+    if (fi === fl && pi === pl) {
+      return true;
+    } else if (fi === fl) {
+      return partial;
+    } else if (pi === pl) {
+      return fi === fl - 1 && file[fi] === "";
+    } else {
+      throw new Error("wtf?");
+    }
+  }
+  braceExpand() {
+    return braceExpand(this.pattern, this.options);
+  }
+  parse(pattern) {
+    assertValidPattern(pattern);
+    const options = this.options;
+    if (pattern === "**")
+      return GLOBSTAR;
+    if (pattern === "")
+      return "";
+    let m;
+    let fastTest = null;
+    if (m = pattern.match(starRE)) {
+      fastTest = options.dot ? starTestDot : starTest;
+    } else if (m = pattern.match(starDotExtRE)) {
+      fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
+    } else if (m = pattern.match(qmarksRE)) {
+      fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
+    } else if (m = pattern.match(starDotStarRE)) {
+      fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+    } else if (m = pattern.match(dotStarRE)) {
+      fastTest = dotStarTest;
+    }
+    const re = AST.fromGlob(pattern, this.options).toMMPattern();
+    if (fastTest && typeof re === "object") {
+      Reflect.defineProperty(re, "test", { value: fastTest });
+    }
+    return re;
+  }
+  makeRe() {
+    if (this.regexp || this.regexp === false)
+      return this.regexp;
+    const set = this.set;
+    if (!set.length) {
+      this.regexp = false;
+      return this.regexp;
+    }
+    const options = this.options;
+    const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
+    const flags = new Set(options.nocase ? ["i"] : []);
+    let re = set.map((pattern) => {
+      const pp = pattern.map((p) => {
+        if (p instanceof RegExp) {
+          for (const f of p.flags.split(""))
+            flags.add(f);
+        }
+        return typeof p === "string" ? regExpEscape2(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
+      });
+      pp.forEach((p, i) => {
+        const next = pp[i + 1];
+        const prev = pp[i - 1];
+        if (p !== GLOBSTAR || prev === GLOBSTAR) {
+          return;
+        }
+        if (prev === void 0) {
+          if (next !== void 0 && next !== GLOBSTAR) {
+            pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
+          } else {
+            pp[i] = twoStar;
+          }
+        } else if (next === void 0) {
+          pp[i - 1] = prev + "(?:\\/|" + twoStar + ")?";
+        } else if (next !== GLOBSTAR) {
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
+          pp[i + 1] = GLOBSTAR;
+        }
+      });
+      return pp.filter((p) => p !== GLOBSTAR).join("/");
+    }).join("|");
+    const [open3, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+    re = "^" + open3 + re + close + "$";
+    if (this.negate)
+      re = "^(?!" + re + ").+$";
+    try {
+      this.regexp = new RegExp(re, [...flags].join(""));
+    } catch (ex) {
+      this.regexp = false;
+    }
+    return this.regexp;
+  }
+  slashSplit(p) {
+    if (this.preserveMultipleSlashes) {
+      return p.split("/");
+    } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
+      return ["", ...p.split(/\/+/)];
+    } else {
+      return p.split(/\/+/);
+    }
+  }
+  match(f, partial = this.partial) {
+    this.debug("match", f, this.pattern);
+    if (this.comment) {
+      return false;
+    }
+    if (this.empty) {
+      return f === "";
+    }
+    if (f === "/" && partial) {
+      return true;
+    }
+    const options = this.options;
+    if (this.isWindows) {
+      f = f.split("\\").join("/");
+    }
+    const ff = this.slashSplit(f);
+    this.debug(this.pattern, "split", ff);
+    const set = this.set;
+    this.debug(this.pattern, "set", set);
+    let filename = ff[ff.length - 1];
+    if (!filename) {
+      for (let i = ff.length - 2; !filename && i >= 0; i--) {
+        filename = ff[i];
+      }
+    }
+    for (let i = 0; i < set.length; i++) {
+      const pattern = set[i];
+      let file = ff;
+      if (options.matchBase && pattern.length === 1) {
+        file = [filename];
+      }
+      const hit = this.matchOne(file, pattern, partial);
+      if (hit) {
+        if (options.flipNegate) {
+          return true;
+        }
+        return !this.negate;
+      }
+    }
+    if (options.flipNegate) {
+      return false;
+    }
+    return this.negate;
+  }
+  static defaults(def) {
+    return minimatch.defaults(def).Minimatch;
+  }
+};
+minimatch.AST = AST;
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape;
+minimatch.unescape = unescape;
+
+// src/cli/cmd/run/execute.ts
 var MAX_WORKER_COUNT = 10;
 async function execute(input2) {
   const effectiveConcurrency = Math.min(
@@ -6209,7 +7749,9 @@ function createWorkerTask(args) {
             const processableData = _lodash2.default.chain(sourceData).entries().filter(
               ([key, value]) => delta.added.includes(key) || delta.updated.includes(key) || !!args.ctx.flags.force
             ).filter(
-              ([key]) => !assignedTask.onlyKeys.length || assignedTask.onlyKeys.includes(key)
+              ([key]) => _optionalChain([assignedTask, 'access', _223 => _223.onlyKeys, 'optionalAccess', _224 => _224.some, 'call', _225 => _225(
+                (pattern) => minimatch(key, pattern)
+              )])
             ).fromPairs().value();
             if (!Object.keys(processableData).length) {
               return { status: "skipped" };
@@ -6296,13 +7838,13 @@ var flagsSchema2 = _zod.z.object({
 
 // src/cli/cmd/run/_utils.ts
 async function determineAuthId(ctx) {
-  const isByokMode = !!_optionalChain([ctx, 'access', _208 => _208.config, 'optionalAccess', _209 => _209.provider]);
+  const isByokMode = !!_optionalChain([ctx, 'access', _226 => _226.config, 'optionalAccess', _227 => _227.provider]);
   if (isByokMode) {
     return null;
   } else {
     try {
-      const authStatus = await _optionalChain([ctx, 'access', _210 => _210.localizer, 'optionalAccess', _211 => _211.checkAuth, 'call', _212 => _212()]);
-      return _optionalChain([authStatus, 'optionalAccess', _213 => _213.username]) || null;
+      const authStatus = await _optionalChain([ctx, 'access', _228 => _228.localizer, 'optionalAccess', _229 => _229.checkAuth, 'call', _230 => _230()]);
+      return _optionalChain([authStatus, 'optionalAccess', _231 => _231.username]) || null;
     } catch (e3) {
       return null;
     }
@@ -6327,7 +7869,7 @@ var run_default = new (0, _interactivecommander.Command)().command("run").descri
   (val, prev) => prev ? [...prev, val] : [val]
 ).option(
   "--key <key>",
-  "Key to process. Process only a specific translation key, useful for updating a single entry",
+  "Key to process. Process only a specific translation key, useful for updating a single entry. Accepts glob patterns.",
   (val, prev) => prev ? [...prev, val] : [val]
 ).option(
   "--force",
@@ -6450,7 +7992,7 @@ var InBranchFlow = class extends IntegrationFlow {
     _child_process.execSync.call(void 0, `git config --global safe.directory ${process.cwd()}`);
     _child_process.execSync.call(void 0, `git config user.name "${gitConfig.userName}"`);
     _child_process.execSync.call(void 0, `git config user.email "${gitConfig.userEmail}"`);
-    _optionalChain([this, 'access', _214 => _214.platformKit, 'optionalAccess', _215 => _215.gitConfig, 'call', _216 => _216()]);
+    _optionalChain([this, 'access', _232 => _232.platformKit, 'optionalAccess', _233 => _233.gitConfig, 'call', _234 => _234()]);
     _child_process.execSync.call(void 0, `git fetch origin ${baseBranchName}`, { stdio: "inherit" });
     _child_process.execSync.call(void 0, `git checkout ${baseBranchName} --`, { stdio: "inherit" });
     if (!processOwnCommits) {
@@ -6460,7 +8002,7 @@ var InBranchFlow = class extends IntegrationFlow {
       ).toString();
       if (authorOfLastCommit === currentAuthor) {
         this.ora.warn(
-          `The last commit was already made by ${currentAuthor}, so this run will be skipped, as running again would have no effect. See docs: https://docs.lingo.dev/ci-action/overview`
+          `The last commit was already made by ${currentAuthor}, so this run will be skipped, as running again would have no effect. See docs: https://lingo.dev/ci`
         );
         return false;
       }
@@ -6482,7 +8024,7 @@ var InBranchFlow = class extends IntegrationFlow {
 // src/cli/cmd/ci/flows/pull-request.ts
 var PullRequestFlow = class extends InBranchFlow {
   async preRun() {
-    const canContinue = await _optionalChain([super.preRun.bind(this), 'optionalCall', _217 => _217()]);
+    const canContinue = await _optionalChain([super.preRun.bind(this), 'optionalCall', _235 => _235()]);
     if (!canContinue) {
       return false;
     }
@@ -6737,10 +8279,10 @@ var BitbucketPlatformKit = class extends PlatformKit {
       repo_slug: this.platformConfig.repositoryName,
       state: "OPEN"
     }).then(({ data: { values } }) => {
-      return _optionalChain([values, 'optionalAccess', _218 => _218.find, 'call', _219 => _219(
-        ({ source, destination }) => _optionalChain([source, 'optionalAccess', _220 => _220.branch, 'optionalAccess', _221 => _221.name]) === branch && _optionalChain([destination, 'optionalAccess', _222 => _222.branch, 'optionalAccess', _223 => _223.name]) === this.platformConfig.baseBranchName
+      return _optionalChain([values, 'optionalAccess', _236 => _236.find, 'call', _237 => _237(
+        ({ source, destination }) => _optionalChain([source, 'optionalAccess', _238 => _238.branch, 'optionalAccess', _239 => _239.name]) === branch && _optionalChain([destination, 'optionalAccess', _240 => _240.branch, 'optionalAccess', _241 => _241.name]) === this.platformConfig.baseBranchName
       )]);
-    }).then((pr) => _optionalChain([pr, 'optionalAccess', _224 => _224.id]));
+    }).then((pr) => _optionalChain([pr, 'optionalAccess', _242 => _242.id]));
   }
   async closePullRequest({ pullRequestNumber }) {
     await this.bb.repositories.declinePullRequest({
@@ -6836,7 +8378,7 @@ var GitHubPlatformKit = class extends PlatformKit {
       repo: this.platformConfig.repositoryName,
       base: this.platformConfig.baseBranchName,
       state: "open"
-    }).then(({ data }) => data[0]).then((pr) => _optionalChain([pr, 'optionalAccess', _225 => _225.number]));
+    }).then(({ data }) => data[0]).then((pr) => _optionalChain([pr, 'optionalAccess', _243 => _243.number]));
   }
   async closePullRequest({ pullRequestNumber }) {
     await this.octokit.rest.pulls.update({
@@ -6963,7 +8505,7 @@ var GitlabPlatformKit = class extends PlatformKit {
       sourceBranch: branch,
       state: "opened"
     });
-    return _optionalChain([mergeRequests, 'access', _226 => _226[0], 'optionalAccess', _227 => _227.iid]);
+    return _optionalChain([mergeRequests, 'access', _244 => _244[0], 'optionalAccess', _245 => _245.iid]);
   }
   async closePullRequest({
     pullRequestNumber
@@ -7053,7 +8595,7 @@ var ci_default = new (0, _interactivecommander.Command)().command("ci").descript
   }
   const env = {
     LINGODOTDEV_API_KEY: settings.auth.apiKey,
-    LINGODOTDEV_PULL_REQUEST: _optionalChain([options, 'access', _228 => _228.pullRequest, 'optionalAccess', _229 => _229.toString, 'call', _230 => _230()]) || "false",
+    LINGODOTDEV_PULL_REQUEST: _optionalChain([options, 'access', _246 => _246.pullRequest, 'optionalAccess', _247 => _247.toString, 'call', _248 => _248()]) || "false",
     ...options.commitMessage && {
       LINGODOTDEV_COMMIT_MESSAGE: options.commitMessage
     },
@@ -7073,7 +8615,7 @@ var ci_default = new (0, _interactivecommander.Command)().command("ci").descript
   const { isPullRequestMode } = platformKit.config;
   ora.info(`Pull request mode: ${isPullRequestMode ? "on" : "off"}`);
   const flow = isPullRequestMode ? new PullRequestFlow(ora, platformKit) : new InBranchFlow(ora, platformKit);
-  const canRun = await _optionalChain([flow, 'access', _231 => _231.preRun, 'optionalCall', _232 => _232()]);
+  const canRun = await _optionalChain([flow, 'access', _249 => _249.preRun, 'optionalCall', _250 => _250()]);
   if (canRun === false) {
     return;
   }
@@ -7083,7 +8625,7 @@ var ci_default = new (0, _interactivecommander.Command)().command("ci").descript
   if (!hasChanges) {
     return;
   }
-  await _optionalChain([flow, 'access', _233 => _233.postRun, 'optionalCall', _234 => _234()]);
+  await _optionalChain([flow, 'access', _251 => _251.postRun, 'optionalCall', _252 => _252()]);
 });
 function parseBooleanArg(val) {
   if (val === true) return true;
@@ -7134,13 +8676,13 @@ var status_default = new (0, _interactivecommander.Command)().command("status").
       flags
     });
     let buckets = getBuckets(i18nConfig);
-    if (_optionalChain([flags, 'access', _235 => _235.bucket, 'optionalAccess', _236 => _236.length])) {
+    if (_optionalChain([flags, 'access', _253 => _253.bucket, 'optionalAccess', _254 => _254.length])) {
       buckets = buckets.filter((bucket) => flags.bucket.includes(bucket.type));
     }
     ora.succeed("Buckets retrieved");
-    if (_optionalChain([flags, 'access', _237 => _237.file, 'optionalAccess', _238 => _238.length])) {
+    if (_optionalChain([flags, 'access', _255 => _255.file, 'optionalAccess', _256 => _256.length])) {
       buckets = buckets.map((bucket) => {
-        const paths = bucket.paths.filter((path16) => flags.file.find((file) => _optionalChain([path16, 'access', _239 => _239.pathPattern, 'optionalAccess', _240 => _240.match, 'call', _241 => _241(file)])));
+        const paths = bucket.paths.filter((path17) => flags.file.find((file) => _optionalChain([path17, 'access', _257 => _257.pathPattern, 'optionalAccess', _258 => _258.match, 'call', _259 => _259(file)])));
         return { ...bucket, paths };
       }).filter((bucket) => bucket.paths.length > 0);
       if (buckets.length === 0) {
@@ -7150,13 +8692,13 @@ var status_default = new (0, _interactivecommander.Command)().command("status").
         ora.info(`\x1B[36mProcessing only filtered buckets:\x1B[0m`);
         buckets.map((bucket) => {
           ora.info(`  ${bucket.type}:`);
-          bucket.paths.forEach((path16) => {
-            ora.info(`    - ${path16.pathPattern}`);
+          bucket.paths.forEach((path17) => {
+            ora.info(`    - ${path17.pathPattern}`);
           });
         });
       }
     }
-    const targetLocales = _optionalChain([flags, 'access', _242 => _242.locale, 'optionalAccess', _243 => _243.length]) ? flags.locale : i18nConfig.locale.targets;
+    const targetLocales = _optionalChain([flags, 'access', _260 => _260.locale, 'optionalAccess', _261 => _261.length]) ? flags.locale : i18nConfig.locale.targets;
     let totalSourceKeyCount = 0;
     let uniqueKeysToTranslate = 0;
     let totalExistingTranslations = 0;
@@ -7235,11 +8777,11 @@ var status_default = new (0, _interactivecommander.Command)().command("status").
               );
             }
             if (!fileExists) {
-              fileStats[filePath].languageStats[targetLocale].missing = sourceKeys.length;
-              fileStats[filePath].languageStats[targetLocale].words = sourceWordCount;
-              languageStats[targetLocale].missing += sourceKeys.length;
-              languageStats[targetLocale].words += sourceWordCount;
-              totalWordCount.set(targetLocale, (totalWordCount.get(targetLocale) || 0) + sourceWordCount);
+              fileStats[filePath].languageStats[_targetLocale].missing = sourceKeys.length;
+              fileStats[filePath].languageStats[_targetLocale].words = sourceWordCount;
+              languageStats[_targetLocale].missing += sourceKeys.length;
+              languageStats[_targetLocale].words += sourceWordCount;
+              totalWordCount.set(_targetLocale, (totalWordCount.get(_targetLocale) || 0) + sourceWordCount);
               bucketOra.succeed(
                 `[${sourceLocale} -> ${targetLocale}] ${_chalk2.default.red(`0% complete`)} (0/${sourceKeys.length} keys) - file not found`
               );
@@ -7264,15 +8806,15 @@ var status_default = new (0, _interactivecommander.Command)().command("status").
                 wordsToTranslate += words;
               }
             }
-            fileStats[filePath].languageStats[targetLocale].missing = missingKeys.length;
-            fileStats[filePath].languageStats[targetLocale].updated = updatedKeys.length;
-            fileStats[filePath].languageStats[targetLocale].complete = completeKeys.length;
-            fileStats[filePath].languageStats[targetLocale].words = wordsToTranslate;
-            languageStats[targetLocale].missing += missingKeys.length;
-            languageStats[targetLocale].updated += updatedKeys.length;
-            languageStats[targetLocale].complete += completeKeys.length;
-            languageStats[targetLocale].words += wordsToTranslate;
-            totalWordCount.set(targetLocale, (totalWordCount.get(targetLocale) || 0) + wordsToTranslate);
+            fileStats[filePath].languageStats[_targetLocale].missing = missingKeys.length;
+            fileStats[filePath].languageStats[_targetLocale].updated = updatedKeys.length;
+            fileStats[filePath].languageStats[_targetLocale].complete = completeKeys.length;
+            fileStats[filePath].languageStats[_targetLocale].words = wordsToTranslate;
+            languageStats[_targetLocale].missing += missingKeys.length;
+            languageStats[_targetLocale].updated += updatedKeys.length;
+            languageStats[_targetLocale].complete += completeKeys.length;
+            languageStats[_targetLocale].words += wordsToTranslate;
+            totalWordCount.set(_targetLocale, (totalWordCount.get(_targetLocale) || 0) + wordsToTranslate);
             const totalKeysInFile = sourceKeys.length;
             const completionPercent = (completeKeys.length / totalKeysInFile * 100).toFixed(1);
             if (missingKeys.length === 0 && updatedKeys.length === 0) {
@@ -7380,10 +8922,10 @@ var status_default = new (0, _interactivecommander.Command)().command("status").
     if (flags.confirm && Object.keys(fileStats).length > 0) {
       console.log(_chalk2.default.bold(`
 \u{1F4D1} BREAKDOWN BY FILE:`));
-      Object.entries(fileStats).sort((a, b) => b[1].wordCount - a[1].wordCount).forEach(([path16, stats]) => {
+      Object.entries(fileStats).sort((a, b) => b[1].wordCount - a[1].wordCount).forEach(([path17, stats]) => {
         if (stats.sourceKeys === 0) return;
         console.log(_chalk2.default.bold(`
-\u2022 ${path16}:`));
+\u2022 ${path17}:`));
         console.log(`  ${stats.sourceKeys} source keys, ~${stats.wordCount.toLocaleString()} source words`);
         const fileTable = new (0, _clitable32.default)({
           head: ["Language", "Status", "Details"],
@@ -7497,12 +9039,12 @@ function validateParams2(i18nConfig, flags) {
       message: "No buckets found in i18n.json. Please add at least one bucket containing i18n content.",
       docUrl: "bucketNotFound"
     });
-  } else if (_optionalChain([flags, 'access', _244 => _244.locale, 'optionalAccess', _245 => _245.some, 'call', _246 => _246((locale) => !i18nConfig.locale.targets.includes(locale))])) {
+  } else if (_optionalChain([flags, 'access', _262 => _262.locale, 'optionalAccess', _263 => _263.some, 'call', _264 => _264((locale) => !i18nConfig.locale.targets.includes(locale))])) {
     throw new CLIError({
       message: `One or more specified locales do not exist in i18n.json locale.targets. Please add them to the list and try again.`,
       docUrl: "localeTargetNotFound"
     });
-  } else if (_optionalChain([flags, 'access', _247 => _247.bucket, 'optionalAccess', _248 => _248.some, 'call', _249 => _249((bucket) => !i18nConfig.buckets[bucket])])) {
+  } else if (_optionalChain([flags, 'access', _265 => _265.bucket, 'optionalAccess', _266 => _266.some, 'call', _267 => _267((bucket) => !i18nConfig.buckets[bucket])])) {
     throw new CLIError({
       message: `One or more specified buckets do not exist in i18n.json. Please add them to the list and try again.`,
       docUrl: "bucketNotFound"
@@ -7585,7 +9127,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.99.3",
+  version: "0.99.5",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {