just-bash 3.1.0 → 3.2.0

package/dist/bundle/chunks/unexpand-YD5BWFH4.js

@@ -0,0 +1,2 @@
+import{createRequire} from"node:module";const require=createRequire(import.meta.url);
+import{a,b}from"./chunk-2VWG4LDT.js";import"./chunk-GN6CQ3J4.js";import"./chunk-QAYAQNCG.js";import"./chunk-NCUTH6QL.js";export{b as flagsForFuzzing,a as unexpand};

package/dist/bundle/chunks/uniq-OVOW532K.js

@@ -0,0 +1,2 @@
+import{createRequire} from"node:module";const require=createRequire(import.meta.url);
+import{a,b}from"./chunk-B3NGH6KE.js";import"./chunk-CHHWTPDH.js";import"./chunk-STHBFACM.js";import"./chunk-EFORKKSH.js";import"./chunk-GN6CQ3J4.js";import"./chunk-QIQMJJZ4.js";import"./chunk-QAYAQNCG.js";import"./chunk-NCUTH6QL.js";export{b as flagsForFuzzing,a as uniqCommand};

package/dist/bundle/chunks/wc-RUR7HE5O.js

@@ -0,0 +1,2 @@
+import{createRequire} from"node:module";const require=createRequire(import.meta.url);
+import{a,b}from"./chunk-P5BOIHWV.js";import"./chunk-CHHWTPDH.js";import"./chunk-STHBFACM.js";import"./chunk-EFORKKSH.js";import"./chunk-GN6CQ3J4.js";import"./chunk-QIQMJJZ4.js";import"./chunk-QAYAQNCG.js";import"./chunk-NCUTH6QL.js";export{b as flagsForFuzzing,a as wcCommand};

package/dist/bundle/chunks/which-UWVKETYW.js

@@ -0,0 +1,2 @@
+import{createRequire} from"node:module";const require=createRequire(import.meta.url);
+import{a,b}from"./chunk-2SMD2AUA.js";import"./chunk-QIQMJJZ4.js";import"./chunk-QAYAQNCG.js";import"./chunk-NCUTH6QL.js";export{b as flagsForFuzzing,a as whichCommand};

package/dist/bundle/chunks/whoami-KR6E7UIR.js

@@ -0,0 +1,2 @@
+import{createRequire} from"node:module";const require=createRequire(import.meta.url);
+import{a,b}from"./chunk-4MZPEZTU.js";import"./chunk-NCUTH6QL.js";export{b as flagsForFuzzing,a as whoami};

package/dist/bundle/chunks/worker.js

@@ -35,6 +35,10 @@ function sanitizeHostErrorMessage(message) {
   return sanitizeWithUnixPrefixes(message, true, true);
 }
 
