@poe-platform/safe-bash 0.1.521 → 0.1.522

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

@@ -41691,6 +41691,8 @@ var Budget25 = class {
   iterations = 0;
   bytes = 0;
   sourceBytes = 0;
+  globstarEntries = 0;
+  globstarStates = 0;
   controller = new AbortController();
   signal;
   #wallClockTimer;
@@ -44606,6 +44608,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 +45683,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 +45692,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;
@@ -46994,8 +46997,195 @@ ${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;
+        }
+      }
+      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(found[child], found[child + 1]) < 0) child++;
+          if (await compare6(found[root], found[child]) >= 0) return;
+          const saved = found[root];
+          found[root] = found[child];
+          found[child] = saved;
+          root = child;
+        }
+      };
+      for (let index = Math.floor(found.length / 2) - 1; index >= 0; index--) await sift(index, found.length);
+      for (let end = found.length - 1; end > 0; end--) {
+        const saved = found[0];
+        found[0] = found[end];
+        found[end] = saved;
+        await sift(0, end);
+      }
+      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 +48028,7 @@ var Shell = class {
           getopts: { cursor: { index: 0 }, integer: true },
           directoryStack: { entries: [], bytes: 0 },
           dotglob: false,
+          globstar: false,
           status: 0,
           substitutionStatus: 0,
           depth: 0,