@poe-platform/safe-bash 0.1.534 → 0.1.535

package/dist/safe-bash/chunks/{chunk-LUJYX5H5.js → chunk-L2GZSOSJ.js}

@@ -106,34 +106,34 @@ var require_base64_js = __commonJS({
     }
     function encodeChunk(uint8, start, end) {
       var tmp;
-      var output2 = [];
+      var output = [];
       for (var i2 = start; i2 < end; i2 += 3) {
         tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
-        output2.push(tripletToBase64(tmp));
+        output.push(tripletToBase64(tmp));
       }
-      return output2.join("");
+      return output.join("");
     }
     function fromByteArray(uint8) {
       var tmp;
       var len2 = uint8.length;
       var extraBytes = len2 % 3;
-      var parts2 = [];
+      var parts = [];
       var maxChunkLength = 16383;
       for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
-        parts2.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+        parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
       }
       if (extraBytes === 1) {
         tmp = uint8[len2 - 1];
-        parts2.push(
+        parts.push(
           lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="
         );
       } else if (extraBytes === 2) {
         tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
-        parts2.push(
+        parts.push(
           lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
         );
       }
-      return parts2.join("");
+      return parts.join("");
     }
   }
 });
@@ -172,7 +172,7 @@ var require_ieee754 = __commonJS({
       }
       return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
     };
