npm - @effect/language-service - Versions diffs - 0.25.0 → 0.25.1 - Mend

@effect/language-service 0.25.0 → 0.25.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/cli.js CHANGED Viewed

@@ -1285,7 +1285,7 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   return [];
 });
 var dedupe = (self) => dedupeWith(self, equivalence());
-var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable(self).join(sep));
+var join = /* @__PURE__ */ dual(2, (self, sep2) => fromIterable(self).join(sep2));
 // node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/context.js
 var TagTypeId = /* @__PURE__ */ Symbol.for("effect/Context/Tag");
@@ -3064,12 +3064,12 @@ var prettyErrorStack = (message, stack, span2) => {
         const stack2 = stackFn();
         if (typeof stack2 === "string") {
           const locationMatchAll = stack2.matchAll(locationRegex);
-          let match18 = false;
+          let match19 = false;
           for (const [, location] of locationMatchAll) {
-            match18 = true;
+            match19 = true;
             out.push(`    at ${current.name} (${location})`);
           }
-          if (!match18) {
+          if (!match19) {
             out.push(`    at ${current.name} (${stack2.replace(/^at /, "")})`);
           }
         } else {
@@ -3123,9 +3123,9 @@ var decode = (input) => {
     }
     return nanos(BigInt(Math.round(input[0] * 1e9)) + BigInt(Math.round(input[1])));
   } else if (isString(input)) {
-    const match18 = DURATION_REGEX.exec(input);
-    if (match18) {
-      const [_, valueStr, unit] = match18;
+    const match19 = DURATION_REGEX.exec(input);
+    if (match19) {
+      const [_, valueStr, unit] = match19;
       const value5 = Number(valueStr);
       switch (unit) {
         case "nano":
@@ -5563,67 +5563,67 @@ var Or = (self, that) => {
   });
   return error4;
 };
-var InvalidData = (path2, message, options3 = {
+var InvalidData = (path3, message, options3 = {
   pathDelim: "."
 }) => {
   const error4 = Object.create(proto2);
   error4._op = OP_INVALID_DATA;
-  error4.path = path2;
+  error4.path = path3;
   error4.message = message;
   Object.defineProperty(error4, "toString", {
     enumerable: false,
     value() {
-      const path3 = pipe(this.path, join(options3.pathDelim));
-      return `(Invalid data at ${path3}: "${this.message}")`;
+      const path4 = pipe(this.path, join(options3.pathDelim));
+      return `(Invalid data at ${path4}: "${this.message}")`;
     }
   });
   return error4;
 };
-var MissingData = (path2, message, options3 = {
+var MissingData = (path3, message, options3 = {
   pathDelim: "."
 }) => {
   const error4 = Object.create(proto2);
   error4._op = OP_MISSING_DATA;
-  error4.path = path2;
+  error4.path = path3;
   error4.message = message;
   Object.defineProperty(error4, "toString", {
     enumerable: false,
     value() {
-      const path3 = pipe(this.path, join(options3.pathDelim));
-      return `(Missing data at ${path3}: "${this.message}")`;
+      const path4 = pipe(this.path, join(options3.pathDelim));
+      return `(Missing data at ${path4}: "${this.message}")`;
     }
   });
   return error4;
 };
-var SourceUnavailable = (path2, message, cause2, options3 = {
+var SourceUnavailable = (path3, message, cause2, options3 = {
   pathDelim: "."
 }) => {
   const error4 = Object.create(proto2);
   error4._op = OP_SOURCE_UNAVAILABLE;
-  error4.path = path2;
+  error4.path = path3;
   error4.message = message;
   error4.cause = cause2;
   Object.defineProperty(error4, "toString", {
     enumerable: false,
     value() {
-      const path3 = pipe(this.path, join(options3.pathDelim));
-      return `(Source unavailable at ${path3}: "${this.message}")`;
+      const path4 = pipe(this.path, join(options3.pathDelim));
+      return `(Source unavailable at ${path4}: "${this.message}")`;
     }
   });
   return error4;
 };
-var Unsupported = (path2, message, options3 = {
+var Unsupported = (path3, message, options3 = {
   pathDelim: "."
 }) => {
   const error4 = Object.create(proto2);
   error4._op = OP_UNSUPPORTED;
-  error4.path = path2;
+  error4.path = path3;
   error4.message = message;
   Object.defineProperty(error4, "toString", {
     enumerable: false,
     value() {
-      const path3 = pipe(this.path, join(options3.pathDelim));
-      return `(Unsupported operation at ${path3}: "${this.message}")`;
+      const path4 = pipe(this.path, join(options3.pathDelim));
+      return `(Unsupported operation at ${path4}: "${this.message}")`;
     }
   });
   return error4;
@@ -5739,9 +5739,9 @@ var isMissingDataOnly = (self) => reduceWithContext2(self, void 0, IsMissingData
 var empty16 = {
   _tag: "Empty"
 };
-var patch5 = /* @__PURE__ */ dual(2, (path2, patch9) => {
+var patch5 = /* @__PURE__ */ dual(2, (path3, patch9) => {
   let input = of3(patch9);
-  let output = path2;
+  let output = path3;
   while (isCons(input)) {
     const patch10 = input.head;
     switch (patch10._tag) {
@@ -5808,7 +5808,7 @@ var make21 = (options3) => ({
 var makeFlat = (options3) => ({
   [FlatConfigProviderTypeId]: FlatConfigProviderTypeId,
   patch: options3.patch,
-  load: (path2, config2, split2 = true) => options3.load(path2, config2, split2),
+  load: (path3, config2, split2 = true) => options3.load(path3, config2, split2),
   enumerateChildren: options3.enumerateChildren
 });
 var fromFlat = (flat) => make21({
@@ -5826,29 +5826,29 @@ var fromEnv = (options3) => {
     pathDelim: "_",
     seqDelim: ","
   }, options3);
-  const makePathString = (path2) => pipe(path2, join(pathDelim));
+  const makePathString = (path3) => pipe(path3, join(pathDelim));
   const unmakePathString = (pathString) => pathString.split(pathDelim);
   const getEnv = () => typeof process !== "undefined" && "env" in process && typeof process.env === "object" ? process.env : {};
-  const load = (path2, primitive2, split2 = true) => {
-    const pathString = makePathString(path2);
+  const load = (path3, primitive2, split2 = true) => {
+    const pathString = makePathString(path3);
     const current = getEnv();
     const valueOpt = pathString in current ? some2(current[pathString]) : none2();
-    return pipe(valueOpt, mapError(() => MissingData(path2, `Expected ${pathString} to exist in the process context`)), flatMap7((value5) => parsePrimitive(value5, path2, primitive2, seqDelim, split2)));
+    return pipe(valueOpt, mapError(() => MissingData(path3, `Expected ${pathString} to exist in the process context`)), flatMap7((value5) => parsePrimitive(value5, path3, primitive2, seqDelim, split2)));
   };
-  const enumerateChildren = (path2) => sync(() => {
+  const enumerateChildren = (path3) => sync(() => {
     const current = getEnv();
     const keys5 = Object.keys(current);
     const keyPaths = keys5.map((value5) => unmakePathString(value5.toUpperCase()));
     const filteredKeyPaths = keyPaths.filter((keyPath) => {
-      for (let i = 0; i < path2.length; i++) {
-        const pathComponent = pipe(path2, unsafeGet(i));
+      for (let i = 0; i < path3.length; i++) {
+        const pathComponent = pipe(path3, unsafeGet(i));
         const currentElement = keyPath[i];
         if (currentElement === void 0 || pathComponent !== currentElement) {
           return false;
         }
       }
       return true;
-    }).flatMap((keyPath) => keyPath.slice(path2.length, path2.length + 1));
+    }).flatMap((keyPath) => keyPath.slice(path3.length, path3.length + 1));
     return fromIterable5(filteredKeyPaths);
   });
   return fromFlat(makeFlat({
@@ -5864,17 +5864,17 @@ var extend = (leftDef, rightDef, left3, right3) => {
   const rightExtension = concat(right3, rightPad);
   return [leftExtension, rightExtension];
 };
-var appendConfigPath = (path2, config2) => {
+var appendConfigPath = (path3, config2) => {
   let op = config2;
   if (op._tag === "Nested") {
-    const out = path2.slice();
+    const out = path3.slice();
     while (op._tag === "Nested") {
       out.push(op.name);
       op = op.config;
     }
     return out;
   }
-  return path2;
+  return path3;
 };
 var fromFlatLoop = (flat, prefix, config2, split2) => {
   const op = config2;
@@ -5950,8 +5950,8 @@ var fromFlatLoop = (flat, prefix, config2, split2) => {
           return fail2(right3.left);
         }
         if (isRight2(left3) && isRight2(right3)) {
-          const path2 = pipe(prefix, join("."));
-          const fail19 = fromFlatLoopFail(prefix, path2);
+          const path3 = pipe(prefix, join("."));
+          const fail19 = fromFlatLoopFail(prefix, path3);
           const [lefts, rights] = extend(fail19, fail19, pipe(left3.right, map3(right2)), pipe(right3.right, map3(right2)));
           return pipe(lefts, zip(rights), forEachSequential(([left4, right4]) => pipe(zip2(left4, right4), map10(([left5, right5]) => op.zip(left5, right5)))));
         }
@@ -5960,19 +5960,19 @@ var fromFlatLoop = (flat, prefix, config2, split2) => {
     }
   }
 };
-var fromFlatLoopFail = (prefix, path2) => (index) => left2(MissingData(prefix, `The element at index ${index} in a sequence at path "${path2}" was missing`));
-var splitPathString = (text8, delim) => {
-  const split2 = text8.split(new RegExp(`\\s*${escape(delim)}\\s*`));
+var fromFlatLoopFail = (prefix, path3) => (index) => left2(MissingData(prefix, `The element at index ${index} in a sequence at path "${path3}" was missing`));
+var splitPathString = (text9, delim) => {
+  const split2 = text9.split(new RegExp(`\\s*${escape(delim)}\\s*`));
   return split2;
 };
-var parsePrimitive = (text8, path2, primitive2, delimiter, split2) => {
+var parsePrimitive = (text9, path3, primitive2, delimiter, split2) => {
   if (!split2) {
-    return pipe(primitive2.parse(text8), mapBoth2({
-      onFailure: prefixed(path2),
+    return pipe(primitive2.parse(text9), mapBoth2({
+      onFailure: prefixed(path3),
       onSuccess: of
     }));
   }
-  return pipe(splitPathString(text8, delimiter), forEachSequential((char4) => primitive2.parse(char4.trim())), mapError(prefixed(path2)));
+  return pipe(splitPathString(text9, delimiter), forEachSequential((char4) => primitive2.parse(char4.trim())), mapError(prefixed(path3)));
 };
 var transpose = (array7) => {
   return Object.keys(array7[0]).map((column3) => array7.map((row) => row[column3]));
@@ -5983,9 +5983,9 @@ var indicesFrom = (quotedIndices) => pipe(forEachSequential(quotedIndices, parse
 }), either2, map10(merge));
 var QUOTED_INDEX_REGEX = /^(\[(\d+)\])$/;
 var parseQuotedIndex = (str) => {
-  const match18 = str.match(QUOTED_INDEX_REGEX);
-  if (match18 !== null) {
-    const matchedIndex = match18[2];
+  const match19 = str.match(QUOTED_INDEX_REGEX);
+  if (match19 !== null) {
+    const matchedIndex = match19[2];
     return pipe(matchedIndex !== void 0 && matchedIndex.length > 0 ? some2(matchedIndex) : none2(), flatMap(parseInteger));
   }
   return none2();
@@ -7912,14 +7912,14 @@ var structuredMessage = (u) => {
     }
   }
 };
-var withColor = (text8, ...colors2) => {
+var withColor = (text9, ...colors2) => {
   let out = "";
   for (let i = 0; i < colors2.length; i++) {
     out += `\x1B[${colors2[i]}m`;
   }
-  return out + text8 + "\x1B[0m";
+  return out + text9 + "\x1B[0m";
 };
-var withColorNoop = (text8, ..._colors) => text8;
+var withColorNoop = (text9, ..._colors) => text9;
 var colors = {
   bold: "1",
   red: "31",
@@ -13692,10 +13692,10 @@ var char = (char4) => {
   op.char = char4;
   return op;
 };
-var text = (text8) => {
+var text = (text9) => {
   const op = Object.create(proto5);
   op._tag = "Text";
-  op.text = text8;
+  op.text = text9;
   return op;
 };
 var flatAlt = /* @__PURE__ */ dual(2, (self, that) => {
@@ -13988,10 +13988,10 @@ var char2 = /* @__PURE__ */ dual(2, (self, char4) => {
   op.stream = self;
   return op;
 });
-var text2 = /* @__PURE__ */ dual(2, (self, text8) => {
+var text2 = /* @__PURE__ */ dual(2, (self, text9) => {
   const op = Object.create(proto6);
   op._tag = "TextStream";
-  op.text = text8;
+  op.text = text9;
   op.stream = self;
   return op;
 });
@@ -14812,8 +14812,8 @@ var make44 = (bytes) => {
   redactedRegistry.set(secret4, bytes.map((byte) => String.fromCharCode(byte)).join(""));
   return secret4;
 };
-var fromString = (text8) => {
-  return make44(text8.split("").map((char4) => char4.charCodeAt(0)));
+var fromString = (text9) => {
+  return make44(text9.split("").map((char4) => char4.charCodeAt(0)));
 };
 // node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/config.js
@@ -14904,14 +14904,14 @@ var formatPropertyKey = (name) => typeof name === "string" ? JSON.stringify(name
 var isNonEmpty5 = (x) => Array.isArray(x);
 var isSingle = (x) => !Array.isArray(x);
 var formatPathKey = (key) => `[${formatPropertyKey(key)}]`;
-var formatPath = (path2) => isNonEmpty5(path2) ? path2.map(formatPathKey).join("") : formatPathKey(path2);
+var formatPath = (path3) => isNonEmpty5(path3) ? path3.map(formatPathKey).join("") : formatPathKey(path3);
 // node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/schema/errors.js
-var getErrorMessage = (reason, details, path2, ast) => {
+var getErrorMessage = (reason, details, path3, ast) => {
   let out = reason;
-  if (path2 && isNonEmptyReadonlyArray(path2)) {
+  if (path3 && isNonEmptyReadonlyArray(path3)) {
     out += `
-at path: ${formatPath(path2)}`;
+at path: ${formatPath(path3)}`;
   }
   if (details !== void 0) {
     out += `
@@ -14923,7 +14923,7 @@ schema (${ast._tag}): ${ast}`;
   }
   return out;
 };
-var getSchemaExtendErrorMessage = (x, y, path2) => getErrorMessage("Unsupported schema or overlapping types", `cannot extend ${x} with ${y}`, path2);
+var getSchemaExtendErrorMessage = (x, y, path3) => getErrorMessage("Unsupported schema or overlapping types", `cannot extend ${x} with ${y}`, path3);
 var getASTUnsupportedKeySchemaErrorMessage = (ast) => getErrorMessage("Unsupported key schema", void 0, void 0, ast);
 var getASTUnsupportedLiteralErrorMessage = (literal2) => getErrorMessage("Unsupported literal", `literal value: ${formatUnknown(literal2)}`);
 var getASTDuplicateIndexSignatureErrorMessage = (type2) => getErrorMessage("Duplicate index signature", `${type2} index signature`);
@@ -15762,8 +15762,8 @@ var unify = (candidates) => {
 var Union = class _Union {
   types;
   annotations;
-  static make = (types, annotations2) => {
-    return isMembers(types) ? new _Union(types, annotations2) : types.length === 1 ? types[0] : neverKeyword;
+  static make = (types2, annotations2) => {
+    return isMembers(types2) ? new _Union(types2, annotations2) : types2.length === 1 ? types2[0] : neverKeyword;
   };
   /** @internal */
   static unify = (candidates, annotations2) => {
@@ -15773,8 +15773,8 @@ var Union = class _Union {
    * @since 3.10.0
    */
   _tag = "Union";
-  constructor(types, annotations2 = {}) {
-    this.types = types;
+  constructor(types2, annotations2 = {}) {
+    this.types = types2;
     this.annotations = annotations2;
   }
   /**
@@ -15845,9 +15845,9 @@ var Refinement = class {
    * @since 3.10.0
    */
   _tag = "Refinement";
-  constructor(from, filter11, annotations2 = {}) {
+  constructor(from, filter12, annotations2 = {}) {
     this.from = from;
-    this.filter = filter11;
+    this.filter = filter12;
     this.annotations = annotations2;
   }
   /**
@@ -16110,8 +16110,8 @@ var typeAST = (ast) => {
       return propertySignatures === ast.propertySignatures && indexSignatures === ast.indexSignatures ? ast : new TypeLiteral(propertySignatures, indexSignatures, ast.annotations);
     }
     case "Union": {
-      const types = changeMap(ast.types, typeAST);
-      return types === ast.types ? ast : Union.make(types, ast.annotations);
+      const types2 = changeMap(ast.types, typeAST);
+      return types2 === ast.types ? ast : Union.make(types2, ast.annotations);
     }
     case "Suspend":
       return new Suspend(() => typeAST(ast.f()), ast.annotations);
@@ -16182,8 +16182,8 @@ var encodedAST_ = (ast, isBound) => {
       return propertySignatures === ast.propertySignatures && indexSignatures === ast.indexSignatures ? ast : new TypeLiteral(propertySignatures, indexSignatures, createJSONIdentifierAnnotation(ast));
     }
     case "Union": {
-      const types = changeMap(ast.types, (ast2) => encodedAST_(ast2, isBound));
-      return types === ast.types ? ast : Union.make(types, createJSONIdentifierAnnotation(ast));
+      const types2 = changeMap(ast.types, (ast2) => encodedAST_(ast2, isBound));
+      return types2 === ast.types ? ast : Union.make(types2, createJSONIdentifierAnnotation(ast));
     }
     case "Suspend":
       return new Suspend(() => encodedAST_(ast.f(), isBound), createJSONIdentifierAnnotation(ast));
@@ -16245,8 +16245,8 @@ var Pointer = class {
    * @since 3.10.0
    */
   _tag = "Pointer";
-  constructor(path2, actual, issue) {
-    this.path = path2;
+  constructor(path3, actual, issue) {
+    this.path = path3;
     this.actual = actual;
     this.issue = issue;
   }
@@ -17356,7 +17356,7 @@ var defaultConfig = {
   showBuiltIns: true,
   showTypes: true
 };
-var normalizeCase = /* @__PURE__ */ dual(2, (self, text8) => self.isCaseSensitive ? text8 : text8.toLowerCase());
+var normalizeCase = /* @__PURE__ */ dual(2, (self, text9) => self.isCaseSensitive ? text9 : text9.toLowerCase());
 // node_modules/.pnpm/@effect+cli@0.66.12_@effect+platform@0.87.12_@effect+printer-ansi@0.44.12_@effect+printer@0.44.12_effect@3.16.12/node_modules/@effect/cli/dist/esm/internal/autoCorrect.js
 var levensteinDistance = (first3, second, config2) => {
@@ -20240,7 +20240,7 @@ function makeTypeLiteralClass(fields, records, ast = getDefaultTypeLiteralAST(fi
 function Struct(fields, ...records) {
   return makeTypeLiteralClass(fields, records);
 }
-var intersectTypeLiterals = (x, y, path2) => {
+var intersectTypeLiterals = (x, y, path3) => {
   if (isTypeLiteral(x) && isTypeLiteral(y)) {
     const propertySignatures = [...x.propertySignatures];
     for (const ps of y.propertySignatures) {
@@ -20253,18 +20253,18 @@ var intersectTypeLiterals = (x, y, path2) => {
           isOptional,
           type: type2
         } = propertySignatures[i];
-        propertySignatures[i] = new PropertySignature(name, extendAST(type2, ps.type, path2.concat(name)), isOptional, true);
+        propertySignatures[i] = new PropertySignature(name, extendAST(type2, ps.type, path3.concat(name)), isOptional, true);
       }
     }
     return new TypeLiteral(propertySignatures, x.indexSignatures.concat(y.indexSignatures));
   }
-  throw new Error(getSchemaExtendErrorMessage(x, y, path2));
+  throw new Error(getSchemaExtendErrorMessage(x, y, path3));
 };
 var preserveRefinementAnnotations = /* @__PURE__ */ omitAnnotations([IdentifierAnnotationId]);
 var addRefinementToMembers = (refinement, asts) => asts.map((ast) => new Refinement(ast, refinement.filter, preserveRefinementAnnotations(refinement)));
-var extendAST = (x, y, path2) => Union.make(intersectUnionMembers([x], [y], path2));
+var extendAST = (x, y, path3) => Union.make(intersectUnionMembers([x], [y], path3));
 var getTypes = (ast) => isUnion3(ast) ? ast.types : [ast];
-var intersectUnionMembers = (xs, ys, path2) => flatMap2(xs, (x) => flatMap2(ys, (y) => {
+var intersectUnionMembers = (xs, ys, path3) => flatMap2(xs, (x) => flatMap2(ys, (y) => {
   switch (y._tag) {
     case "Literal": {
       if (isString(y.literal) && isStringKeyword(x) || isNumber(y.literal) && isNumberKeyword(x) || isBoolean(y.literal) && isBooleanKeyword(x)) {
@@ -20277,7 +20277,7 @@ var intersectUnionMembers = (xs, ys, path2) => flatMap2(xs, (x) => flatMap2(ys,
         if (isStringKeyword(x) || isLiteral(x) && isString(x.literal)) {
           return [x];
         } else if (isRefinement(x)) {
-          return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path2));
+          return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path3));
         }
       } else if (x === stringKeyword) {
         return [y];
@@ -20289,7 +20289,7 @@ var intersectUnionMembers = (xs, ys, path2) => flatMap2(xs, (x) => flatMap2(ys,
         if (isNumberKeyword(x) || isLiteral(x) && isNumber(x.literal)) {
           return [x];
         } else if (isRefinement(x)) {
-          return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path2));
+          return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path3));
         }
       } else if (x === numberKeyword) {
         return [y];
@@ -20301,7 +20301,7 @@ var intersectUnionMembers = (xs, ys, path2) => flatMap2(xs, (x) => flatMap2(ys,
         if (isBooleanKeyword(x) || isLiteral(x) && isBoolean(x.literal)) {
           return [x];
         } else if (isRefinement(x)) {
-          return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path2));
+          return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path3));
         }
       } else if (x === booleanKeyword) {
         return [y];
@@ -20309,25 +20309,25 @@ var intersectUnionMembers = (xs, ys, path2) => flatMap2(xs, (x) => flatMap2(ys,
       break;
     }
     case "Union":
-      return intersectUnionMembers(getTypes(x), y.types, path2);
+      return intersectUnionMembers(getTypes(x), y.types, path3);
     case "Suspend":
-      return [new Suspend(() => extendAST(x, y.f(), path2))];
+      return [new Suspend(() => extendAST(x, y.f(), path3))];
     case "Refinement":
-      return addRefinementToMembers(y, intersectUnionMembers(getTypes(x), getTypes(y.from), path2));
+      return addRefinementToMembers(y, intersectUnionMembers(getTypes(x), getTypes(y.from), path3));
     case "TypeLiteral": {
       switch (x._tag) {
         case "Union":
-          return intersectUnionMembers(x.types, [y], path2);
+          return intersectUnionMembers(x.types, [y], path3);
         case "Suspend":
-          return [new Suspend(() => extendAST(x.f(), y, path2))];
+          return [new Suspend(() => extendAST(x.f(), y, path3))];
         case "Refinement":
-          return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path2));
+          return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path3));
         case "TypeLiteral":
-          return [intersectTypeLiterals(x, y, path2)];
+          return [intersectTypeLiterals(x, y, path3)];
         case "Transformation": {
           const transformation = x.transformation;
-          const from = intersectTypeLiterals(x.from, y, path2);
-          const to = intersectTypeLiterals(x.to, typeAST(y), path2);
+          const from = intersectTypeLiterals(x.from, y, path3);
+          const to = intersectTypeLiterals(x.to, typeAST(y), path3);
           switch (transformation._tag) {
             case "TypeLiteralTransformation":
               return [new Transformation(from, to, new TypeLiteralTransformation(transformation.propertySignatureTransformations))];
@@ -20349,28 +20349,28 @@ var intersectUnionMembers = (xs, ys, path2) => flatMap2(xs, (x) => flatMap2(ys,
     case "Transformation": {
       if (isTransformation(x)) {
         if (isTypeLiteralTransformation(y.transformation) && isTypeLiteralTransformation(x.transformation)) {
-          return [new Transformation(intersectTypeLiterals(x.from, y.from, path2), intersectTypeLiterals(x.to, y.to, path2), new TypeLiteralTransformation(y.transformation.propertySignatureTransformations.concat(x.transformation.propertySignatureTransformations)))];
+          return [new Transformation(intersectTypeLiterals(x.from, y.from, path3), intersectTypeLiterals(x.to, y.to, path3), new TypeLiteralTransformation(y.transformation.propertySignatureTransformations.concat(x.transformation.propertySignatureTransformations)))];
         }
       } else {
-        return intersectUnionMembers([y], [x], path2);
+        return intersectUnionMembers([y], [x], path3);
       }
       break;
     }
   }
-  throw new Error(getSchemaExtendErrorMessage(x, y, path2));
+  throw new Error(getSchemaExtendErrorMessage(x, y, path3));
 }));
 var extend3 = /* @__PURE__ */ dual(2, (self, that) => make50(extendAST(self.ast, that.ast, [])));
 var compose3 = /* @__PURE__ */ dual((args3) => isSchema(args3[1]), (from, to) => makeTransformationClass(from, to, compose(from.ast, to.ast)));
 var suspend10 = (f) => make50(new Suspend(() => f().ast));
 var RefineSchemaId = /* @__PURE__ */ Symbol.for("effect/SchemaId/Refine");
-function makeRefineClass(from, filter11, ast) {
+function makeRefineClass(from, filter12, ast) {
   return class RefineClass extends make50(ast) {
     static annotations(annotations2) {
       return makeRefineClass(this.from, this.filter, mergeSchemaAnnotations(this.ast, annotations2));
     }
     static [RefineSchemaId] = from;
     static from = from;
-    static filter = filter11;
+    static filter = filter12;
     static make = (a, options3) => {
       return getDisableValidationMakeOption(options3) ? a : validateSync(this)(a);
     };
@@ -20406,11 +20406,11 @@ var toFilterParseIssue = (out, ast, input) => {
 };
 function filter10(predicate, annotations2) {
   return (self) => {
-    function filter11(input, options3, ast2) {
+    function filter12(input, options3, ast2) {
       return toFilterParseIssue(predicate(input, options3, ast2), ast2, input);
     }
-    const ast = new Refinement(self.ast, filter11, toASTAnnotations(annotations2));
-    return makeRefineClass(self, filter11, ast);
+    const ast = new Refinement(self.ast, filter12, toASTAnnotations(annotations2));
+    return makeRefineClass(self, filter12, ast);
   };
 }
 function makeTransformationClass(from, to, ast) {
@@ -21055,8 +21055,8 @@ var bigintPiB = bigint1024 * bigint1024 * bigint1024 * bigint1024 * bigint1024;
 var make51 = (impl) => {
   return tag.of({
     ...impl,
-    exists: (path2) => pipe(impl.access(path2), as4(true), catchTag2("SystemError", (e) => e.reason === "NotFound" ? succeed7(false) : fail7(e))),
-    readFileString: (path2, encoding) => tryMap2(impl.readFile(path2), {
+    exists: (path3) => pipe(impl.access(path3), as4(true), catchTag2("SystemError", (e) => e.reason === "NotFound" ? succeed7(false) : fail7(e))),
+    readFileString: (path3, encoding) => tryMap2(impl.readFile(path3), {
       try: (_) => new TextDecoder(encoding).decode(_),
       catch: (cause2) => new BadArgument({
         module: "FileSystem",
@@ -21065,14 +21065,14 @@ var make51 = (impl) => {
         cause: cause2
       })
     }),
-    stream: (path2, options3) => pipe(impl.open(path2, {
+    stream: (path3, options3) => pipe(impl.open(path3, {
       flag: "r"
     }), options3?.offset ? tap2((file3) => file3.seek(options3.offset, "start")) : identity, map16((file3) => stream(file3, options3)), unwrapScoped6),
-    sink: (path2, options3) => pipe(impl.open(path2, {
+    sink: (path3, options3) => pipe(impl.open(path3, {
       flag: "w",
       ...options3
     }), map16((file3) => forEach10((_) => file3.writeAll(_))), unwrapScoped5),
-    writeFileString: (path2, data, options3) => flatMap9(try_2({
+    writeFileString: (path3, data, options3) => flatMap9(try_2({
       try: () => new TextEncoder().encode(data),
       catch: (cause2) => new BadArgument({
         module: "FileSystem",
@@ -21080,7 +21080,7 @@ var make51 = (impl) => {
         description: "could not encode string",
         cause: cause2
       })
-    }), (_) => impl.writeFile(path2, _, options3))
+    }), (_) => impl.writeFile(path3, _, options3))
   });
 };
 var stream = (file3, {
@@ -21383,12 +21383,12 @@ var windowsFigures = {
   pointer: /* @__PURE__ */ text3(">")
 };
 var figures = /* @__PURE__ */ map16(/* @__PURE__ */ sync4(() => process.platform === "win32"), (isWindows) => isWindows ? windowsFigures : defaultFigures);
-function eraseText(text8, columns) {
+function eraseText(text9, columns) {
   if (columns === 0) {
     return cat2(eraseLine3, cursorTo3(0));
   }
   let rows = 0;
-  const lines3 = text8.split(/\r?\n/);
+  const lines3 = text9.split(/\r?\n/);
   for (const line4 of lines3) {
     rows += 1 + Math.floor(Math.max(line4.length - 1, 0) / columns);
   }
@@ -21672,10 +21672,10 @@ var makeDateParts = (dateMask, date5, locales) => {
   const parts2 = [];
   let result = null;
   while (result = DATE_PART_REGEX.exec(dateMask)) {
-    const match18 = result.shift();
+    const match19 = result.shift();
     const index = result.findIndex((group4) => group4 !== void 0);
     if (index in regexGroups) {
-      const token = result[index] || match18;
+      const token = result[index] || match19;
       parts2.push(regexGroups[index]({
         token,
         date: date5,
@@ -21684,7 +21684,7 @@ var makeDateParts = (dateMask, date5, locales) => {
       }));
     } else {
       parts2.push(new Token({
-        token: result[index] || match18,
+        token: result[index] || match19,
         date: date5,
         parts: parts2,
         locales
@@ -21879,15 +21879,15 @@ var Meridiem = class extends DatePart {
 // node_modules/.pnpm/@effect+platform@0.87.12_effect@3.16.12/node_modules/@effect/platform/dist/esm/internal/path.js
 var TypeId19 = /* @__PURE__ */ Symbol.for("@effect/platform/Path");
 var Path = /* @__PURE__ */ GenericTag("@effect/platform/Path");
-function normalizeStringPosix(path2, allowAboveRoot) {
+function normalizeStringPosix(path3, allowAboveRoot) {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let code2;
-  for (let i = 0; i <= path2.length; ++i) {
-    if (i < path2.length) {
-      code2 = path2.charCodeAt(i);
+  for (let i = 0; i <= path3.length; ++i) {
+    if (i < path3.length) {
+      code2 = path3.charCodeAt(i);
     } else if (code2 === 47) {
       break;
     } else {
@@ -21929,9 +21929,9 @@ function normalizeStringPosix(path2, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += "/" + path2.slice(lastSlash + 1, i);
+          res += "/" + path3.slice(lastSlash + 1, i);
         } else {
-          res = path2.slice(lastSlash + 1, i);
+          res = path3.slice(lastSlash + 1, i);
         }
         lastSegmentLength = i - lastSlash - 1;
       }
@@ -21946,7 +21946,7 @@ function normalizeStringPosix(path2, allowAboveRoot) {
   }
   return res;
 }
-function _format(sep, pathObject) {
+function _format(sep2, pathObject) {
   const dir2 = pathObject.dir || pathObject.root;
   const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
   if (!dir2) {
@@ -21955,7 +21955,7 @@ function _format(sep, pathObject) {
   if (dir2 === pathObject.root) {
     return dir2 + base;
   }
-  return dir2 + sep + base;
+  return dir2 + sep2 + base;
 }
 function fromFileUrl(url2) {
   if (url2.protocol !== "file:") {
@@ -21991,21 +21991,21 @@ var resolve = function resolve2() {
   let resolvedAbsolute = false;
   let cwd = void 0;
   for (let i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    let path2;
+    let path3;
     if (i >= 0) {
-      path2 = arguments[i];
+      path3 = arguments[i];
     } else {
       const process2 = globalThis.process;
       if (cwd === void 0 && "process" in globalThis && typeof process2 === "object" && process2 !== null && typeof process2.cwd === "function") {
         cwd = process2.cwd();
       }
-      path2 = cwd;
+      path3 = cwd;
     }
-    if (path2.length === 0) {
+    if (path3.length === 0) {
       continue;
     }
-    resolvedPath = path2 + "/" + resolvedPath;
-    resolvedAbsolute = path2.charCodeAt(0) === 47;
+    resolvedPath = path3 + "/" + resolvedPath;
+    resolvedAbsolute = path3.charCodeAt(0) === 47;
   }
   resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
   if (resolvedAbsolute) {
@@ -22057,18 +22057,18 @@ function encodePathChars(filepath) {
 var posixImpl = /* @__PURE__ */ Path.of({
   [TypeId19]: TypeId19,
   resolve,
-  normalize(path2) {
-    if (path2.length === 0) return ".";
-    const isAbsolute = path2.charCodeAt(0) === 47;
-    const trailingSeparator = path2.charCodeAt(path2.length - 1) === 47;
-    path2 = normalizeStringPosix(path2, !isAbsolute);
-    if (path2.length === 0 && !isAbsolute) path2 = ".";
-    if (path2.length > 0 && trailingSeparator) path2 += "/";
-    if (isAbsolute) return "/" + path2;
-    return path2;
+  normalize(path3) {
+    if (path3.length === 0) return ".";
+    const isAbsolute = path3.charCodeAt(0) === 47;
+    const trailingSeparator = path3.charCodeAt(path3.length - 1) === 47;
+    path3 = normalizeStringPosix(path3, !isAbsolute);
+    if (path3.length === 0 && !isAbsolute) path3 = ".";
+    if (path3.length > 0 && trailingSeparator) path3 += "/";
+    if (isAbsolute) return "/" + path3;
+    return path3;
   },
-  isAbsolute(path2) {
-    return path2.length > 0 && path2.charCodeAt(0) === 47;
+  isAbsolute(path3) {
+    return path3.length > 0 && path3.charCodeAt(0) === 47;
   },
   join() {
     if (arguments.length === 0) {
@@ -22160,14 +22160,14 @@ var posixImpl = /* @__PURE__ */ Path.of({
       return to.slice(toStart);
     }
   },
-  dirname(path2) {
-    if (path2.length === 0) return ".";
-    let code2 = path2.charCodeAt(0);
+  dirname(path3) {
+    if (path3.length === 0) return ".";
+    let code2 = path3.charCodeAt(0);
     const hasRoot = code2 === 47;
     let end5 = -1;
     let matchedSlash = true;
-    for (let i = path2.length - 1; i >= 1; --i) {
-      code2 = path2.charCodeAt(i);
+    for (let i = path3.length - 1; i >= 1; --i) {
+      code2 = path3.charCodeAt(i);
       if (code2 === 47) {
         if (!matchedSlash) {
           end5 = i;
@@ -22179,19 +22179,19 @@ var posixImpl = /* @__PURE__ */ Path.of({
     }
     if (end5 === -1) return hasRoot ? "/" : ".";
     if (hasRoot && end5 === 1) return "//";
-    return path2.slice(0, end5);
+    return path3.slice(0, end5);
   },
-  basename(path2, ext) {
+  basename(path3, ext2) {
     let start4 = 0;
     let end5 = -1;
     let matchedSlash = true;
     let i;
-    if (ext !== void 0 && ext.length > 0 && ext.length <= path2.length) {
-      if (ext.length === path2.length && ext === path2) return "";
-      let extIdx = ext.length - 1;
+    if (ext2 !== void 0 && ext2.length > 0 && ext2.length <= path3.length) {
+      if (ext2.length === path3.length && ext2 === path3) return "";
+      let extIdx = ext2.length - 1;
       let firstNonSlashEnd = -1;
-      for (i = path2.length - 1; i >= 0; --i) {
-        const code2 = path2.charCodeAt(i);
+      for (i = path3.length - 1; i >= 0; --i) {
+        const code2 = path3.charCodeAt(i);
         if (code2 === 47) {
           if (!matchedSlash) {
             start4 = i + 1;
@@ -22203,7 +22203,7 @@ var posixImpl = /* @__PURE__ */ Path.of({
             firstNonSlashEnd = i + 1;
           }
           if (extIdx >= 0) {
-            if (code2 === ext.charCodeAt(extIdx)) {
+            if (code2 === ext2.charCodeAt(extIdx)) {
               if (--extIdx === -1) {
                 end5 = i;
               }
@@ -22215,11 +22215,11 @@ var posixImpl = /* @__PURE__ */ Path.of({
         }
       }
       if (start4 === end5) end5 = firstNonSlashEnd;
-      else if (end5 === -1) end5 = path2.length;
-      return path2.slice(start4, end5);
+      else if (end5 === -1) end5 = path3.length;
+      return path3.slice(start4, end5);
     } else {
-      for (i = path2.length - 1; i >= 0; --i) {
-        if (path2.charCodeAt(i) === 47) {
+      for (i = path3.length - 1; i >= 0; --i) {
+        if (path3.charCodeAt(i) === 47) {
           if (!matchedSlash) {
             start4 = i + 1;
             break;
@@ -22230,17 +22230,17 @@ var posixImpl = /* @__PURE__ */ Path.of({
         }
       }
       if (end5 === -1) return "";
-      return path2.slice(start4, end5);
+      return path3.slice(start4, end5);
     }
   },
-  extname(path2) {
+  extname(path3) {
     let startDot = -1;
     let startPart = 0;
     let end5 = -1;
     let matchedSlash = true;
     let preDotState = 0;
-    for (let i = path2.length - 1; i >= 0; --i) {
-      const code2 = path2.charCodeAt(i);
+    for (let i = path3.length - 1; i >= 0; --i) {
+      const code2 = path3.charCodeAt(i);
       if (code2 === 47) {
         if (!matchedSlash) {
           startPart = i + 1;
@@ -22267,7 +22267,7 @@ var posixImpl = /* @__PURE__ */ Path.of({
     preDotState === 1 && startDot === end5 - 1 && startDot === startPart + 1) {
       return "";
     }
-    return path2.slice(startDot, end5);
+    return path3.slice(startDot, end5);
   },
   format: function format5(pathObject) {
     if (pathObject === null || typeof pathObject !== "object") {
@@ -22275,7 +22275,7 @@ var posixImpl = /* @__PURE__ */ Path.of({
     }
     return _format("/", pathObject);
   },
-  parse(path2) {
+  parse(path3) {
     const ret = {
       root: "",
       dir: "",
@@ -22283,8 +22283,8 @@ var posixImpl = /* @__PURE__ */ Path.of({
       ext: "",
       name: ""
     };
-    if (path2.length === 0) return ret;
-    let code2 = path2.charCodeAt(0);
+    if (path3.length === 0) return ret;
+    let code2 = path3.charCodeAt(0);
     const isAbsolute = code2 === 47;
     let start4;
     if (isAbsolute) {
@@ -22297,10 +22297,10 @@ var posixImpl = /* @__PURE__ */ Path.of({
     let startPart = 0;
     let end5 = -1;
     let matchedSlash = true;
-    let i = path2.length - 1;
+    let i = path3.length - 1;
     let preDotState = 0;
     for (; i >= start4; --i) {
-      code2 = path2.charCodeAt(i);
+      code2 = path3.charCodeAt(i);
       if (code2 === 47) {
         if (!matchedSlash) {
           startPart = i + 1;
@@ -22323,20 +22323,20 @@ var posixImpl = /* @__PURE__ */ Path.of({
     preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
     preDotState === 1 && startDot === end5 - 1 && startDot === startPart + 1) {
       if (end5 !== -1) {
-        if (startPart === 0 && isAbsolute) ret.base = ret.name = path2.slice(1, end5);
-        else ret.base = ret.name = path2.slice(startPart, end5);
+        if (startPart === 0 && isAbsolute) ret.base = ret.name = path3.slice(1, end5);
+        else ret.base = ret.name = path3.slice(startPart, end5);
       }
     } else {
       if (startPart === 0 && isAbsolute) {
-        ret.name = path2.slice(1, startDot);
-        ret.base = path2.slice(1, end5);
+        ret.name = path3.slice(1, startDot);
+        ret.base = path3.slice(1, end5);
       } else {
-        ret.name = path2.slice(startPart, startDot);
-        ret.base = path2.slice(startPart, end5);
+        ret.name = path3.slice(startPart, startDot);
+        ret.base = path3.slice(startPart, end5);
       }
-      ret.ext = path2.slice(startDot, end5);
+      ret.ext = path3.slice(startDot, end5);
     }
-    if (startPart > 0) ret.dir = path2.slice(0, startPart - 1);
+    if (startPart > 0) ret.dir = path3.slice(0, startPart - 1);
     else if (isAbsolute) ret.dir = "/";
     return ret;
   },
@@ -22371,22 +22371,22 @@ var showConfirmation = /* @__PURE__ */ Confirm.$is("Show");
 var renderBeep2 = /* @__PURE__ */ render3(beep3, {
   style: "pretty"
 });
-function resolveCurrentPath(path2, options3) {
-  return match2(path2, {
+function resolveCurrentPath(path3, options3) {
+  return match2(path3, {
     onNone: () => match2(options3.startingPath, {
       onNone: () => sync4(() => process.cwd()),
-      onSome: (path3) => flatMap9(FileSystem, (fs) => (
+      onSome: (path4) => flatMap9(FileSystem, (fs) => (
         // Ensure the user provided starting path exists
-        orDie2(fs.exists(path3)).pipe(filterOrDieMessage2(identity, `The provided starting path '${path3}' does not exist`), as4(path3))
+        orDie2(fs.exists(path4)).pipe(filterOrDieMessage2(identity, `The provided starting path '${path4}' does not exist`), as4(path4))
       ))
     }),
-    onSome: (path3) => succeed7(path3)
+    onSome: (path4) => succeed7(path4)
   });
 }
 function getFileList(directory2, options3) {
   return gen2(function* () {
     const fs = yield* FileSystem;
-    const path2 = yield* Path2;
+    const path3 = yield* Path2;
     const files = yield* orDie2(fs.readDirectory(directory2)).pipe(
       // Always prepend the `".."` option to the file list but allow it
       // to be filtered out if the user so desires
@@ -22395,7 +22395,7 @@ function getFileList(directory2, options3) {
     return yield* filter8(files, (file3) => {
       const result = options3.filter(file3);
       const userDefinedFilter = isEffect2(result) ? result : succeed7(result);
-      const directoryFilter = options3.type === "directory" ? map16(orDie2(fs.stat(path2.join(directory2, file3))), (info2) => info2.type === "Directory") : succeed7(true);
+      const directoryFilter = options3.type === "directory" ? map16(orDie2(fs.stat(path3.join(directory2, file3))), (info2) => info2.type === "Directory") : succeed7(true);
       return zipWith4(userDefinedFilter, directoryFilter, (a, b) => a && b);
     }, {
       concurrency: files.length
@@ -22408,12 +22408,12 @@ function handleClear2(options3) {
       const terminal = yield* Terminal;
       const columns = yield* terminal.columns;
       const currentPath = yield* resolveCurrentPath(state.path, options3);
-      const text8 = "\n".repeat(Math.min(state.files.length, options3.maxPerPage));
+      const text9 = "\n".repeat(Math.min(state.files.length, options3.maxPerPage));
       const clearPath = eraseText(currentPath, columns);
       const message = showConfirmation(state.confirm) ? CONFIRM_MESSAGE : options3.message;
       const clearPrompt = eraseText(`
 ${message}`, columns);
-      const clearOptions = eraseText(text8, columns);
+      const clearOptions = eraseText(text9, columns);
       return clearOptions.pipe(cat2(clearPath), cat2(clearPrompt), optimize3(Deep), render3({
         style: "pretty",
         options: {
@@ -22461,13 +22461,13 @@ function renderFiles(state, files, figures2, options3) {
 }
 function renderNextFrame2(state, options3) {
   return gen2(function* () {
-    const path2 = yield* Path2;
+    const path3 = yield* Path2;
     const terminal = yield* Terminal;
     const columns = yield* terminal.columns;
     const figures2 = yield* figures;
     const currentPath = yield* resolveCurrentPath(state.path, options3);
     const selectedPath = state.files[state.cursor];
-    const resolvedPath = path2.resolve(currentPath, selectedPath);
+    const resolvedPath = path3.resolve(currentPath, selectedPath);
     const resolvedPathMsg = figures2.pointerSmall.pipe(cat2(space2), cat2(text3(resolvedPath)), annotate2(blackBright2));
     if (showConfirmation(state.confirm)) {
       const leadingSymbol2 = annotate2(text3("?"), cyanBright2);
@@ -22542,10 +22542,10 @@ function processCursorDown(state) {
 function processSelection(state, options3) {
   return gen2(function* () {
     const fs = yield* FileSystem;
-    const path2 = yield* Path2;
+    const path3 = yield* Path2;
     const currentPath = yield* resolveCurrentPath(state.path, options3);
     const selectedPath = state.files[state.cursor];
-    const resolvedPath = path2.resolve(currentPath, selectedPath);
+    const resolvedPath = path3.resolve(currentPath, selectedPath);
     const info2 = yield* orDie2(fs.stat(resolvedPath));
     if (info2.type === "Directory") {
       const files = yield* getFileList(resolvedPath, options3);
@@ -22593,10 +22593,10 @@ function handleProcess2(options3) {
       case "y":
       case "t": {
         if (showConfirmation(state.confirm)) {
-          const path2 = yield* Path2;
+          const path3 = yield* Path2;
           const currentPath = yield* resolveCurrentPath(state.path, options3);
           const selectedPath = state.files[state.cursor];
-          const resolvedPath = path2.resolve(currentPath, selectedPath);
+          const resolvedPath = path3.resolve(currentPath, selectedPath);
           const files = yield* getFileList(resolvedPath, options3);
           return Action.NextFrame({
             state: {
@@ -22612,10 +22612,10 @@ function handleProcess2(options3) {
       case "n":
       case "f": {
         if (showConfirmation(state.confirm)) {
-          const path2 = yield* Path2;
+          const path3 = yield* Path2;
           const currentPath = yield* resolveCurrentPath(state.path, options3);
           const selectedPath = state.files[state.cursor];
-          const resolvedPath = path2.resolve(currentPath, selectedPath);
+          const resolvedPath = path3.resolve(currentPath, selectedPath);
           return Action.Submit({
             value: resolvedPath
           });
@@ -22637,14 +22637,14 @@ var file = (options3 = {}) => {
     filter: options3.filter ?? (() => succeed7(true))
   };
   const initialState3 = gen2(function* () {
-    const path2 = none2();
-    const currentPath = yield* resolveCurrentPath(path2, opts);
+    const path3 = none2();
+    const currentPath = yield* resolveCurrentPath(path3, opts);
     const files = yield* getFileList(currentPath, opts);
     const confirm = Confirm.Hide();
     return {
       cursor: 0,
       files,
-      path: path2,
+      path: path3,
       confirm
     };
   });
@@ -23123,8 +23123,8 @@ function handleClear4(options3) {
     const terminal = yield* Terminal;
     const columns = yield* terminal.columns;
     const clearPrompt = cat2(eraseLine3, cursorLeft3);
-    const text8 = "\n".repeat(Math.min(options3.choices.length, options3.maxPerPage)) + options3.message;
-    const clearOutput = eraseText(text8, columns);
+    const text9 = "\n".repeat(Math.min(options3.choices.length, options3.maxPerPage)) + options3.message;
+    const clearOutput = eraseText(text9, columns);
     return clearOutput.pipe(cat2(clearPrompt), optimize3(Deep), render3({
       style: "pretty",
       options: {
@@ -23210,7 +23210,7 @@ ${error4}`, columns))
   });
 }
 function renderInput2(nextState, options3, submitted) {
-  const text8 = getValue(nextState, options3);
+  const text9 = getValue(nextState, options3);
   const annotation = match2(nextState.error, {
     onNone: () => {
       if (submitted) {
@@ -23228,10 +23228,10 @@ function renderInput2(nextState, options3, submitted) {
       return empty32;
     }
     case "password": {
-      return annotate2(text3("*".repeat(text8.length)), annotation);
+      return annotate2(text3("*".repeat(text9.length)), annotation);
     }
     case "text": {
-      return annotate2(text3(text8), annotation);
+      return annotate2(text3(text9), annotation);
     }
   }
 }
@@ -23608,6 +23608,11 @@ var choice = (alternatives) => {
   op.alternatives = alternatives;
   return op;
 };
+var text6 = /* @__PURE__ */ (() => {
+  const op = /* @__PURE__ */ Object.create(proto19);
+  op._tag = "Text";
+  return op;
+})();
 var getChoices = (self) => getChoicesInternal(self);
 var getHelp = (self) => getHelpInternal(self);
 var getTypeName = (self) => getTypeNameInternal(self);
@@ -23756,7 +23761,7 @@ var validateInternal = (self, value5, config2) => {
     case "Path": {
       return flatMap9(FileSystem, (fileSystem) => {
         const errorMsg = "Path options do not have a default value";
-        return orElseFail2(value5, () => errorMsg).pipe(tap2((path2) => orDie2(fileSystem.exists(path2)).pipe(tap2((pathExists) => validatePathExistence(path2, self.pathExists, pathExists).pipe(zipRight3(validatePathType(path2, self.pathType, fileSystem).pipe(when2(() => self.pathExists !== "no" && pathExists))))))));
+        return orElseFail2(value5, () => errorMsg).pipe(tap2((path3) => orDie2(fileSystem.exists(path3)).pipe(tap2((pathExists) => validatePathExistence(path3, self.pathExists, pathExists).pipe(zipRight3(validatePathType(path3, self.pathType, fileSystem).pipe(when2(() => self.pathExists !== "no" && pathExists))))))));
       });
     }
     case "Redacted": {
@@ -23771,24 +23776,24 @@ var validateInternal = (self, value5, config2) => {
   }
 };
 var attempt = (option5, typeName, parse5) => orElseFail2(option5, () => `${typeName} options do not have a default value`).pipe(flatMap9((value5) => orElseFail2(parse5(value5), () => `'${value5}' is not a ${typeName}`)));
-var validatePathExistence = (path2, shouldPathExist, pathExists) => {
+var validatePathExistence = (path3, shouldPathExist, pathExists) => {
   if (shouldPathExist === "no" && pathExists) {
-    return fail7(`Path '${path2}' must not exist`);
+    return fail7(`Path '${path3}' must not exist`);
   }
   if (shouldPathExist === "yes" && !pathExists) {
-    return fail7(`Path '${path2}' must exist`);
+    return fail7(`Path '${path3}' must exist`);
   }
   return _void;
 };
-var validatePathType = (path2, pathType, fileSystem) => {
+var validatePathType = (path3, pathType, fileSystem) => {
   switch (pathType) {
     case "file": {
-      const checkIsFile = fileSystem.stat(path2).pipe(map16((info2) => info2.type === "File"), orDie2);
-      return fail7(`Expected path '${path2}' to be a regular file`).pipe(unlessEffect2(checkIsFile), asVoid2);
+      const checkIsFile = fileSystem.stat(path3).pipe(map16((info2) => info2.type === "File"), orDie2);
+      return fail7(`Expected path '${path3}' to be a regular file`).pipe(unlessEffect2(checkIsFile), asVoid2);
     }
     case "directory": {
-      const checkIsDirectory = fileSystem.stat(path2).pipe(map16((info2) => info2.type === "Directory"), orDie2);
-      return fail7(`Expected path '${path2}' to be a directory`).pipe(unlessEffect2(checkIsDirectory), asVoid2);
+      const checkIsDirectory = fileSystem.stat(path3).pipe(map16((info2) => info2.type === "Directory"), orDie2);
+      return fail7(`Expected path '${path3}' to be a directory`).pipe(unlessEffect2(checkIsDirectory), asVoid2);
     }
     case "either": {
       return _void;
@@ -24237,6 +24242,7 @@ var none10 = /* @__PURE__ */ (() => {
   op._tag = "Empty";
   return op;
 })();
+var text7 = (name) => makeSingle(name, empty2(), text6);
 var getHelp3 = (self) => getHelpInternal2(self);
 var getUsage = (self) => getUsageInternal(self);
 var map28 = /* @__PURE__ */ dual(2, (self, f) => makeMap(self, (a) => right2(f(a))));
@@ -25195,6 +25201,8 @@ var getZshCompletions2 = (self, state = {
 // node_modules/.pnpm/@effect+cli@0.66.12_@effect+platform@0.87.12_@effect+printer-ansi@0.44.12_@effect+printer@0.44.12_effect@3.16.12/node_modules/@effect/cli/dist/esm/Options.js
 var all7 = all6;
 var choice3 = choice2;
+var text8 = text7;
+var optional4 = optional3;
 var withDefault3 = withDefault2;
 var withDescription3 = withDescription2;
@@ -25411,7 +25419,7 @@ var validateInternal2 = (self, args3, config2) => {
             return fail7(missingValue(p(`Missing argument ${getTypeName(self.primitiveType)}`)));
           },
           onNonEmpty: (head5, tail) => validate4(self.primitiveType, some2(head5), config2).pipe(mapBoth4({
-            onFailure: (text8) => invalidArgument(p(text8)),
+            onFailure: (text9) => invalidArgument(p(text9)),
             onSuccess: (a) => [tail, a]
           }))
         });
@@ -25559,11 +25567,11 @@ var getZshCompletions3 = (self, state = {
     }
     case "Single": {
       const multiple = state.multiple ? "*" : "";
-      const optional4 = state.optional ? "::" : ":";
+      const optional5 = state.optional ? "::" : ":";
       const shortDescription = getShortDescription2(self);
       const description = shortDescription.length > 0 ? ` -- ${shortDescription}` : "";
       const possibleValues = getZshCompletions(self.primitiveType);
-      return possibleValues.length === 0 ? empty2() : of(`${multiple}${optional4}${self.name}${description}${possibleValues}`);
+      return possibleValues.length === 0 ? empty2() : of(`${multiple}${optional5}${self.name}${description}${possibleValues}`);
     }
     case "Map": {
       return getZshCompletions3(self.args, state);
@@ -26280,10 +26288,10 @@ var handleBuiltInOption = (self, executable, args3, builtIn2, execute2, config2)
       const description = descriptionList([[text4("Instructions"), instructions]]);
       const header = h1(spans([code("Wizard Mode for CLI Application:"), space3, code(self.name), space3, code(`(${self.version})`), summary5]));
       const help = sequence(header, description);
-      const text8 = toAnsiText(help);
+      const text9 = toAnsiText(help);
       const command = fromIterable(getNames2(self.command))[0];
       const wizardPrefix = getWizardPrefix(builtIn2, command, args3);
-      return log3(text8).pipe(zipRight3(wizard4(builtIn2.command, wizardPrefix, config2)), tap2((args4) => log3(toAnsiText(renderWizardArgs(args4)))), flatMap9((args4) => toggle2({
+      return log3(text9).pipe(zipRight3(wizard4(builtIn2.command, wizardPrefix, config2)), tap2((args4) => log3(toAnsiText(renderWizardArgs(args4)))), flatMap9((args4) => toggle2({
         message: "Would you like to run the command?",
         initial: true,
         active: "yes",
@@ -26610,7 +26618,7 @@ var makeExecutor2 = makeExecutor;
 var ChildProcess = __toESM(require("child_process"), 1);
 // node_modules/.pnpm/@effect+platform-node-shared@0.42.17_@effect+cluster@0.41.17_@effect+platform@0.87.12_@effect_4gcr4mmnr23kd4czky4xf3cnsa/node_modules/@effect/platform-node-shared/dist/esm/internal/error.js
-var handleErrnoException = (module2, method) => (err, [path2]) => {
+var handleErrnoException = (module2, method) => (err, [path3]) => {
   let reason = "Unknown";
   switch (err.code) {
     case "ENOENT":
@@ -26639,7 +26647,7 @@ var handleErrnoException = (module2, method) => (err, [path2]) => {
     reason,
     module: module2,
     method,
-    pathOrDescriptor: path2,
+    pathOrDescriptor: path3,
     syscall: err.syscall,
     description: err.message,
     cause: err
@@ -27292,7 +27300,7 @@ var handleBadArgument = (method) => (cause2) => new BadArgument({
 });
 var access2 = /* @__PURE__ */ (() => {
   const nodeAccess = /* @__PURE__ */ effectify2(NFS.access, /* @__PURE__ */ handleErrnoException("FileSystem", "access"), /* @__PURE__ */ handleBadArgument("access"));
-  return (path2, options3) => {
+  return (path3, options3) => {
     let mode = NFS.constants.F_OK;
     if (options3?.readable) {
       mode |= NFS.constants.R_OK;
@@ -27300,7 +27308,7 @@ var access2 = /* @__PURE__ */ (() => {
     if (options3?.writable) {
       mode |= NFS.constants.W_OK;
     }
-    return nodeAccess(path2, mode);
+    return nodeAccess(path3, mode);
   };
 })();
 var copy3 = /* @__PURE__ */ (() => {
@@ -27317,11 +27325,11 @@ var copyFile2 = /* @__PURE__ */ (() => {
 })();
 var chmod2 = /* @__PURE__ */ (() => {
   const nodeChmod = /* @__PURE__ */ effectify2(NFS.chmod, /* @__PURE__ */ handleErrnoException("FileSystem", "chmod"), /* @__PURE__ */ handleBadArgument("chmod"));
-  return (path2, mode) => nodeChmod(path2, mode);
+  return (path3, mode) => nodeChmod(path3, mode);
 })();
 var chown2 = /* @__PURE__ */ (() => {
   const nodeChown = /* @__PURE__ */ effectify2(NFS.chown, /* @__PURE__ */ handleErrnoException("FileSystem", "chown"), /* @__PURE__ */ handleBadArgument("chown"));
-  return (path2, uid, gid) => nodeChown(path2, uid, gid);
+  return (path3, uid, gid) => nodeChown(path3, uid, gid);
 })();
 var link2 = /* @__PURE__ */ (() => {
   const nodeLink = /* @__PURE__ */ effectify2(NFS.link, /* @__PURE__ */ handleErrnoException("FileSystem", "link"), /* @__PURE__ */ handleBadArgument("link"));
@@ -27329,7 +27337,7 @@ var link2 = /* @__PURE__ */ (() => {
 })();
 var makeDirectory = /* @__PURE__ */ (() => {
   const nodeMkdir = /* @__PURE__ */ effectify2(NFS.mkdir, /* @__PURE__ */ handleErrnoException("FileSystem", "makeDirectory"), /* @__PURE__ */ handleBadArgument("makeDirectory"));
-  return (path2, options3) => nodeMkdir(path2, {
+  return (path3, options3) => nodeMkdir(path3, {
     recursive: options3?.recursive ?? false,
     mode: options3?.mode
   });
@@ -27345,7 +27353,7 @@ var makeTempDirectoryFactory = (method) => {
 var makeTempDirectory = /* @__PURE__ */ makeTempDirectoryFactory("makeTempDirectory");
 var removeFactory = (method) => {
   const nodeRm = effectify2(NFS.rm, handleErrnoException("FileSystem", method), handleBadArgument(method));
-  return (path2, options3) => nodeRm(path2, {
+  return (path3, options3) => nodeRm(path3, {
     recursive: options3?.recursive ?? false,
     force: options3?.force ?? false
   });
@@ -27361,7 +27369,7 @@ var makeTempDirectoryScoped = /* @__PURE__ */ (() => {
 var openFactory = (method) => {
   const nodeOpen = effectify2(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
   const nodeClose = effectify2(NFS.close, handleErrnoException("FileSystem", method), handleBadArgument(method));
-  return (path2, options3) => pipe(acquireRelease2(nodeOpen(path2, options3?.flag ?? "r", options3?.mode), (fd) => orDie2(nodeClose(fd))), map16((fd) => makeFile(FileDescriptor(fd), options3?.flag?.startsWith("a") ?? false)));
+  return (path3, options3) => pipe(acquireRelease2(nodeOpen(path3, options3?.flag ?? "r", options3?.mode), (fd) => orDie2(nodeClose(fd))), map16((fd) => makeFile(FileDescriptor(fd), options3?.flag?.startsWith("a") ?? false)));
 };
 var open2 = /* @__PURE__ */ openFactory("open");
 var makeFile = /* @__PURE__ */ (() => {
@@ -27476,7 +27484,7 @@ var makeTempFileFactory = (method) => {
   const makeDirectory2 = makeTempDirectoryFactory(method);
   const open3 = openFactory(method);
   const randomHexString2 = (bytes) => sync4(() => Crypto.randomBytes(bytes).toString("hex"));
-  return (options3) => pipe(zip5(makeDirectory2(options3), randomHexString2(6)), map16(([directory2, random3]) => Path3.join(directory2, random3)), tap2((path2) => scoped2(open3(path2, {
+  return (options3) => pipe(zip5(makeDirectory2(options3), randomHexString2(6)), map16(([directory2, random3]) => Path3.join(directory2, random3)), tap2((path3) => scoped2(open3(path3, {
     flag: "w+"
   }))));
 };
@@ -27488,17 +27496,17 @@ var makeTempFileScoped = /* @__PURE__ */ (() => {
     recursive: true
   })));
 })();
-var readDirectory = (path2, options3) => tryPromise2({
-  try: () => NFS.promises.readdir(path2, options3),
-  catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path2])
+var readDirectory = (path3, options3) => tryPromise2({
+  try: () => NFS.promises.readdir(path3, options3),
+  catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path3])
 });
-var readFile2 = (path2) => async2((resume2, signal) => {
+var readFile2 = (path3) => async2((resume2, signal) => {
   try {
-    NFS.readFile(path2, {
+    NFS.readFile(path3, {
       signal
     }, (err, data) => {
       if (err) {
-        resume2(fail7(handleErrnoException("FileSystem", "readFile")(err, [path2])));
+        resume2(fail7(handleErrnoException("FileSystem", "readFile")(err, [path3])));
       } else {
         resume2(succeed7(data));
       }
@@ -27509,11 +27517,11 @@ var readFile2 = (path2) => async2((resume2, signal) => {
 });
 var readLink = /* @__PURE__ */ (() => {
   const nodeReadLink = /* @__PURE__ */ effectify2(NFS.readlink, /* @__PURE__ */ handleErrnoException("FileSystem", "readLink"), /* @__PURE__ */ handleBadArgument("readLink"));
-  return (path2) => nodeReadLink(path2);
+  return (path3) => nodeReadLink(path3);
 })();
 var realPath = /* @__PURE__ */ (() => {
   const nodeRealPath = /* @__PURE__ */ effectify2(NFS.realpath, /* @__PURE__ */ handleErrnoException("FileSystem", "realPath"), /* @__PURE__ */ handleBadArgument("realPath"));
-  return (path2) => nodeRealPath(path2);
+  return (path3) => nodeRealPath(path3);
 })();
 var rename3 = /* @__PURE__ */ (() => {
   const nodeRename = /* @__PURE__ */ effectify2(NFS.rename, /* @__PURE__ */ handleErrnoException("FileSystem", "rename"), /* @__PURE__ */ handleBadArgument("rename"));
@@ -27537,40 +27545,40 @@ var makeFileInfo = (stat3) => ({
 });
 var stat2 = /* @__PURE__ */ (() => {
   const nodeStat = /* @__PURE__ */ effectify2(NFS.stat, /* @__PURE__ */ handleErrnoException("FileSystem", "stat"), /* @__PURE__ */ handleBadArgument("stat"));
-  return (path2) => map16(nodeStat(path2), makeFileInfo);
+  return (path3) => map16(nodeStat(path3), makeFileInfo);
 })();
 var symlink2 = /* @__PURE__ */ (() => {
   const nodeSymlink = /* @__PURE__ */ effectify2(NFS.symlink, /* @__PURE__ */ handleErrnoException("FileSystem", "symlink"), /* @__PURE__ */ handleBadArgument("symlink"));
-  return (target, path2) => nodeSymlink(target, path2);
+  return (target, path3) => nodeSymlink(target, path3);
 })();
 var truncate2 = /* @__PURE__ */ (() => {
   const nodeTruncate = /* @__PURE__ */ effectify2(NFS.truncate, /* @__PURE__ */ handleErrnoException("FileSystem", "truncate"), /* @__PURE__ */ handleBadArgument("truncate"));
-  return (path2, length3) => nodeTruncate(path2, length3 !== void 0 ? Number(length3) : void 0);
+  return (path3, length3) => nodeTruncate(path3, length3 !== void 0 ? Number(length3) : void 0);
 })();
 var utimes2 = /* @__PURE__ */ (() => {
   const nodeUtimes = /* @__PURE__ */ effectify2(NFS.utimes, /* @__PURE__ */ handleErrnoException("FileSystem", "utime"), /* @__PURE__ */ handleBadArgument("utime"));
-  return (path2, atime, mtime) => nodeUtimes(path2, atime, mtime);
+  return (path3, atime, mtime) => nodeUtimes(path3, atime, mtime);
 })();
-var watchNode = (path2, options3) => asyncScoped2((emit) => acquireRelease2(sync4(() => {
-  const watcher = NFS.watch(path2, {
+var watchNode = (path3, options3) => asyncScoped2((emit) => acquireRelease2(sync4(() => {
+  const watcher = NFS.watch(path3, {
     recursive: options3?.recursive
-  }, (event, path3) => {
-    if (!path3) return;
+  }, (event, path4) => {
+    if (!path4) return;
     switch (event) {
       case "rename": {
-        emit.fromEffect(matchEffect2(stat2(path3), {
+        emit.fromEffect(matchEffect2(stat2(path4), {
           onSuccess: (_) => succeed7(WatchEventCreate({
-            path: path3
+            path: path4
           })),
           onFailure: (err) => err._tag === "SystemError" && err.reason === "NotFound" ? succeed7(WatchEventRemove({
-            path: path3
+            path: path4
           })) : fail7(err)
         }));
         return;
       }
       case "change": {
         emit.single(WatchEventUpdate({
-          path: path3
+          path: path4
         }));
         return;
       }
@@ -27581,7 +27589,7 @@ var watchNode = (path2, options3) => asyncScoped2((emit) => acquireRelease2(sync
       module: "FileSystem",
       reason: "Unknown",
       method: "watch",
-      pathOrDescriptor: path2,
+      pathOrDescriptor: path3,
       cause: error4
     }));
   });
@@ -27590,16 +27598,16 @@ var watchNode = (path2, options3) => asyncScoped2((emit) => acquireRelease2(sync
   });
   return watcher;
 }), (watcher) => sync4(() => watcher.close())));
-var watch2 = (backend, path2, options3) => stat2(path2).pipe(map16((stat3) => backend.pipe(flatMap((_) => _.register(path2, stat3, options3)), getOrElse2(() => watchNode(path2, options3)))), unwrap5);
-var writeFile2 = (path2, data, options3) => async2((resume2, signal) => {
+var watch2 = (backend, path3, options3) => stat2(path3).pipe(map16((stat3) => backend.pipe(flatMap((_) => _.register(path3, stat3, options3)), getOrElse2(() => watchNode(path3, options3)))), unwrap5);
+var writeFile2 = (path3, data, options3) => async2((resume2, signal) => {
   try {
-    NFS.writeFile(path2, data, {
+    NFS.writeFile(path3, data, {
       signal,
       flag: options3?.flag,
       mode: options3?.mode
     }, (err) => {
       if (err) {
-        resume2(fail7(handleErrnoException("FileSystem", "writeFile")(err, [path2])));
+        resume2(fail7(handleErrnoException("FileSystem", "writeFile")(err, [path3])));
       } else {
         resume2(_void);
       }
@@ -27631,8 +27639,8 @@ var makeFileSystem = /* @__PURE__ */ map16(/* @__PURE__ */ serviceOption2(WatchB
   symlink: symlink2,
   truncate: truncate2,
   utimes: utimes2,
-  watch(path2, options3) {
-    return watch2(backend, path2, options3);
+  watch(path3, options3) {
+    return watch2(backend, path3, options3);
   },
   writeFile: writeFile2
 }));
@@ -27653,12 +27661,12 @@ var fromFileUrl2 = (url2) => try_2({
     cause: error4
   })
 });
-var toFileUrl2 = (path2) => try_2({
-  try: () => NodeUrl.pathToFileURL(path2),
+var toFileUrl2 = (path3) => try_2({
+  try: () => NodeUrl.pathToFileURL(path3),
   catch: (error4) => new BadArgument({
     module: "Path",
     method: "toFileUrl",
-    description: `Invalid path: ${path2}`,
+    description: `Invalid path: ${path3}`,
     cause: error4
   })
 });
@@ -28211,6 +28219,1544 @@ var runMain2 = runMain;
 // node_modules/.pnpm/@effect+platform-node@0.89.5_@effect+cluster@0.41.17_@effect+platform@0.87.12_@effect+rpc@0.6_sr25567vovx2tzrgsyzt4avpa4/node_modules/@effect/platform-node/dist/esm/NodeRuntime.js
 var runMain3 = runMain2;
+// 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 && range3(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 range3 = (a, b, str) => {
+  let begs, beg, left3, right3 = 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 = [];
+    left3 = 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 < left3) {
+          left3 = beg;
+          right3 = bi;
+        }
+        bi = str.indexOf(b, i + 1);
+      }
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+    if (begs.length && right3 !== void 0) {
+      result = [left3, right3];
+    }
+  }
+  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 parts2 = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p2 = pre.split(",");
+  p2[p2.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    ;
+    p2[p2.length - 1] += postParts.shift();
+    p2.push.apply(p2, postParts);
+  }
+  parts2.push.apply(parts2, p2);
+  return parts2;
+}
+function expand2(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 isOptions2 = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions2) {
+      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((p2) => m.pre + n[0] + p2);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width3 = 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 reverse5 = y < x;
+      if (reverse5) {
+        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 = width3 - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + 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 = (pattern2) => {
+  if (typeof pattern2 !== "string") {
+    throw new TypeError("invalid pattern");
+  }
+  if (pattern2.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 = (glob, position) => {
+  const pos = position;
+  if (glob.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 negate3 = false;
+  let endPos = pos;
+  let rangeStart = "";
+  WHILE: while (i < glob.length) {
+    const c = glob.charAt(i);
+    if ((c === "!" || c === "^") && i === pos + 1) {
+      negate3 = 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 (glob.startsWith(cls, i)) {
+          if (rangeStart) {
+            return ["$.", false, glob.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 (glob.startsWith("-]", i + 1)) {
+      ranges.push(braceEscape(c + "-"));
+      i += 2;
+      continue;
+    }
+    if (glob.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, glob.length - pos, true];
+  }
+  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate3) {
+    const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+    return [regexpEscape(r), false, endPos - pos, false];
+  }
+  const sranges = "[" + (negate3 ? "^" : "") + rangesToString(ranges) + "]";
+  const snegs = "[" + (negate3 ? "" : "^") + 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 {
+  type;
+  #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(type2, parent, options3 = {}) {
+    this.type = type2;
+    if (type2)
+      this.#hasMagic = true;
+    this.#parent = parent;
+    this.#root = this.#parent ? this.#parent.#root : this;
+    this.#options = this.#root === this ? options3 : this.#root.#options;
+    this.#negs = this.#root === this ? [] : this.#root.#negs;
+    if (type2 === "!" && !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 p2 of this.#parts) {
+      if (typeof p2 === "string")
+        continue;
+      if (p2.type || p2.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((p2) => String(p2)).join("");
+    } else {
+      return this.#toString = this.type + "(" + this.#parts.map((p2) => String(p2)).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 p2 = n;
+      let pp = p2.#parent;
+      while (pp) {
+        for (let i = p2.#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]);
+          }
+        }
+        p2 = pp;
+        pp = p2.#parent;
+      }
+    }
+    return this;
+  }
+  push(...parts2) {
+    for (const p2 of parts2) {
+      if (p2 === "")
+        continue;
+      if (typeof p2 !== "string" && !(p2 instanceof _AST && p2.#parent === this)) {
+        throw new Error("invalid part: " + p2);
+      }
+      this.#parts.push(p2);
+    }
+  }
+  toJSON() {
+    const ret = this.type === null ? this.#parts.slice().map((p2) => typeof p2 === "string" ? p2 : p2.toJSON()) : [this.type, ...this.#parts.map((p2) => p2.toJSON())];
+    if (this.isStart() && !this.type)
+      ret.unshift([]);
+    if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
+      ret.push({});
+    }
+    return ret;
+  }
+  isStart() {
+    if (this.#root === this)
+      return true;
+    if (!this.#parent?.isStart())
+      return false;
+    if (this.#parentIndex === 0)
+      return true;
+    const p2 = this.#parent;
+    for (let i = 0; i < this.#parentIndex; i++) {
+      const pp = p2.#parts[i];
+      if (!(pp instanceof _AST && pp.type === "!")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isEnd() {
+    if (this.#root === this)
+      return true;
+    if (this.#parent?.type === "!")
+      return true;
+    if (!this.#parent?.isEnd())
+      return false;
+    if (!this.type)
+      return this.#parent?.isEnd();
+    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 p2 of this.#parts) {
+      c.copyIn(p2);
+    }
+    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 parts2 = [];
+    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 = "";
+        parts2.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(...parts2, part);
+        return i;
+      }
+      acc += c;
+    }
+    ast.type = null;
+    ast.#hasMagic = void 0;
+    ast.#parts = [str.substring(pos - 1)];
+    return i;
+  }
+  static fromGlob(pattern2, options3 = {}) {
+    const ast = new _AST(null, void 0, options3);
+    _AST.#parseAST(pattern2, ast, 0, options3);
+    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 glob = this.toString();
+    const [re, body, hasMagic, uflag] = this.toRegExpSource();
+    const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
+    if (!anyMagic) {
+      return body;
+    }
+    const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
+    return Object.assign(new RegExp(`^${re}$`, flags), {
+      _src: re,
+      _glob: glob
+    });
+  }
+  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 dot3 = allowDot ?? !!this.#options.dot;
+    if (this.#root === this)
+      this.#fillNegs();
+    if (!this.type) {
+      const noEmpty = this.isStart() && this.isEnd();
+      const src = this.#parts.map((p2) => {
+        const [re, _, hasMagic, uflag] = typeof p2 === "string" ? _AST.#parseGlob(p2, this.#hasMagic, noEmpty) : p2.toRegExpSource(allowDot);
+        this.#hasMagic = this.#hasMagic || hasMagic;
+        this.#uflag = this.#uflag || uflag;
+        return re;
+      }).join("");
+      let start5 = "";
+      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 .
+              dot3 && 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 = !dot3 && !allowDot && aps.has(src.charAt(0));
+            start5 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+          }
+        }
+      }
+      let end5 = "";
+      if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
+        end5 = "(?:$|\\/)";
+      }
+      const final2 = start5 + src + end5;
+      return [
+        final2,
+        unescape(src),
+        this.#hasMagic = !!this.#hasMagic,
+        this.#uflag
+      ];
+    }
+    const repeated4 = this.type === "*" || this.type === "+";
+    const start4 = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let body = this.#partsToRegExp(dot3);
+    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 = !repeated4 || allowDot || dot3 || !startNoDot ? "" : this.#partsToRegExp(true);
+    if (bodyDotAllowed === body) {
+      bodyDotAllowed = "";
+    }
+    if (bodyDotAllowed) {
+      body = `(?:${body})(?:${bodyDotAllowed})*?`;
+    }
+    let final = "";
+    if (this.type === "!" && this.#emptyExt) {
+      final = (this.isStart() && !dot3 ? startNoDot : "") + starNoEmpty;
+    } else {
+      const close3 = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !dot3 && !allowDot ? startNoDot : "") + star + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
+      final = start4 + body + close3;
+    }
+    return [
+      final,
+      unescape(body),
+      this.#hasMagic = !!this.#hasMagic,
+      this.#uflag
+    ];
+  }
+  #partsToRegExp(dot3) {
+    return this.#parts.map((p2) => {
+      if (typeof p2 === "string") {
+        throw new Error("string type in extglob ast??");
+      }
+      const [re, _, _hasMagic, uflag] = p2.toRegExpSource(dot3);
+      this.#uflag = this.#uflag || uflag;
+      return re;
+    }).filter((p2) => !(this.isStart() && this.isEnd()) || !!p2).join("|");
+  }
+  static #parseGlob(glob, hasMagic, noEmpty = false) {
+    let escaping = false;
+    let re = "";
+    let uflag = false;
+    for (let i = 0; i < glob.length; i++) {
+      const c = glob.charAt(i);
+      if (escaping) {
+        escaping = false;
+        re += (reSpecials.has(c) ? "\\" : "") + c;
+        continue;
+      }
+      if (c === "\\") {
+        if (i === glob.length - 1) {
+          re += "\\\\";
+        } else {
+          escaping = true;
+        }
+        continue;
+      }
+      if (c === "[") {
+        const [src, needUflag, consumed, magic] = parseClass(glob, i);
+        if (consumed) {
+          re += src;
+          uflag = uflag || needUflag;
+          i += consumed - 1;
+          hasMagic = hasMagic || magic;
+          continue;
+        }
+      }
+      if (c === "*") {
+        if (noEmpty && glob === "*")
+          re += starNoEmpty;
+        else
+          re += star;
+        hasMagic = true;
+        continue;
+      }
+      if (c === "?") {
+        re += qmark;
+        hasMagic = true;
+        continue;
+      }
+      re += regExpEscape(c);
+    }
+    return [re, unescape(glob), !!hasMagic, uflag];
+  }
+};
+// node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/escape.js
+var escape3 = (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 = (p2, pattern2, options3 = {}) => {
+  assertValidPattern(pattern2);
+  if (!options3.nocomment && pattern2.charAt(0) === "#") {
+    return false;
+  }
+  return new Minimatch(pattern2, options3).match(p2);
+};
+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 path2 = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+};
+var sep = defaultPlatform === "win32" ? path2.win32.sep : path2.posix.sep;
+minimatch.sep = sep;
+var GLOBSTAR = Symbol("globstar **");
+minimatch.GLOBSTAR = GLOBSTAR;
+var qmark2 = "[^/]";
+var star2 = qmark2 + "*?";
+var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+var filter11 = (pattern2, options3 = {}) => (p2) => minimatch(p2, pattern2, options3);
+minimatch.filter = filter11;
+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 = (p2, pattern2, options3 = {}) => orig(p2, pattern2, ext(def, options3));
+  return Object.assign(m, {
+    Minimatch: class Minimatch extends orig.Minimatch {
+      constructor(pattern2, options3 = {}) {
+        super(pattern2, ext(def, options3));
+      }
+      static defaults(options3) {
+        return orig.defaults(ext(def, options3)).Minimatch;
+      }
+    },
+    AST: class AST extends orig.AST {
+      /* c8 ignore start */
+      constructor(type2, parent, options3 = {}) {
+        super(type2, parent, ext(def, options3));
+      }
+      /* c8 ignore stop */
+      static fromGlob(pattern2, options3 = {}) {
+        return orig.AST.fromGlob(pattern2, ext(def, options3));
+      }
+    },
+    unescape: (s, options3 = {}) => orig.unescape(s, ext(def, options3)),
+    escape: (s, options3 = {}) => orig.escape(s, ext(def, options3)),
+    filter: (pattern2, options3 = {}) => orig.filter(pattern2, ext(def, options3)),
+    defaults: (options3) => orig.defaults(ext(def, options3)),
+    makeRe: (pattern2, options3 = {}) => orig.makeRe(pattern2, ext(def, options3)),
+    braceExpand: (pattern2, options3 = {}) => orig.braceExpand(pattern2, ext(def, options3)),
+    match: (list4, pattern2, options3 = {}) => orig.match(list4, pattern2, ext(def, options3)),
+    sep: orig.sep,
+    GLOBSTAR
+  });
+};
+minimatch.defaults = defaults;
+var braceExpand = (pattern2, options3 = {}) => {
+  assertValidPattern(pattern2);
+  if (options3.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern2)) {
+    return [pattern2];
+  }
+  return expand2(pattern2);
+};
+minimatch.braceExpand = braceExpand;
+var makeRe = (pattern2, options3 = {}) => new Minimatch(pattern2, options3).makeRe();
+minimatch.makeRe = makeRe;
+var match17 = (list4, pattern2, options3 = {}) => {
+  const mm = new Minimatch(pattern2, options3);
+  list4 = list4.filter((f) => mm.match(f));
+  if (mm.options.nonull && !list4.length) {
+    list4.push(pattern2);
+  }
+  return list4;
+};
+minimatch.match = match17;
+var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var Minimatch = class {
+  options;
+  set;
+  pattern;
+  windowsPathsNoEscape;
+  nonegate;
+  negate;
+  comment;
+  empty;
+  preserveMultipleSlashes;
+  partial;
+  globSet;
+  globParts;
+  nocase;
+  isWindows;
+  platform;
+  windowsNoMagicRoot;
+  regexp;
+  constructor(pattern2, options3 = {}) {
+    assertValidPattern(pattern2);
+    options3 = options3 || {};
+    this.options = options3;
+    this.pattern = pattern2;
+    this.platform = options3.platform || defaultPlatform;
+    this.isWindows = this.platform === "win32";
+    this.windowsPathsNoEscape = !!options3.windowsPathsNoEscape || options3.allowWindowsEscape === false;
+    if (this.windowsPathsNoEscape) {
+      this.pattern = this.pattern.replace(/\\/g, "/");
+    }
+    this.preserveMultipleSlashes = !!options3.preserveMultipleSlashes;
+    this.regexp = null;
+    this.negate = false;
+    this.nonegate = !!options3.nonegate;
+    this.comment = false;
+    this.empty = false;
+    this.partial = !!options3.partial;
+    this.nocase = !!this.options.nocase;
+    this.windowsNoMagicRoot = options3.windowsNoMagicRoot !== void 0 ? options3.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 pattern2 of this.set) {
+      for (const part of pattern2) {
+        if (typeof part !== "string")
+          return true;
+      }
+    }
+    return false;
+  }
+  debug(..._) {
+  }
+  make() {
+    const pattern2 = this.pattern;
+    const options3 = this.options;
+    if (!options3.nocomment && pattern2.charAt(0) === "#") {
+      this.comment = true;
+      return;
+    }
+    if (!pattern2) {
+      this.empty = true;
+      return;
+    }
+    this.parseNegate();
+    this.globSet = [...new Set(this.braceExpand())];
+    if (options3.debug) {
+      this.debug = (...args3) => console.error(...args3);
+    }
+    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 set7 = this.globParts.map((s, _, __) => {
+      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, set7);
+    this.set = set7.filter((s) => s.indexOf(false) === -1);
+    if (this.isWindows) {
+      for (let i = 0; i < this.set.length; i++) {
+        const p2 = this.set[i];
+        if (p2[0] === "" && p2[1] === "" && this.globParts[i][2] === "?" && typeof p2[3] === "string" && /^[a-z]:$/i.test(p2[3])) {
+          p2[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((parts2) => {
+      let gs = -1;
+      while (-1 !== (gs = parts2.indexOf("**", gs + 1))) {
+        let i = gs;
+        while (parts2[i + 1] === "**") {
+          i++;
+        }
+        if (i !== gs) {
+          parts2.splice(gs, i - gs);
+        }
+      }
+      return parts2;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(globParts) {
+    return globParts.map((parts2) => {
+      parts2 = parts2.reduce((set7, part) => {
+        const prev = set7[set7.length - 1];
+        if (part === "**" && prev === "**") {
+          return set7;
+        }
+        if (part === "..") {
+          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
+            set7.pop();
+            return set7;
+          }
+        }
+        set7.push(part);
+        return set7;
+      }, []);
+      return parts2.length === 0 ? [""] : parts2;
+    });
+  }
+  levelTwoFileOptimize(parts2) {
+    if (!Array.isArray(parts2)) {
+      parts2 = this.slashSplit(parts2);
+    }
+    let didSomething = false;
+    do {
+      didSomething = false;
+      if (!this.preserveMultipleSlashes) {
+        for (let i = 1; i < parts2.length - 1; i++) {
+          const p2 = parts2[i];
+          if (i === 1 && p2 === "" && parts2[0] === "")
+            continue;
+          if (p2 === "." || p2 === "") {
+            didSomething = true;
+            parts2.splice(i, 1);
+            i--;
+          }
+        }
+        if (parts2[0] === "." && parts2.length === 2 && (parts2[1] === "." || parts2[1] === "")) {
+          didSomething = true;
+          parts2.pop();
+        }
+      }
+      let dd = 0;
+      while (-1 !== (dd = parts2.indexOf("..", dd + 1))) {
+        const p2 = parts2[dd - 1];
+        if (p2 && p2 !== "." && p2 !== ".." && p2 !== "**") {
+          didSomething = true;
+          parts2.splice(dd - 1, 2);
+          dd -= 2;
+        }
+      }
+    } while (didSomething);
+    return parts2.length === 0 ? [""] : parts2;
+  }
+  // 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 parts2 of globParts) {
+        let gs = -1;
+        while (-1 !== (gs = parts2.indexOf("**", gs + 1))) {
+          let gss = gs;
+          while (parts2[gss + 1] === "**") {
+            gss++;
+          }
+          if (gss > gs) {
+            parts2.splice(gs + 1, gss - gs);
+          }
+          let next = parts2[gs + 1];
+          const p2 = parts2[gs + 2];
+          const p22 = parts2[gs + 3];
+          if (next !== "..")
+            continue;
+          if (!p2 || p2 === "." || p2 === ".." || !p22 || p22 === "." || p22 === "..") {
+            continue;
+          }
+          didSomething = true;
+          parts2.splice(gs, 1);
+          const other = parts2.slice(0);
+          other[gs] = "**";
+          globParts.push(other);
+          gs--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let i = 1; i < parts2.length - 1; i++) {
+            const p2 = parts2[i];
+            if (i === 1 && p2 === "" && parts2[0] === "")
+              continue;
+            if (p2 === "." || p2 === "") {
+              didSomething = true;
+              parts2.splice(i, 1);
+              i--;
+            }
+          }
+          if (parts2[0] === "." && parts2.length === 2 && (parts2[1] === "." || parts2[1] === "")) {
+            didSomething = true;
+            parts2.pop();
+          }
+        }
+        let dd = 0;
+        while (-1 !== (dd = parts2.indexOf("..", dd + 1))) {
+          const p2 = parts2[dd - 1];
+          if (p2 && p2 !== "." && p2 !== ".." && p2 !== "**") {
+            didSomething = true;
+            const needDot = dd === 1 && parts2[dd + 1] === "**";
+            const splin = needDot ? ["."] : [];
+            parts2.splice(dd - 1, 2, ...splin);
+            if (parts2.length === 0)
+              parts2.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 pattern2 = this.pattern;
+    let negate3 = false;
+    let negateOffset = 0;
+    for (let i = 0; i < pattern2.length && pattern2.charAt(i) === "!"; i++) {
+      negate3 = !negate3;
+      negateOffset++;
+    }
+    if (negateOffset)
+      this.pattern = pattern2.slice(negateOffset);
+    this.negate = negate3;
+  }
+  // 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(file3, pattern2, partial2 = false) {
+    const options3 = this.options;
+    if (this.isWindows) {
+      const fileDrive = typeof file3[0] === "string" && /^[a-z]:$/i.test(file3[0]);
+      const fileUNC = !fileDrive && file3[0] === "" && file3[1] === "" && file3[2] === "?" && /^[a-z]:$/i.test(file3[3]);
+      const patternDrive = typeof pattern2[0] === "string" && /^[a-z]:$/i.test(pattern2[0]);
+      const patternUNC = !patternDrive && pattern2[0] === "" && pattern2[1] === "" && pattern2[2] === "?" && typeof pattern2[3] === "string" && /^[a-z]:$/i.test(pattern2[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] = [file3[fdi], pattern2[pdi]];
+        if (fd.toLowerCase() === pd.toLowerCase()) {
+          pattern2[pdi] = fd;
+          if (pdi > fdi) {
+            pattern2 = pattern2.slice(pdi);
+          } else if (fdi > pdi) {
+            file3 = file3.slice(fdi);
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      file3 = this.levelTwoFileOptimize(file3);
+    }
+    this.debug("matchOne", this, { file: file3, pattern: pattern2 });
+    this.debug("matchOne", file3.length, pattern2.length);
+    for (var fi = 0, pi = 0, fl = file3.length, pl = pattern2.length; fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      var p2 = pattern2[pi];
+      var f = file3[fi];
+      this.debug(pattern2, p2, f);
+      if (p2 === false) {
+        return false;
+      }
+      if (p2 === GLOBSTAR) {
+        this.debug("GLOBSTAR", [pattern2, p2, f]);
+        var fr = fi;
+        var pr = pi + 1;
+        if (pr === pl) {
+          this.debug("** at the end");
+          for (; fi < fl; fi++) {
+            if (file3[fi] === "." || file3[fi] === ".." || !options3.dot && file3[fi].charAt(0) === ".")
+              return false;
+          }
+          return true;
+        }
+        while (fr < fl) {
+          var swallowee = file3[fr];
+          this.debug("\nglobstar while", file3, fr, pattern2, pr, swallowee);
+          if (this.matchOne(file3.slice(fr), pattern2.slice(pr), partial2)) {
+            this.debug("globstar found match!", fr, fl, swallowee);
+            return true;
+          } else {
+            if (swallowee === "." || swallowee === ".." || !options3.dot && swallowee.charAt(0) === ".") {
+              this.debug("dot detected!", file3, fr, pattern2, pr);
+              break;
+            }
+            this.debug("globstar swallow a segment, and continue");
+            fr++;
+          }
+        }
+        if (partial2) {
+          this.debug("\n>>> no match, partial?", file3, fr, pattern2, pr);
+          if (fr === fl) {
+            return true;
+          }
+        }
+        return false;
+      }
+      let hit;
+      if (typeof p2 === "string") {
+        hit = f === p2;
+        this.debug("string match", p2, f, hit);
+      } else {
+        hit = p2.test(f);
+        this.debug("pattern match", p2, f, hit);
+      }
+      if (!hit)
+        return false;
+    }
+    if (fi === fl && pi === pl) {
+      return true;
+    } else if (fi === fl) {
+      return partial2;
+    } else if (pi === pl) {
+      return fi === fl - 1 && file3[fi] === "";
+    } else {
+      throw new Error("wtf?");
+    }
+  }
+  braceExpand() {
+    return braceExpand(this.pattern, this.options);
+  }
+  parse(pattern2) {
+    assertValidPattern(pattern2);
+    const options3 = this.options;
+    if (pattern2 === "**")
+      return GLOBSTAR;
+    if (pattern2 === "")
+      return "";
+    let m;
+    let fastTest = null;
+    if (m = pattern2.match(starRE)) {
+      fastTest = options3.dot ? starTestDot : starTest;
+    } else if (m = pattern2.match(starDotExtRE)) {
+      fastTest = (options3.nocase ? options3.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options3.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
+    } else if (m = pattern2.match(qmarksRE)) {
+      fastTest = (options3.nocase ? options3.dot ? qmarksTestNocaseDot : qmarksTestNocase : options3.dot ? qmarksTestDot : qmarksTest)(m);
+    } else if (m = pattern2.match(starDotStarRE)) {
+      fastTest = options3.dot ? starDotStarTestDot : starDotStarTest;
+    } else if (m = pattern2.match(dotStarRE)) {
+      fastTest = dotStarTest;
+    }
+    const re = AST.fromGlob(pattern2, 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 set7 = this.set;
+    if (!set7.length) {
+      this.regexp = false;
+      return this.regexp;
+    }
+    const options3 = this.options;
+    const twoStar = options3.noglobstar ? star2 : options3.dot ? twoStarDot : twoStarNoDot;
+    const flags = new Set(options3.nocase ? ["i"] : []);
+    let re = set7.map((pattern2) => {
+      const pp = pattern2.map((p2) => {
+        if (p2 instanceof RegExp) {
+          for (const f of p2.flags.split(""))
+            flags.add(f);
+        }
+        return typeof p2 === "string" ? regExpEscape2(p2) : p2 === GLOBSTAR ? GLOBSTAR : p2._src;
+      });
+      pp.forEach((p2, i) => {
+        const next = pp[i + 1];
+        const prev = pp[i - 1];
+        if (p2 !== 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((p2) => p2 !== GLOBSTAR).join("/");
+    }).join("|");
+    const [open3, close3] = set7.length > 1 ? ["(?:", ")"] : ["", ""];
+    re = "^" + open3 + re + close3 + "$";
+    if (this.negate)
+      re = "^(?!" + re + ").+$";
+    try {
+      this.regexp = new RegExp(re, [...flags].join(""));
+    } catch (ex) {
+      this.regexp = false;
+    }
+    return this.regexp;
+  }
+  slashSplit(p2) {
+    if (this.preserveMultipleSlashes) {
+      return p2.split("/");
+    } else if (this.isWindows && /^\/\/[^\/]+/.test(p2)) {
+      return ["", ...p2.split(/\/+/)];
+    } else {
+      return p2.split(/\/+/);
+    }
+  }
+  match(f, partial2 = this.partial) {
+    this.debug("match", f, this.pattern);
+    if (this.comment) {
+      return false;
+    }
+    if (this.empty) {
+      return f === "";
+    }
+    if (f === "/" && partial2) {
+      return true;
+    }
+    const options3 = this.options;
+    if (this.isWindows) {
+      f = f.split("\\").join("/");
+    }
+    const ff = this.slashSplit(f);
+    this.debug(this.pattern, "split", ff);
+    const set7 = this.set;
+    this.debug(this.pattern, "set", set7);
+    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 < set7.length; i++) {
+      const pattern2 = set7[i];
+      let file3 = ff;
+      if (options3.matchBase && pattern2.length === 1) {
+        file3 = [filename];
+      }
+      const hit = this.matchOne(file3, pattern2, partial2);
+      if (hit) {
+        if (options3.flipNegate) {
+          return true;
+        }
+        return !this.negate;
+      }
+    }
+    if (options3.flipNegate) {
+      return false;
+    }
+    return this.negate;
+  }
+  static defaults(def) {
+    return minimatch.defaults(def).Minimatch;
+  }
+};
+minimatch.AST = AST;
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape3;
+minimatch.unescape = unescape;
 // src/cli.ts
 var ts = __toESM(require("typescript"));
@@ -28285,6 +29831,7 @@ var NanoFiber = class {
   _stack = [];
   _yielded = void 0;
   _services = {};
+  _cache = {};
   runLoop(nano) {
     let current = nano;
     while (true) {
@@ -28377,7 +29924,7 @@ var MatchProto = {
     return this[args2];
   }
 };
-var match17 = (fa, opts) => {
+var match18 = (fa, opts) => {
   const nano = Object.create(MatchProto);
   nano[args2] = fa;
   nano[contA] = opts.onSuccess;
@@ -28400,7 +29947,7 @@ var ProvideServiceProto = {
       ...fiber._services,
       [tag4.key]: value5
     };
-    return match17(fa, {
+    return match18(fa, {
       onSuccess: (_) => {
         fiber._services = prevServices;
         return succeed17(_);
@@ -28435,8 +29982,32 @@ var service2 = (tag4) => {
   nano[args2] = tag4;
   return nano;
 };
-function cachedBy(fa, _key, _lookupKey) {
-  return (...args3) => fa(...args3);
+var CachedProto = {
+  ...PrimitiveProto,
+  [evaluate2](fiber) {
+    const [fa, type2, key] = this[args2];
+    const cache = fiber._cache[type2] || /* @__PURE__ */ new WeakMap();
+    fiber._cache[type2] = cache;
+    const cached3 = cache.get(key);
+    if (cached3) return cached3;
+    return match18(fa, {
+      onSuccess: (_) => {
+        cache.set(key, succeed17(_));
+        return succeed17(_);
+      },
+      onFailure: (_) => {
+        cache.set(key, fail18(_));
+        return fail18(_);
+      }
+    });
+  }
+};
+function cachedBy(fa, type2, lookupKey) {
+  return (...p2) => {
+    const nano = Object.create(CachedProto);
+    nano[args2] = [fa(...p2), type2, lookupKey(...p2)];
+    return nano;
+  };
 }
 var option4 = (fa) => {
   const nano = Object.create(MatchProto);
@@ -28667,10 +30238,10 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     const sectionOverrides = {};
     const skippedRules = [];
     const regex = /@effect-diagnostics(-next-line)?((?:\s[a-zA-Z0-9/]+:(?:off|warning|error|message|suggestion|skip-file))+)?/gm;
-    let match18;
-    while ((match18 = regex.exec(sourceFile.text)) !== null) {
-      const nextLineCaptureGroup = match18[1];
-      const rulesCaptureGroup = match18[2];
+    let match19;
+    while ((match19 = regex.exec(sourceFile.text)) !== null) {
+      const nextLineCaptureGroup = match19[1];
+      const rulesCaptureGroup = match19[2];
       if (rulesCaptureGroup) {
         const trimmedRuleString = rulesCaptureGroup.trim();
         if (trimmedRuleString) {
@@ -28682,7 +30253,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               if (ruleLevel === "skip-file") skippedRules.push(ruleName);
               const isOverrideNextLine = nextLineCaptureGroup && nextLineCaptureGroup.trim().toLowerCase() === "-next-line";
               if (isOverrideNextLine) {
-                const node = findNodeWithLeadingCommentAtPosition(match18.index);
+                const node = findNodeWithLeadingCommentAtPosition(match19.index);
                 if (node) {
                   lineOverrides[ruleName] = lineOverrides[ruleName] || [];
                   lineOverrides[ruleName].unshift({
@@ -28694,7 +30265,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               } else {
                 sectionOverrides[ruleName] = sectionOverrides[ruleName] || [];
                 sectionOverrides[ruleName].unshift({
-                  pos: match18.index,
+                  pos: match19.index,
                   level: ruleLevel
                 });
               }
@@ -29013,8 +30584,7 @@ var unrollUnionMembers = (type2) => {
 var appendToUniqueTypesMap = fn(
   "TypeCheckerApi.appendToUniqueTypesMap"
 )(
-  function* (memory, initialType, excludeNever) {
-    const ts2 = yield* service2(TypeScriptApi);
+  function* (memory, initialType, shouldExclude) {
     const typeChecker = yield* service2(TypeCheckerApi);
     const newIndexes = /* @__PURE__ */ new Set();
     const knownIndexes = /* @__PURE__ */ new Set();
@@ -29022,7 +30592,7 @@ var appendToUniqueTypesMap = fn(
     while (toTest.length > 0) {
       const type2 = toTest.pop();
       if (!type2) break;
-      if (excludeNever && type2.flags & ts2.TypeFlags.Never) {
+      if (yield* shouldExclude(type2)) {
         continue;
       }
       if (type2.isUnion()) {
@@ -30270,7 +31840,18 @@ var leakingRequirements = createDiagnostic({
             );
             if (effectContextType) {
               effectMembers++;
-              const { allIndexes } = yield* appendToUniqueTypesMap(memory, effectContextType, true);
+              const { allIndexes } = yield* appendToUniqueTypesMap(
+                memory,
+                effectContextType,
+                (type2) => {
+                  if (type2.flags & ts2.TypeFlags.Never) return succeed17(true);
+                  return pipe(
+                    typeParser.scopeType(type2, atLocation),
+                    map33(() => true),
+                    orElse14(() => succeed17(false))
+                  );
+                }
+              );
               if (!sharedRequirementsKeys) {
                 sharedRequirementsKeys = allIndexes;
               } else {
@@ -30827,7 +32408,7 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
 var tryCatchInEffectGen = createDiagnostic({
   name: "tryCatchInEffectGen",
   code: 12,
-  severity: "warning",
+  severity: "suggestion",
   apply: fn("tryCatchInEffectGen.apply")(function* (sourceFile, report) {
     const ts2 = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -31011,7 +32592,7 @@ var printCodeSnippet = (sourceFile, showStartPosition, showEndPosition) => gen2(
   const out = [];
   for (let lineIdx = 0; lineIdx < lines3.length; lineIdx++) {
     const lineNumber = (startLine + 1 + lineIdx).toFixed(0);
-    const lineCounterText = " ".repeat(lineNumberMaxLength - lineNumber.length) + lineNumber + "  ";
+    const lineCounterText = " ".repeat(Math.max(0, lineNumberMaxLength - lineNumber.length)) + lineNumber + "  ";
     out.push(
       hcat2([
         string4(lineCounterText),
@@ -31052,7 +32633,7 @@ var formatDiagnostic = (cwd, sourceFile, diagnostic) => gen2(function* () {
       annotate2(italicized2)
     ),
     space2,
-    string4("\u2501".repeat(terminalColumns - titleWidth))
+    string4("\u2501".repeat(Math.max(0, terminalColumns - titleWidth)))
   ]);
   const codeSnippet = yield* printCodeSnippet(
     sourceFile,
@@ -31092,7 +32673,7 @@ var formatDiagnosticAsJson = (cwd, sourceFile, diagnostic) => {
     message: messageText
   };
 };
-var checkEffect2 = (format6) => gen2(function* () {
+var checkEffect2 = (format6, filter12) => gen2(function* () {
   const host = ts.createSolutionBuilderHost(
     ts.sys,
     ts.createSemanticDiagnosticsBuilderProgram
@@ -31106,7 +32687,14 @@ var checkEffect2 = (format6) => gen2(function* () {
       (_2) => hasProperty(_2, "name") && _2.name === "@effect/language-service"
     ) || {};
     const rootNames = program.getRootFileNames();
-    const sourceFiles = program.getSourceFiles().filter((_2) => rootNames.indexOf(_2.fileName) !== -1);
+    let sourceFiles = program.getSourceFiles().filter((_2) => rootNames.indexOf(_2.fileName) !== -1);
+    if (isSome2(filter12)) {
+      const filterPattern = filter12.value;
+      sourceFiles = sourceFiles.filter((sourceFile) => {
+        const relativePath = sourceFile.fileName.startsWith(cwd) ? sourceFile.fileName.slice(cwd.length + 1) : sourceFile.fileName;
+        return minimatch(relativePath, filterPattern);
+      });
+    }
     for (const sourceFile of sourceFiles) {
       const outputDiagnostics = pipe(
         getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
@@ -31147,9 +32735,9 @@ var checkEffect2 = (format6) => gen2(function* () {
   while (project2) {
     project2.done(
       void 0,
-      (fileName, text8, bom) => {
+      (fileName, text9, bom) => {
         if (fileName.endsWith(".d.ts") || fileName.endsWith(".map")) return;
-        return ts.sys.writeFile(fileName, text8, bom);
+        return ts.sys.writeFile(fileName, text9, bom);
       }
     );
     project2 = solution.getNextInvalidatedProject();
@@ -31159,7 +32747,15 @@ var formatOption = choice3("format", ["default", "json"]).pipe(
   withDefault3("default"),
   withDescription3("Output format for diagnostics (default or json)")
 );
-var checkCommand = make56("check", { format: formatOption }, ({ format: format6 }) => checkEffect2(format6));
+var filterOption = text8("filter").pipe(
+  optional4,
+  withDescription3("Filter files by pattern (e.g., '**/*.test.ts', 'src/**/*.ts')")
+);
+var checkCommand = make56(
+  "check",
+  { format: formatOption, filter: filterOption },
+  ({ filter: filter12, format: format6 }) => checkEffect2(format6, filter12)
+);
 var cliCommand = make56(
   "effect-language-service",
   {},