@poe-platform/safe-bash 0.1.506 → 0.1.508

package/dist/safe-bash/chunks/chunk-3ISDVRIM.js

@@ -0,0 +1,3821 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/base64-js/index.js
+var require_base64_js = __commonJS({
+  "node_modules/base64-js/index.js"(exports) {
+    "use strict";
+    init_platform();
+    exports.byteLength = byteLength;
+    exports.toByteArray = toByteArray;
+    exports.fromByteArray = fromByteArray;
+    var lookup = [];
+    var revLookup = [];
+    var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+    var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    for (i = 0, len = code.length; i < len; ++i) {
+      lookup[i] = code[i];
+      revLookup[code.charCodeAt(i)] = i;
+    }
+    var i;
+    var len;
+    revLookup["-".charCodeAt(0)] = 62;
+    revLookup["_".charCodeAt(0)] = 63;
+    function getLens(b64) {
+      var len2 = b64.length;
+      if (len2 % 4 > 0) {
+        throw new Error("Invalid string. Length must be a multiple of 4");
+      }
+      var validLen = b64.indexOf("=");
+      if (validLen === -1) validLen = len2;
+      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+      return [validLen, placeHoldersLen];
+    }
+    function byteLength(b64) {
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    function _byteLength(b64, validLen, placeHoldersLen) {
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    function toByteArray(b64) {
+      var tmp;
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+      var curByte = 0;
+      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+      var i2;
+      for (i2 = 0; i2 < len2; i2 += 4) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
+        arr[curByte++] = tmp >> 16 & 255;
+        arr[curByte++] = tmp >> 8 & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      if (placeHoldersLen === 2) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
+        arr[curByte++] = tmp & 255;
+      }
+      if (placeHoldersLen === 1) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
+        arr[curByte++] = tmp >> 8 & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      return arr;
+    }
+    function tripletToBase64(num) {
+      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+    }
+    function encodeChunk(uint8, start, end) {
+      var tmp;
+      var output2 = [];
+      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));
+      }
+      return output2.join("");
+    }
+    function fromByteArray(uint8) {
+      var tmp;
+      var len2 = uint8.length;
+      var extraBytes = len2 % 3;
+      var parts2 = [];
+      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));
+      }
+      if (extraBytes === 1) {
+        tmp = uint8[len2 - 1];
+        parts2.push(
+          lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="
+        );
+      } else if (extraBytes === 2) {
+        tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
+        parts2.push(
+          lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
+        );
+      }
+      return parts2.join("");
+    }
+  }
+});
+
+// node_modules/ieee754/index.js
+var require_ieee754 = __commonJS({
+  "node_modules/ieee754/index.js"(exports) {
+    init_platform();
+    exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+      var e, m;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var nBits = -7;
+      var i = isLE ? nBytes - 1 : 0;
+      var d = isLE ? -1 : 1;
+      var s = buffer[offset + i];
+      i += d;
+      e = s & (1 << -nBits) - 1;
+      s >>= -nBits;
+      nBits += eLen;
+      for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
+      }
+      m = e & (1 << -nBits) - 1;
+      e >>= -nBits;
+      nBits += mLen;
+      for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
+      }
+      if (e === 0) {
+        e = 1 - eBias;
+      } else if (e === eMax) {
+        return m ? NaN : (s ? -1 : 1) * Infinity;
+      } else {
+        m = m + Math.pow(2, mLen);
+        e = e - eBias;
+      }
+      return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+    };
+    exports.write = function(buffer, value2, offset, isLE, mLen, nBytes) {
+      var e, m, c;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      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;
+        e = eMax;
+      } else {
+        e = Math.floor(Math.log(value2) / Math.LN2);
+        if (value2 * (c = Math.pow(2, -e)) < 1) {
+          e--;
+          c *= 2;
+        }
+        if (e + eBias >= 1) {
+          value2 += rt / c;
+        } else {
+          value2 += rt * Math.pow(2, 1 - eBias);
+        }
+        if (value2 * c >= 2) {
+          e++;
+          c /= 2;
+        }
+        if (e + eBias >= eMax) {
+          m = 0;
+          e = eMax;
+        } else if (e + eBias >= 1) {
+          m = (value2 * c - 1) * Math.pow(2, mLen);
+          e = e + eBias;
+        } else {
+          m = value2 * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+          e = 0;
+        }
+      }
+      for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+      }
+      e = e << mLen | m;
+      eLen += mLen;
+      for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+      }
+      buffer[offset + i - d] |= s * 128;
+    };
+  }
+});
+
+// node_modules/buffer/index.js
+var require_buffer = __commonJS({
+  "node_modules/buffer/index.js"(exports) {
+    "use strict";
+    init_platform();
+    var base64 = require_base64_js();
+    var ieee754 = require_ieee754();
+    var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+    exports.Buffer = Buffer3;
+    exports.SlowBuffer = SlowBuffer;
+    exports.INSPECT_MAX_BYTES = 50;
+    var K_MAX_LENGTH = 2147483647;
+    exports.kMaxLength = K_MAX_LENGTH;
+    Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport();
+    if (!Buffer3.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+      console.error(
+        "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+      );
+    }
+    function typedArraySupport() {
+      try {
+        const arr = new Uint8Array(1);
+        const proto = { foo: function() {
+          return 42;
+        } };
+        Object.setPrototypeOf(proto, Uint8Array.prototype);
+        Object.setPrototypeOf(arr, proto);
+        return arr.foo() === 42;
+      } catch (e) {
+        return false;
+      }
+    }
+    Object.defineProperty(Buffer3.prototype, "parent", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer3.isBuffer(this)) return void 0;
+        return this.buffer;
+      }
+    });
+    Object.defineProperty(Buffer3.prototype, "offset", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer3.isBuffer(this)) return void 0;
+        return this.byteOffset;
+      }
+    });
+    function createBuffer(length) {
+      if (length > K_MAX_LENGTH) {
+        throw new RangeError('The value "' + length + '" is invalid for option "size"');
+      }
+      const buf = new Uint8Array(length);
+      Object.setPrototypeOf(buf, Buffer3.prototype);
+      return buf;
+    }
+    function Buffer3(arg, encodingOrOffset, length) {
+      if (typeof arg === "number") {
+        if (typeof encodingOrOffset === "string") {
+          throw new TypeError(
+            'The "string" argument must be of type string. Received type number'
+          );
+        }
+        return allocUnsafe(arg);
+      }
+      return from(arg, encodingOrOffset, length);
+    }
+    Buffer3.poolSize = 8192;
+    function from(value2, encodingOrOffset, length) {
+      if (typeof value2 === "string") {
+        return fromString(value2, encodingOrOffset);
+      }
+      if (ArrayBuffer.isView(value2)) {
+        return fromArrayView(value2);
+      }
+      if (value2 == null) {
+        throw new TypeError(
+          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value2
+        );
+      }
+      if (isInstance(value2, ArrayBuffer) || value2 && isInstance(value2.buffer, ArrayBuffer)) {
+        return fromArrayBuffer(value2, encodingOrOffset, length);
+      }
+      if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value2, SharedArrayBuffer) || value2 && isInstance(value2.buffer, SharedArrayBuffer))) {
+        return fromArrayBuffer(value2, encodingOrOffset, length);
+      }
+      if (typeof value2 === "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) {
+        return Buffer3.from(valueOf, encodingOrOffset, length);
+      }
+      const b = fromObject(value2);
+      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);
+      }
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value2
+      );
+    }
+    Buffer3.from = function(value2, encodingOrOffset, length) {
+      return from(value2, encodingOrOffset, length);
+    };
+    Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype);
+    Object.setPrototypeOf(Buffer3, Uint8Array);
+    function assertSize(size) {
+      if (typeof size !== "number") {
+        throw new TypeError('"size" argument must be of type number');
+      } else if (size < 0) {
+        throw new RangeError('The value "' + size + '" is invalid for option "size"');
+      }
+    }
+    function alloc(size, fill, encoding) {
+      assertSize(size);
+      if (size <= 0) {
+        return createBuffer(size);
+      }
+      if (fill !== void 0) {
+        return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+      }
+      return createBuffer(size);
+    }
+    Buffer3.alloc = function(size, fill, encoding) {
+      return alloc(size, fill, encoding);
+    };
+    function allocUnsafe(size) {
+      assertSize(size);
+      return createBuffer(size < 0 ? 0 : checked(size) | 0);
+    }
+    Buffer3.allocUnsafe = function(size) {
+      return allocUnsafe(size);
+    };
+    Buffer3.allocUnsafeSlow = function(size) {
+      return allocUnsafe(size);
+    };
+    function fromString(string, encoding) {
+      if (typeof encoding !== "string" || encoding === "") {
+        encoding = "utf8";
+      }
+      if (!Buffer3.isEncoding(encoding)) {
+        throw new TypeError("Unknown encoding: " + encoding);
+      }
+      const length = byteLength(string, encoding) | 0;
+      let buf = createBuffer(length);
+      const actual = buf.write(string, encoding);
+      if (actual !== length) {
+        buf = buf.slice(0, actual);
+      }
+      return buf;
+    }
+    function fromArrayLike(array) {
+      const length = array.length < 0 ? 0 : checked(array.length) | 0;
+      const buf = createBuffer(length);
+      for (let i = 0; i < length; i += 1) {
+        buf[i] = array[i] & 255;
+      }
+      return buf;
+    }
+    function fromArrayView(arrayView) {
+      if (isInstance(arrayView, Uint8Array)) {
+        const copy = new Uint8Array(arrayView);
+        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+      }
+      return fromArrayLike(arrayView);
+    }
+    function fromArrayBuffer(array, byteOffset, length) {
+      if (byteOffset < 0 || array.byteLength < byteOffset) {
+        throw new RangeError('"offset" is outside of buffer bounds');
+      }
+      if (array.byteLength < byteOffset + (length || 0)) {
+        throw new RangeError('"length" is outside of buffer bounds');
+      }
+      let buf;
+      if (byteOffset === void 0 && length === void 0) {
+        buf = new Uint8Array(array);
+      } else if (length === void 0) {
+        buf = new Uint8Array(array, byteOffset);
+      } else {
+        buf = new Uint8Array(array, byteOffset, length);
+      }
+      Object.setPrototypeOf(buf, Buffer3.prototype);
+      return buf;
+    }
+    function fromObject(obj) {
+      if (Buffer3.isBuffer(obj)) {
+        const len = checked(obj.length) | 0;
+        const buf = createBuffer(len);
+        if (buf.length === 0) {
+          return buf;
+        }
+        obj.copy(buf, 0, 0, len);
+        return buf;
+      }
+      if (obj.length !== void 0) {
+        if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+          return createBuffer(0);
+        }
+        return fromArrayLike(obj);
+      }
+      if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+        return fromArrayLike(obj.data);
+      }
+    }
+    function checked(length) {
+      if (length >= K_MAX_LENGTH) {
+        throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+      }
+      return length | 0;
+    }
+    function SlowBuffer(length) {
+      if (+length != length) {
+        length = 0;
+      }
+      return Buffer3.alloc(+length);
+    }
+    Buffer3.isBuffer = function isBuffer(b) {
+      return b != null && b._isBuffer === true && b !== Buffer3.prototype;
+    };
+    Buffer3.compare = function compare(a, b) {
+      if (isInstance(a, Uint8Array)) a = Buffer3.from(a, a.offset, a.byteLength);
+      if (isInstance(b, Uint8Array)) b = Buffer3.from(b, b.offset, b.byteLength);
+      if (!Buffer3.isBuffer(a) || !Buffer3.isBuffer(b)) {
+        throw new TypeError(
+          'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+        );
+      }
+      if (a === b) return 0;
+      let x = a.length;
+      let y = b.length;
+      for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+        if (a[i] !== b[i]) {
+          x = a[i];
+          y = b[i];
+          break;
+        }
+      }
+      if (x < y) return -1;
+      if (y < x) return 1;
+      return 0;
+    };
+    Buffer3.isEncoding = function isEncoding(encoding) {
+      switch (String(encoding).toLowerCase()) {
+        case "hex":
+        case "utf8":
+        case "utf-8":
+        case "ascii":
+        case "latin1":
+        case "binary":
+        case "base64":
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return true;
+        default:
+          return false;
+      }
+    };
+    Buffer3.concat = function concat(list, length) {
+      if (!Array.isArray(list)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      }
+      if (list.length === 0) {
+        return Buffer3.alloc(0);
+      }
+      let i;
+      if (length === void 0) {
+        length = 0;
+        for (i = 0; i < list.length; ++i) {
+          length += list[i].length;
+        }
+      }
+      const buffer = Buffer3.allocUnsafe(length);
+      let pos = 0;
+      for (i = 0; i < list.length; ++i) {
+        let buf = list[i];
+        if (isInstance(buf, Uint8Array)) {
+          if (pos + buf.length > buffer.length) {
+            if (!Buffer3.isBuffer(buf)) buf = Buffer3.from(buf);
+            buf.copy(buffer, pos);
+          } else {
+            Uint8Array.prototype.set.call(
+              buffer,
+              buf,
+              pos
+            );
+          }
+        } else if (!Buffer3.isBuffer(buf)) {
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        } else {
+          buf.copy(buffer, pos);
+        }
+        pos += buf.length;
+      }
+      return buffer;
+    };
+    function byteLength(string, encoding) {
+      if (Buffer3.isBuffer(string)) {
+        return string.length;
+      }
+      if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+        return string.byteLength;
+      }
+      if (typeof string !== "string") {
+        throw new TypeError(
+          'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
+        );
+      }
+      const len = string.length;
+      const mustMatch = arguments.length > 2 && arguments[2] === true;
+      if (!mustMatch && len === 0) return 0;
+      let loweredCase = false;
+      for (; ; ) {
+        switch (encoding) {
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return len;
+          case "utf8":
+          case "utf-8":
+            return utf8ToBytes(string).length;
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return len * 2;
+          case "hex":
+            return len >>> 1;
+          case "base64":
+            return base64ToBytes(string).length;
+          default:
+            if (loweredCase) {
+              return mustMatch ? -1 : utf8ToBytes(string).length;
+            }
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    Buffer3.byteLength = byteLength;
+    function slowToString(encoding, start, end) {
+      let loweredCase = false;
+      if (start === void 0 || start < 0) {
+        start = 0;
+      }
+      if (start > this.length) {
+        return "";
+      }
+      if (end === void 0 || end > this.length) {
+        end = this.length;
+      }
+      if (end <= 0) {
+        return "";
+      }
+      end >>>= 0;
+      start >>>= 0;
+      if (end <= start) {
+        return "";
+      }
+      if (!encoding) encoding = "utf8";
+      while (true) {
+        switch (encoding) {
+          case "hex":
+            return hexSlice(this, start, end);
+          case "utf8":
+          case "utf-8":
+            return utf8Slice(this, start, end);
+          case "ascii":
+            return asciiSlice(this, start, end);
+          case "latin1":
+          case "binary":
+            return latin1Slice(this, start, end);
+          case "base64":
+            return base64Slice(this, start, end);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return utf16leSlice(this, start, end);
+          default:
+            if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+            encoding = (encoding + "").toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    Buffer3.prototype._isBuffer = true;
+    function swap(b, n, m) {
+      const i = b[n];
+      b[n] = b[m];
+      b[m] = i;
+    }
+    Buffer3.prototype.swap16 = function swap16() {
+      const len = this.length;
+      if (len % 2 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 16-bits");
+      }
+      for (let i = 0; i < len; i += 2) {
+        swap(this, i, i + 1);
+      }
+      return this;
+    };
+    Buffer3.prototype.swap32 = function swap32() {
+      const len = this.length;
+      if (len % 4 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 32-bits");
+      }
+      for (let i = 0; i < len; i += 4) {
+        swap(this, i, i + 3);
+        swap(this, i + 1, i + 2);
+      }
+      return this;
+    };
+    Buffer3.prototype.swap64 = function swap64() {
+      const len = this.length;
+      if (len % 8 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 64-bits");
+      }
+      for (let i = 0; i < len; i += 8) {
+        swap(this, i, i + 7);
+        swap(this, i + 1, i + 6);
+        swap(this, i + 2, i + 5);
+        swap(this, i + 3, i + 4);
+      }
+      return this;
+    };
+    Buffer3.prototype.toString = function toString() {
+      const length = this.length;
+      if (length === 0) return "";
+      if (arguments.length === 0) return utf8Slice(this, 0, length);
+      return slowToString.apply(this, arguments);
+    };
+    Buffer3.prototype.toLocaleString = Buffer3.prototype.toString;
+    Buffer3.prototype.equals = function equals(b) {
+      if (!Buffer3.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
+      if (this === b) return true;
+      return Buffer3.compare(this, b) === 0;
+    };
+    Buffer3.prototype.inspect = function inspect() {
+      let str = "";
+      const max = exports.INSPECT_MAX_BYTES;
+      str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+      if (this.length > max) str += " ... ";
+      return "<Buffer " + str + ">";
+    };
+    if (customInspectSymbol) {
+      Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
+    }
+    Buffer3.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+      if (isInstance(target, Uint8Array)) {
+        target = Buffer3.from(target, target.offset, target.byteLength);
+      }
+      if (!Buffer3.isBuffer(target)) {
+        throw new TypeError(
+          'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
+        );
+      }
+      if (start === void 0) {
+        start = 0;
+      }
+      if (end === void 0) {
+        end = target ? target.length : 0;
+      }
+      if (thisStart === void 0) {
+        thisStart = 0;
+      }
+      if (thisEnd === void 0) {
+        thisEnd = this.length;
+      }
+      if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+        throw new RangeError("out of range index");
+      }
+      if (thisStart >= thisEnd && start >= end) {
+        return 0;
+      }
+      if (thisStart >= thisEnd) {
+        return -1;
+      }
+      if (start >= end) {
+        return 1;
+      }
+      start >>>= 0;
+      end >>>= 0;
+      thisStart >>>= 0;
+      thisEnd >>>= 0;
+      if (this === target) return 0;
+      let x = thisEnd - thisStart;
+      let y = end - start;
+      const len = Math.min(x, y);
+      const thisCopy = this.slice(thisStart, thisEnd);
+      const targetCopy = target.slice(start, end);
+      for (let i = 0; i < len; ++i) {
+        if (thisCopy[i] !== targetCopy[i]) {
+          x = thisCopy[i];
+          y = targetCopy[i];
+          break;
+        }
+      }
+      if (x < y) return -1;
+      if (y < x) return 1;
+      return 0;
+    };
+    function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+      if (buffer.length === 0) return -1;
+      if (typeof byteOffset === "string") {
+        encoding = byteOffset;
+        byteOffset = 0;
+      } else if (byteOffset > 2147483647) {
+        byteOffset = 2147483647;
+      } else if (byteOffset < -2147483648) {
+        byteOffset = -2147483648;
+      }
+      byteOffset = +byteOffset;
+      if (numberIsNaN(byteOffset)) {
+        byteOffset = dir ? 0 : buffer.length - 1;
+      }
+      if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
+      if (byteOffset >= buffer.length) {
+        if (dir) return -1;
+        else byteOffset = buffer.length - 1;
+      } else if (byteOffset < 0) {
+        if (dir) byteOffset = 0;
+        else return -1;
+      }
+      if (typeof val === "string") {
+        val = Buffer3.from(val, encoding);
+      }
+      if (Buffer3.isBuffer(val)) {
+        if (val.length === 0) {
+          return -1;
+        }
+        return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+      } else if (typeof val === "number") {
+        val = val & 255;
+        if (typeof Uint8Array.prototype.indexOf === "function") {
+          if (dir) {
+            return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+          } else {
+            return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+          }
+        }
+        return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+      }
+      throw new TypeError("val must be string, number or Buffer");
+    }
+    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+      let indexSize = 1;
+      let arrLength = arr.length;
+      let valLength = val.length;
+      if (encoding !== void 0) {
+        encoding = String(encoding).toLowerCase();
+        if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+          if (arr.length < 2 || val.length < 2) {
+            return -1;
+          }
+          indexSize = 2;
+          arrLength /= 2;
+          valLength /= 2;
+          byteOffset /= 2;
+        }
+      }
+      function read(buf, i2) {
+        if (indexSize === 1) {
+          return buf[i2];
+        } else {
+          return buf.readUInt16BE(i2 * indexSize);
+        }
+      }
+      let i;
+      if (dir) {
+        let foundIndex = -1;
+        for (i = byteOffset; i < arrLength; i++) {
+          if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+            if (foundIndex === -1) foundIndex = i;
+            if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
+          } else {
+            if (foundIndex !== -1) i -= i - foundIndex;
+            foundIndex = -1;
+          }
+        }
+      } else {
+        if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
+        for (i = byteOffset; i >= 0; i--) {
+          let found = true;
+          for (let j = 0; j < valLength; j++) {
+            if (read(arr, i + j) !== read(val, j)) {
+              found = false;
+              break;
+            }
+          }
+          if (found) return i;
+        }
+      }
+      return -1;
+    }
+    Buffer3.prototype.includes = function includes(val, byteOffset, encoding) {
+      return this.indexOf(val, byteOffset, encoding) !== -1;
+    };
+    Buffer3.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+    };
+    Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+    };
+    function hexWrite(buf, string, offset, length) {
+      offset = Number(offset) || 0;
+      const remaining = buf.length - offset;
+      if (!length) {
+        length = remaining;
+      } else {
+        length = Number(length);
+        if (length > remaining) {
+          length = remaining;
+        }
+      }
+      const strLen = string.length;
+      if (length > strLen / 2) {
+        length = strLen / 2;
+      }
+      let i;
+      for (i = 0; i < length; ++i) {
+        const parsed = parseInt(string.substr(i * 2, 2), 16);
+        if (numberIsNaN(parsed)) return i;
+        buf[offset + i] = parsed;
+      }
+      return i;
+    }
+    function utf8Write(buf, string, offset, length) {
+      return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+    }
+    function asciiWrite(buf, string, offset, length) {
+      return blitBuffer(asciiToBytes(string), buf, offset, length);
+    }
+    function base64Write(buf, string, offset, length) {
+      return blitBuffer(base64ToBytes(string), buf, offset, length);
+    }
+    function ucs2Write(buf, string, offset, length) {
+      return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+    }
+    Buffer3.prototype.write = function write(string, offset, length, encoding) {
+      if (offset === void 0) {
+        encoding = "utf8";
+        length = this.length;
+        offset = 0;
+      } else if (length === void 0 && typeof offset === "string") {
+        encoding = offset;
+        length = this.length;
+        offset = 0;
+      } else if (isFinite(offset)) {
+        offset = offset >>> 0;
+        if (isFinite(length)) {
+          length = length >>> 0;
+          if (encoding === void 0) encoding = "utf8";
+        } else {
+          encoding = length;
+          length = void 0;
+        }
+      } else {
+        throw new Error(
+          "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+        );
+      }
+      const remaining = this.length - offset;
+      if (length === void 0 || length > remaining) length = remaining;
+      if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
+        throw new RangeError("Attempt to write outside buffer bounds");
+      }
+      if (!encoding) encoding = "utf8";
+      let loweredCase = false;
+      for (; ; ) {
+        switch (encoding) {
+          case "hex":
+            return hexWrite(this, string, offset, length);
+          case "utf8":
+          case "utf-8":
+            return utf8Write(this, string, offset, length);
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return asciiWrite(this, string, offset, length);
+          case "base64":
+            return base64Write(this, string, offset, length);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return ucs2Write(this, string, offset, length);
+          default:
+            if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    };
+    Buffer3.prototype.toJSON = function toJSON() {
+      return {
+        type: "Buffer",
+        data: Array.prototype.slice.call(this._arr || this, 0)
+      };
+    };
+    function base64Slice(buf, start, end) {
+      if (start === 0 && end === buf.length) {
+        return base64.fromByteArray(buf);
+      } else {
+        return base64.fromByteArray(buf.slice(start, end));
+      }
+    }
+    function utf8Slice(buf, start, end) {
+      end = Math.min(buf.length, end);
+      const res = [];
+      let i = start;
+      while (i < end) {
+        const firstByte = buf[i];
+        let codePoint = null;
+        let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+        if (i + bytesPerSequence <= end) {
+          let secondByte, thirdByte, fourthByte, tempCodePoint;
+          switch (bytesPerSequence) {
+            case 1:
+              if (firstByte < 128) {
+                codePoint = firstByte;
+              }
+              break;
+            case 2:
+              secondByte = buf[i + 1];
+              if ((secondByte & 192) === 128) {
+                tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+                if (tempCodePoint > 127) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 3:
+              secondByte = buf[i + 1];
+              thirdByte = buf[i + 2];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+                tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+                if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 4:
+              secondByte = buf[i + 1];
+              thirdByte = buf[i + 2];
+              fourthByte = buf[i + 3];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+                tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+                if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                  codePoint = tempCodePoint;
+                }
+              }
+          }
+        }
+        if (codePoint === null) {
+          codePoint = 65533;
+          bytesPerSequence = 1;
+        } else if (codePoint > 65535) {
+          codePoint -= 65536;
+          res.push(codePoint >>> 10 & 1023 | 55296);
+          codePoint = 56320 | codePoint & 1023;
+        }
+        res.push(codePoint);
+        i += bytesPerSequence;
+      }
+      return decodeCodePointsArray(res);
+    }
+    var MAX_ARGUMENTS_LENGTH = 4096;
+    function decodeCodePointsArray(codePoints) {
+      const len = codePoints.length;
+      if (len <= MAX_ARGUMENTS_LENGTH) {
+        return String.fromCharCode.apply(String, codePoints);
+      }
+      let res = "";
+      let i = 0;
+      while (i < len) {
+        res += String.fromCharCode.apply(
+          String,
+          codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+        );
+      }
+      return res;
+    }
+    function asciiSlice(buf, start, end) {
+      let ret = "";
+      end = Math.min(buf.length, end);
+      for (let i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf[i] & 127);
+      }
+      return ret;
+    }
+    function latin1Slice(buf, start, end) {
+      let ret = "";
+      end = Math.min(buf.length, end);
+      for (let i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf[i]);
+      }
+      return ret;
+    }
+    function hexSlice(buf, start, end) {
+      const len = buf.length;
+      if (!start || start < 0) start = 0;
+      if (!end || end < 0 || end > len) end = len;
+      let out = "";
+      for (let i = start; i < end; ++i) {
+        out += hexSliceLookupTable[buf[i]];
+      }
+      return out;
+    }
+    function utf16leSlice(buf, start, end) {
+      const bytes = buf.slice(start, end);
+      let res = "";
+      for (let i = 0; i < bytes.length - 1; i += 2) {
+        res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+      }
+      return res;
+    }
+    Buffer3.prototype.slice = function slice(start, end) {
+      const len = this.length;
+      start = ~~start;
+      end = end === void 0 ? len : ~~end;
+      if (start < 0) {
+        start += len;
+        if (start < 0) start = 0;
+      } else if (start > len) {
+        start = len;
+      }
+      if (end < 0) {
+        end += len;
+        if (end < 0) end = 0;
+      } else if (end > len) {
+        end = len;
+      }
+      if (end < start) end = start;
+      const newBuf = this.subarray(start, end);
+      Object.setPrototypeOf(newBuf, Buffer3.prototype);
+      return newBuf;
+    };
+    function checkOffset(offset, ext, length) {
+      if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
+      if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
+    }
+    Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      let val = this[offset];
+      let mul = 1;
+      let i = 0;
+      while (++i < byteLength2 && (mul *= 256)) {
+        val += this[offset + i] * mul;
+      }
+      return val;
+    };
+    Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        checkOffset(offset, byteLength2, this.length);
+      }
+      let val = this[offset + --byteLength2];
+      let mul = 1;
+      while (byteLength2 > 0 && (mul *= 256)) {
+        val += this[offset + --byteLength2] * mul;
+      }
+      return val;
+    };
+    Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 1, this.length);
+      return this[offset];
+    };
+    Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      return this[offset] | this[offset + 1] << 8;
+    };
+    Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      return this[offset] << 8 | this[offset + 1];
+    };
+    Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+    };
+    Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+    };
+    Buffer3.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
+      const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
+      return BigInt(lo) + (BigInt(hi) << BigInt(32));
+    });
+    Buffer3.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+      const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
+      return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+    });
+    Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      let val = this[offset];
+      let mul = 1;
+      let i = 0;
+      while (++i < byteLength2 && (mul *= 256)) {
+        val += this[offset + i] * mul;
+      }
+      mul *= 128;
+      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    };
+    Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      let i = byteLength2;
+      let mul = 1;
+      let val = this[offset + --i];
+      while (i > 0 && (mul *= 256)) {
+        val += this[offset + --i] * mul;
+      }
+      mul *= 128;
+      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    };
+    Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 1, this.length);
+      if (!(this[offset] & 128)) return this[offset];
+      return (255 - this[offset] + 1) * -1;
+    };
+    Buffer3.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      const val = this[offset] | this[offset + 1] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    };
+    Buffer3.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      const val = this[offset + 1] | this[offset] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    };
+    Buffer3.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+    };
+    Buffer3.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+    };
+    Buffer3.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
+      return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
+    });
+    Buffer3.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const val = (first << 24) + // Overflow
+      this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+      return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
+    });
+    Buffer3.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, true, 23, 4);
+    };
+    Buffer3.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, false, 23, 4);
+    };
+    Buffer3.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, true, 52, 8);
+    };
+    Buffer3.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, false, 52, 8);
+    };
+    function checkInt(buf, value2, 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 (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;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value2, offset, byteLength2, maxBytes, 0);
+      }
+      let mul = 1;
+      let i = 0;
+      this[offset] = value2 & 255;
+      while (++i < byteLength2 && (mul *= 256)) {
+        this[offset + i] = value2 / mul & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value2, offset, byteLength2, noAssert) {
+      value2 = +value2;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value2, offset, byteLength2, maxBytes, 0);
+      }
+      let i = byteLength2 - 1;
+      let mul = 1;
+      this[offset + i] = value2 & 255;
+      while (--i >= 0 && (mul *= 256)) {
+        this[offset + i] = value2 / mul & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value2, offset, noAssert) {
+      value2 = +value2;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value2, offset, 1, 255, 0);
+      this[offset] = value2 & 255;
+      return offset + 1;
+    };
+    Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value2, offset, noAssert) {
+      value2 = +value2;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value2, offset, 2, 65535, 0);
+      this[offset] = value2 & 255;
+      this[offset + 1] = value2 >>> 8;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value2, offset, noAssert) {
+      value2 = +value2;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value2, offset, 2, 65535, 0);
+      this[offset] = value2 >>> 8;
+      this[offset + 1] = value2 & 255;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value2, offset, noAssert) {
+      value2 = +value2;
+      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;
+      return offset + 4;
+    };
+    Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value2, offset, noAssert) {
+      value2 = +value2;
+      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;
+      return offset + 4;
+    };
+    function wrtBigUInt64LE(buf, value2, offset, min, max) {
+      checkIntBI(value2, min, max, buf, offset, 7);
+      let lo = Number(value2 & BigInt(4294967295));
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      let hi = Number(value2 >> BigInt(32) & BigInt(4294967295));
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      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));
+      buf[offset + 7] = lo;
+      lo = lo >> 8;
+      buf[offset + 6] = lo;
+      lo = lo >> 8;
+      buf[offset + 5] = lo;
+      lo = lo >> 8;
+      buf[offset + 4] = lo;
+      let hi = Number(value2 >> BigInt(32) & BigInt(4294967295));
+      buf[offset + 3] = hi;
+      hi = hi >> 8;
+      buf[offset + 2] = hi;
+      hi = hi >> 8;
+      buf[offset + 1] = hi;
+      hi = hi >> 8;
+      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.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value2, offset = 0) {
+      return wrtBigUInt64BE(this, value2, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
+    Buffer3.prototype.writeIntLE = function writeIntLE(value2, offset, byteLength2, noAssert) {
+      value2 = +value2;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        const limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value2, offset, byteLength2, limit - 1, -limit);
+      }
+      let i = 0;
+      let mul = 1;
+      let sub = 0;
+      this[offset] = value2 & 255;
+      while (++i < byteLength2 && (mul *= 256)) {
+        if (value2 < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+          sub = 1;
+        }
+        this[offset + i] = (value2 / mul >> 0) - sub & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeIntBE = function writeIntBE(value2, offset, byteLength2, noAssert) {
+      value2 = +value2;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        const limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value2, offset, byteLength2, limit - 1, -limit);
+      }
+      let i = byteLength2 - 1;
+      let mul = 1;
+      let sub = 0;
+      this[offset + i] = value2 & 255;
+      while (--i >= 0 && (mul *= 256)) {
+        if (value2 < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+          sub = 1;
+        }
+        this[offset + i] = (value2 / mul >> 0) - sub & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeInt8 = function writeInt8(value2, offset, noAssert) {
+      value2 = +value2;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value2, offset, 1, 127, -128);
+      if (value2 < 0) value2 = 255 + value2 + 1;
+      this[offset] = value2 & 255;
+      return offset + 1;
+    };
+    Buffer3.prototype.writeInt16LE = function writeInt16LE(value2, offset, noAssert) {
+      value2 = +value2;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value2, offset, 2, 32767, -32768);
+      this[offset] = value2 & 255;
+      this[offset + 1] = value2 >>> 8;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeInt16BE = function writeInt16BE(value2, offset, noAssert) {
+      value2 = +value2;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value2, offset, 2, 32767, -32768);
+      this[offset] = value2 >>> 8;
+      this[offset + 1] = value2 & 255;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeInt32LE = function writeInt32LE(value2, offset, noAssert) {
+      value2 = +value2;
+      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;
+      return offset + 4;
+    };
+    Buffer3.prototype.writeInt32BE = function writeInt32BE(value2, offset, noAssert) {
+      value2 = +value2;
+      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;
+      return offset + 4;
+    };
+    Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value2, offset = 0) {
+      return wrtBigUInt64LE(this, value2, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    });
+    Buffer3.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value2, offset = 0) {
+      return wrtBigUInt64BE(this, value2, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    });
+    function checkIEEE754(buf, value2, 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;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf, value2, offset, 4, 34028234663852886e22, -34028234663852886e22);
+      }
+      ieee754.write(buf, value2, offset, littleEndian, 23, 4);
+      return offset + 4;
+    }
+    Buffer3.prototype.writeFloatLE = function writeFloatLE(value2, offset, noAssert) {
+      return writeFloat(this, value2, offset, true, noAssert);
+    };
+    Buffer3.prototype.writeFloatBE = function writeFloatBE(value2, offset, noAssert) {
+      return writeFloat(this, value2, offset, false, noAssert);
+    };
+    function writeDouble(buf, value2, offset, littleEndian, noAssert) {
+      value2 = +value2;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf, value2, offset, 8, 17976931348623157e292, -17976931348623157e292);
+      }
+      ieee754.write(buf, value2, offset, littleEndian, 52, 8);
+      return offset + 8;
+    }
+    Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value2, offset, noAssert) {
+      return writeDouble(this, value2, offset, true, noAssert);
+    };
+    Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value2, offset, noAssert) {
+      return writeDouble(this, value2, offset, false, noAssert);
+    };
+    Buffer3.prototype.copy = function copy(target, targetStart, start, end) {
+      if (!Buffer3.isBuffer(target)) throw new TypeError("argument should be a Buffer");
+      if (!start) start = 0;
+      if (!end && end !== 0) end = this.length;
+      if (targetStart >= target.length) targetStart = target.length;
+      if (!targetStart) targetStart = 0;
+      if (end > 0 && end < start) end = start;
+      if (end === start) return 0;
+      if (target.length === 0 || this.length === 0) return 0;
+      if (targetStart < 0) {
+        throw new RangeError("targetStart out of bounds");
+      }
+      if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
+      if (end < 0) throw new RangeError("sourceEnd out of bounds");
+      if (end > this.length) end = this.length;
+      if (target.length - targetStart < end - start) {
+        end = target.length - targetStart + start;
+      }
+      const len = end - start;
+      if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
+        this.copyWithin(targetStart, start, end);
+      } else {
+        Uint8Array.prototype.set.call(
+          target,
+          this.subarray(start, end),
+          targetStart
+        );
+      }
+      return len;
+    };
+    Buffer3.prototype.fill = function fill(val, start, end, encoding) {
+      if (typeof val === "string") {
+        if (typeof start === "string") {
+          encoding = start;
+          start = 0;
+          end = this.length;
+        } else if (typeof end === "string") {
+          encoding = end;
+          end = this.length;
+        }
+        if (encoding !== void 0 && typeof encoding !== "string") {
+          throw new TypeError("encoding must be a string");
+        }
+        if (typeof encoding === "string" && !Buffer3.isEncoding(encoding)) {
+          throw new TypeError("Unknown encoding: " + encoding);
+        }
+        if (val.length === 1) {
+          const code = val.charCodeAt(0);
+          if (encoding === "utf8" && code < 128 || encoding === "latin1") {
+            val = code;
+          }
+        }
+      } else if (typeof val === "number") {
+        val = val & 255;
+      } else if (typeof val === "boolean") {
+        val = Number(val);
+      }
+      if (start < 0 || this.length < start || this.length < end) {
+        throw new RangeError("Out of range index");
+      }
+      if (end <= start) {
+        return this;
+      }
+      start = start >>> 0;
+      end = end === void 0 ? this.length : end >>> 0;
+      if (!val) val = 0;
+      let i;
+      if (typeof val === "number") {
+        for (i = start; i < end; ++i) {
+          this[i] = val;
+        }
+      } else {
+        const bytes = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
+        const len = bytes.length;
+        if (len === 0) {
+          throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+        }
+        for (i = 0; i < end - start; ++i) {
+          this[i + start] = bytes[i % len];
+        }
+      }
+      return this;
+    };
+    var errors = {};
+    function E(sym, getMessage, Base) {
+      errors[sym] = class NodeError extends Base {
+        constructor() {
+          super();
+          Object.defineProperty(this, "message", {
+            value: getMessage.apply(this, arguments),
+            writable: true,
+            configurable: true
+          });
+          this.name = `${this.name} [${sym}]`;
+          this.stack;
+          delete this.name;
+        }
+        get code() {
+          return sym;
+        }
+        set code(value2) {
+          Object.defineProperty(this, "code", {
+            configurable: true,
+            enumerable: true,
+            value: value2,
+            writable: true
+          });
+        }
+        toString() {
+          return `${this.name} [${sym}]: ${this.message}`;
+        }
+      };
+    }
+    E(
+      "ERR_BUFFER_OUT_OF_BOUNDS",
+      function(name) {
+        if (name) {
+          return `${name} is outside of buffer bounds`;
+        }
+        return "Attempt to access memory outside buffer bounds";
+      },
+      RangeError
+    );
+    E(
+      "ERR_INVALID_ARG_TYPE",
+      function(name, actual) {
+        return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
+      },
+      TypeError
+    );
+    E(
+      "ERR_OUT_OF_RANGE",
+      function(str, range, input3) {
+        let msg = `The value of "${str}" is out of range.`;
+        let received = input3;
+        if (Number.isInteger(input3) && Math.abs(input3) > 2 ** 32) {
+          received = addNumericalSeparator(String(input3));
+        } else if (typeof input3 === "bigint") {
+          received = String(input3);
+          if (input3 > BigInt(2) ** BigInt(32) || input3 < -(BigInt(2) ** BigInt(32))) {
+            received = addNumericalSeparator(received);
+          }
+          received += "n";
+        }
+        msg += ` It must be ${range}. Received ${received}`;
+        return msg;
+      },
+      RangeError
+    );
+    function addNumericalSeparator(val) {
+      let res = "";
+      let i = val.length;
+      const start = val[0] === "-" ? 1 : 0;
+      for (; i >= start + 4; i -= 3) {
+        res = `_${val.slice(i - 3, i)}${res}`;
+      }
+      return `${val.slice(0, i)}${res}`;
+    }
+    function checkBounds(buf, offset, byteLength2) {
+      validateNumber(offset, "offset");
+      if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
+        boundsError(offset, buf.length - (byteLength2 + 1));
+      }
+    }
+    function checkIntBI(value2, min, max, buf, offset, byteLength2) {
+      if (value2 > max || value2 < min) {
+        const n = typeof min === "bigint" ? "n" : "";
+        let range;
+        if (byteLength2 > 3) {
+          if (min === 0 || min === BigInt(0)) {
+            range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
+          } else {
+            range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
+          }
+        } else {
+          range = `>= ${min}${n} and <= ${max}${n}`;
+        }
+        throw new errors.ERR_OUT_OF_RANGE("value", range, value2);
+      }
+      checkBounds(buf, offset, byteLength2);
+    }
+    function validateNumber(value2, name) {
+      if (typeof value2 !== "number") {
+        throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value2);
+      }
+    }
+    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);
+      }
+      if (length < 0) {
+        throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
+      }
+      throw new errors.ERR_OUT_OF_RANGE(
+        type || "offset",
+        `>= ${type ? 1 : 0} and <= ${length}`,
+        value2
+      );
+    }
+    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+    function base64clean(str) {
+      str = str.split("=")[0];
+      str = str.trim().replace(INVALID_BASE64_RE, "");
+      if (str.length < 2) return "";
+      while (str.length % 4 !== 0) {
+        str = str + "=";
+      }
+      return str;
+    }
+    function utf8ToBytes(string, units) {
+      units = units || Infinity;
+      let codePoint;
+      const length = string.length;
+      let leadSurrogate = null;
+      const bytes = [];
+      for (let i = 0; i < length; ++i) {
+        codePoint = string.charCodeAt(i);
+        if (codePoint > 55295 && codePoint < 57344) {
+          if (!leadSurrogate) {
+            if (codePoint > 56319) {
+              if ((units -= 3) > -1) bytes.push(239, 191, 189);
+              continue;
+            } else if (i + 1 === length) {
+              if ((units -= 3) > -1) bytes.push(239, 191, 189);
+              continue;
+            }
+            leadSurrogate = codePoint;
+            continue;
+          }
+          if (codePoint < 56320) {
+            if ((units -= 3) > -1) bytes.push(239, 191, 189);
+            leadSurrogate = codePoint;
+            continue;
+          }
+          codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+        } else if (leadSurrogate) {
+          if ((units -= 3) > -1) bytes.push(239, 191, 189);
+        }
+        leadSurrogate = null;
+        if (codePoint < 128) {
+          if ((units -= 1) < 0) break;
+          bytes.push(codePoint);
+        } else if (codePoint < 2048) {
+          if ((units -= 2) < 0) break;
+          bytes.push(
+            codePoint >> 6 | 192,
+            codePoint & 63 | 128
+          );
+        } else if (codePoint < 65536) {
+          if ((units -= 3) < 0) break;
+          bytes.push(
+            codePoint >> 12 | 224,
+            codePoint >> 6 & 63 | 128,
+            codePoint & 63 | 128
+          );
+        } else if (codePoint < 1114112) {
+          if ((units -= 4) < 0) break;
+          bytes.push(
+            codePoint >> 18 | 240,
+            codePoint >> 12 & 63 | 128,
+            codePoint >> 6 & 63 | 128,
+            codePoint & 63 | 128
+          );
+        } else {
+          throw new Error("Invalid code point");
+        }
+      }
+      return bytes;
+    }
+    function asciiToBytes(str) {
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
+        byteArray.push(str.charCodeAt(i) & 255);
+      }
+      return byteArray;
+    }
+    function utf16leToBytes(str, units) {
+      let c, hi, lo;
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
+        if ((units -= 2) < 0) break;
+        c = str.charCodeAt(i);
+        hi = c >> 8;
+        lo = c % 256;
+        byteArray.push(lo);
+        byteArray.push(hi);
+      }
+      return byteArray;
+    }
+    function base64ToBytes(str) {
+      return base64.toByteArray(base64clean(str));
+    }
+    function blitBuffer(src, dst, offset, length) {
+      let i;
+      for (i = 0; i < length; ++i) {
+        if (i + offset >= dst.length || i >= src.length) break;
+        dst[i + offset] = src[i];
+      }
+      return i;
+    }
+    function isInstance(obj, type) {
+      return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+    }
+    function numberIsNaN(obj) {
+      return obj !== obj;
+    }
+    var hexSliceLookupTable = (function() {
+      const alphabet = "0123456789abcdef";
+      const table = new Array(256);
+      for (let i = 0; i < 16; ++i) {
+        const i16 = i * 16;
+        for (let j = 0; j < 16; ++j) {
+          table[i16 + j] = alphabet[i] + alphabet[j];
+        }
+      }
+      return table;
+    })();
+    function defineBigIntMethod(fn) {
+      return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+    }
+    function BufferBigIntNotDefined() {
+      throw new Error("BigInt not supported");
+    }
+  }
+});
+
+// packages/safe-bash/browser/platform.mjs
+import { posixPath } from "@poe-platform/safe-fs/core";
+var import_buffer, TransformStream;
+var init_platform = __esm({
+  "packages/safe-bash/browser/platform.mjs"() {
+    "use strict";
+    import_buffer = __toESM(require_buffer(), 1);
+    TransformStream = globalThis.TransformStream;
+  }
+});
+
+// packages/safe-bash/src/commands/xml/index.ts
+init_platform();
+import { parseXmlSteps, XmlLimitError } from "@poe-platform/safe-fs/core";
+
+// packages/safe-bash/src/contracts/command.ts
+init_platform();
+
+// packages/safe-bash/src/contracts/value.ts
+init_platform();
+var byteValues = /* @__PURE__ */ new WeakMap();
+var encoder = new TextEncoder();
+var decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+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);
+  if (!result) throw new TypeError("Expected an owned shell byte value");
+  return result;
+}
+function allocationSize(length, multiplier) {
+  const result = length * multiplier + 64;
+  if (!Number.isSafeInteger(result)) throw new RangeError("Shell value allocation is too large");
+  return result;
+}
+function allocate(bytes, allocation, create, slots = 1) {
+  allocation?.assertOpen();
+  const reservation = allocation?.reserve(bytes, slots);
+  try {
+    const result = create();
+    reservation?.commit(result);
+    return result;
+  } catch (error) {
+    try {
+      reservation?.release();
+    } catch (cleanup) {
+      throw new AggregateError([error, cleanup], "Shell value allocation and release failed");
+    }
+    throw error;
+  }
+}
+function ownedBytes(bytes) {
+  const value2 = Object.freeze({});
+  byteValues.set(value2, { bytes, text: decoder.decode(bytes) });
+  return value2;
+}
+function shellValueFromBytes(bytes, allocation) {
+  if (!(bytes instanceof Uint8Array)) throw new TypeError("Shell bytes must be Uint8Array");
+  const buffer = viewBuffer.call(bytes);
+  const offset = viewOffset.call(bytes);
+  const length = viewLength.call(bytes);
+  return allocate(allocationSize(length, 3), allocation, () => {
+    if (viewOffset.call(bytes) !== offset || viewLength.call(bytes) < length) throw new TypeError("Shell byte input extent changed during admission");
+    return ownedBytes(new Uint8Array(new Uint8Array(buffer, offset, length)));
+  });
+}
+function shellValueText(value2) {
+  return typeof value2 === "string" ? value2 : record(value2).text;
+}
+function shellValueByteLength(value2) {
+  return typeof value2 === "string" ? import_buffer.Buffer.byteLength(value2) : record(value2).bytes.byteLength;
+}
+function shellValueRetainedBytes(value2) {
+  const stored = record(value2);
+  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 concatShellValues(values, allocation) {
+  allocation?.assertOpen();
+  if (!Array.isArray(values)) throw new TypeError("Shell value concatenation requires an array");
+  const count = values.length;
+  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);
+    if (values.length !== count) throw new TypeError("Shell value input extent changed");
+    return value2;
+  }
+  let textOnly = true;
+  for (let index = 0; index < count; index++) {
+    if (typeof values[index] !== "string") {
+      textOnly = false;
+      break;
+    }
+  }
+  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;
+    }
+    if (values.length !== count) throw new TypeError("Shell value input extent changed");
+    return text;
+  }
+  let reservation = allocation?.reserve(allocationSize(count, 16), count + 1);
+  const release = () => {
+    const pending = reservation;
+    reservation = void 0;
+    pending?.release();
+  };
+  try {
+    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;
+    }
+    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")) {
+      const result = snapshot.join("");
+      release();
+      return result;
+    }
+    const length = encodeValues(snapshot);
+    return allocate(allocationSize(length, 3), allocation, () => {
+      const bytes = new Uint8Array(length);
+      encodeValues(snapshot, bytes);
+      const result = ownedBytes(bytes);
+      release();
+      return result;
+    });
+  } catch (error) {
+    try {
+      release();
+    } catch (cleanup) {
+      throw new AggregateError([error, cleanup], "Shell value snapshot and release failed");
+    }
+    throw error;
+  }
+}
+function encodeValues(values, output2) {
+  let offset = 0;
+  let high = 0;
+  const write = (byte) => {
+    if (output2) output2[offset] = byte;
+    offset++;
+  };
+  const point = (code) => {
+    if (code < 128) write(code);
+    else if (code < 2048) {
+      write(192 | code >> 6);
+      write(128 | code & 63);
+    } else if (code < 65536) {
+      write(224 | code >> 12);
+      write(128 | code >> 6 & 63);
+      write(128 | code & 63);
+    } else {
+      write(240 | code >> 18);
+      write(128 | code >> 12 & 63);
+      write(128 | code >> 6 & 63);
+      write(128 | code & 63);
+    }
+  };
+  for (const value2 of values) {
+    if (typeof value2 !== "string") {
+      if (high) {
+        point(65533);
+        high = 0;
+      }
+      const bytes = record(value2).bytes;
+      output2?.set(bytes, offset);
+      offset += bytes.byteLength;
+      continue;
+    }
+    for (let index = 0; index < value2.length; index++) {
+      const code = value2.charCodeAt(index);
+      if (high) {
+        const previous = high;
+        high = 0;
+        if (code >= 56320 && code <= 57343) {
+          point(65536 + (previous - 55296 << 10) + code - 56320);
+          continue;
+        }
+        point(65533);
+      }
+      if (code >= 55296 && code <= 56319) high = code;
+      else point(code >= 56320 && code <= 57343 ? 65533 : code);
+    }
+  }
+  if (high) point(65533);
+  if (!Number.isSafeInteger(offset)) throw new RangeError("Shell value allocation is too large");
+  return offset;
+}
+
+// packages/safe-bash/src/contracts/command.ts
+var argumentCarriers = /* @__PURE__ */ new WeakSet();
+var CommandArgumentIdentityError = class extends TypeError {
+  constructor() {
+    super("Command argument identity does not match its carrier");
+  }
+};
+function argumentAllocation(allocation) {
+  const reservations = [];
+  const tracked = allocation && {
+    assertOpen() {
+      allocation.assertOpen();
+    },
+    reserve(bytes, slots) {
+      const reservation = allocation.reserve(bytes, slots);
+      let released = false;
+      const owned = {
+        commit(value2) {
+          reservation.commit(value2);
+        },
+        release() {
+          if (released) return;
+          released = true;
+          reservation.release();
+        }
+      };
+      reservations.push(owned);
+      return owned;
+    }
+  };
+  return {
+    allocation: tracked,
+    rollback(error) {
+      const failures = [error];
+      for (let index = reservations.length - 1; index >= 0; index--) {
+        try {
+          reservations[index].release();
+        } catch (cleanup) {
+          failures.push(cleanup);
+        }
+      }
+      if (failures.length > 1) throw new AggregateError(failures, "Command argument allocation and release failed");
+      throw error;
+    }
+  };
+}
+function ownedCommandArguments(size, valueAt, allocation, extent) {
+  allocation?.assertOpen();
+  const length = typeof size === "number" ? size : size();
+  const bytes = 128 + length * 40;
+  const slots = length * 4 + 1;
+  if (!Number.isSafeInteger(length) || length < 0 || !Number.isSafeInteger(bytes) || !Number.isSafeInteger(slots)) {
+    throw new RangeError("Command argument allocation is too large");
+  }
+  const transaction = argumentAllocation(allocation);
+  const reservation = transaction.allocation?.reserve(bytes, slots);
+  try {
+    if (extent && extent() !== length) throw new TypeError("Command argument extent changed during admission");
+    const snapshot = [];
+    for (let index = 0; index < length; index++) snapshot.push(valueAt(index));
+    if (extent && extent() !== length) throw new TypeError("Command argument extent changed during admission");
+    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);
+    }
+    Object.freeze(values);
+    Object.freeze(args);
+    const carrier = Object.freeze({
+      args,
+      values,
+      bytes(index) {
+        return Number.isInteger(index) && index >= 0 && index < length ? shellValueBytes(values[index], allocation) : void 0;
+      },
+      slice(start = 0, end = length) {
+        const offset = (index) => {
+          const integral = Math.trunc(index) || 0;
+          return integral < 0 ? Math.max(0, length + integral) : Math.min(length, integral);
+        };
+        const first = offset(start);
+        return ownedCommandArguments(Math.max(0, offset(end) - first), (index) => values[first + index], allocation);
+      },
+      select(indices) {
+        return ownedCommandArguments(() => {
+          if (!Array.isArray(indices)) throw new TypeError("Command argument selection must be an array");
+          return indices.length;
+        }, (index) => {
+          const selected = indices[index];
+          if (!Number.isInteger(selected) || selected < 0 || selected >= length) throw new RangeError("Command argument index is out of range");
+          return values[selected];
+        }, allocation, () => indices.length);
+      },
+      concat(...others) {
+        let total = length;
+        for (const other of others) {
+          if (!argumentCarriers.has(other)) throw new TypeError("Expected owned command arguments");
+          total += other.values.length;
+        }
+        return ownedCommandArguments(total, (index) => {
+          if (index < length) return values[index];
+          let offset = index - length;
+          for (const other of others) {
+            if (offset < other.values.length) return other.values[offset];
+            offset -= other.values.length;
+          }
+          throw new RangeError("Command argument index is out of range");
+        }, allocation);
+      },
+      withValues(incoming) {
+        return ownedCommandArguments(() => {
+          if (!Array.isArray(incoming)) throw new TypeError("Command arguments must be an array");
+          return incoming.length;
+        }, (index) => incoming[index], allocation, () => incoming.length);
+      },
+      join(separator = "") {
+        allocation?.assertOpen();
+        const count = Math.max(0, length * 2 - 1);
+        const bytes2 = 128 + count * 16;
+        if (!Number.isSafeInteger(bytes2) || !Number.isSafeInteger(count + 1)) throw new RangeError("Command argument join allocation is too large");
+        const transaction2 = argumentAllocation(allocation);
+        const scratch = transaction2.allocation?.reserve(bytes2, count + 1);
+        try {
+          const parts2 = [];
+          for (let index = 0; index < length; index++) {
+            if (index) parts2.push(separator);
+            parts2.push(values[index]);
+          }
+          Object.freeze(parts2);
+          scratch?.commit(parts2);
+          const result = concatShellValues(parts2, transaction2.allocation);
+          scratch?.release();
+          return result;
+        } catch (error) {
+          return transaction2.rollback(error);
+        }
+      }
+    });
+    reservation?.commit(carrier);
+    argumentCarriers.add(carrier);
+    return carrier;
+  } catch (error) {
+    return transaction.rollback(error);
+  }
+}
+function createCommandArguments(values, allocation) {
+  return ownedCommandArguments(() => {
+    if (!Array.isArray(values)) throw new TypeError("Command arguments must be an array");
+    return values.length;
+  }, (index) => values[index], allocation, () => values.length);
+}
+function getCommandArguments(context) {
+  const carrier = context.argumentValues;
+  if (carrier === void 0) return createCommandArguments(context.args);
+  if (!argumentCarriers.has(carrier)) throw new TypeError("Expected owned command arguments");
+  if (carrier.args !== context.args) throw new CommandArgumentIdentityError();
+  return carrier;
+}
+var CommandRegistry = class {
+  #commands = /* @__PURE__ */ new Map();
+  constructor(commands = []) {
+    for (const command of commands) this.register(command);
+  }
+  register(command, options2 = {}) {
+    const { name, execute: execute2 } = 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");
+    }
+    if (typeof execute2 !== "function") {
+      throw new TypeError("Command execute must be a function");
+    }
+    if (this.#commands.has(name) && !options2.replace) {
+      throw new Error(`Command already registered: ${name}`);
+    }
+    this.#commands.set(name, Object.freeze({ ...command, name, execute: execute2 }));
+    return this;
+  }
+  get(name) {
+    return this.#commands.get(name);
+  }
+  has(name) {
+    return this.#commands.has(name);
+  }
+  unregister(name) {
+    return this.#commands.delete(name);
+  }
+  list() {
+    return Array.from(this.#commands.values());
+  }
+};
+function validateExitCode(exitCode) {
+  if (!Number.isInteger(exitCode) || exitCode < 0 || exitCode > 255) {
+    throw new RangeError("Exit status must be an integer between 0 and 255");
+  }
+  return exitCode;
+}
+
+// packages/safe-bash/src/contracts/command-requirements.ts
+init_platform();
+
+// packages/safe-bash/src/contracts/errors.ts
+init_platform();
+import { isErrnoCode, isFsError, toFsError, FsError } from "@poe-platform/safe-fs/core";
+
+// packages/safe-bash/src/contracts/command-requirements.ts
+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;
+  if (!Number.isSafeInteger(highWaterMark) || highWaterMark < 1) {
+    throw new RangeError("highWaterMark must be a positive safe integer");
+  }
+  const stream = new TransformStream(
+    void 0,
+    { highWaterMark: 1 },
+    { highWaterMark, size: (chunk) => chunk.byteLength }
+  );
+  const reader = stream.readable.getReader();
+  const writer = stream.writable.getWriter();
+  let ended = false;
+  let failed = false;
+  let failure;
+  let closePromise;
+  let abortPromise;
+  let finished = false;
+  const consumer = new AbortController();
+  const abort = (reason = new FsError("EPIPE", { syscall: "pipe" })) => {
+    if (abortPromise) return abortPromise;
+    if (finished) return Promise.resolve();
+    failed = true;
+    failure = reason;
+    ended = true;
+    consumer.abort(reason);
+    abortPromise = Promise.allSettled([reader.cancel(reason), writer.abort(reason)]).then(() => {
+    });
+    return abortPromise;
+  };
+  const onAbort = () => {
+    void abort(signal?.reason);
+  };
+  const cleanup = () => signal?.removeEventListener("abort", onAbort);
+  void writer.closed.catch(() => {
+  });
+  void reader.closed.then(cleanup, cleanup);
+  if (signal?.aborted) onAbort();
+  else signal?.addEventListener("abort", onAbort, { once: true });
+  const iterator = (async function* () {
+    try {
+      while (true) {
+        if (failed) throw failure;
+        const result = await reader.read();
+        if (failed) throw failure;
+        if (result.done) {
+          finished = true;
+          return;
+        }
+        yield result.value;
+      }
+    } finally {
+      if (!finished) await abort();
+      reader.releaseLock();
+    }
+  })();
+  const readable = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next() {
+      return iterator.next();
+    },
+    async return() {
+      if (!finished) await abort();
+      try {
+        return await iterator.return(void 0);
+      } finally {
+        reader.releaseLock();
+      }
+    },
+    async throw(reason) {
+      await abort(reason);
+      try {
+        return await iterator.throw(reason);
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  };
+  const write = async (chunk) => {
+    if (failed) throw failure;
+    if (ended) throw new FsError("EPIPE", { syscall: "write" });
+    if (!(chunk instanceof Uint8Array)) throw new TypeError("Byte sinks require Uint8Array chunks");
+    if (chunk.byteLength > 0) await writer.write(new Uint8Array(chunk));
+  };
+  return {
+    readable,
+    writable: {
+      write,
+      [outputFailure]: abort,
+      ownedOutput: { consumerClosed: consumer.signal, write }
+    },
+    close() {
+      if (failed) return Promise.reject(failure);
+      ended = true;
+      closePromise ??= writer.close();
+      return closePromise;
+    },
+    abort
+  };
+}
+async function writeText(sink, text) {
+  await sink.write(new TextEncoder().encode(text));
+}
+async function writeBytes(sink, chunk, signal) {
+  if (!(chunk instanceof Uint8Array)) throw new TypeError("Byte sinks require Uint8Array chunks");
+  await abortable(() => sink.write(chunk), signal);
+}
+async function pipeBytes(source, sink, signal) {
+  signal?.throwIfAborted();
+  for await (const chunk of readBytes(source, signal)) {
+    await writeBytes(sink, chunk, signal);
+  }
+  signal?.throwIfAborted();
+}
+async function collectText(source, options2) {
+  return new TextDecoder().decode(await collectBytes(source, options2));
+}
+async function abortable(operation, signal) {
+  signal?.throwIfAborted();
+  if (!signal) return operation();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      Promise.resolve(operation()).then(
+        (result) => {
+          signal.removeEventListener("abort", onAbort);
+          resolve(result);
+        },
+        (error) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(error);
+        }
+      );
+    } catch (error) {
+      signal.removeEventListener("abort", onAbort);
+      reject(error);
+    }
+  });
+}
+
+// packages/safe-bash/src/contracts/path.ts
+init_platform();
+import { validatePath, resolvePath, normalizePath, relativePath, isPathWithin, assertPathWithin, basename, dirname, extname, joinPath, isAbsolutePath, posixPath as posixPath2 } from "@poe-platform/safe-fs/core";
+
+// packages/safe-bash/src/escaping.ts
+init_platform();
+
+// packages/safe-bash/src/contracts/yield.ts
+init_platform();
+var checkpoints = /* @__PURE__ */ new WeakMap();
+function monotonicNow() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function registerYieldCheckpoint(signal, checkpoint) {
+  checkpoints.set(signal, checkpoint);
+}
+function scheduleTurn(callback) {
+  const host = globalThis;
+  return host.setImmediate ? { kind: "immediate", value: host.setImmediate(callback) } : { kind: "timeout", value: setTimeout(callback, 0) };
+}
+function cancelTurn(handle) {
+  if (handle?.kind === "immediate") globalThis.clearImmediate?.(handle.value);
+  else if (handle) clearTimeout(handle.value);
+}
+function yieldTurn(signal) {
+  signal?.throwIfAborted();
+  if (signal) checkpoints.get(signal)?.();
+  return new Promise((resolve, reject) => {
+    let handle;
+    const finish = () => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    };
+    const abort = () => {
+      cancelTurn(handle);
+      reject(signal.reason);
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    else handle = scheduleTurn(finish);
+  });
+}
+
+// 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
+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 };
+}
+
+// packages/safe-bash/src/commands/structured/limits.ts
+init_platform();
+
+// packages/safe-bash/src/commands/structured/numbers.ts
+init_platform();
+var Decimal = class {
+  constructor(digits, exponent, negative, text, double) {
+    this.digits = digits;
+    this.exponent = exponent;
+    this.negative = negative;
+    this.text = text;
+    this.double = double;
+    Object.freeze(this);
+  }
+  digits;
+  exponent;
+  negative;
+  text;
+  double;
+};
+function isNumber(value2) {
+  return typeof value2 === "number" || value2 instanceof Decimal;
+}
+function numberValue(value2) {
+  return typeof value2 === "number" ? value2 : value2.double;
+}
+function numericToken(token, budget) {
+  budget.step(Math.ceil(token.length / 32));
+  const end = token.indexOf("\0");
+  const text = end < 0 ? token : token.slice(0, end);
+  if (/^[+-]?s?nan[0-9]*$/iu.test(text)) return new Decimal("0", NaN, false, "null", NaN);
+  if (/^[+-]?inf(?:inity)?$/iu.test(text)) {
+    const negative = text[0] === "-";
+    const value2 = negative ? -Infinity : Infinity;
+    return new Decimal("1", Infinity, negative, numberText(value2), value2);
+  }
+  if (!/^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/u.test(text)) return void 0;
+  return decimalNumber(text[0] === "+" ? text.slice(1) : text, budget);
+}
+function increment(digits) {
+  let position = digits.length - 1;
+  while (position >= 0 && digits[position] === "9") position--;
+  return position < 0 ? `1${"0".repeat(digits.length)}` : `${digits.slice(0, position)}${Number(digits[position]) + 1}${"0".repeat(digits.length - position - 1)}`;
+}
+function decimalDouble(digits, exponent, negative) {
+  let rounded = digits;
+  if (digits.length > 17) {
+    rounded = digits.slice(0, 17);
+    const next = digits[17];
+    if (next > "5" || next === "5" && (/[1-9]/u.test(digits.slice(18)) || Number(rounded[16]) % 2 !== 0)) rounded = increment(rounded);
+    exponent += digits.length - 17;
+  }
+  return Number(`${negative ? "-" : ""}${rounded}e${exponent}`);
+}
+function decimalText(digits, exponent, negative) {
+  const sign = negative ? "-" : "";
+  const adjusted = exponent + digits.length - 1;
+  if (exponent > 0 || adjusted < -6) return `${sign}${digits[0]}${digits.length > 1 ? `.${digits.slice(1)}` : ""}E${adjusted >= 0 ? "+" : ""}${adjusted}`;
+  const point = digits.length + exponent;
+  if (point <= 0) return `${sign}0.${"0".repeat(-point)}${digits}`;
+  return `${sign}${digits.slice(0, point)}${point < digits.length ? `.${digits.slice(point)}` : ""}`;
+}
+function decimalNumber(token, budget) {
+  budget.text(token);
+  budget.step(Math.ceil(token.length / 32));
+  const negative = token[0] === "-";
+  const unsigned = negative ? token.slice(1) : token;
+  const marker = unsigned.search(/[eE]/u);
+  const coefficient = marker < 0 ? unsigned : unsigned.slice(0, marker);
+  const point = coefficient.indexOf(".");
+  let exponent = (marker < 0 ? 0 : Number(unsigned.slice(marker + 1))) - (point < 0 ? 0 : coefficient.length - point - 1);
+  let digits = coefficient.replace(".", "").replace(/^0+/u, "") || "0";
+  const minimumExponent = -1147483646;
+  const maximumExponent = 999999999;
+  if (digits === "0") exponent = Math.max(minimumExponent, Math.min(maximumExponent, exponent));
+  else if (exponent + digits.length - 1 > maximumExponent) {
+    const infinity = negative ? -Infinity : Infinity;
+    return new Decimal("1", Infinity, negative, numberText(infinity), infinity);
+  } else if (exponent < minimumExponent) {
+    const retained = digits.length - (minimumExponent - exponent);
+    const roundUp = retained >= 0 && digits[retained] >= "5";
+    digits = retained > 0 ? digits.slice(0, retained) : "0";
+    if (roundUp) digits = increment(digits);
+    exponent = minimumExponent;
+  }
+  const text = decimalText(digits, exponent, negative);
+  budget.text(text);
+  return new Decimal(digits, exponent, negative, text, decimalDouble(digits, exponent, negative));
+}
+function compareNumbers(left, right, budget) {
+  if (Number.isNaN(numberValue(left))) return -1;
+  if (Number.isNaN(numberValue(right))) return 1;
+  if (!(left instanceof Decimal) || !(right instanceof Decimal)) {
+    const first = numberValue(left);
+    const second = numberValue(right);
+    return first < second ? -1 : first === second ? 0 : 1;
+  }
+  if (left.digits === "0" && right.digits === "0") return 0;
+  const sign = left.negative ? -1 : 1;
+  if (left.negative !== right.negative) return sign;
+  if (left.digits === "0") return -sign;
+  if (right.digits === "0") return sign;
+  if (left.exponent === Infinity || right.exponent === Infinity) return left.exponent === right.exponent ? 0 : left.exponent === Infinity ? sign : -sign;
+  const magnitude = left.exponent + left.digits.length - right.exponent - right.digits.length;
+  if (magnitude) return Math.sign(magnitude) * sign;
+  const length = Math.max(left.digits.length, right.digits.length);
+  budget.step(Math.ceil(length / 32));
+  for (let index = 0; index < length; index++) {
+    if (index % 1024 === 0) budget.step();
+    const first = left.digits[index] ?? "0";
+    const second = right.digits[index] ?? "0";
+    if (first !== second) return (first < second ? -1 : 1) * sign;
+  }
+  return 0;
+}
+function numberText(value2) {
+  if (value2 instanceof Decimal) return value2.text;
+  if (Number.isNaN(value2)) return "null";
+  const bounded = Math.max(-Number.MAX_VALUE, Math.min(Number.MAX_VALUE, value2));
+  const sign = bounded < 0 || Object.is(bounded, -0) ? "-" : "";
+  const [mantissa, power] = Math.abs(bounded).toExponential().split("e");
+  const digits = mantissa.replace(".", "");
+  const exponent = Number(power);
+  const point = exponent + 1;
+  if (point <= -4 || point > digits.length + 15) return `${sign}${mantissa}e${exponent < 0 ? "-" : "+"}${String(Math.abs(exponent)).padStart(2, "0")}`;
+  if (point <= 0) return `${sign}0.${"0".repeat(-point)}${digits}`;
+  return `${sign}${point >= digits.length ? digits.padEnd(point, "0") : `${digits.slice(0, point)}.${digits.slice(point)}`}`;
+}
+
+// packages/safe-bash/src/commands/structured/limits.ts
+var defaultJqLimits = Object.freeze({
+  maxInputBytes: 64 * 1024 * 1024,
+  maxValueBytes: 8 * 1024 * 1024,
+  maxOutputBytes: 16 * 1024 * 1024,
+  maxSourceBytes: 64 * 1024,
+  maxDepth: 128,
+  maxAstDepth: 64,
+  maxSteps: 1e6,
+  maxResults: 1e5,
+  maxCollectionSize: 1e5
+});
+var JqError = class extends Error {
+  constructor(message, exitCode = 5) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+  exitCode;
+};
+var JqLimitError = class extends JqError {
+  constructor(name) {
+    super(`${name} limit exceeded`);
+  }
+};
+function resolveJqLimits(options2 = {}) {
+  const limits = { ...defaultJqLimits, ...options2 };
+  for (const [name, value2] of Object.entries(limits)) {
+    if (!Number.isSafeInteger(value2) || value2 < 1) throw new RangeError(`${name} must be a positive safe integer`);
+  }
+  if (limits.maxDepth > 256 || limits.maxAstDepth > 128) throw new RangeError("maxDepth must be <=256 and maxAstDepth <=128");
+  return Object.freeze(limits);
+}
+var Budget = class {
+  constructor(limits, signal) {
+    this.limits = limits;
+    this.signal = signal;
+  }
+  limits;
+  signal;
+  steps = 0;
+  nextYield = 1024;
+  lastYield = monotonicNow();
+  inputBytes = 0;
+  outputBytes = 0;
+  results = 0;
+  inputLocation = { name: "<unknown>", line: 0, complete: true };
+  step(count = 1) {
+    this.signal.throwIfAborted();
+    this.steps += count;
+    if (this.steps > this.limits.maxSteps) throw new JqLimitError("maxSteps");
+  }
+  async tick(count = 1) {
+    this.step(count);
+    if (this.steps >= this.nextYield || monotonicNow() - this.lastYield >= 25) {
+      await yieldTurn(this.signal);
+      this.signal.throwIfAborted();
+      this.nextYield = this.steps + 1024;
+      this.lastYield = monotonicNow();
+    }
+  }
+  collection(size) {
+    if (size > this.limits.maxCollectionSize) throw new JqLimitError("maxCollectionSize");
+  }
+  text(text) {
+    if (text.length > this.limits.maxValueBytes || import_buffer.Buffer.byteLength(text) > this.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+  }
+  value(value2) {
+    let bytes = 0;
+    const visit = (current, depth) => {
+      this.step();
+      if (depth > this.limits.maxDepth) throw new JqLimitError("maxDepth");
+      if (current !== null && typeof current === "object" && !(current instanceof Decimal)) {
+        if (depth + 1 > this.limits.maxDepth) throw new JqLimitError("maxDepth");
+        const keys = Array.isArray(current) ? Object.keys(current) : objectKeys(current);
+        this.collection(keys.length);
+        bytes += 2 + Math.max(0, keys.length - 1);
+        for (const key of keys) {
+          if (!Array.isArray(current)) {
+            this.text(key);
+            bytes += import_buffer.Buffer.byteLength(JSON.stringify(key)) + 1;
+          }
+          if (bytes > this.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+          visit(current[key], depth + 1);
+        }
+      } else {
+        if (typeof current === "string") {
+          this.step(current.length);
+          this.text(current);
+        }
+        bytes += import_buffer.Buffer.byteLength(scalarJson(current, this));
+      }
+      if (bytes > this.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+    };
+    visit(value2, 0);
+    return bytes;
+  }
+};
+var keyOrders = /* @__PURE__ */ new WeakMap();
+function object() {
+  const result = /* @__PURE__ */ Object.create(null);
+  keyOrders.set(result, []);
+  return result;
+}
+function objectKeys(value2) {
+  return keyOrders.get(value2)?.slice() ?? Object.keys(value2);
+}
+function* objectKeyIterator(value2) {
+  const keys = keyOrders.get(value2);
+  if (keys) yield* keys;
+  else for (const key in value2) if (Object.hasOwn(value2, key)) yield key;
+}
+function objectSize(value2) {
+  return keyOrders.get(value2)?.length ?? Object.keys(value2).length;
+}
+function put(value2, key, item) {
+  if (!Object.hasOwn(value2, key)) keyOrders.get(value2)?.push(key);
+  value2[key] = item;
+}
+function remove(value2, key) {
+  delete value2[key];
+  const keys = keyOrders.get(value2);
+  if (keys) {
+    const index = keys.indexOf(key);
+    if (index >= 0) keys.splice(index, 1);
+  }
+}
+function copyObject(...sources) {
+  const result = object();
+  for (const source of sources) if (source) for (const key of objectKeys(source)) put(result, key, source[key]);
+  return result;
+}
+function wellFormed(text) {
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const next = text.charCodeAt(++index);
+      if (!(next >= 56320 && next <= 57343)) return false;
+    } else if (code >= 56320 && code <= 57343) return false;
+  }
+  return true;
+}
+function isObject(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2) && !(value2 instanceof Decimal);
+}
+function truth(value2) {
+  return value2 !== null && value2 !== false;
+}
+function scalarJson(value2, budget) {
+  if (value2 instanceof Decimal) budget.step(Math.ceil(value2.text.length / 32));
+  return isNumber(value2) ? numberText(value2) : JSON.stringify(value2);
+}
+async function interruptible(operation, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const aborted = () => {
+      signal.removeEventListener("abort", aborted);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", aborted, { once: true });
+    try {
+      Promise.resolve(operation()).then(
+        (result) => {
+          signal.removeEventListener("abort", aborted);
+          resolve(result);
+        },
+        (error) => {
+          signal.removeEventListener("abort", aborted);
+          reject(error);
+        }
+      );
+    } catch (error) {
+      signal.removeEventListener("abort", aborted);
+      reject(error);
+    }
+  });
+}
+
+// packages/safe-bash/src/commands/xml/limits.ts
+init_platform();
+var defaultXmlQueryLimits = Object.freeze({
+  maxInputBytes: 8 * 1024 * 1024,
+  maxOutputBytes: 8 * 1024 * 1024,
+  maxSourceBytes: 64 * 1024,
+  maxDepth: 64,
+  maxNodes: 1e5,
+  maxAttributes: 1e4,
+  maxAttributesPerElement: 128,
+  maxNamespaces: 256,
+  maxSteps: 1e6,
+  maxResults: 1e5
+});
+var XmlQueryError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var XmlQueryLimitError = class extends XmlQueryError {
+  constructor(name) {
+    super(`${name} limit exceeded`, 5);
+  }
+};
+function resolveXmlQueryLimits(options2 = {}) {
+  const limits = { ...defaultXmlQueryLimits, ...options2 };
+  for (const [name, value2] of Object.entries(limits)) {
+    if (!Object.hasOwn(defaultXmlQueryLimits, name) || !Number.isSafeInteger(value2) || value2 < 1) {
+      throw new RangeError(`${name} must be a positive safe integer XML limit`);
+    }
+  }
+  if (limits.maxDepth > 256) throw new RangeError("maxDepth must be <=256");
+  return Object.freeze(limits);
+}
+var XmlBudget = class {
+  constructor(limits, signal) {
+    this.limits = limits;
+    this.signal = signal;
+  }
+  limits;
+  signal;
+  steps = 0;
+  checkpoint = 0;
+  outputBytes = 0;
+  async tick(work = 1) {
+    this.signal.throwIfAborted();
+    this.steps += work;
+    if (this.steps > this.limits.maxSteps) throw new XmlQueryLimitError("maxSteps");
+    this.checkpoint += work;
+    if (this.checkpoint >= 1024) {
+      this.checkpoint = 0;
+      await yieldTurn(this.signal);
+    }
+  }
+  results(size) {
+    if (size > this.limits.maxResults) throw new XmlQueryLimitError("maxResults");
+  }
+};
+
+// packages/safe-bash/src/commands/xml/query.ts
+init_platform();
+var nameStart = (character) => character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character === "_";
+var namePart = (character) => nameStart(character) || character >= "0" && character <= "9" || character === "-" || character === ".";
+async function parseQuery(source, budget) {
+  if (source.length > budget.limits.maxSourceBytes || import_buffer.Buffer.byteLength(source) > budget.limits.maxSourceBytes) throw new XmlQueryLimitError("maxSourceBytes");
+  for (let offset = 0; offset < source.length; offset += 256) await budget.tick(Math.min(256, source.length - offset));
+  let at = 0;
+  const fail = () => {
+    throw new XmlQueryError(`unsupported XPath syntax at offset ${at}`, 10);
+  };
+  const space = () => {
+    while (source[at] === " " || source[at] === "	" || source[at] === "\r" || source[at] === "\n") at++;
+  };
+  const expect = (value2) => {
+    space();
+    if (!source.startsWith(value2, at)) fail();
+    at += value2.length;
+  };
+  const name = () => {
+    space();
+    const start = at;
+    if (!nameStart(source[at] ?? "")) fail();
+    while (namePart(source[at] ?? "")) at++;
+    if (source[at] === ":") fail();
+    return source.slice(start, at);
+  };
+  space();
+  let scalar;
+  if (source[at] !== "/") {
+    const value2 = name();
+    if (value2 !== "string" && value2 !== "count" && value2 !== "boolean") fail();
+    scalar = value2;
+    expect("(");
+  }
+  const steps = [];
+  space();
+  while (source[at] === "/") {
+    at++;
+    const descendant = source[at] === "/";
+    if (descendant) at++;
+    space();
+    let kind = "element";
+    if (source[at] === "@") {
+      kind = "attribute";
+      at++;
+    }
+    let selected;
+    if (source[at] === "*") {
+      selected = "*";
+      at++;
+    } else {
+      selected = name();
+      space();
+      if (source[at] === "(") {
+        if (selected !== "text" || kind !== "element") fail();
+        expect("(");
+        expect(")");
+        kind = "text";
+      }
+    }
+    const predicates = [];
+    space();
+    while (source[at] === "[") {
+      at++;
+      space();
+      if (source[at] === "@") {
+        at++;
+        const attribute = name();
+        expect("=");
+        space();
+        const quote = source[at++];
+        if (quote !== "'" && quote !== '"') fail();
+        const start = at;
+        while (at < source.length && source[at] !== quote) at++;
+        if (at === source.length) fail();
+        predicates.push({ kind: "attribute", name: attribute, value: source.slice(start, at++) });
+      } else {
+        const start = at;
+        while ((source[at] ?? "") >= "0" && (source[at] ?? "") <= "9") at++;
+        const value2 = Number(source.slice(start, at));
+        if (start === at || !Number.isSafeInteger(value2) || value2 < 1) fail();
+        predicates.push({ kind: "position", value: value2 });
+      }
+      expect("]");
+      space();
+    }
+    steps.push({ descendant, kind, name: selected, predicates });
+    if (kind !== "element" && source[at] === "/") fail();
+    await budget.tick();
+  }
+  if (!steps.length) fail();
+  if (scalar !== void 0) expect(")");
+  space();
+  if (at !== source.length) fail();
+  return { scalar, steps };
+}
+
+// packages/safe-bash/src/commands/xml/evaluate.ts
+init_platform();
+var xmlns = "http://www.w3.org/2000/xmlns/";
+async function indexTree(root, budget) {
+  const document = { kind: "document", children: [] };
+  const order = [document];
+  const pending = [{ parent: document, content: root }];
+  while (pending.length) {
+    await budget.tick();
+    const { parent, content } = pending.pop();
+    if (content.kind === "element") {
+      const node = { kind: "element", value: content, children: [], attributes: [] };
+      parent.children.push(node);
+      order.push(node);
+      for (const attribute of content.attributes) {
+        await budget.tick();
+        if (attribute.namespace === xmlns) continue;
+        const selected = { kind: "attribute", value: attribute };
+        node.attributes.push(selected);
+        order.push(selected);
+      }
+      for (let index = content.content.length - 1; index >= 0; index--) {
+        await budget.tick();
+        pending.push({ parent: node, content: content.content[index] });
+      }
+    } else {
+      const node = { kind: content.kind, value: content };
+      parent.children.push(node);
+      order.push(node);
+    }
+  }
+  return { document, order };
+}
+function matches(node, step) {
+  if (step.kind === "text") return node.kind === "text" || node.kind === "cdata";
+  if (node.kind !== step.kind) return false;
+  if (node.kind === "element" || node.kind === "attribute") {
+    return step.name === "*" || node.value.namespace === "" && node.value.localName === step.name;
+  }
+  return false;
+}
+async function evaluate(query, root, budget) {
+  const { document, order } = await indexTree(root, budget);
+  let contexts = [document];
+  for (const step of query.steps) {
+    const parents = /* @__PURE__ */ new Set();
+    const pending = [...contexts];
+    while (pending.length) {
+      await budget.tick();
+      const node = pending.pop();
+      if (parents.has(node)) continue;
+      parents.add(node);
+      if (step.descendant && (node.kind === "document" || node.kind === "element")) {
+        for (const child of node.children) {
+          await budget.tick();
+          pending.push(child);
+        }
+      }
+    }
+    const selected = /* @__PURE__ */ new Set();
+    for (const parent of parents) {
+      await budget.tick();
+      const candidates = step.kind === "attribute" ? parent.kind === "element" ? parent.attributes : [] : parent.kind === "element" || parent.kind === "document" ? parent.children : [];
+      let matched = [];
+      for (const candidate of candidates) {
+        await budget.tick();
+        if (matches(candidate, step)) matched.push(candidate);
+      }
+      for (const predicate of step.predicates) {
+        await budget.tick();
+        if (predicate.kind === "position") matched = matched[predicate.value - 1] ? [matched[predicate.value - 1]] : [];
+        else {
+          const filtered = [];
+          for (const candidate of matched) {
+            await budget.tick();
+            if (candidate.kind !== "element") continue;
+            for (const attribute of candidate.attributes) {
+              await budget.tick(attribute.value.value.length + 1);
+              if (attribute.value.namespace === "" && attribute.value.localName === predicate.name && attribute.value.value === predicate.value) {
+                filtered.push(candidate);
+                break;
+              }
+            }
+          }
+          matched = filtered;
+        }
+      }
+      for (const node of matched) {
+        await budget.tick();
+        if (!selected.has(node)) {
+          budget.results(selected.size + 1);
+          selected.add(node);
+        }
+      }
+    }
+    contexts = [];
+    for (const node of order) {
+      await budget.tick();
+      if (selected.has(node)) contexts.push(node);
+    }
+  }
+  return contexts;
+}
+async function* stringValue(node, budget) {
+  if (node === void 0) return;
+  if (node.kind === "attribute") {
+    yield node.value.value;
+    return;
+  }
+  const pending = [node];
+  while (pending.length) {
+    await budget.tick();
+    const current = pending.pop();
+    if (current.kind === "element" || current.kind === "document") {
+      for (let index = current.children.length - 1; index >= 0; index--) {
+        await budget.tick();
+        pending.push(current.children[index]);
+      }
+    } else if (current.kind === "text" || current.kind === "cdata") yield current.value.text;
+  }
+}
+async function* serialize(node, budget) {
+  if (node.kind === "attribute") {
+    yield ` ${node.value.name}="`;
+    yield* escape(node.value.value, true, budget);
+    yield '"';
+    return;
+  }
+  if (node.kind === "document") return;
+  const pending = [node.value];
+  while (pending.length) {
+    await budget.tick();
+    const current = pending.pop();
+    if (typeof current === "string") {
+      yield current;
+      continue;
+    }
+    if (current.kind === "element") {
+      yield `<${current.name}`;
+      for (const attribute of current.attributes) {
+        await budget.tick();
+        yield ` ${attribute.name}="`;
+        yield* escape(attribute.value, true, budget);
+        yield '"';
+      }
+      if (!current.content.length) yield "/>";
+      else {
+        yield ">";
+        pending.push(`</${current.name}>`);
+        for (let index = current.content.length - 1; index >= 0; index--) {
+          await budget.tick();
+          pending.push(current.content[index]);
+        }
+      }
+    } else if (current.kind === "text") yield* escape(current.text, false, budget);
+    else if (current.kind === "cdata") {
+      yield "<![CDATA[";
+      yield current.text;
+      yield "]]>";
+    } else if (current.kind === "comment") {
+      yield "<!--";
+      yield current.text;
+      yield "-->";
+    } else if (current.kind === "processing-instruction") {
+      yield `<?${current.target}`;
+      if (current.text) {
+        yield " ";
+        yield current.text;
+      }
+      yield "?>";
+    }
+  }
+}
+async function* escape(value2, attribute, budget) {
+  let part = "";
+  for (const character of value2) {
+    await budget.tick();
+    part += character === "&" ? "&amp;" : character === "<" ? "&lt;" : character === ">" ? "&gt;" : attribute && character === '"' ? "&quot;" : attribute && character === "\n" ? "&#10;" : character === "\r" ? "&#13;" : attribute && character === "	" ? "&#9;" : character;
+    if (part.length >= 4096) {
+      yield part;
+      part = "";
+    }
+  }
+  if (part) yield part;
+}
+
+// packages/safe-bash/src/commands/xml/index.ts
+async function argumentsFor(context, budget) {
+  if (context.args.length > 5) throw new XmlQueryError("expected one XML input FILE or -", 2);
+  const carrier = getCommandArguments(context);
+  const args = carrier.args;
+  async function admitted(position, limit) {
+    const text = args[position];
+    if (text.length > budget.limits[limit]) throw new XmlQueryLimitError(limit);
+    const size = shellValueByteLength(carrier.values[position]);
+    if (size > budget.limits[limit]) throw new XmlQueryLimitError(limit);
+    for (let offset = 0; offset < size; offset += 1024) await budget.tick(Math.min(1024, size - offset));
+    let decoded;
+    try {
+      decoded = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(carrier.bytes(position));
+    } catch {
+      throw new XmlQueryError("XPath and filenames require valid UTF-8", 2);
+    }
+    if (decoded !== text) throw new XmlQueryError("XPath and filenames require lossless UTF-8", 2);
+    return decoded;
+  }
+  let index = 0;
+  if (context.command === "xmllint") {
+    if (args[index++] !== "--xpath") throw new XmlQueryError("expected --xpath QUERY [FILE|-]", 2);
+  }
+  if (args[index] === "--") index++;
+  const sourceIndex = index++;
+  const source = args[sourceIndex];
+  if (source === void 0 || source.startsWith("-")) throw new XmlQueryError("expected QUERY [FILE|-]", 2);
+  if (args[index] === "--") index++;
+  const fileIndex = index++;
+  const file = args[fileIndex];
+  if (index < args.length || file !== void 0 && file.startsWith("-") && file !== "-") throw new XmlQueryError("expected one XML input FILE or -", 2);
+  const query = await parseQuery(await admitted(sourceIndex, "maxSourceBytes"), budget);
+  return { query, file: file === void 0 ? void 0 : await admitted(fileIndex, "maxInputBytes") };
+}
+async function input2(context, file, budget) {
+  let source = context.stdin;
+  if (file !== void 0 && file !== "-") {
+    const path = pathOf(context, file);
+    const capabilities = context.fs.capabilitiesFor ? await interruptible(() => context.fs.capabilitiesFor(path, { signal: context.signal }), context.signal) : context.fs.capabilities;
+    context.signal.throwIfAborted();
+    if (context.fs.readStream && capabilities.streamingRead !== false) source = context.fs.readStream(path, { signal: context.signal });
+    else {
+      try {
+        source = toByteSource(await interruptible(() => context.fs.readFile(path, { signal: context.signal, maxBytes: budget.limits.maxInputBytes }), context.signal));
+      } catch (error) {
+        context.signal.throwIfAborted();
+        if (error instanceof FsError && error.code === "EFBIG") throw new XmlQueryLimitError("maxInputBytes");
+        throw error;
+      }
+    }
+  }
+  const parts2 = [];
+  let size = 0;
+  const decoder3 = new TextDecoder("utf-8", { fatal: true });
+  for await (const chunk of readBytes2(source, context.signal)) {
+    await budget.tick();
+    size += chunk.byteLength;
+    if (size > budget.limits.maxInputBytes) throw new XmlQueryLimitError("maxInputBytes");
+    for (let offset = 0; offset < chunk.length; offset += 4096) {
+      await budget.tick(Math.min(4096, chunk.length - offset));
+      try {
+        parts2.push(decoder3.decode(chunk.subarray(offset, offset + 4096), { stream: true }));
+      } catch {
+        throw new XmlQueryError("XML input must be UTF-8", 1);
+      }
+    }
+  }
+  try {
+    parts2.push(decoder3.decode());
+  } catch {
+    throw new XmlQueryError("XML input must be UTF-8", 1);
+  }
+  return parts2.join("");
+}
+async function execute(context, limits) {
+  const budget = new XmlBudget(limits, context.signal);
+  let outputFailed = false;
+  try {
+    const options2 = await argumentsFor(context, budget);
+    const source = await input2(context, options2.file, budget);
+    const parser = parseXmlSteps(source, { ...limits, maxContentNodes: limits.maxNodes, expectedEncoding: "UTF-8" });
+    let parsed = parser.next();
+    try {
+      while (!parsed.done) {
+        await budget.tick(parsed.value);
+        parsed = parser.next();
+      }
+    } finally {
+      if (!parsed.done) parser.return(void 0);
+    }
+    const nodes = await evaluate(options2.query, parsed.value, budget);
+    async function write(part) {
+      for (let offset = 0; offset < part.length; ) {
+        let end = Math.min(offset + 4096, part.length);
+        if (end < part.length && part.charCodeAt(end - 1) >= 55296 && part.charCodeAt(end - 1) <= 56319) end--;
+        await budget.tick(end - offset);
+        const slice = part.slice(offset, end);
+        const size = import_buffer.Buffer.byteLength(slice);
+        if (size > limits.maxOutputBytes - budget.outputBytes) throw new XmlQueryLimitError("maxOutputBytes");
+        budget.outputBytes += size;
+        try {
+          await writeBytes(context.stdout, import_buffer.Buffer.from(slice), context.signal);
+        } catch (error) {
+          outputFailed = true;
+          throw error;
+        }
+        offset = end;
+      }
+    }
+    if (options2.query.scalar === "count") await write(String(nodes.length));
+    else if (options2.query.scalar === "boolean") await write(nodes.length ? "true" : "false");
+    else if (options2.query.scalar === "string") {
+      for await (const part of stringValue(nodes[0], budget)) await write(part);
+    } else {
+      if (!nodes.length) throw new XmlQueryError("XPath set is empty", 11);
+      for (const node of nodes) {
+        for await (const part of serialize(node, budget)) await write(part);
+        await write("\n");
+      }
+      return { exitCode: 0 };
+    }
+    await write("\n");
+    return { exitCode: 0 };
+  } catch (error) {
+    context.signal.throwIfAborted();
+    if (outputFailed || error instanceof FsError && error.code === "EPIPE") throw error;
+    const status = error instanceof XmlQueryError ? error.status : error instanceof XmlLimitError ? 5 : error instanceof SyntaxError || error instanceof FsError ? 1 : void 0;
+    if (status === void 0) throw error;
+    const message = error instanceof Error ? error.message.slice(0, 1e3) : "XML query failed";
+    await writeDiagnostic(context.stderr, `${context.command}: ${message}
+`, context.signal);
+    return { exitCode: status };
+  }
+}
+function createXmlCommands(options2 = {}) {
+  const limits = resolveXmlQueryLimits(options2.limits);
+  return ["xq", "xmllint"].map((name) => ({ name, execute: (context) => execute(context, limits) }));
+}
+function xmlCommands(options2 = {}) {
+  const definitions = createXmlCommands(options2);
+  const replace = options2.replace ?? false;
+  return { name: "xml-commands", setup(host) {
+    if (!replace) for (const definition of definitions) {
+      if (host.commands.has(definition.name)) throw new Error(`Command already registered: ${definition.name}`);
+    }
+    for (const definition of definitions) host.commands.register(definition, { replace });
+  } };
+}
+
+export {
+  import_buffer,
+  init_platform,
+  shellValueFromBytes,
+  shellValueText,
+  shellValueByteLength,
+  shellValueRetainedBytes,
+  shellValueBytes,
+  concatShellValues,
+  CommandArgumentIdentityError,
+  createCommandArguments,
+  getCommandArguments,
+  CommandRegistry,
+  validateExitCode,
+  isErrnoCode,
+  isFsError,
+  toFsError,
+  FsError,
+  evaluateCommandSupport,
+  assertCommandRequirements,
+  outputFailure,
+  createBytePipe,
+  writeText,
+  writeBytes,
+  pipeBytes,
+  collectText,
+  collectBytes2 as collectBytes,
+  readBytes2 as readBytes,
+  toByteSource,
+  PublicDiagnostic,
+  publicDiagnosticMessage,
+  monotonicNow,
+  registerYieldCheckpoint,
+  scheduleTurn,
+  cancelTurn,
+  yieldTurn,
+  validatePath,
+  resolvePath,
+  relativePath,
+  isPathWithin,
+  basename,
+  dirname,
+  joinPath,
+  isAbsolutePath,
+  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,
+  isNumber,
+  numberValue,
+  numericToken,
+  decimalNumber,
+  compareNumbers,
+  defaultJqLimits,
+  JqError,
+  JqLimitError,
+  resolveJqLimits,
+  Budget,
+  object,
+  objectKeys,
+  objectKeyIterator,
+  objectSize,
+  put,
+  remove,
+  copyObject,
+  wellFormed,
+  isObject,
+  truth,
+  scalarJson,
+  interruptible,
+  defaultXmlQueryLimits,
+  createXmlCommands,
+  xmlCommands
+};
+/*! Bundled license information:
+
+ieee754/index.js:
+  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+buffer/index.js:
+  (*!
+   * The buffer module from node.js, for the browser.
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+*/
+//# sourceMappingURL=chunk-3ISDVRIM.js.map