-    exports.write = function(buffer, value2, offset, isLE, mLen, nBytes) {
+    exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
       var e, m, c;
       var eLen = nBytes * 8 - mLen - 1;
       var eMax = (1 << eLen) - 1;
@@ -180,23 +180,23 @@ var require_ieee754 = __commonJS({
       var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
       var i = isLE ? 0 : nBytes - 1;
       var d = isLE ? 1 : -1;
-      var s = value2 < 0 || value2 === 0 && 1 / value2 < 0 ? 1 : 0;
-      value2 = Math.abs(value2);
-      if (isNaN(value2) || value2 === Infinity) {
-        m = isNaN(value2) ? 1 : 0;
+      var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+      value = Math.abs(value);
+      if (isNaN(value) || value === Infinity) {
+        m = isNaN(value) ? 1 : 0;
         e = eMax;
       } else {
-        e = Math.floor(Math.log(value2) / Math.LN2);
-        if (value2 * (c = Math.pow(2, -e)) < 1) {
+        e = Math.floor(Math.log(value) / Math.LN2);
+        if (value * (c = Math.pow(2, -e)) < 1) {
           e--;
           c *= 2;
         }
         if (e + eBias >= 1) {
-          value2 += rt / c;
+          value += rt / c;
         } else {
-          value2 += rt * Math.pow(2, 1 - eBias);
+          value += rt * Math.pow(2, 1 - eBias);
         }
-        if (value2 * c >= 2) {
+        if (value * c >= 2) {
           e++;
           c /= 2;
         }
@@ -204,10 +204,10 @@ var require_ieee754 = __commonJS({
           m = 0;
           e = eMax;
         } else if (e + eBias >= 1) {
-          m = (value2 * c - 1) * Math.pow(2, mLen);
+          m = (value * c - 1) * Math.pow(2, mLen);
           e = e + eBias;
         } else {
-          m = value2 * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
           e = 0;
         }
       }
@@ -288,44 +288,44 @@ var require_buffer = __commonJS({
       return from(arg, encodingOrOffset, length);
     }
     Buffer3.poolSize = 8192;
-    function from(value2, encodingOrOffset, length) {
-      if (typeof value2 === "string") {
-        return fromString(value2, encodingOrOffset);
+    function from(value, encodingOrOffset, length) {
+      if (typeof value === "string") {
+        return fromString(value, encodingOrOffset);
       }
-      if (ArrayBuffer.isView(value2)) {
-        return fromArrayView(value2);
+      if (ArrayBuffer.isView(value)) {
+        return fromArrayView(value);
       }
-      if (value2 == null) {
+      if (value == null) {
         throw new TypeError(
-          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value2
+          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
         );
       }
-      if (isInstance(value2, ArrayBuffer) || value2 && isInstance(value2.buffer, ArrayBuffer)) {
-        return fromArrayBuffer(value2, encodingOrOffset, length);
+      if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
       }
-      if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value2, SharedArrayBuffer) || value2 && isInstance(value2.buffer, SharedArrayBuffer))) {
-        return fromArrayBuffer(value2, encodingOrOffset, length);
+      if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
       }
-      if (typeof value2 === "number") {
+      if (typeof value === "number") {
         throw new TypeError(
           'The "value" argument must not be of type number. Received type number'
         );
       }
-      const valueOf = value2.valueOf && value2.valueOf();
-      if (valueOf != null && valueOf !== value2) {
+      const valueOf = value.valueOf && value.valueOf();
+      if (valueOf != null && valueOf !== value) {
         return Buffer3.from(valueOf, encodingOrOffset, length);
       }
-      const b = fromObject(value2);
+      const b = fromObject(value);
       if (b) return b;
-      if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value2[Symbol.toPrimitive] === "function") {
-        return Buffer3.from(value2[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+      if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+        return Buffer3.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
       }
       throw new TypeError(
-        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value2
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
       );
     }
-    Buffer3.from = function(value2, encodingOrOffset, length) {
-      return from(value2, encodingOrOffset, length);
+    Buffer3.from = function(value, encodingOrOffset, length) {
+      return from(value, encodingOrOffset, length);
     };
     Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype);
     Object.setPrototypeOf(Buffer3, Uint8Array);
@@ -1239,89 +1239,89 @@ var require_buffer = __commonJS({
       if (!noAssert) checkOffset(offset, 8, this.length);
       return ieee754.read(this, offset, false, 52, 8);
     };
-    function checkInt(buf, value2, offset, ext, max, min) {
+    function checkInt(buf, value, offset, ext, max, min) {
       if (!Buffer3.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
-      if (value2 > max || value2 < min) throw new RangeError('"value" argument is out of bounds');
+      if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
       if (offset + ext > buf.length) throw new RangeError("Index out of range");
     }
-    Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value2, offset, byteLength2, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) {
         const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
-        checkInt(this, value2, offset, byteLength2, maxBytes, 0);
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
       }
       let mul = 1;
       let i = 0;
-      this[offset] = value2 & 255;
+      this[offset] = value & 255;
       while (++i < byteLength2 && (mul *= 256)) {
-        this[offset + i] = value2 / mul & 255;
+        this[offset + i] = value / mul & 255;
       }
       return offset + byteLength2;
     };
-    Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value2, offset, byteLength2, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) {
         const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
-        checkInt(this, value2, offset, byteLength2, maxBytes, 0);
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
       }
       let i = byteLength2 - 1;
       let mul = 1;
-      this[offset + i] = value2 & 255;
+      this[offset + i] = value & 255;
       while (--i >= 0 && (mul *= 256)) {
-        this[offset + i] = value2 / mul & 255;
+        this[offset + i] = value / mul & 255;
       }
       return offset + byteLength2;
     };
-    Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value2, offset, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+      value = +value;
       offset = offset >>> 0;
-      if (!noAssert) checkInt(this, value2, offset, 1, 255, 0);
-      this[offset] = value2 & 255;
+      if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
+      this[offset] = value & 255;
       return offset + 1;
     };
-    Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value2, offset, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+      value = +value;
       offset = offset >>> 0;
-      if (!noAssert) checkInt(this, value2, offset, 2, 65535, 0);
-      this[offset] = value2 & 255;
-      this[offset + 1] = value2 >>> 8;
+      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
       return offset + 2;
     };
-    Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value2, offset, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+      value = +value;
       offset = offset >>> 0;
-      if (!noAssert) checkInt(this, value2, offset, 2, 65535, 0);
-      this[offset] = value2 >>> 8;
-      this[offset + 1] = value2 & 255;
+      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
       return offset + 2;
     };
-    Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value2, offset, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+      value = +value;
       offset = offset >>> 0;
-      if (!noAssert) checkInt(this, value2, offset, 4, 4294967295, 0);
-      this[offset + 3] = value2 >>> 24;
-      this[offset + 2] = value2 >>> 16;
-      this[offset + 1] = value2 >>> 8;
-      this[offset] = value2 & 255;
+      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+      this[offset + 3] = value >>> 24;
+      this[offset + 2] = value >>> 16;
+      this[offset + 1] = value >>> 8;
+      this[offset] = value & 255;
       return offset + 4;
     };
-    Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value2, offset, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+      value = +value;
       offset = offset >>> 0;
-      if (!noAssert) checkInt(this, value2, offset, 4, 4294967295, 0);
-      this[offset] = value2 >>> 24;
-      this[offset + 1] = value2 >>> 16;
-      this[offset + 2] = value2 >>> 8;
-      this[offset + 3] = value2 & 255;
+      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
       return offset + 4;
     };
-    function wrtBigUInt64LE(buf, value2, offset, min, max) {
-      checkIntBI(value2, min, max, buf, offset, 7);
-      let lo = Number(value2 & BigInt(4294967295));
+    function wrtBigUInt64LE(buf, value, offset, min, max) {
+      checkIntBI(value, min, max, buf, offset, 7);
+      let lo = Number(value & BigInt(4294967295));
       buf[offset++] = lo;
       lo = lo >> 8;
       buf[offset++] = lo;
@@ -1329,7 +1329,7 @@ var require_buffer = __commonJS({
       buf[offset++] = lo;
       lo = lo >> 8;
       buf[offset++] = lo;
-      let hi = Number(value2 >> BigInt(32) & BigInt(4294967295));
+      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
       buf[offset++] = hi;
       hi = hi >> 8;
       buf[offset++] = hi;
@@ -1339,9 +1339,9 @@ var require_buffer = __commonJS({
       buf[offset++] = hi;
       return offset;
     }
-    function wrtBigUInt64BE(buf, value2, offset, min, max) {
-      checkIntBI(value2, min, max, buf, offset, 7);
-      let lo = Number(value2 & BigInt(4294967295));
+    function wrtBigUInt64BE(buf, value, offset, min, max) {
+      checkIntBI(value, min, max, buf, offset, 7);
+      let lo = Number(value & BigInt(4294967295));
       buf[offset + 7] = lo;
       lo = lo >> 8;
       buf[offset + 6] = lo;
@@ -1349,7 +1349,7 @@ var require_buffer = __commonJS({
       buf[offset + 5] = lo;
       lo = lo >> 8;
       buf[offset + 4] = lo;
-      let hi = Number(value2 >> BigInt(32) & BigInt(4294967295));
+      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
       buf[offset + 3] = hi;
       hi = hi >> 8;
       buf[offset + 2] = hi;
@@ -1359,134 +1359,134 @@ var require_buffer = __commonJS({
       buf[offset] = hi;
       return offset + 8;
     }
-    Buffer3.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value2, offset = 0) {
-      return wrtBigUInt64LE(this, value2, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    Buffer3.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
     });
-    Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value2, offset = 0) {
-      return wrtBigUInt64BE(this, value2, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
     });
-    Buffer3.prototype.writeIntLE = function writeIntLE(value2, offset, byteLength2, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
       offset = offset >>> 0;
       if (!noAssert) {
         const limit = Math.pow(2, 8 * byteLength2 - 1);
-        checkInt(this, value2, offset, byteLength2, limit - 1, -limit);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
       }
       let i = 0;
       let mul = 1;
       let sub = 0;
-      this[offset] = value2 & 255;
+      this[offset] = value & 255;
       while (++i < byteLength2 && (mul *= 256)) {
-        if (value2 < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+        if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
           sub = 1;
         }
-        this[offset + i] = (value2 / mul >> 0) - sub & 255;
+        this[offset + i] = (value / mul >> 0) - sub & 255;
       }
       return offset + byteLength2;
     };
-    Buffer3.prototype.writeIntBE = function writeIntBE(value2, offset, byteLength2, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
       offset = offset >>> 0;
       if (!noAssert) {
         const limit = Math.pow(2, 8 * byteLength2 - 1);
-        checkInt(this, value2, offset, byteLength2, limit - 1, -limit);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
       }
       let i = byteLength2 - 1;
       let mul = 1;
       let sub = 0;
-      this[offset + i] = value2 & 255;
+      this[offset + i] = value & 255;
       while (--i >= 0 && (mul *= 256)) {
-        if (value2 < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+        if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
           sub = 1;
         }
-        this[offset + i] = (value2 / mul >> 0) - sub & 255;
+        this[offset + i] = (value / mul >> 0) - sub & 255;
       }
       return offset + byteLength2;
     };
-    Buffer3.prototype.writeInt8 = function writeInt8(value2, offset, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+      value = +value;
       offset = offset >>> 0;
-      if (!noAssert) checkInt(this, value2, offset, 1, 127, -128);
-      if (value2 < 0) value2 = 255 + value2 + 1;
-      this[offset] = value2 & 255;
+      if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
+      if (value < 0) value = 255 + value + 1;
+      this[offset] = value & 255;
       return offset + 1;
     };
-    Buffer3.prototype.writeInt16LE = function writeInt16LE(value2, offset, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+      value = +value;
       offset = offset >>> 0;
-      if (!noAssert) checkInt(this, value2, offset, 2, 32767, -32768);
-      this[offset] = value2 & 255;
-      this[offset + 1] = value2 >>> 8;
+      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
       return offset + 2;
     };
-    Buffer3.prototype.writeInt16BE = function writeInt16BE(value2, offset, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+      value = +value;
       offset = offset >>> 0;
-      if (!noAssert) checkInt(this, value2, offset, 2, 32767, -32768);
-      this[offset] = value2 >>> 8;
-      this[offset + 1] = value2 & 255;
+      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
       return offset + 2;
     };
-    Buffer3.prototype.writeInt32LE = function writeInt32LE(value2, offset, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+      value = +value;
       offset = offset >>> 0;
-      if (!noAssert) checkInt(this, value2, offset, 4, 2147483647, -2147483648);
-      this[offset] = value2 & 255;
-      this[offset + 1] = value2 >>> 8;
-      this[offset + 2] = value2 >>> 16;
-      this[offset + 3] = value2 >>> 24;
+      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      this[offset + 2] = value >>> 16;
+      this[offset + 3] = value >>> 24;
       return offset + 4;
     };
-    Buffer3.prototype.writeInt32BE = function writeInt32BE(value2, offset, noAssert) {
-      value2 = +value2;
+    Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+      value = +value;
       offset = offset >>> 0;
-      if (!noAssert) checkInt(this, value2, offset, 4, 2147483647, -2147483648);
-      if (value2 < 0) value2 = 4294967295 + value2 + 1;
-      this[offset] = value2 >>> 24;
-      this[offset + 1] = value2 >>> 16;
-      this[offset + 2] = value2 >>> 8;
-      this[offset + 3] = value2 & 255;
+      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      if (value < 0) value = 4294967295 + value + 1;
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
       return offset + 4;
     };
-    Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value2, offset = 0) {
-      return wrtBigUInt64LE(this, value2, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
     });
-    Buffer3.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value2, offset = 0) {
-      return wrtBigUInt64BE(this, value2, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    Buffer3.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
+      return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
     });
-    function checkIEEE754(buf, value2, offset, ext, max, min) {
+    function checkIEEE754(buf, value, offset, ext, max, min) {
       if (offset + ext > buf.length) throw new RangeError("Index out of range");
       if (offset < 0) throw new RangeError("Index out of range");
     }
-    function writeFloat(buf, value2, offset, littleEndian, noAssert) {
-      value2 = +value2;
+    function writeFloat(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
       offset = offset >>> 0;
       if (!noAssert) {
-        checkIEEE754(buf, value2, offset, 4, 34028234663852886e22, -34028234663852886e22);
+        checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
       }
-      ieee754.write(buf, value2, offset, littleEndian, 23, 4);
+      ieee754.write(buf, value, offset, littleEndian, 23, 4);
       return offset + 4;
     }
-    Buffer3.prototype.writeFloatLE = function writeFloatLE(value2, offset, noAssert) {
-      return writeFloat(this, value2, offset, true, noAssert);
+    Buffer3.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, true, noAssert);
     };
-    Buffer3.prototype.writeFloatBE = function writeFloatBE(value2, offset, noAssert) {
-      return writeFloat(this, value2, offset, false, noAssert);
+    Buffer3.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, false, noAssert);
     };
-    function writeDouble(buf, value2, offset, littleEndian, noAssert) {
-      value2 = +value2;
+    function writeDouble(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
       offset = offset >>> 0;
       if (!noAssert) {
-        checkIEEE754(buf, value2, offset, 8, 17976931348623157e292, -17976931348623157e292);
+        checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
       }
-      ieee754.write(buf, value2, offset, littleEndian, 52, 8);
+      ieee754.write(buf, value, offset, littleEndian, 52, 8);
       return offset + 8;
     }
-    Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value2, offset, noAssert) {
-      return writeDouble(this, value2, offset, true, noAssert);
+    Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, true, noAssert);
     };
-    Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value2, offset, noAssert) {
-      return writeDouble(this, value2, offset, false, noAssert);
+    Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, false, noAssert);
     };
     Buffer3.prototype.copy = function copy(target, targetStart, start, end) {
       if (!Buffer3.isBuffer(target)) throw new TypeError("argument should be a Buffer");
@@ -1588,11 +1588,11 @@ var require_buffer = __commonJS({
         get code() {
           return sym;
         }
-        set code(value2) {
+        set code(value) {
           Object.defineProperty(this, "code", {
             configurable: true,
             enumerable: true,
-            value: value2,
+            value,
             writable: true
           });
         }
@@ -1620,14 +1620,14 @@ var require_buffer = __commonJS({
     );
     E(
       "ERR_OUT_OF_RANGE",
-      function(str, range, input2) {
+      function(str, range, input) {
         let msg = `The value of "${str}" is out of range.`;
-        let received = input2;
-        if (Number.isInteger(input2) && Math.abs(input2) > 2 ** 32) {
-          received = addNumericalSeparator(String(input2));
-        } else if (typeof input2 === "bigint") {
-          received = String(input2);
-          if (input2 > BigInt(2) ** BigInt(32) || input2 < -(BigInt(2) ** BigInt(32))) {
+        let received = input;
+        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+          received = addNumericalSeparator(String(input));
+        } else if (typeof input === "bigint") {
+          received = String(input);
+          if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
             received = addNumericalSeparator(received);
           }
           received += "n";
@@ -1652,8 +1652,8 @@ var require_buffer = __commonJS({
         boundsError(offset, buf.length - (byteLength2 + 1));
       }
     }
-    function checkIntBI(value2, min, max, buf, offset, byteLength2) {
-      if (value2 > max || value2 < min) {
+    function checkIntBI(value, min, max, buf, offset, byteLength2) {
+      if (value > max || value < min) {
         const n = typeof min === "bigint" ? "n" : "";
         let range;
         if (byteLength2 > 3) {
@@ -1665,19 +1665,19 @@ var require_buffer = __commonJS({
         } else {
           range = `>= ${min}${n} and <= ${max}${n}`;
         }
-        throw new errors.ERR_OUT_OF_RANGE("value", range, value2);
+        throw new errors.ERR_OUT_OF_RANGE("value", range, value);
       }
       checkBounds(buf, offset, byteLength2);
     }
-    function validateNumber(value2, name) {
-      if (typeof value2 !== "number") {
-        throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value2);
+    function validateNumber(value, name) {
+      if (typeof value !== "number") {
+        throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
       }
     }
-    function boundsError(value2, length, type) {
-      if (Math.floor(value2) !== value2) {
-        validateNumber(value2, type);
-        throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value2);
+    function boundsError(value, length, type) {
+      if (Math.floor(value) !== value) {
+        validateNumber(value, type);
+        throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
       }
       if (length < 0) {
         throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
@@ -1685,7 +1685,7 @@ var require_buffer = __commonJS({
       throw new errors.ERR_OUT_OF_RANGE(
         type || "offset",
         `>= ${type ? 1 : 0} and <= ${length}`,
-        value2
+        value
       );
     }
     var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
@@ -1835,8 +1835,8 @@ var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
 var viewBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
 var viewOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
 var viewLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
-function record(value2) {
-  const result = byteValues.get(value2);
+function record(value) {
+  const result = byteValues.get(value);
   if (!result) throw new TypeError("Expected an owned shell byte value");
   return result;
 }
@@ -1862,9 +1862,9 @@ function allocate(bytes, allocation, create, slots = 1) {
   }
 }
 function ownedBytes(bytes) {
-  const value2 = Object.freeze({});
-  byteValues.set(value2, { bytes, text: decoder.decode(bytes) });
-  return value2;
+  const value = Object.freeze({});
+  byteValues.set(value, { bytes, text: decoder.decode(bytes) });
+  return value;
 }
 function shellValueFromBytes(bytes, allocation) {
   if (!(bytes instanceof Uint8Array)) throw new TypeError("Shell bytes must be Uint8Array");
@@ -1876,19 +1876,19 @@ function shellValueFromBytes(bytes, allocation) {
     return ownedBytes(new Uint8Array(new Uint8Array(buffer, offset, length)));
   });
 }
-function shellValueText(value2) {
-  return typeof value2 === "string" ? value2 : record(value2).text;
+function shellValueText(value) {
+  return typeof value === "string" ? value : record(value).text;
 }
-function shellValueByteLength(value2) {
-  return typeof value2 === "string" ? import_buffer.Buffer.byteLength(value2) : record(value2).bytes.byteLength;
+function shellValueByteLength(value) {
+  return typeof value === "string" ? import_buffer.Buffer.byteLength(value) : record(value).bytes.byteLength;
 }
-function shellValueRetainedBytes(value2) {
-  const stored = record(value2);
+function shellValueRetainedBytes(value) {
+  const stored = record(value);
   return stored.bytes.byteLength + stored.text.length * 2 + 64;
 }
-function shellValueBytes(value2, allocation) {
-  const length = shellValueByteLength(value2);
-  return allocate(allocationSize(length, 1), allocation, () => typeof value2 === "string" ? encoder.encode(value2) : new Uint8Array(record(value2).bytes));
+function shellValueBytes(value, allocation) {
+  const length = shellValueByteLength(value);
+  return allocate(allocationSize(length, 1), allocation, () => typeof value === "string" ? encoder.encode(value) : new Uint8Array(record(value).bytes));
 }
 function concatShellValues(values, allocation) {
   allocation?.assertOpen();
@@ -1897,10 +1897,10 @@ function concatShellValues(values, allocation) {
   if (!Number.isSafeInteger(count) || count < 0 || count > 4294967295) throw new RangeError("Invalid shell value input extent");
   if (!count) return "";
   if (count === 1) {
-    const value2 = values[0];
-    if (typeof value2 !== "string") record(value2);
+    const value = values[0];
+    if (typeof value !== "string") record(value);
     if (values.length !== count) throw new TypeError("Shell value input extent changed");
-    return value2;
+    return value;
   }
   let textOnly = true;
   for (let index = 0; index < count; index++) {
@@ -1912,9 +1912,9 @@ function concatShellValues(values, allocation) {
   if (textOnly) {
     let text = "";
     for (let index = 0; index < count; index++) {
-      const value2 = values[index];
-      if (typeof value2 !== "string") throw new TypeError("Shell value input type changed during text concatenation");
-      text += value2;
+      const value = values[index];
+      if (typeof value !== "string") throw new TypeError("Shell value input type changed during text concatenation");
+      text += value;
     }
     if (values.length !== count) throw new TypeError("Shell value input extent changed");
     return text;
@@ -1929,14 +1929,14 @@ function concatShellValues(values, allocation) {
     if (values.length !== count) throw new TypeError("Shell value input extent changed during metadata admission");
     const snapshot = new Array(count);
     for (let index = 0; index < count; index++) {
-      const value2 = values[index];
-      if (typeof value2 !== "string") record(value2);
-      snapshot[index] = value2;
+      const value = values[index];
+      if (typeof value !== "string") record(value);
+      snapshot[index] = value;
     }
     if (values.length !== count) throw new TypeError("Shell value input extent changed during snapshot capture");
     Object.freeze(snapshot);
     reservation?.commit(snapshot);
-    if (snapshot.every((value2) => typeof value2 === "string")) {
+    if (snapshot.every((value) => typeof value === "string")) {
       const result = snapshot.join("");
       release();
       return result;
@@ -1958,11 +1958,11 @@ function concatShellValues(values, allocation) {
     throw error;
   }
 }
-function encodeValues(values, output2) {
+function encodeValues(values, output) {
   let offset = 0;
   let high = 0;
   const write = (byte) => {
-    if (output2) output2[offset] = byte;
+    if (output) output[offset] = byte;
     offset++;
   };
   const point = (code) => {
@@ -1981,19 +1981,19 @@ function encodeValues(values, output2) {
       write(128 | code & 63);
     }
   };
-  for (const value2 of values) {
-    if (typeof value2 !== "string") {
+  for (const value of values) {
+    if (typeof value !== "string") {
       if (high) {
         point(65533);
         high = 0;
       }
-      const bytes = record(value2).bytes;
-      output2?.set(bytes, offset);
+      const bytes = record(value).bytes;
+      output?.set(bytes, offset);
       offset += bytes.byteLength;
       continue;
     }
-    for (let index = 0; index < value2.length; index++) {
-      const code = value2.charCodeAt(index);
+    for (let index = 0; index < value.length; index++) {
+      const code = value.charCodeAt(index);
       if (high) {
         const previous = high;
         high = 0;
@@ -2030,8 +2030,8 @@ function argumentAllocation(allocation) {
       const reservation = allocation.reserve(bytes, slots);
       let released = false;
       const owned = {
-        commit(value2) {
-          reservation.commit(value2);
+        commit(value) {
+          reservation.commit(value);
         },
         release() {
           if (released) return;
@@ -2077,9 +2077,9 @@ function ownedCommandArguments(size, valueAt, allocation, extent) {
     const values = [];
     const args = [];
     for (const incoming of snapshot) {
-      const value2 = incoming instanceof Uint8Array ? shellValueFromBytes(incoming, transaction.allocation) : incoming;
-      args.push(shellValueText(value2));
-      values.push(value2);
+      const value = incoming instanceof Uint8Array ? shellValueFromBytes(incoming, transaction.allocation) : incoming;
+      args.push(shellValueText(value));
+      values.push(value);
     }
     Object.freeze(values);
     Object.freeze(args);
@@ -2137,14 +2137,14 @@ function ownedCommandArguments(size, valueAt, allocation, extent) {
         const transaction2 = argumentAllocation(allocation);
         const scratch = transaction2.allocation?.reserve(bytes2, count + 1);
         try {
-          const parts2 = [];
+          const parts = [];
           for (let index = 0; index < length; index++) {
-            if (index) parts2.push(separator);
-            parts2.push(values[index]);
+            if (index) parts.push(separator);
+            parts.push(values[index]);
           }
-          Object.freeze(parts2);
-          scratch?.commit(parts2);
-          const result = concatShellValues(parts2, transaction2.allocation);
+          Object.freeze(parts);
+          scratch?.commit(parts);
+          const result = concatShellValues(parts, transaction2.allocation);
           scratch?.release();
           return result;
         } catch (error) {
@@ -2177,7 +2177,7 @@ var CommandRegistry = class {
   constructor(commands = []) {
     for (const command of commands) this.register(command);
   }
-  register(command, options2 = {}) {
+  register(command, options = {}) {
     const { name, execute } = command;
     if (typeof name !== "string" || !name || /[\s/\0]/u.test(name)) {
       throw new TypeError("Command names must be nonempty and contain no whitespace, slash, or NUL");
@@ -2185,7 +2185,7 @@ var CommandRegistry = class {
     if (typeof execute !== "function") {
       throw new TypeError("Command execute must be a function");
     }
-    if (this.#commands.has(name) && !options2.replace) {
+    if (this.#commands.has(name) && !options.replace) {
       throw new Error(`Command already registered: ${name}`);
     }
     this.#commands.set(name, Object.freeze({ ...command, name, execute }));
@@ -2215,59 +2215,15 @@ function validateExitCode(exitCode) {
 init_platform();
 import { isErrnoCode, isFsError, toFsError, FsError } from "@poe-platform/safe-fs/core";
 
-// packages/safe-bash/src/contracts/command-requirements.ts
-init_platform();
-function evaluateMode(requirement, capabilities) {
-  const missing = requirement.capabilities.filter((name) => capabilities[name] === false);
-  const unknown = requirement.capabilities.filter((name) => capabilities[name] === void 0);
-  if (requirement.mutates && capabilities.readOnly === true) missing.push("readOnly");
-  const alternatives = requirement.anyOf;
-  if (alternatives && !alternatives.some((group) => group.every((name) => capabilities[name] === true))) {
-    if (alternatives.every((group) => group.some((name) => capabilities[name] === false))) {
-      missing.push(...alternatives.flatMap((group) => group.filter((name) => capabilities[name] === false)));
-    } else {
-      unknown.push(...alternatives.filter((group) => !group.some((name) => capabilities[name] === false)).flatMap((group) => group.filter((name) => capabilities[name] === void 0)));
-    }
-  }
-  return {
-    ...requirement,
-    status: missing.length ? "unsupported" : unknown.length ? "unknown" : "supported",
-    missing: [...new Set(missing)],
-    unknown: [...new Set(unknown)]
-  };
-}
-function evaluateCommandSupport(command, capabilities) {
-  const modes = (command.filesystemRequirements ?? []).map((requirement) => evaluateMode(requirement, capabilities));
-  return {
-    declared: command.filesystemRequirements !== void 0,
-    status: command.filesystemRequirements !== void 0 && modes.every((mode) => mode.status === "supported") ? "supported" : modes.length && modes.every((mode) => mode.status === "unsupported") ? "unsupported" : "partial",
-    modes
-  };
-}
-function assertCommandRequirements(context, requirements, selected, capabilities = context.fs.capabilities) {
-  context.signal.throwIfAborted();
-  for (const id of new Set(selected)) {
-    const requirement = requirements.find((mode) => mode.id === id);
-    if (!requirement) throw new TypeError(`Unknown filesystem requirement mode: ${id}`);
-    const support = evaluateMode(requirement, capabilities);
-    if (support.status === "unsupported") {
-      throw new FsError(support.missing.includes("readOnly") ? "EROFS" : "ENOTSUP", {
-        syscall: context.command,
-        message: `${requirement.description} requires unavailable filesystem capabilities: ${support.missing.join(", ")}`
-      });
-    }
-  }
-}
-
 // packages/safe-bash/src/contracts/io.ts
 init_platform();
 init_platform();
 import { collectBytes, readBytes } from "@poe-platform/safe-fs/core";
 import { collectBytes as collectBytes2, readBytes as readBytes2, toByteSource } from "@poe-platform/safe-fs/core";
 var outputFailure = /* @__PURE__ */ Symbol("output failure");
-function createBytePipe(options2 = {}) {
-  const highWaterMark = options2.highWaterMark ?? 64 * 1024;
-  const signal = options2.signal;
+function createBytePipe(options = {}) {
+  const highWaterMark = options.highWaterMark ?? 64 * 1024;
+  const signal = options.signal;
   if (!Number.isSafeInteger(highWaterMark) || highWaterMark < 1) {
     throw new RangeError("highWaterMark must be a positive safe integer");
   }
@@ -2382,8 +2338,8 @@ async function pipeBytes(source, sink, signal) {
   }
   signal?.throwIfAborted();
 }
-async function collectText(source, options2) {
-  return new TextDecoder().decode(await collectBytes(source, options2));
+async function collectText(source, options) {
+  return new TextDecoder().decode(await collectBytes(source, options));
 }
 async function abortable(operation, signal) {
   signal?.throwIfAborted();
@@ -2412,12 +2368,23 @@ async function abortable(operation, signal) {
   });
 }
 
-// packages/safe-bash/src/escaping.ts
-init_platform();
-
-// packages/safe-bash/src/contracts/path.ts
+// packages/safe-bash/src/diagnostics.ts
 init_platform();
-import { validatePath, resolvePath, normalizePath, relativePath, isPathWithin, assertPathWithin, basename, dirname, extname, joinPath, isAbsolutePath, posixPath as posixPath2 } from "@poe-platform/safe-fs/core";
+var PublicDiagnostic = class extends Error {
+};
+function publicDiagnosticMessage(error, onInternalError) {
+  if (error instanceof FsError || error instanceof CommandArgumentIdentityError) return error.message;
+  if (error instanceof PublicDiagnostic && !Object.hasOwn(error, "cause")) return error.message;
+  const original = error instanceof PublicDiagnostic ? error.cause : error;
+  const detail = error instanceof PublicDiagnostic ? error.message : "internal error";
+  try {
+    const pending = onInternalError?.(original);
+    if (pending !== void 0) void Promise.resolve(pending).catch(() => void 0);
+  } catch {
+    return detail;
+  }
+  return detail;
+}
 
 // packages/safe-bash/src/contracts/yield.ts
 init_platform();
@@ -2455,448 +2422,9 @@ function yieldTurn(signal) {
   });
 }
 
-// packages/safe-bash/src/escaping.ts
-var controls = { 8: "\\b", 9: "\\t", 10: "\\n", 11: "\\v", 12: "\\f", 13: "\\r", 92: "\\\\" };
-var encoder2 = new TextEncoder();
-function* parts(value2, mode) {
-  for (const character of value2) {
-    const point = character.codePointAt(0);
-    if (mode === "diagnostic" && (point === 9 || point === 10 || point >= 32 && (point < 127 || point > 159))) {
-      yield character;
-    } else {
-      for (const byte of encoder2.encode(character)) {
-        yield controls[byte] ?? (byte >= 32 && byte < 127 ? String.fromCharCode(byte) : `\\${byte.toString(8).padStart(3, "0")}`);
-      }
-    }
-  }
-}
-function escapeText(value2, mode, checkOutput) {
-  let result = "", bytes = 0;
-  for (const part of parts(value2, mode)) {
-    bytes += import_buffer.Buffer.byteLength(part);
-    checkOutput?.(bytes);
-    result += part;
-  }
-  return result;
-}
-async function writeDiagnostic(sink, value2, signal) {
-  signal?.throwIfAborted();
-  let chunk = "", bytes = 0, work = 0;
-  for (const part of parts(value2, "diagnostic")) {
-    signal?.throwIfAborted();
-    const size = import_buffer.Buffer.byteLength(part);
-    if (bytes + size > 16384) {
-      await writeBytes(sink, encoder2.encode(chunk), signal);
-      chunk = "";
-      bytes = 0;
-    }
-    chunk += part;
-    bytes += size;
-    if (++work % 1024 === 0) await yieldTurn(signal);
-  }
-  if (bytes) await writeBytes(sink, encoder2.encode(chunk), signal);
-  signal?.throwIfAborted();
-}
-
-// packages/safe-bash/src/commands/internal.ts
-init_platform();
-
-// packages/safe-bash/src/diagnostics.ts
-init_platform();
-var PublicDiagnostic = class extends Error {
-};
-function publicDiagnosticMessage(error, onInternalError) {
-  if (error instanceof FsError || error instanceof CommandArgumentIdentityError) return error.message;
-  if (error instanceof PublicDiagnostic && !Object.hasOwn(error, "cause")) return error.message;
-  const original = error instanceof PublicDiagnostic ? error.cause : error;
-  const detail = error instanceof PublicDiagnostic ? error.message : "internal error";
-  try {
-    const pending = onInternalError?.(original);
-    if (pending !== void 0) void Promise.resolve(pending).catch(() => void 0);
-  } catch {
-    return detail;
-  }
-  return detail;
-}
-
-// packages/safe-bash/src/commands/portable-requirements.ts
-init_platform();
-var inputRequirements = [
-  { id: "stdin", description: "Read standard input", capabilities: [] },
-  { id: "file", description: "Read file operands", capabilities: [], anyOf: [["streamingRead"], ["read"]] }
-];
-var textOutputRequirements = [
-  ...inputRequirements,
-  { id: "output", description: "Write or truncate an output file", capabilities: [], anyOf: [["streamingWrite"], ["write"]], mutates: true }
-];
-var pwdRequirements = [
-  { id: "logical", description: "Print the logical working directory", capabilities: [] },
-  { id: "physical", description: "Resolve the physical working directory (-P)", capabilities: ["realpath"] }
-];
-var predicateRequirements = [
-  { id: "expression", description: "Evaluate strings and integers", capabilities: [] },
-  { id: "metadata", description: "Inspect file metadata", capabilities: ["stat"] },
-  { id: "access", description: "Inspect path access permissions", capabilities: ["access"] }
-];
-
-// packages/safe-bash/src/commands/record-buffer.ts
+// packages/safe-bash/src/contracts/path.ts
 init_platform();
-var segmentSize = 4096;
-var RecordBuffer = class {
-  constructor(capacity, finalizationCapacity = capacity * 2) {
-    this.capacity = capacity;
-    this.finalizationCapacity = finalizationCapacity;
-  }
-  capacity;
-  finalizationCapacity;
-  #segments = [];
-  #size = 0;
-  #allocated = 0;
-  get size() {
-    return this.#size;
-  }
-  #admit(length) {
-    if (length > this.capacity - this.#size) {
-      throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
-    }
-  }
-  append(bytes, start = 0, end = bytes.length) {
-    this.#admit(end - start);
-    let offset = start;
-    while (offset < end) {
-      let segment = this.#segments.at(-1);
-      const used = this.#size % segmentSize;
-      if (!segment || used === 0) {
-        segment = new Uint8Array(Math.min(segmentSize, this.capacity - this.#allocated));
-        this.#segments.push(segment);
-        this.#allocated += segment.length;
-      }
-      const length = Math.min(end - offset, segment.length - used);
-      segment.set(bytes.subarray(offset, offset + length), used);
-      this.#size += length;
-      offset += length;
-    }
-  }
-  finish(admit, bytes, start = 0, end = bytes?.length ?? 0) {
-    this.#admit(end - start);
-    const size = this.#size + end - start;
-    admit?.(size);
-    if (size > this.finalizationCapacity - this.#allocated) {
-      throw new FsError("EFBIG", { message: "line finalization buffer limit exceeded" });
-    }
-    const result = new Uint8Array(size);
-    let offset = 0;
-    for (const segment of this.#segments) {
-      const length = Math.min(segment.length, this.#size - offset);
-      result.set(segment.subarray(0, length), offset);
-      offset += length;
-    }
-    if (bytes && end > start) result.set(bytes.subarray(start, end), offset);
-    this.clear();
-    return result;
-  }
-  clear() {
-    this.#segments = [];
-    this.#size = 0;
-    this.#allocated = 0;
-  }
-};
-
-// packages/safe-bash/src/commands/internal.ts
-var encoder3 = new TextEncoder();
-var decoder2 = new TextDecoder();
-var bufferLimit = 32 * 1024 * 1024;
-var UsageError = class extends PublicDiagnostic {
-};
-function options(args, short, long = {}, stopAtOperand = false, onOperand) {
-  const flags = /* @__PURE__ */ new Set();
-  const values = /* @__PURE__ */ new Map();
-  const operands = [];
-  const specifications = /* @__PURE__ */ new Map();
-  for (let index = 0; index < short.length; index++) {
-    const key = short[index];
-    specifications.set(key, short[index + 1] === ":");
-    if (short[index + 1] === ":") index++;
-  }
-  let ended = false;
-  for (let index = 0; index < args.length; index++) {
-    const argument = args[index];
-    if (ended || argument === "-" || !argument.startsWith("-")) {
-      operands.push(argument);
-      onOperand?.(index);
-      if (stopAtOperand) ended = true;
-      continue;
-    }
-    if (argument === "--") {
-      ended = true;
-      continue;
-    }
-    if (argument.startsWith("--")) {
-      const equals = argument.indexOf("=");
-      const name = argument.slice(2, equals < 0 ? void 0 : equals);
-      const key = long[name];
-      if (!key || !specifications.has(key)) throw new UsageError(`unrecognized option '${argument}'`);
-      if (specifications.get(key)) {
-        const value2 = equals >= 0 ? argument.slice(equals + 1) : args[++index];
-        if (value2 === void 0) throw new UsageError(`option '--${name}' requires an argument`);
-        values.set(key, [...values.get(key) ?? [], value2]);
-      } else if (equals >= 0) throw new UsageError(`option '--${name}' does not take an argument`);
-      flags.add(key);
-      continue;
-    }
-    for (let offset = 1; offset < argument.length; offset++) {
-      const key = argument[offset];
-      if (!specifications.has(key)) throw new UsageError(`invalid option -- '${key}'`);
-      if (specifications.get(key)) {
-        const value2 = argument.slice(offset + 1) || args[++index];
-        if (value2 === void 0) throw new UsageError(`option requires an argument -- '${key}'`);
-        values.set(key, [...values.get(key) ?? [], value2]);
-        offset = argument.length;
-      }
-      flags.add(key);
-    }
-  }
-  return { flags, values, operands };
-}
-function value(parsed, key) {
-  return parsed.values.get(key)?.at(-1);
-}
-function integer(text, minimum = 0) {
-  if (!/^[+]?[0-9]+$/u.test(text)) throw new UsageError(`invalid number '${text}'`);
-  const number = Number(text);
-  if (!Number.isSafeInteger(number) || number < minimum) throw new UsageError(`invalid number '${text}'`);
-  return number;
-}
-function requireOperands(operands, minimum = 1, maximum = Infinity) {
-  if (operands.length < minimum) throw new UsageError("missing operand");
-  if (operands.length > maximum) throw new UsageError(`extra operand '${operands[maximum]}'`);
-}
-function pathOf(context, path) {
-  if (!path) throw new FsError("ENOENT", { path });
-  validatePath(path);
-  validatePath(context.cwd);
-  if (!isAbsolutePath(context.cwd)) throw new FsError("EINVAL", { path: context.cwd, message: "cwd must be absolute" });
-  return isAbsolutePath(path) ? path : `${context.cwd.replace(/\/$/u, "")}/${path}`;
-}
-function codeOf(error) {
-  return error instanceof Error && "code" in error ? String(error.code) : void 0;
-}
-async function output(context, text) {
-  context.signal.throwIfAborted();
-  await writeBytes(context.stdout, typeof text === "string" ? encoder3.encode(text) : text, context.signal);
-}
-async function diagnostic(context, error) {
-  context.signal.throwIfAborted();
-  await writeDiagnostic(context.stderr, `${context.command}: ${publicDiagnosticMessage(error, context.onInternalError)}
-`, context.signal);
-}
-function define(name, handler, failureCode = 1) {
-  return {
-    name,
-    async execute(context) {
-      context.signal.throwIfAborted();
-      try {
-        return await handler(context);
-      } catch (error) {
-        context.signal.throwIfAborted();
-        await diagnostic(context, error);
-        return { exitCode: error instanceof UsageError ? 2 : failureCode };
-      }
-    }
-  };
-}
-async function eachOperand(context, operands, operation) {
-  let exitCode = 0;
-  for (const operand of operands) {
-    context.signal.throwIfAborted();
-    try {
-      await operation(operand);
-    } catch (error) {
-      await diagnostic(context, error);
-      exitCode = 1;
-    }
-  }
-  return { exitCode };
-}
-async function* input(context, name = "-") {
-  context.signal.throwIfAborted();
-  if (name === "-") {
-    yield* readBytes2(context.stdin, context.signal);
-  } else {
-    await assertInputRequirements(context, [name]);
-    const path = pathOf(context, name);
-    const capabilities = await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities;
-    if (context.fs.readStream && capabilities.streamingRead !== false) {
-      let emitted = false;
-      let reading = true;
-      try {
-        for await (const chunk of readBytes2(context.fs.readStream(path, { signal: context.signal }), context.signal)) {
-          reading = false;
-          if (chunk.byteLength) emitted = true;
-          yield chunk;
-          reading = true;
-        }
-        return;
-      } catch (error) {
-        context.signal.throwIfAborted();
-        if (!reading || emitted || !(error instanceof FsError) || error.code !== "ENOTSUP") throw error;
-      }
-    }
-    if (capabilities.read === false) throw new FsError("ENOTSUP", { syscall: "readFile", path });
-    yield* readBytes2({
-      async *[Symbol.asyncIterator]() {
-        const bytes = await context.fs.readFile(path, { signal: context.signal, maxBytes: bufferLimit });
-        context.signal.throwIfAborted();
-        if (bytes.byteLength > bufferLimit) throw new FsError("EFBIG", { syscall: "readFile", path });
-        yield bytes;
-      }
-    }, context.signal);
-  }
-}
-async function assertInputRequirements(context, names) {
-  const files = names.filter((name) => name !== "-");
-  assertCommandRequirements(context, inputRequirements, [files.length ? "file" : "stdin"]);
-  if (!context.fs.capabilitiesFor) return;
-  for (const name of files) {
-    try {
-      const capabilities = await context.fs.capabilitiesFor(pathOf(context, name), { signal: context.signal });
-      assertCommandRequirements(context, inputRequirements, ["file"], capabilities);
-    } catch (error) {
-      context.signal.throwIfAborted();
-      if (codeOf(error) === "ENOTSUP" || codeOf(error) === "EROFS") throw error;
-    }
-  }
-}
-function concatenate(chunks, size = chunks.reduce((sum, chunk) => sum + chunk.length, 0)) {
-  const result = new Uint8Array(size);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.length;
-  }
-  return result;
-}
-async function* lines(source, separator = 10, admit) {
-  const pending = new RecordBuffer(bufferLimit);
-  try {
-    for await (const chunk of source) {
-      let start = 0;
-      for (let offset = 0; offset < chunk.length; offset++) {
-        if (chunk[offset] !== separator) continue;
-        yield { bytes: pending.finish(admit, chunk, start, offset), terminated: true };
-        start = offset + 1;
-      }
-      pending.append(chunk, start);
-    }
-    if (pending.size) yield { bytes: pending.finish(admit), terminated: false };
-  } finally {
-    pending.clear();
-  }
-}
-function emptyInput() {
-  return toByteSource("");
-}
-function replaceArgument(source, pattern, replacement) {
-  if (typeof source === "string") return source.split(pattern).join(replacement);
-  const needle = encoder3.encode(pattern);
-  if (!needle.length) throw new UsageError("replacement string cannot be empty");
-  const substituted = encoder3.encode(replacement);
-  const chunks = [];
-  let start = 0;
-  for (let offset = 0; offset <= source.length - needle.length; ) {
-    if (needle.every((byte, index) => source[offset + index] === byte)) {
-      chunks.push(source.subarray(start, offset), substituted);
-      offset += needle.length;
-      start = offset;
-    } else offset++;
-  }
-  chunks.push(source.subarray(start));
-  return concatenate(chunks);
-}
-function escapeBytes(text, zeroOctal = false, bareOctal = false) {
-  if (typeof text === "string") {
-    const chunks = [];
-    const control2 = { a: 7, b: 8, e: 27, E: 27, f: 12, n: 10, r: 13, t: 9, v: 11, "\\": 92 };
-    for (let index = 0; index < text.length; ) {
-      if (text[index] !== "\\" || index + 1 === text.length) {
-        const character = String.fromCodePoint(text.codePointAt(index));
-        chunks.push(encoder3.encode(character));
-        index += character.length;
-        continue;
-      }
-      const next = text[index + 1];
-      if (next === "c") return { bytes: concatenate(chunks), stop: true };
-      if (control2[next] !== void 0) {
-        chunks.push(Uint8Array.of(control2[next]));
-        index += 2;
-        continue;
-      }
-      const rest = text.slice(index + 1);
-      const octal = zeroOctal ? (bareOctal ? /^(?:0([0-7]{0,3})|([1-7][0-7]{0,2}))/u : /^0([0-7]{0,3})/u).exec(rest) : /^([0-7]{1,3})/u.exec(rest);
-      if (octal) {
-        chunks.push(Uint8Array.of(parseInt(octal[1] || octal[2] || "0", 8) & 255));
-        index += 1 + octal[0].length;
-        continue;
-      }
-      const hexadecimal = /^x([0-9a-fA-F]{1,2})/u.exec(rest);
-      if (hexadecimal) {
-        chunks.push(Uint8Array.of(parseInt(hexadecimal[1], 16)));
-        index += 1 + hexadecimal[0].length;
-        continue;
-      }
-      chunks.push(encoder3.encode(`\\${next}`));
-      index += 2;
-    }
-    return { bytes: concatenate(chunks), stop: false };
-  }
-  const source = text;
-  const bytes = new Uint8Array(source.length);
-  const control = { 97: 7, 98: 8, 101: 27, 69: 27, 102: 12, 110: 10, 114: 13, 116: 9, 118: 11, 92: 92 };
-  let size = 0;
-  for (let index = 0; index < source.length; ) {
-    if (source[index] !== 92 || index + 1 === source.length) {
-      bytes[size++] = source[index++];
-      continue;
-    }
-    const next = source[index + 1];
-    if (next === 99) return { bytes: bytes.subarray(0, size), stop: true };
-    if (control[next] !== void 0) {
-      bytes[size++] = control[next];
-      index += 2;
-      continue;
-    }
-    if (zeroOctal ? next === 48 || bareOctal && next >= 49 && next <= 55 : next >= 48 && next <= 55) {
-      let offset = index + (zeroOctal && next === 48 ? 2 : 1);
-      const end = Math.min(source.length, offset + 3);
-      let value2 = 0;
-      while (offset < end && source[offset] >= 48 && source[offset] <= 55) value2 = value2 * 8 + source[offset++] - 48;
-      bytes[size++] = value2 & 255;
-      index = offset;
-      continue;
-    }
-    if (next === 120) {
-      let offset = index + 2;
-      const end = Math.min(source.length, offset + 2);
-      let value2 = 0;
-      while (offset < end) {
-        const digit = source[offset];
-        const number = digit >= 48 && digit <= 57 ? digit - 48 : digit >= 65 && digit <= 70 ? digit - 55 : digit >= 97 && digit <= 102 ? digit - 87 : -1;
-        if (number < 0) break;
-        value2 = value2 * 16 + number;
-        offset++;
-      }
-      if (offset > index + 2) {
-        bytes[size++] = value2;
-        index = offset;
-        continue;
-      }
-    }
-    bytes[size++] = 92;
-    bytes[size++] = next;
-    index += 2;
-  }
-  return { bytes: bytes.subarray(0, size), stop: false };
-}
+import { validatePath, resolvePath, normalizePath, relativePath, isPathWithin, assertPathWithin, basename, dirname, extname, joinPath, isAbsolutePath, posixPath as posixPath2 } from "@poe-platform/safe-fs/core";
 
 export {
   __toESM,
@@ -2918,8 +2446,6 @@ export {
   isFsError,
   toFsError,
   FsError,
-  evaluateCommandSupport,
-  assertCommandRequirements,
   outputFailure,
   createBytePipe,
   writeText,
@@ -2945,35 +2471,7 @@ export {
   dirname,
   joinPath,
   isAbsolutePath,
-  posixPath2 as posixPath,
-  escapeText,
-  writeDiagnostic,
-  inputRequirements,
-  textOutputRequirements,
-  pwdRequirements,
-  predicateRequirements,
-  RecordBuffer,
-  encoder3 as encoder,
-  decoder2 as decoder,
-  bufferLimit,
-  UsageError,
-  options,
-  value,
-  integer,
-  requireOperands,
-  pathOf,
-  codeOf,
-  output,
-  diagnostic,
-  define,
-  eachOperand,
-  input,
-  assertInputRequirements,
-  concatenate,
-  lines,
-  emptyInput,
-  replaceArgument,
-  escapeBytes
+  posixPath2 as posixPath
 };
 /*! Bundled license information:
 
@@ -2988,4 +2486,4 @@ buffer/index.js:
    * @license  MIT
    *)
 */
-//# sourceMappingURL=chunk-LUJYX5H5.js.map
+//# sourceMappingURL=chunk-L2GZSOSJ.js.map