+// src/security/defense-in-depth-box.ts
+import * as nodeAsyncHooks from "node:async_hooks";
+import * as nodeModule from "node:module";
+
 // src/security/blocked-globals.ts
 function getBlockedGlobals() {
   const globals = [
@@ -269,6 +273,21 @@ function getBlockedGlobals() {
       strategy: "throw",
       reason: "setUncaughtExceptionCaptureCallback could intercept security errors"
     },
+    ...[
+      "on",
+      "once",
+      "addListener",
+      "prependListener",
+      "prependOnceListener"
+    ].map(
+      (prop) => ({
+        prop,
+        target: process,
+        violationType: "process_exception_handler",
+        strategy: "throw",
+        reason: "process-global listeners can outlive the sandbox and lose its security context"
+      })
+    ),
     // IPC communication vectors (may be undefined in non-IPC contexts)
     {
       prop: "send",
@@ -505,10 +524,13 @@ function getBlockedGlobals() {
 // src/security/defense-in-depth-box.ts
 var IS_BROWSER = typeof __BROWSER__ !== "undefined" && __BROWSER__;
 var AsyncLocalStorageClass = null;
+var nodeModuleApi = null;
+var nodeModuleClass = null;
 if (!IS_BROWSER) {
   try {
-    const { AsyncLocalStorage } = __require("node:async_hooks");
-    AsyncLocalStorageClass = AsyncLocalStorage;
+    AsyncLocalStorageClass = nodeAsyncHooks.AsyncLocalStorage;
+    nodeModuleApi = nodeModule;
+    nodeModuleClass = nodeModuleApi.Module ?? nodeModuleApi.default ?? null;
   } catch {
   }
 }
@@ -525,6 +547,25 @@ var WorkerSecurityViolationError = class extends Error {
   violation;
 };
 var MAX_STORED_VIOLATIONS = 1e3;
+var nodeModuleClass2 = null;
+try {
+  const getBuiltinModule = process.getBuiltinModule;
+  const moduleApi = typeof getBuiltinModule === "function" ? getBuiltinModule("module") : typeof __require === "function" ? (
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    __require("node:module")
+  ) : null;
+  nodeModuleClass2 = moduleApi?.Module ?? moduleApi?.default ?? null;
+  if (typeof getBuiltinModule === "function") {
+    const workerThreads = getBuiltinModule("worker_threads");
+    const isWorkerThread = workerThreads?.isMainThread === false;
+    if (isWorkerThread) {
+      const cryptoApi = getBuiltinModule("crypto");
+      cryptoApi?.randomUUID?.();
+    }
+  }
+} catch {
+  nodeModuleClass2 = null;
+}
 function generateExecutionId() {
   if (typeof crypto !== "undefined" && crypto.randomUUID) {
     return crypto.randomUUID();
@@ -539,6 +580,7 @@ var WorkerDefenseInDepth = class {
   config;
   isActivated = false;
   originalDescriptors = [];
+  patchFailures = [];
   violations = [];
   executionId;
   /**
@@ -604,8 +646,14 @@ var WorkerDefenseInDepth = class {
     if (this.isActivated) {
       return;
     }
-    this.applyPatches();
-    this.isActivated = true;
+    try {
+      this.applyPatches();
+      this.isActivated = true;
+    } catch (error) {
+      this.restorePatches();
+      this.isActivated = false;
+      throw error;
+    }
   }
   /**
    * Get a human-readable path for a target object and property.
@@ -853,16 +901,64 @@ var WorkerDefenseInDepth = class {
       }
     });
   }
+  createReadonlyObjectProxy(original, path, violationType) {
+    const auditMode = this.config.auditMode;
+    const allowOrThrow = (operation) => {
+      const message = `${path} ${operation} is blocked in worker context`;
+      const violation = this.recordViolation(violationType, path, message);
+      if (!auditMode) {
+        throw new WorkerSecurityViolationError(message, violation);
+      }
+    };
+    return new this.originalProxy(original, {
+      set(target, prop, value, receiver) {
+        allowOrThrow("modification");
+        return Reflect.set(target, prop, value, receiver);
+      },
+      defineProperty(target, prop, descriptor) {
+        allowOrThrow("defineProperty");
+        return Reflect.defineProperty(target, prop, descriptor);
+      },
+      deleteProperty(target, prop) {
+        allowOrThrow("deletion");
+        return Reflect.deleteProperty(target, prop);
+      },
+      setPrototypeOf(target, prototype) {
+        allowOrThrow("setPrototypeOf");
+        return Reflect.setPrototypeOf(target, prototype);
+      },
+      preventExtensions(target) {
+        allowOrThrow("preventExtensions");
+        return Reflect.preventExtensions(target);
+      }
+    });
+  }
   /**
    * Apply security patches to dangerous globals.
    */
   applyPatches() {
+    this.patchFailures = [];
     const blockedGlobals = getBlockedGlobals();
     const excludeTypes = new Set(this.config.excludeViolationTypes ?? []);
+    const workerInfrastructureListenerMethods = /* @__PURE__ */ new Set([
+      "on",
+      "once",
+      "addListener",
+      "prependListener",
+      "prependOnceListener"
+    ]);
+    const permanentIntrinsicPatches = [];
     for (const blocked of blockedGlobals) {
       if (excludeTypes.has(blocked.violationType)) {
         continue;
       }
+      if (blocked.target === process && workerInfrastructureListenerMethods.has(blocked.prop)) {
+        continue;
+      }
+      if (blocked.strategy === "freeze") {
+        permanentIntrinsicPatches.push(blocked);
+        continue;
+      }
       this.applyPatch(blocked);
     }
     if (!excludeTypes.has("function_constructor")) {
@@ -886,10 +982,27 @@ var WorkerDefenseInDepth = class {
     if (!excludeTypes.has("process_connected")) {
       this.protectProcessConnected();
     }
-    this.lockWellKnownSymbols();
     if (!excludeTypes.has("proxy")) {
       this.protectProxyRevocable();
     }
+    const criticalPaths = [
+      "Function.prototype.constructor",
+      "Module._load",
+      "Module._resolveFilename"
+    ];
+    const criticalFailures = this.patchFailures.filter(
+      (path) => criticalPaths.includes(path)
+    );
+    if (criticalFailures.length > 0) {
+      this.restorePatches();
+      throw new Error(
+        `WorkerDefenseInDepth: critical patches failed: ${criticalFailures.join(", ")}`
+      );
+    }
+    for (const blocked of permanentIntrinsicPatches) {
+      this.applyPatch(blocked);
+    }
+    this.lockWellKnownSymbols();
   }
   /**
    * Lock well-known Symbol properties on built-in constructors/prototypes.
@@ -944,23 +1057,6 @@ var WorkerDefenseInDepth = class {
     ]) {
       lock(proto, Symbol.toStringTag);
     }
-    try {
-      const stackDesc = Object.getOwnPropertyDescriptor(
-        Error,
-        "stackTraceLimit"
-      );
-      this.originalDescriptors.push({
-        target: Error,
-        prop: "stackTraceLimit",
-        descriptor: stackDesc
-      });
-      Object.defineProperty(Error, "stackTraceLimit", {
-        value: Error.stackTraceLimit,
-        writable: false,
-        configurable: true
-      });
-    } catch {
-    }
   }
   /**
    * Block Proxy.revocable to prevent bypassing Proxy constructor blocking.
@@ -1175,6 +1271,7 @@ var WorkerDefenseInDepth = class {
         configurable: true
       });
     } catch {
+      this.patchFailures.push(path);
     }
   }
   /**
@@ -1367,47 +1464,7 @@ var WorkerDefenseInDepth = class {
    * We access the Module class and replace _load with a blocking proxy.
    */
   protectModuleLoad() {
-    const self = this;
-    const auditMode = this.config.auditMode;
-    try {
-      let ModuleClass = null;
-      if (typeof process !== "undefined") {
-        const mainModule = process.mainModule;
-        if (mainModule && typeof mainModule === "object") {
-          ModuleClass = mainModule.constructor;
-        }
-      }
-      if (!ModuleClass && typeof __require !== "undefined" && typeof __require.main !== "undefined") {
-        ModuleClass = __require.main.constructor;
-      }
-      if (!ModuleClass || typeof ModuleClass._load !== "function") {
-        return;
-      }
-      const original = ModuleClass._load;
-      const descriptor = Object.getOwnPropertyDescriptor(ModuleClass, "_load");
-      this.originalDescriptors.push({
-        target: ModuleClass,
-        prop: "_load",
-        descriptor
-      });
-      const path = "Module._load";
-      const proxy = new this.originalProxy(original, {
-        apply(_target, _thisArg, _args) {
-          const message = `${path} is blocked in worker context`;
-          const violation = self.recordViolation("module_load", path, message);
-          if (!auditMode) {
-            throw new WorkerSecurityViolationError(message, violation);
-          }
-          return Reflect.apply(_target, _thisArg, _args);
-        }
-      });
-      Object.defineProperty(ModuleClass, "_load", {
-        value: proxy,
-        writable: true,
-        configurable: true
-      });
-    } catch {
-    }
+    this.protectModuleMethod("_load", "module_load");
   }
   /**
    * Protect Module._resolveFilename from being called in worker context.
@@ -1419,53 +1476,55 @@ var WorkerDefenseInDepth = class {
    * in the main thread (DefenseInDepthBox.protectDynamicImport).
    */
   protectModuleResolveFilename() {
+    this.protectModuleMethod("_resolveFilename", "module_resolve_filename");
+  }
+  protectModuleMethod(prop, violationType) {
+    const path = `Module.${prop}`;
     const self = this;
     const auditMode = this.config.auditMode;
     try {
-      let ModuleClass = null;
-      if (typeof process !== "undefined") {
-        const mainModule = process.mainModule;
-        if (mainModule && typeof mainModule === "object") {
-          ModuleClass = mainModule.constructor;
-        }
+      const ModuleClass = nodeModuleClass2;
+      const original = ModuleClass?.[prop];
+      if (!ModuleClass || typeof original !== "function") {
+        throw new Error("node:module Module class or method is unavailable");
       }
-      if (!ModuleClass && typeof __require !== "undefined" && typeof __require.main !== "undefined") {
-        ModuleClass = __require.main.constructor;
+      const descriptor = Object.getOwnPropertyDescriptor(ModuleClass, prop);
+      if (!descriptor) throw new Error("method descriptor is unavailable");
+      if (descriptor.configurable === false && descriptor.writable === false) {
+        throw new Error("method is non-configurable and non-writable");
       }
-      if (!ModuleClass || typeof ModuleClass._resolveFilename !== "function") {
-        return;
-      }
-      const original = ModuleClass._resolveFilename;
-      const descriptor = Object.getOwnPropertyDescriptor(
-        ModuleClass,
-        "_resolveFilename"
+      const proxy = new this.originalProxy(
+        original,
+        {
+          apply(target, thisArg, args) {
+            const message = `${path} is blocked in worker context`;
+            const violation = self.recordViolation(
+              violationType,
+              path,
+              message
+            );
+            if (!auditMode) {
+              throw new WorkerSecurityViolationError(message, violation);
+            }
+            return Reflect.apply(target, thisArg, args);
+          }
+        }
       );
       this.originalDescriptors.push({
         target: ModuleClass,
-        prop: "_resolveFilename",
+        prop,
         descriptor
       });
-      const path = "Module._resolveFilename";
-      const proxy = new this.originalProxy(original, {
-        apply(_target, _thisArg, _args) {
-          const message = `${path} is blocked in worker context`;
-          const violation = self.recordViolation(
-            "module_resolve_filename",
-            path,
-            message
-          );
-          if (!auditMode) {
-            throw new WorkerSecurityViolationError(message, violation);
-          }
-          return Reflect.apply(_target, _thisArg, _args);
-        }
-      });
-      Object.defineProperty(ModuleClass, "_resolveFilename", {
-        value: proxy,
-        writable: true,
-        configurable: true
+      Object.defineProperty(ModuleClass, prop, {
+        ...descriptor,
+        value: proxy
       });
+      const installed = Object.getOwnPropertyDescriptor(ModuleClass, prop);
+      if (ModuleClass[prop] !== proxy || installed?.value !== proxy) {
+        throw new Error("installed patch failed verification");
+      }
     } catch {
+      this.patchFailures.push(path);
     }
   }
   /**
@@ -1483,6 +1542,16 @@ var WorkerDefenseInDepth = class {
       if (strategy === "freeze") {
         if (typeof original === "object" && original !== null) {
           Object.freeze(original);
+          const path = this.getPathForTarget(target, prop);
+          const proxy = this.createReadonlyObjectProxy(
+            original,
+            path,
+            violationType
+          );
+          Object.defineProperty(target, prop, {
+            ...descriptor,
+            value: proxy
+          });
         }
       } else {
         const path = this.getPathForTarget(target, prop);
@@ -1545,6 +1614,7 @@ var _SharedArrayBuffer = globalThis.SharedArrayBuffer;
 var _Atomics = globalThis.Atomics;
 var _performanceNow = performance.now.bind(performance);
 var _Headers = globalThis.Headers;
+var _Proxy = globalThis.Proxy;
 
 // src/commands/worker-bridge/protocol.ts
 var OpCode = {
@@ -2095,8 +2165,9 @@ function assertApprovedPath(path, kind) {
 }
 try {
   const NodeModule = require2("node:module");
-  if (typeof NodeModule._load === "function") {
+  if (typeof NodeModule._load === "function" && typeof NodeModule._resolveFilename === "function") {
     const originalLoad = NodeModule._load;
+    const originalResolveFilename = NodeModule._resolveFilename;
     const blockedModules = /* @__PURE__ */ new Set([
       "child_process",
       "node:child_process",
@@ -2133,6 +2204,14 @@ try {
       }
       return originalLoad.apply(this, [request, ...rest]);
     };
+    NodeModule._resolveFilename = function(request, ...rest) {
+      if (blockedModules.has(request)) {
+        throw new Error(
+          `[Defense-in-depth] resolving '${request}' is blocked in worker context`
+        );
+      }
+      return originalResolveFilename.apply(this, [request, ...rest]);
+    };
     moduleLoadGuardInstalled = true;
   }
 } catch {
@@ -2149,7 +2228,8 @@ assertApprovedPath(cpythonEntryPath, "cpython-entry");
 var cpythonDir = dirname(cpythonEntryPath);
 var stdlibZipPath = `${cpythonDir}/python313.zip`;
 assertApprovedPath(stdlibZipPath, "cpython-stdlib");
-function createHOSTFS(backend, FS, PATH) {
+function createHOSTFS(backend, FS, PATH, configuredMaxFileSize) {
+  const maxFileSize = Number.isSafeInteger(configuredMaxFileSize) && configuredMaxFileSize >= 0 ? configuredMaxFileSize : 0;
   const ERRNO_CODES = Object.assign(
     /* @__PURE__ */ Object.create(null),
     {
@@ -2164,6 +2244,7 @@ function createHOSTFS(backend, FS, PATH) {
       ENOTDIR: 54,
       EISDIR: 31,
       EINVAL: 28,
+      EFBIG: 27,
       EMFILE: 33,
       ENOSPC: 51,
       ESPIPE: 70,
@@ -2271,9 +2352,13 @@ function createHOSTFS(backend, FS, PATH) {
           node.mode = mode;
         }
         if (attr.size !== void 0) {
+          if (!Number.isSafeInteger(attr.size) || attr.size < 0 || attr.size > maxFileSize) {
+            throw new FS.ErrnoError(ERRNO_CODES.EFBIG);
+          }
           tryFSOperation(() => {
             const content = backend.readFile(path);
-            const newContent = content.slice(0, attr.size);
+            const newContent = new Uint8Array(attr.size);
+            newContent.set(content.subarray(0, attr.size));
             backend.writeFile(path, newContent);
           });
         }
@@ -2357,6 +2442,9 @@ function createHOSTFS(backend, FS, PATH) {
             throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
           }
         }
+        if (content.length > maxFileSize) {
+          throw new FS.ErrnoError(ERRNO_CODES.EFBIG);
+        }
         stream.hostContent = content;
         stream.hostModified = isTruncate && isWrite;
         stream.hostPath = path;
@@ -2384,6 +2472,9 @@ function createHOSTFS(backend, FS, PATH) {
         return bytesToRead;
       },
       write(stream, buffer, offset, length, position) {
+        if (!Number.isSafeInteger(position) || !Number.isSafeInteger(length) || !Number.isSafeInteger(offset) || position < 0 || length < 0 || offset < 0 || length > buffer.length - offset || position > maxFileSize - length) {
+          throw new FS.ErrnoError(ERRNO_CODES.EFBIG);
+        }
         let content = stream.hostContent || new Uint8Array(0);
         const newSize = Math.max(content.length, position + length);
         if (newSize > content.length) {
@@ -2397,8 +2488,12 @@ function createHOSTFS(backend, FS, PATH) {
         return length;
       },
       llseek(stream, offset, whence) {
+        const SEEK_SET = 0;
         const SEEK_CUR = 1;
         const SEEK_END = 2;
+        if (whence !== SEEK_SET && whence !== SEEK_CUR && whence !== SEEK_END) {
+          throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+        }
         let position = offset;
         if (whence === SEEK_CUR) {
           position += stream.position;
@@ -2408,7 +2503,7 @@ function createHOSTFS(backend, FS, PATH) {
             position += content ? content.length : 0;
           }
         }
-        if (position < 0) {
+        if (!Number.isSafeInteger(position) || position < 0 || position > maxFileSize) {
           throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
         }
         return position;
@@ -3025,11 +3120,15 @@ async function runPython(input) {
       error: `Failed to load CPython: ${message}`
     };
   }
-  activateDefense(input.protocolToken);
   moduleReady = true;
   for (const text of pendingStdout) backend.writeStdout(text);
   for (const text of pendingStderr) backend.writeStderr(text);
-  const HOSTFS = createHOSTFS(backend, Module.FS, Module.PATH);
+  const HOSTFS = createHOSTFS(
+    backend,
+    Module.FS,
+    Module.PATH,
+    input.maxFileSize ?? 8 * 1024 * 1024
+  );
   try {
     Module.FS.mkdir("/host");
     Module.FS.mount(HOSTFS, { root: "/" }, "/host");
@@ -3077,6 +3176,7 @@ sys.exit(_jb_exit_code)
   const scriptData = encoder.encode(wrappedCode);
   Module.FS.writeFile(scriptPath, scriptData);
   try {
+    activateDefense(input.protocolToken);
     const ret = Module.callMain([scriptPath]);
     const exitCode = (typeof ret === "number" ? ret : 0) || process.exitCode || 0;
     backend.exit(exitCode);
@@ -3116,7 +3216,14 @@ function activateDefense(protocolToken) {
       "atomics",
       // performance: Excluded because we replaced it above with a ms-precision
       // stub. Defense doesn't need to block it — it's already degraded.
-      "performance_timing"
+      "performance_timing",
+      // CPython's Emscripten runtime performs lazy CJS loads during callMain.
+      // A worker-entry guard installed before CPython loads rejects the exact
+      // dangerous builtin set without relying on loader stack text. CPython
+      // exposes no JS bridge to guest Python, so this compatibility exclusion
+      // does not make Module methods guest-reachable.
+      "module_load",
+      "module_resolve_filename"
     ],
     onViolation
   });

package/dist/bundle/chunks/xan-KKPV2TJ3.js

@@ -0,0 +1,2 @@
+import{createRequire} from"node:module";const require=createRequire(import.meta.url);
+import{a,b}from"./chunk-5KGKXQF6.js";import"./chunk-3DHFIWMM.js";import"./chunk-Y3DGIAIG.js";import"./chunk-65Z4QURM.js";import"./chunk-FIMO5HLX.js";import"./chunk-DLL7UR66.js";import"./chunk-AI5LSBJC.js";import"./chunk-XVL654YD.js";import"./chunk-CHHWTPDH.js";import"./chunk-LJRVJXUI.js";import"./chunk-UBTKJ6MG.js";import"./chunk-6D3WD6YU.js";import"./chunk-AH7VTVWU.js";import"./chunk-STHBFACM.js";import"./chunk-EFORKKSH.js";import"./chunk-GN6CQ3J4.js";import"./chunk-QAYAQNCG.js";import"./chunk-NCUTH6QL.js";export{b as flagsForFuzzing,a as xanCommand};

package/dist/bundle/chunks/xan-view-47P277LZ.js

@@ -0,0 +1,2 @@
+import{createRequire} from"node:module";const require=createRequire(import.meta.url);
+import{k as a,l as b}from"./chunk-3DHFIWMM.js";import"./chunk-Y3DGIAIG.js";import"./chunk-LJRVJXUI.js";import"./chunk-UBTKJ6MG.js";import"./chunk-AH7VTVWU.js";import"./chunk-EFORKKSH.js";import"./chunk-GN6CQ3J4.js";import"./chunk-NCUTH6QL.js";export{a as cmdFlatten,b as cmdView};

package/dist/bundle/chunks/xargs-L7TJHOJT.js

@@ -0,0 +1,2 @@
+import{createRequire} from"node:module";const require=createRequire(import.meta.url);
+import{a,b}from"./chunk-EQQGPAXI.js";import"./chunk-J2OBOJ64.js";import"./chunk-L2UW7DWF.js";import"./chunk-6D3WD6YU.js";import"./chunk-EFORKKSH.js";import"./chunk-GN6CQ3J4.js";import"./chunk-QAYAQNCG.js";import"./chunk-NCUTH6QL.js";export{b as flagsForFuzzing,a as xargsCommand};

package/dist/bundle/chunks/yq-ZGB3W46S.js

@@ -0,0 +1,2 @@
+import{createRequire} from"node:module";const require=createRequire(import.meta.url);
+import{a,b}from"./chunk-NOPXHH6G.js";import"./chunk-Y3DGIAIG.js";import"./chunk-65Z4QURM.js";import"./chunk-FIMO5HLX.js";import"./chunk-DLL7UR66.js";import"./chunk-AI5LSBJC.js";import"./chunk-XVL654YD.js";import"./chunk-UBTKJ6MG.js";import"./chunk-6D3WD6YU.js";import"./chunk-AH7VTVWU.js";import"./chunk-EFORKKSH.js";import"./chunk-GN6CQ3J4.js";import"./chunk-FOCWZZDE.js";import"./chunk-QAYAQNCG.js";import"./chunk-NCUTH6QL.js";export{b as flagsForFuzzing,a as yqCommand};