@poe-platform/safe-bash 0.1.521 → 0.1.523

package/dist/safe-bash/core.browser.js

@@ -37479,6 +37479,7 @@ init_platform();
 var assignments = /* @__PURE__ */ new WeakMap();
 var selectors = /* @__PURE__ */ new WeakMap();
 var quoteMarkers = /* @__PURE__ */ new WeakSet();
+var prefixNameQuoteGroups = /* @__PURE__ */ new WeakMap();
 function setQuoteMarker(part, synthetic) {
   if (synthetic) quoteMarkers.add(part);
   else quoteMarkers.delete(part);
@@ -37514,6 +37515,8 @@ function copyArraySelector(original, copy2) {
   const selector = selectors.get(original);
   if (selector) selectors.set(copy2, selector);
   setQuoteMarker(copy2, isQuoteMarker(original));
+  const group = prefixNameQuoteGroups.get(original);
+  if (group) prefixNameQuoteGroups.set(copy2, group);
   return copy2;
 }
 function setArrayAssignment(word, assignment) {
@@ -38113,14 +38116,18 @@ shell: command substitution: line ${line}: \`${sourceLine}'
         this.position++;
         text3("", true, true, this.position - 1, this.position);
         const quoteParts = parts.length;
+        let nameListing = false;
         while (this.position < this.source.length && this.source[this.position] !== '"') {
           const inner = this.source[this.position];
           const opaque2 = this.braceReplay?.get(this.position);
           if (opaque2 !== void 0) {
             text3(opaque2, true);
             this.position++;
-          } else if (!literal && (inner === "$" || inner === "`")) this.expansion(parts, true);
-          else if (inner === "\\" && /[$`"\\\n]/u.test(this.source[this.position + 1] ?? "")) {
+          } else if (!literal && (inner === "$" || inner === "`")) {
+            this.expansion(parts, true);
+            const part = parts.at(-1);
+            nameListing ||= part.kind === "variable" && part.prefixNames === "@";
+          } else if (inner === "\\" && /[$`"\\\n]/u.test(this.source[this.position + 1] ?? "")) {
             const escaped3 = this.source[this.position + 1];
             if (escaped3 !== "\n") text3(escaped3, true, false, this.position, this.position + 2);
             else this.printedNewlineReduction++;
@@ -38132,6 +38139,15 @@ shell: command substitution: line ${line}: \`${sourceLine}'
         }
         if (this.source[this.position] !== '"' && !this.braceReplay) this.error("Unterminated double quote", { quote: '"', line: quoteLine });
         if (parts.length === quoteParts) setQuoteMarker(parts.at(-1), false);
+        if (nameListing) {
+          this.budget.admit();
+          const group = {};
+          for (let index = quoteParts - 1; index < parts.length; index++) {
+            this.budget.admit();
+            const part = parts[index];
+            if (index !== quoteParts - 1 || isQuoteMarker(part) || part.kind !== "text" || part.value !== "") prefixNameQuoteGroups.set(part, group);
+          }
+        }
         const spelling2 = expansionSpellings.get(parts.at(-1));
         if (spelling2) spelling2.end = Math.min(this.position + 1, this.source.length);
         if (this.position < this.source.length) this.position++;
@@ -38291,11 +38307,20 @@ shell: command substitution: line ${line}: \`${sourceLine}'
     } else if (this.source[this.position] === "{") {
       this.position++;
       const parameterStart = this.position - 2;
-      const length = this.source[this.position] === "#" && /[a-zA-Z_]/u.test(this.source[this.position + 1] ?? "");
+      const listing = this.source[this.position] === "!";
+      if (listing) this.position++;
+      const length = !listing && this.source[this.position] === "#" && /[a-zA-Z_]/u.test(this.source[this.position + 1] ?? "");
       if (length) this.position++;
       const name2 = /^(?:[a-zA-Z_][a-zA-Z_0-9]*|[0-9]+|[?@*#-])/u.exec(this.source.slice(this.position))?.[0];
       if (!name2) this.error("Unsupported parameter expansion");
       this.position += name2.length;
+      let prefixNames;
+      if (listing) {
+        const separator = this.source[this.position];
+        if (!/^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(name2) || separator !== "*" && separator !== "@" || this.source[this.position + 1] !== "}") this.error("Unsupported indirect parameter expansion");
+        prefixNames = separator;
+        this.position++;
+      }
       let selector;
       if (this.source[this.position] === "[") {
         if (!/^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(name2)) this.error("Unsupported indexed-array parameter");
@@ -38348,7 +38373,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
         parts.push({ kind: "failed-parameter", source: this.source.slice(parameterStart, this.position), line, quoted: quoted2 });
       } else {
         this.position++;
-        const part = { kind: "variable", name: name2, quoted: quoted2, line, ...length ? { length } : {}, ...operator ? { operator, alternate } : {}, ...replacement ? { replacement } : {}, ...substring ? { substring } : {} };
+        const part = { kind: "variable", name: name2, quoted: quoted2, line, ...prefixNames ? { prefixNames } : {}, ...length ? { length } : {}, ...operator ? { operator, alternate } : {}, ...replacement ? { replacement } : {}, ...substring ? { substring } : {} };
         if (selector) setArraySelector(part, selector);
         parts.push(part);
       }
@@ -40760,6 +40785,7 @@ var IndexedBinding = class _IndexedBinding {
   generation = 0;
   version = 0;
   references = 1;
+  assigned = false;
   static create(parent) {
     const owner = ArrayOwner.create(parent.ledger, parent);
     try {
@@ -40791,11 +40817,13 @@ var IndexedBinding = class _IndexedBinding {
       text3.release();
     };
     this.values.set(index, element);
+    this.assigned = true;
     if (index > this.maximum) this.maximum = index;
     previous?.slot.release();
   }
   async copy(signal) {
     const copy2 = _IndexedBinding.create(this.owner.parent);
+    copy2.assigned = this.assigned;
     this.retain();
     try {
       for (const [index, element] of this.values) {
@@ -41671,6 +41699,35 @@ function resolveLimits(...limits) {
   return result2;
 }
 var budgetedSinks = /* @__PURE__ */ new WeakMap();
+async function sortExpansionStrings(values, work) {
+  const compare6 = async (left, right) => {
+    for (let index = 0; index < Math.min(left.length, right.length); index++) {
+      const pending = stringCheckpoint(work);
+      if (pending) await pending;
+      const difference = left.charCodeAt(index) - right.charCodeAt(index);
+      if (difference) return difference;
+    }
+    return left.length - right.length;
+  };
+  const sift = async (root, end) => {
+    while (root * 2 + 1 < end) {
+      let child = root * 2 + 1;
+      if (child + 1 < end && await compare6(values[child], values[child + 1]) < 0) child++;
+      if (await compare6(values[root], values[child]) >= 0) return;
+      const saved = values[root];
+      values[root] = values[child];
+      values[child] = saved;
+      root = child;
+    }
+  };
+  for (let index = Math.floor(values.length / 2) - 1; index >= 0; index--) await sift(index, values.length);
+  for (let end = values.length - 1; end > 0; end--) {
+    const saved = values[0];
+    values[0] = values[end];
+    values[end] = saved;
+    await sift(0, end);
+  }
+}
 var Budget25 = class {
   constructor(limits, signal, onInternalError) {
     this.limits = limits;
@@ -41691,6 +41748,8 @@ var Budget25 = class {
   iterations = 0;
   bytes = 0;
   sourceBytes = 0;
+  globstarEntries = 0;
+  globstarStates = 0;
   controller = new AbortController();
   signal;
   #wallClockTimer;
@@ -41839,7 +41898,7 @@ var typedSavedVariables = /* @__PURE__ */ new WeakMap();
 var valueScope = /* @__PURE__ */ Symbol("shell value allocation scope");
 var invokedValues = /* @__PURE__ */ new WeakMap();
 function isolateIO(io) {
-  return { ...io, ...io.descriptors ? { descriptors: new Map([...io.descriptors].map(([number5, descriptor2]) => [number5, { ...descriptor2 }])) } : {} };
+  return { ...io, nameExpansionContext: void 0, ...io.descriptors ? { descriptors: new Map([...io.descriptors].map(([number5, descriptor2]) => [number5, { ...descriptor2 }])) } : {} };
 }
 function activeIO(io) {
   const input3 = io.descriptors?.get(0);
@@ -43036,6 +43095,7 @@ var Runtime = class _Runtime {
       const current = store.get(name2);
       if (index !== void 0 && current) {
         staged = index === "members" ? IndexedBinding.create(store.owner) : await current.copy(this.signal);
+        staged.assigned = current.assigned;
         let maximum = -1;
         for (const key of staged.values.keys()) {
           operation2.reserve({ work: 2 }).release();
@@ -43236,7 +43296,8 @@ var Runtime = class _Runtime {
       this.signal.throwIfAborted();
       if (state.readonlyVariables?.has(name2)) throw new ArrayFailure("readonly binding");
       if (!watch.valid()) throw new ArrayFailure("stale binding");
-      if (!(assignment.kind === "compound" && assignment.append && writes === 0)) {
+      staged.assigned = true;
+      if (!(assignment.kind === "compound" && assignment.append && writes === 0 && current?.assigned)) {
         let released;
         stateMonitor(state).publish(tickets, name2, () => {
           supersede();
@@ -43539,8 +43600,8 @@ var Runtime = class _Runtime {
               signal: this.signal,
               locale: state.variables.LC_ALL || state.variables.LC_COLLATE || state.variables.LANG || "C",
               work: { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes"), allocation },
-              expand: async (word, pattern = false) => (await this.word(word, state, io, false, pattern, false, pattern)).join(""),
-              regex: (subject, pattern) => this.ere(subject, pattern, state, io),
+              expand: async (word, pattern = false) => (await this.word(word, state, { ...io, nameExpansionContext: "conditional" }, false, pattern, false, pattern)).join(""),
+              regex: (subject, pattern) => this.ere(subject, pattern, state, { ...io, nameExpansionContext: "conditional" }),
               option: (name2) => name2 === "braceexpand" ? state.braceexpand !== false : name2 === "errexit" ? !!state.errexit : name2 === "nounset" ? !!state.nounset : name2 === "pipefail" ? state.pipefail : false,
               present: (name2) => {
                 const match = /^([a-zA-Z_][a-zA-Z_0-9]*)(?:\[(0|[1-9][0-9]*|[@*])\])?$/u.exec(name2);
@@ -43763,7 +43824,7 @@ var Runtime = class _Runtime {
         for (const warning of warnings.splice(0)) await writeDiagnostic(io.stderr, `shell: warning: ${warning}
 `);
         if (++words % 128 === 0) await yieldTurn(this.signal);
-        const part = (await this.word(word, state, io, false)).join("");
+        const part = (await this.word(word, state, { ...io, nameExpansionContext: "document" }, false)).join("");
         size += import_buffer.Buffer.byteLength(part);
         if (size > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
         value2 += part;
@@ -44606,6 +44667,7 @@ ${functionDisplay(name2, state.functions.get(name2))}`;
       getopts: { cursor: createGetoptsState(), integer: true },
       directoryStack: { entries: [], bytes: 0 },
       dotglob: false,
+      globstar: false,
       positional: [...args],
       arg0,
       profile: context2.command === "sh" ? "sh" : "bash",
@@ -45680,7 +45742,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         else if (flag === "u") unset2 = true;
         else {
           await this.diagnostic(context2, `shopt: ${option.startsWith("--") ? option : `-${flag}`}: unsupported option`);
-          await writeDiagnostic(context2.stderr, "shopt: usage: shopt [-pqsu] [--] [dotglob ...]\n");
+          await writeDiagnostic(context2.stderr, "shopt: usage: shopt [-pqsu] [--] [dotglob globstar ...]\n");
           return 2;
         }
       }
@@ -45689,26 +45751,26 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       await this.diagnostic(context2, "shopt: cannot set and unset shell options simultaneously");
       return 1;
     }
-    const emit2 = async () => {
-      if (!quiet) await writeText(context2.stdout, print ? `shopt -${state.dotglob ? "s" : "u"} dotglob
-` : `dotglob             	${state.dotglob ? "on" : "off"}
+    const emit2 = async (name2) => {
+      if (!quiet) await writeText(context2.stdout, print ? `shopt -${state[name2] ? "s" : "u"} ${name2}
+` : `${name2.padEnd(20)}	${state[name2] ? "on" : "off"}
 `);
     };
     if (index === context2.args.length) {
-      if ((!set || state.dotglob) && (!unset2 || !state.dotglob)) await emit2();
+      for (const name2 of ["dotglob", "globstar"]) if ((!set || state[name2]) && (!unset2 || !state[name2])) await emit2(name2);
       return 0;
     }
     let status2 = 0;
     for (; index < context2.args.length; index++) {
       this.signal.throwIfAborted();
       const name2 = context2.args[index];
-      if (name2 !== "dotglob") {
-        await this.diagnostic(context2, `shopt: ${name2}: unsupported shell option name (only dotglob is supported)`);
+      if (name2 !== "dotglob" && name2 !== "globstar") {
+        await this.diagnostic(context2, `shopt: ${name2}: unsupported shell option name (supported: dotglob, globstar)`);
         status2 = 1;
-      } else if (set || unset2) state.dotglob = set;
+      } else if (set || unset2) state[name2] = set;
       else {
-        await emit2();
-        if (!state.dotglob) status2 = 1;
+        await emit2(name2);
+        if (!state[name2]) status2 = 1;
       }
     }
     return status2;
@@ -46340,7 +46402,66 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
   async part(part, state, io, hereString = false) {
     return shellValueText(await this.valuePart(part, state, io, hereString));
   }
+  async *prefixNames(prefix3, state) {
+    const allocation = this.budget.values.scope();
+    const store = arrayStore(state);
+    const holding = store?.owner.hold();
+    const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+    try {
+      allocation.reserveBytes(128);
+      const names = [];
+      const seen = /* @__PURE__ */ new Set();
+      let bytes3 = 0;
+      const consider = async (name2, assigned) => {
+        const scanned = await scanString(name2, work);
+        const pending = stringCheckpoint(work, name2.length + 1);
+        if (pending) await pending;
+        if (!assigned || !name2.startsWith(prefix3) || seen.has(name2)) return;
+        for (let index = 0; index < name2.length; index++) {
+          const pending2 = stringCheckpoint(work);
+          if (pending2) await pending2;
+          const code = name2.charCodeAt(index);
+          if (!(code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || index > 0 && code >= 48 && code <= 57)) return;
+        }
+        if (names.length >= this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
+        if (scanned.bytes > this.budget.limits.maxExpansionBytes - bytes3) this.budget.fail("maxExpansionBytes");
+        bytes3 += scanned.bytes;
+        allocation.reserveBytes(name2.length * 2 + 64);
+        seen.add(name2);
+        names.push(name2);
+      };
+      for (const name2 in state.variables) if (Object.hasOwn(state.variables, name2)) await consider(name2, state.variables[name2] !== void 0);
+      if (store) for (const [name2, entry] of store.bindings) await consider(name2, entry.binding.assigned);
+      for (const frame of state.locals) for (const [name2, saved] of frame) {
+        await consider(name2, saved.value !== void 0 || typedSavedVariables.get(saved)?.binding?.assigned === true);
+      }
+      await sortExpansionStrings(names, work);
+      for (const name2 of names) {
+        const pending = stringCheckpoint(work);
+        if (pending) await pending;
+        yield name2;
+      }
+    } finally {
+      allocation.close();
+      holding?.release();
+    }
+  }
   async valuePart(part, state, io, hereString = false) {
+    if (part.kind === "variable" && part.prefixNames) {
+      const ifs = state.variables.IFS ?? " ";
+      const separator = io.nameExpansionContext === "document" || io.nameExpansionContext === "conditional" && part.prefixNames === "@" ? " " : ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
+      const fragments = [];
+      let bytes3 = 0;
+      for await (const name2 of this.prefixNames(part.name, state)) {
+        const join = fragments.length ? separator : "";
+        bytes3 += import_buffer.Buffer.byteLength(name2) + import_buffer.Buffer.byteLength(join);
+        if (bytes3 > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
+        io[valueScope]?.reserve((name2.length + join.length) * 2 + 32, 0);
+        fragments.push(join, name2);
+      }
+      io[valueScope]?.reserve(bytes3 * 2, 0);
+      return fragments.join("");
+    }
     const binding = part.kind === "variable" ? arrayStore(state)?.get(part.name) : void 0;
     const holding = binding ? requireArrays(state).owner.hold() : void 0;
     const selector = getArraySelector(part);
@@ -46730,7 +46851,8 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       }
       return fields3;
     }
-    const arrayOwned = word.parts.some((part) => part.kind === "variable" && (getArraySelector(part) !== void 0 || arrayStore(state)?.get(part.name) !== void 0));
+    const arrayOwned = word.parts.some((part) => part.kind === "variable" && !part.prefixNames && (getArraySelector(part) !== void 0 || arrayStore(state)?.get(part.name) !== void 0));
+    const prefixOwned = word.parts.some((part) => part.kind === "variable" && part.prefixNames === "@");
     const owner = arrayOwned ? requireArrays(state).owner : void 0;
     const holding = owner?.hold();
     const scratch = !owner && split4 && state.variables.IFS !== "" && word.parts.some((part) => !part.quoted && part.kind !== "text") ? this.budget.values.scope() : void 0;
@@ -46739,11 +46861,13 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       owner?.reserve({ metadata: 128 + word.parts.length * 32, allocatedSlots: word.parts.length + 1, work: word.parts.length + 5 });
       scratch?.reserve(word.parts.length * 32, 0);
       const fields3 = [];
+      let emptyNameGroups;
+      let quoteGroup;
       const addField = () => {
         if (fields3.length >= this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
         scratch?.reserve(32, 0);
         owner?.reserve({ metadata: 32, allocatedSlots: 1, work: 3 });
-        fields3.push({ fragments: [], bytes: false, patterns: void 0, present: false });
+        fields3.push({ fragments: [], bytes: false, patterns: void 0, present: false, independentPresence: false });
       };
       addField();
       let expansionBytes = 0;
@@ -46776,6 +46900,14 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         regexAppend?.(text3, !glob);
         field2.fragments.push(value2);
         field2.present ||= present;
+        if (present) {
+          if (size > 0 || !quoteGroup) field2.independentPresence = true;
+          else {
+            io[valueScope]?.reserve(32, 0);
+            field2.quoteGroups ??= [];
+            field2.quoteGroups.push(quoteGroup);
+          }
+        }
       };
       const appendSplit = async (value2) => {
         this.budget.cpuCheckpoint();
@@ -46824,7 +46956,8 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       const parts = word.parts.map((part) => ({ part, splitText: false, io }));
       for (let index = 0; index < parts.length; index++) {
         const { part, splitText, io: partIO } = parts[index];
-        const quotedPresence = part.quoted && !(arrayOwned && isQuoteMarker(part));
+        quoteGroup = prefixNameQuoteGroups.get(part);
+        const quotedPresence = part.quoted && !((arrayOwned || prefixOwned) && isQuoteMarker(part));
         if (part.kind === "variable" && ["-", "+", ":-", ":+"].includes(part.operator ?? "") && /^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(part.name)) {
           const value2 = this.variable(state, part.name);
           const missing = value2 === void 0 || part.operator.startsWith(":") && value2 === "";
@@ -46838,7 +46971,18 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
           }
         }
         const selector = getArraySelector(part);
-        if (part.kind === "variable" && selector?.kind === "members" && !part.length && split4 && (!part.quoted || selector.separator === "@")) {
+        if (part.kind === "variable" && part.prefixNames === "@" && split4 && (part.quoted || state.variables.IFS === "")) {
+          let position = 0;
+          for await (const name2 of this.prefixNames(part.name, state)) {
+            if (position++) addField();
+            append(name2, !part.quoted, true);
+          }
+          if (position === 0 && quoteGroup) {
+            io[valueScope]?.reserve(32, 0);
+            emptyNameGroups ??= /* @__PURE__ */ new Set();
+            emptyNameGroups.add(quoteGroup);
+          }
+        } else if (part.kind === "variable" && selector?.kind === "members" && !part.length && split4 && (!part.quoted || selector.separator === "@")) {
           const members = await this.arrayMembers(part.name, state);
           for (let position = 0; position < members.length; position++) {
             if (position > 0) addField();
@@ -46868,6 +47012,19 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       let resultBytes = 0;
       for (const field2 of fields3) {
         if (!field2.present && split4) continue;
+        if (split4 && !field2.independentPresence && field2.quoteGroups) {
+          const work = { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+          let empty2 = true;
+          for (const group of field2.quoteGroups) {
+            const pending = stringCheckpoint(work);
+            if (pending) await pending;
+            if (!emptyNameGroups?.has(group)) {
+              empty2 = false;
+              break;
+            }
+          }
+          if (empty2) continue;
+        }
         if (scratch && field2.fragments.length > 1 && !field2.bytes) scratch.reserve(field2.fragments.reduce((bytes3, value2) => bytes3 + shellValueText(value2).length * 2, 0), 0);
         const assembled = concatShellValues(field2.fragments, io[valueScope]);
         const projection = shellValueText(assembled);
@@ -46994,8 +47151,169 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       holding.release();
     }
   }
+  async recursiveGlob(value2, pattern, state) {
+    const failWalk = (message3) => {
+      const error = new FsError("EFBIG", { syscall: "glob", message: message3 });
+      this.budget.controller.abort(error);
+      throw error;
+    };
+    const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+    const scratch = this.budget.values.scope();
+    work.allocation = scratch;
+    try {
+      const segments = [];
+      let start = 0;
+      for (let end = 0; end <= pattern.length; end++) {
+        const pending = stringCheckpoint(work);
+        if (pending) await pending;
+        if (end !== pattern.length && pattern[end] !== "/") continue;
+        if (end > start) {
+          const bytes3 = (await scanString(pattern, work, start, end)).bytes;
+          if (++this.budget.globstarStates > 1e5) failWalk("globstar traversal state limit exceeded");
+          scratch.reserveBytes(bytes3 * 2 + 64);
+          segments.push(pattern.slice(start, end));
+        }
+        start = end + 1;
+      }
+      const make = (parent, suffix2, bytes3, descend, depth) => {
+        const separator = parent.path && parent.path !== "/" ? "/" : "";
+        const size = parent.bytes + separator.length + bytes3;
+        if (size > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
+        if (++this.budget.globstarStates > 1e5) failWalk("globstar traversal state limit exceeded");
+        if (depth > 128) failWalk("globstar directory depth limit exceeded");
+        scratch.reserveBytes(size * 2 + 128);
+        return { path: parent.path + separator + suffix2, bytes: size, descend, depth };
+      };
+      const empty2 = { path: "", bytes: 0, descend: true, depth: 0 };
+      let candidates = [make(empty2, pattern.startsWith("/") ? "/" : "", pattern.startsWith("/") ? 1 : 0, true, 0)];
+      const ignored = (error) => {
+        this.signal.throwIfAborted();
+        return ["ENOENT", "ENOTDIR", "EACCES"].includes(errorCode(error) ?? "");
+      };
+      const read = async (candidate) => {
+        const maxEntries = 1e5 - this.budget.globstarEntries;
+        let entries2;
+        try {
+          entries2 = await interruptible3(this.fs.readdir(pathOf(state, candidate.path || "."), { signal: this.signal, maxEntries }), this.signal);
+        } catch (error) {
+          this.signal.throwIfAborted();
+          if (errorCode(error) === "EFBIG") this.budget.controller.abort(error);
+          throw error;
+        }
+        this.signal.throwIfAborted();
+        if (entries2.length > maxEntries) failWalk("globstar directory entry limit exceeded");
+        this.budget.globstarEntries += entries2.length;
+        return entries2;
+      };
+      let wildcardPrefix = false;
+      for (let index = 0; index < segments.length; index++) {
+        const segment2 = segments[index];
+        const terminal = index === segments.length - 1;
+        const next = /* @__PURE__ */ new Map();
+        const add3 = (candidate) => {
+          const prior = next.get(candidate.path);
+          if (!prior || candidate.descend && !prior.descend) next.set(candidate.path, candidate);
+        };
+        if (segment2 === "**") {
+          const visited = /* @__PURE__ */ new Set();
+          for (const root of candidates) {
+            this.signal.throwIfAborted();
+            try {
+              if ((await interruptible3(this.fs.stat(pathOf(state, root.path || "."), { signal: this.signal }), this.signal)).type !== "directory") continue;
+            } catch (error) {
+              if (ignored(error)) continue;
+              throw error;
+            }
+            if (!terminal || root.path) {
+              add3(terminal && !wildcardPrefix && root.path !== "/" ? make(root, "", 0, root.descend, root.depth) : root);
+            }
+            const queue = root.descend ? [root] : [];
+            while (queue.length) {
+              const directory2 = queue.pop();
+              if (visited.has(directory2.path)) continue;
+              visited.add(directory2.path);
+              let entries2;
+              try {
+                entries2 = await read(directory2);
+              } catch (error) {
+                if (ignored(error)) continue;
+                throw error;
+              }
+              for (const entry of entries2) {
+                const pending = stringCheckpoint(work);
+                if (pending) await pending;
+                if (entry.name === "." || entry.name === ".." || !state.dotglob && entry.name.startsWith(".")) continue;
+                const bytes3 = (await scanString(entry.name, work)).bytes;
+                const child = make(directory2, entry.name, bytes3, entry.type === "directory", directory2.depth + (entry.type === "directory" ? 1 : 0));
+                if (terminal || entry.type === "directory" || entry.type === "symlink" && root.path !== "") add3(child);
+                if (entry.type === "directory") queue.push(child);
+              }
+            }
+          }
+          wildcardPrefix = true;
+        } else if (!/(?:^|[^\\])[*?[]/u.test(segment2)) {
+          const literal = segment2.replace(/\\(.)/gu, "$1");
+          const bytes3 = (await scanString(literal, work)).bytes;
+          for (const candidate of candidates) add3(make(candidate, literal, bytes3, true, candidate.depth));
+        } else {
+          const matches3 = await compilePattern(segment2, work);
+          for (const candidate of candidates) {
+            let entries2;
+            try {
+              entries2 = await read(candidate);
+            } catch (error) {
+              if (ignored(error)) continue;
+              throw error;
+            }
+            for (const entry of entries2) {
+              const pending = stringCheckpoint(work);
+              if (pending) await pending;
+              if (entry.name !== "." && entry.name !== ".." && (state.dotglob || !entry.name.startsWith(".") || segment2.startsWith(".")) && await matches3(entry.name)) {
+                add3(make(candidate, entry.name, (await scanString(entry.name, work)).bytes, true, candidate.depth));
+              }
+            }
+          }
+          wildcardPrefix = true;
+        }
+        candidates = [...next.values()];
+      }
+      const found = [];
+      let outputBytes = 0;
+      for (const candidate of candidates) {
+        this.signal.throwIfAborted();
+        try {
+          const path = pathOf(state, candidate.path);
+          const stat = await interruptible3(value2.endsWith("/") ? this.fs.stat(path, { signal: this.signal }) : this.fs.lstat(path, { signal: this.signal }), this.signal);
+          if (value2.endsWith("/") && stat.type !== "directory") continue;
+          const slash = value2.endsWith("/") && !candidate.path.endsWith("/") ? "/" : "";
+          if (found.length >= this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
+          outputBytes += candidate.bytes + slash.length;
+          if (outputBytes > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
+          scratch.reserveBytes(candidate.bytes * 2 + slash.length + 8);
+          found.push(candidate.path + slash);
+        } catch (error) {
+          if (!ignored(error)) throw error;
+        }
+      }
+      await sortExpansionStrings(found, work);
+      return found.length ? found : [value2];
+    } finally {
+      scratch.close();
+    }
+  }
   async glob(value2, pattern, state) {
     if (!/(?:^|[^\\])[*?[]/u.test(pattern)) return [value2];
+    if (state.globstar) {
+      const work2 = { remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+      let start = 0;
+      for (let end = 0; end <= pattern.length; end++) {
+        const pending = stringCheckpoint(work2);
+        if (pending) await pending;
+        if (end !== pattern.length && pattern[end] !== "/") continue;
+        if (end - start === 2 && pattern[start] === "*" && pattern[start + 1] === "*") return this.recursiveGlob(value2, pattern, state);
+        start = end + 1;
+      }
+    }
     const absolute2 = pattern.startsWith("/");
     const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
     let candidates = [absolute2 ? "/" : ""];
@@ -47838,6 +48156,7 @@ var Shell = class {
           getopts: { cursor: { index: 0 }, integer: true },
           directoryStack: { entries: [], bytes: 0 },
           dotglob: false,
+          globstar: false,
           status: 0,
           substitutionStatus: 0,
           depth: 0,