@uipath/filesystem 0.1.7 → 0.2.0

package/dist/index.browser.js

@@ -300,13 +300,13 @@ function fromByteArray(uint82) {
     tmp = (uint82[len2 - 2] << 8) + uint82[len2 - 1], parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
   return parts.join("");
 }
-function read(buffer, offset, isLE, mLen, nBytes) {
-  var e, m, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7, i2 = isLE ? nBytes - 1 : 0, d = isLE ? -1 : 1, s = buffer[offset + i2];
+function read(buffer2, offset, isLE, mLen, nBytes) {
+  var e, m, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7, i2 = isLE ? nBytes - 1 : 0, d = isLE ? -1 : 1, s = buffer2[offset + i2];
   i2 += d, e = s & (1 << -nBits) - 1, s >>= -nBits, nBits += eLen;
-  for (;nBits > 0; e = e * 256 + buffer[offset + i2], i2 += d, nBits -= 8)
+  for (;nBits > 0; e = e * 256 + buffer2[offset + i2], i2 += d, nBits -= 8)
     ;
   m = e & (1 << -nBits) - 1, e >>= -nBits, nBits += mLen;
-  for (;nBits > 0; m = m * 256 + buffer[offset + i2], i2 += d, nBits -= 8)
+  for (;nBits > 0; m = m * 256 + buffer2[offset + i2], i2 += d, nBits -= 8)
     ;
   if (e === 0)
     e = 1 - eBias;
@@ -316,7 +316,7 @@ function read(buffer, offset, isLE, mLen, nBytes) {
     m = m + Math.pow(2, mLen), e = e - eBias;
   return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
 }
-function write(buffer, value, offset, isLE, mLen, nBytes) {
+function write(buffer2, value, offset, isLE, mLen, nBytes) {
   var e, m, c, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, i2 = isLE ? 0 : nBytes - 1, d = isLE ? 1 : -1, s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
   if (value = Math.abs(value), isNaN(value) || value === 1 / 0)
     m = isNaN(value) ? 1 : 0, e = eMax;
@@ -336,12 +336,12 @@ function write(buffer, value, offset, isLE, mLen, nBytes) {
     else
       m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen), e = 0;
   }
-  for (;mLen >= 8; buffer[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8)
+  for (;mLen >= 8; buffer2[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8)
     ;
   e = e << mLen | m, eLen += mLen;
-  for (;eLen > 0; buffer[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8)
+  for (;eLen > 0; buffer2[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8)
     ;
-  buffer[offset + i2 - d] |= s * 128;
+  buffer2[offset + i2 - d] |= s * 128;
 }
 function createBuffer(length) {
   if (length > kMaxLength)
@@ -423,10 +423,10 @@ function fromString(string2, encoding) {
     buf = buf.slice(0, actual);
   return buf;
 }
-function fromArrayLike(array3) {
-  let length = array3.length < 0 ? 0 : checked(array3.length) | 0, buf = createBuffer(length);
+function fromArrayLike(array4) {
+  let length = array4.length < 0 ? 0 : checked(array4.length) | 0, buf = createBuffer(length);
   for (let i2 = 0;i2 < length; i2 += 1)
-    buf[i2] = array3[i2] & 255;
+    buf[i2] = array4[i2] & 255;
   return buf;
 }
 function fromArrayView(arrayView) {
@@ -436,18 +436,18 @@ function fromArrayView(arrayView) {
   }
   return fromArrayLike(arrayView);
 }
-function fromArrayBuffer(array3, byteOffset, length) {
-  if (byteOffset < 0 || array3.byteLength < byteOffset)
+function fromArrayBuffer(array4, byteOffset, length) {
+  if (byteOffset < 0 || array4.byteLength < byteOffset)
     throw RangeError('"offset" is outside of buffer bounds');
-  if (array3.byteLength < byteOffset + (length || 0))
+  if (array4.byteLength < byteOffset + (length || 0))
     throw RangeError('"length" is outside of buffer bounds');
   let buf;
   if (byteOffset === undefined && length === undefined)
-    buf = new Uint8Array(array3);
+    buf = new Uint8Array(array4);
   else if (length === undefined)
-    buf = new Uint8Array(array3, byteOffset);
+    buf = new Uint8Array(array4, byteOffset);
   else
-    buf = new Uint8Array(array3, byteOffset, length);
+    buf = new Uint8Array(array4, byteOffset, length);
   return Object.setPrototypeOf(buf, Buffer.prototype), buf;
 }
 function fromObject(obj) {
@@ -548,8 +548,8 @@ function swap(b, n, m) {
   let i2 = b[n];
   b[n] = b[m], b[m] = i2;
 }
-function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
-  if (buffer.length === 0)
+function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) {
+  if (buffer2.length === 0)
     return -1;
   if (typeof byteOffset === "string")
     encoding = byteOffset, byteOffset = 0;
@@ -558,14 +558,14 @@ function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
   else if (byteOffset < -2147483648)
     byteOffset = -2147483648;
   if (byteOffset = +byteOffset, Number.isNaN(byteOffset))
-    byteOffset = dir ? 0 : buffer.length - 1;
+    byteOffset = dir ? 0 : buffer2.length - 1;
   if (byteOffset < 0)
-    byteOffset = buffer.length + byteOffset;
-  if (byteOffset >= buffer.length)
+    byteOffset = buffer2.length + byteOffset;
+  if (byteOffset >= buffer2.length)
     if (dir)
       return -1;
     else
-      byteOffset = buffer.length - 1;
+      byteOffset = buffer2.length - 1;
   else if (byteOffset < 0)
     if (dir)
       byteOffset = 0;
@@ -576,14 +576,14 @@ function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
   if (Buffer.isBuffer(val)) {
     if (val.length === 0)
       return -1;
-    return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+    return arrayIndexOf(buffer2, val, byteOffset, encoding, dir);
   } else if (typeof val === "number") {
     if (val = val & 255, typeof Uint8Array.prototype.indexOf === "function")
       if (dir)
-        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+        return Uint8Array.prototype.indexOf.call(buffer2, val, byteOffset);
       else
-        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
-    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+        return Uint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset);
+    return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir);
   }
   throw TypeError("val must be string, number or Buffer");
 }
@@ -1041,23 +1041,23 @@ var init_buffer = __esm(() => {
       for (i2 = 0;i2 < list2.length; ++i2)
         length += list2[i2].length;
     }
-    let buffer = Buffer.allocUnsafe(length), pos = 0;
+    let buffer2 = Buffer.allocUnsafe(length), pos = 0;
     for (i2 = 0;i2 < list2.length; ++i2) {
       let buf = list2[i2];
       if (isInstance(buf, Uint8Array))
-        if (pos + buf.length > buffer.length) {
+        if (pos + buf.length > buffer2.length) {
           if (!Buffer.isBuffer(buf))
             buf = Buffer.from(buf);
-          buf.copy(buffer, pos);
+          buf.copy(buffer2, pos);
         } else
-          Uint8Array.prototype.set.call(buffer, buf, pos);
+          Uint8Array.prototype.set.call(buffer2, buf, pos);
       else if (!Buffer.isBuffer(buf))
         throw TypeError('"list" argument must be an Array of Buffers');
       else
-        buf.copy(buffer, pos);
+        buf.copy(buffer2, pos);
       pos += buf.length;
     }
-    return buffer;
+    return buffer2;
   };
   Buffer.byteLength = byteLength;
   Buffer.prototype._isBuffer = true;
@@ -2699,9 +2699,9 @@ var require_validators = __commonJS((exports, module) => {
       throw new ERR_UNKNOWN_SIGNAL(signal);
     }
   }
-  var validateBuffer = hideStackFrames((buffer, name = "buffer") => {
-    if (!isArrayBufferView(buffer)) {
-      throw new ERR_INVALID_ARG_TYPE3(name, ["Buffer", "TypedArray", "DataView"], buffer);
+  var validateBuffer = hideStackFrames((buffer2, name = "buffer") => {
+    if (!isArrayBufferView(buffer2)) {
+      throw new ERR_INVALID_ARG_TYPE3(name, ["Buffer", "TypedArray", "DataView"], buffer2);
     }
   });
   function validateEncoding(data, encoding) {
@@ -2916,9 +2916,9 @@ var require_browser2 = __commonJS((exports, module) => {
       runTimeout(drainQueue);
     }
   };
-  function Item(fun, array3) {
+  function Item(fun, array4) {
     this.fun = fun;
-    this.array = array3;
+    this.array = array4;
   }
   Item.prototype.run = function() {
     this.fun.apply(null, this.array);
@@ -4021,17 +4021,17 @@ var require_state = __commonJS((exports, module) => {
 // ../../node_modules/@zenfs/core/node_modules/readable-stream/node_modules/string_decoder/node_modules/safe-buffer/index.js
 var require_safe_buffer = __commonJS((exports, module) => {
   /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
-  var buffer = (init_buffer(), __toCommonJS(exports_buffer));
-  var Buffer2 = buffer.Buffer;
+  var buffer2 = (init_buffer(), __toCommonJS(exports_buffer));
+  var Buffer2 = buffer2.Buffer;
   function copyProps(src, dst) {
     for (var key in src) {
       dst[key] = src[key];
     }
   }
   if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
-    module.exports = buffer;
+    module.exports = buffer2;
   } else {
-    copyProps(buffer, exports);
+    copyProps(buffer2, exports);
     exports.Buffer = SafeBuffer;
   }
   function SafeBuffer(arg, encodingOrOffset, length) {
@@ -4071,7 +4071,7 @@ var require_safe_buffer = __commonJS((exports, module) => {
     if (typeof size !== "number") {
       throw new TypeError("Argument must be a number");
     }
-    return buffer.SlowBuffer(size);
+    return buffer2.SlowBuffer(size);
   };
 });
 
@@ -4680,14 +4680,14 @@ var require_readable = __commonJS((exports, module) => {
     const decoder2 = new StringDecoder(enc);
     this._readableState.decoder = decoder2;
     this._readableState.encoding = this._readableState.decoder.encoding;
-    const buffer = this._readableState.buffer;
+    const buffer2 = this._readableState.buffer;
     let content = "";
-    for (const data of buffer) {
+    for (const data of buffer2) {
       content += decoder2.write(data);
     }
-    buffer.clear();
+    buffer2.clear();
     if (content !== "")
-      buffer.push(content);
+      buffer2.push(content);
     this._readableState.length = content.length;
     return this;
   };
@@ -7753,7 +7753,219 @@ var require_browser3 = __commonJS((exports, module) => {
   module.exports.Stream = CustomStream.Stream;
   module.exports.default = module.exports;
 });
-
+// ../../node_modules/utilium/dist/buffer.js
+function extendBuffer(buffer, newByteLength) {
+  if (buffer.byteLength >= newByteLength)
+    return buffer;
+  if (ArrayBuffer.isView(buffer)) {
+    const newBuffer = extendBuffer(buffer.buffer, newByteLength);
+    return new buffer.constructor(newBuffer, buffer.byteOffset, newByteLength);
+  }
+  const isShared = typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
+  if (buffer.maxByteLength > newByteLength) {
+    isShared ? buffer.grow(newByteLength) : buffer.resize(newByteLength);
+    return buffer;
+  }
+  if (isShared) {
+    const newBuffer = new SharedArrayBuffer(newByteLength);
+    new Uint8Array(newBuffer).set(new Uint8Array(buffer));
+    return newBuffer;
+  }
+  try {
+    return buffer.transfer(newByteLength);
+  } catch {
+    const newBuffer = new ArrayBuffer(newByteLength);
+    new Uint8Array(newBuffer).set(new Uint8Array(buffer));
+    return newBuffer;
+  }
+}
+class BufferView extends DataView {
+  constructor(_buffer, _byteOffset, _byteLength) {
+    const { buffer, byteOffset, byteLength } = new Uint8Array(_buffer, _byteOffset, _byteLength);
+    super(buffer, byteOffset, byteLength);
+  }
+}
+for (const key of Object.getOwnPropertyNames(DataView.prototype)) {
+  if (!key.startsWith("get") && !key.startsWith("set"))
+    continue;
+  Object.defineProperty(BufferView.prototype, key, {
+    value: () => {
+      throw new ReferenceError("Do not use DataView methods on a BufferView.");
+    },
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+}
+// ../../node_modules/utilium/dist/cache.js
+class Resource {
+  id;
+  _size;
+  options;
+  regions = [];
+  get size() {
+    return this._size;
+  }
+  set size(value) {
+    if (value >= this._size) {
+      this._size = value;
+      return;
+    }
+    this._size = value;
+    for (let i = this.regions.length - 1;i >= 0; i--) {
+      const region = this.regions[i];
+      if (region.offset >= value) {
+        this.regions.splice(i, 1);
+        continue;
+      }
+      const maxLength = value - region.offset;
+      if (region.data.byteLength > maxLength) {
+        region.data = region.data.subarray(0, maxLength);
+      }
+      region.ranges = region.ranges.filter((range) => range.start < value).map((range) => {
+        if (range.end > value) {
+          return { start: range.start, end: value };
+        }
+        return range;
+      });
+    }
+  }
+  constructor(id, _size, options, resources) {
+    this.id = id;
+    this._size = _size;
+    this.options = options;
+    options.sparse ??= true;
+    if (!options.sparse)
+      this.regions.push({ offset: 0, data: new Uint8Array(_size), ranges: [] });
+    resources?.set(id, this);
+  }
+  collect() {
+    if (!this.options.sparse)
+      return;
+    const { regionGapThreshold = 4095 } = this.options;
+    for (let i = 0;i < this.regions.length - 1; ) {
+      const current = this.regions[i];
+      const next = this.regions[i + 1];
+      if (next.offset - (current.offset + current.data.byteLength) > regionGapThreshold) {
+        i++;
+        continue;
+      }
+      current.ranges.push(...next.ranges);
+      current.ranges.sort((a, b) => a.start - b.start);
+      current.ranges = current.ranges.reduce((acc, range) => {
+        if (!acc.length || acc.at(-1).end < range.start) {
+          acc.push(range);
+        } else {
+          acc.at(-1).end = Math.max(acc.at(-1).end, range.end);
+        }
+        return acc;
+      }, []);
+      current.data = extendBuffer(current.data, next.offset + next.data.byteLength);
+      current.data.set(next.data, next.offset - current.offset);
+      this.regions.splice(i + 1, 1);
+    }
+  }
+  missing(start, end) {
+    const missingRanges = [];
+    for (const region of this.regions) {
+      if (region.offset >= end)
+        break;
+      for (const range of region.ranges) {
+        if (range.end <= start)
+          continue;
+        if (range.start >= end)
+          break;
+        if (range.start > start) {
+          missingRanges.push({ start, end: Math.min(range.start, end) });
+        }
+        if (range.end > start)
+          start = Math.max(start, range.end);
+        if (start >= end)
+          break;
+      }
+      if (start >= end)
+        break;
+    }
+    if (start < end)
+      missingRanges.push({ start, end });
+    return missingRanges;
+  }
+  cached(start, end) {
+    const cachedRanges = [];
+    for (const region of this.regions) {
+      if (region.offset >= end)
+        break;
+      for (const range of region.ranges) {
+        if (range.end <= start)
+          continue;
+        if (range.start >= end)
+          break;
+        cachedRanges.push({
+          start: Math.max(start, range.start),
+          end: Math.min(end, range.end)
+        });
+      }
+    }
+    cachedRanges.sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const curr of cachedRanges) {
+      const last = merged.at(-1);
+      if (last && curr.start <= last.end) {
+        last.end = Math.max(last.end, curr.end);
+      } else {
+        merged.push(curr);
+      }
+    }
+    return merged;
+  }
+  regionAt(offset) {
+    if (!this.regions.length)
+      return;
+    for (const region of this.regions) {
+      if (region.offset > offset)
+        break;
+      if (offset >= region.offset && offset < region.offset + region.data.byteLength)
+        return region;
+    }
+  }
+  add(data, offset) {
+    const end = offset + data.byteLength;
+    const region = this.regionAt(offset);
+    if (region) {
+      region.data = extendBuffer(region.data, end);
+      region.data.set(data, offset);
+      region.ranges.push({ start: offset, end });
+      region.ranges.sort((a, b) => a.start - b.start);
+      this.collect();
+      return this;
+    }
+    const newRegion = { data, offset, ranges: [{ start: offset, end }] };
+    const insertIndex = this.regions.findIndex((region2) => region2.offset > offset);
+    if (insertIndex == -1) {
+      this.regions.push(newRegion);
+    } else {
+      this.regions.splice(insertIndex, 0, newRegion);
+    }
+    this.collect();
+    return this;
+  }
+}
+// ../../node_modules/utilium/dist/checksum.js
+var crc32cTable = new Uint32Array(256);
+for (let i = 0;i < 256; i++) {
+  let value = i;
+  for (let j = 0;j < 8; j++) {
+    value = value & 1 ? 2197175160 ^ value >>> 1 : value >>> 1;
+  }
+  crc32cTable[i] = value;
+}
+function crc32c(data) {
+  let crc = 4294967295;
+  for (let i = 0;i < data.length; i++) {
+    crc = crc >>> 8 ^ crc32cTable[(crc ^ data[i]) & 255];
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
 // ../../node_modules/eventemitter3/index.mjs
 var import__ = __toESM(require_eventemitter3(), 1);
 
@@ -8639,80 +8851,14 @@ var S_IXOTH = 1;
 var UV_FS_O_FILEMAP = 0;
 var size_max = 4294967295;
 
-// ../../node_modules/memium/dist/array.js
-function StructArray(type) {
-  class StructArray2 extends DataView {
-    length;
-    type = type;
-    *[Symbol.iterator]() {
-      for (let i = 0;i < this.length; i++)
-        yield this[i];
-    }
-    constructor(lengthOrBuffer, byteOffset, byteLength) {
-      const buffer = typeof lengthOrBuffer === "object" ? lengthOrBuffer : new ArrayBuffer((lengthOrBuffer ?? 0) * type.size);
-      super(buffer, byteOffset, byteLength);
-      this.length = typeof lengthOrBuffer === "number" ? lengthOrBuffer : Math.floor(this.byteLength / type.size);
-      return new Proxy(this, {
-        get(target, index) {
-          if (index in target)
-            return target[index];
-          const i = parseInt(index.toString());
-          if (!Number.isSafeInteger(i))
-            throw withErrno("EINVAL", "Invalid index: " + index.toString());
-          return type.get(target.buffer, target.byteOffset + i * type.size);
-        },
-        set(target, index, value) {
-          const i = parseInt(index.toString());
-          if (!Number.isSafeInteger(i))
-            throw withErrno("EINVAL", "Invalid index: " + index.toString());
-          type.set(target.buffer, target.byteOffset + i * type.size, value);
-          return true;
-        }
-      });
-    }
-  }
-  for (const key of Object.getOwnPropertyNames(DataView.prototype)) {
-    if (!key.startsWith("get") && !key.startsWith("set"))
-      continue;
-    Object.defineProperty(StructArray2.prototype, key, {
-      enumerable: false,
-      configurable: false,
-      writable: false,
-      value: undefined
-    });
-  }
-  return StructArray2;
+// ../../node_modules/memium/dist/types.js
+function isArrayType(type) {
+  return "__isArrayType" in type && type.__isArrayType === true;
 }
-
-class ArrayType {
-  type;
-  length;
-  name;
-  size;
-  __arrayType;
-  constructor(type, length) {
-    this.type = type;
-    this.length = length;
-    this.name = `${type.name}[${length}]`;
-    this.size = type.size * length;
-    this.array = StructArray(this);
-    this.__arrayType = type.array ? type.array : StructArray(type);
-  }
-  get = (buffer, offset) => {
-    return new this.__arrayType(buffer, offset, this.size);
-  };
-  set = (buffer, offset, value) => {
-    for (let i = 0;i < this.length; i++) {
-      this.type.set(buffer, offset + i * this.type.size, value[i]);
-    }
-  };
-  array;
-}
-// ../../node_modules/memium/dist/types.js
 function isType(type) {
   if (typeof type != "object" && typeof type != "function" || type === null || type === undefined)
     return false;
-  if (type instanceof ArrayType)
+  if (isArrayType(type))
     return isType(type.type);
   return "name" in type && "size" in type && "get" in type && "set" in type && typeof type.name == "string" && typeof type.size == "number" && typeof type.get == "function" && typeof type.set == "function" && typeRegistry.has(type.name) && typeRegistry.get(type.name)?.name === type.name;
 }
@@ -8723,168 +8869,81 @@ function registerType(t) {
   typeRegistry.set(t.name, t);
 }
 
-// ../../node_modules/memium/dist/fields.js
-function parseFieldConfig(init) {
-  if (isType(init))
-    return { type: init };
-  if (init instanceof FieldBuilder)
-    return init.toInit();
-  return init;
-}
-
-class FieldBuilder {
-  type;
-  init;
-  constructor(type, init) {
-    this.type = type;
-    this.init = init;
-    const _toArray = (length) => {
-      return new FieldBuilder(new ArrayType(type, length), init);
-    };
-    Object.setPrototypeOf(_toArray, new.target.prototype);
-    Object.assign(_toArray, { type, init });
-    return _toArray;
-  }
-  align(align) {
-    return new FieldBuilder(this.type, { ...this.init, align });
-  }
-  countedBy(field) {
-    return new FieldBuilder(this.type, { ...this.init, countedBy: field });
-  }
-  bigEndian() {
-    return new FieldBuilder(this.type, { ...this.init, bigEndian: true });
-  }
-  toInit() {
-    return { type: this.type, ...this.init };
-  }
-  $type() {
-    return new FieldBuilder(this.type, this.init);
-  }
-}
-function array(type, length = 0) {
-  return new FieldBuilder(new ArrayType(type, length), {});
-}
-
-// ../../node_modules/memium/dist/fields.internal.js
-function __fieldInit(_name, init, extraOpts = {}) {
-  if (!_name)
-    throw withErrno("EINVAL", "Invalid name for struct field");
-  if (typeof _name == "symbol")
-    console.warn("Symbol used for struct field name will be coerced to string: " + _name.toString());
-  const name = _name.toString();
-  const opt = Object.assign(parseFieldConfig(init), extraOpts);
-  if (!isType(opt.type))
-    throw withErrno("EINVAL", `Invalid type for struct field "${name}"`);
-  return {
-    name,
-    offset: 0,
-    type: opt.type,
-    countedBy: opt.countedBy,
-    alignment: opt.align ?? opt.type.size,
-    decl: opt.type instanceof ArrayType ? `${opt.typeName ?? opt.type.type.name} ${name}[${opt.type.length}]${opt.countedBy ? ` counted_by(${opt.countedBy})` : ""}` : `${opt.typeName ?? opt.type.name} ${name}`,
-    littleEndian: !opt.bigEndian
-  };
-}
-function __fault(err2) {
-  if (err2.message !== "offset is outside the bounds of the DataView")
-    throw err2;
-  else
-    throw withErrno("EFAULT", "Segmentation fault");
-}
-function __fieldSet(instance, field, value, index) {
-  try {
-    if (typeof value == "string")
-      value = value.charCodeAt(0);
-    const offset = instance.byteOffset + field.offset + (index ?? 0) * field.type.size;
-    field.type.set(instance.buffer, offset, value);
-    return;
-  } catch (err2) {
-    __fault(err2);
-  }
-}
-function __fieldGet(instance, field) {
-  try {
-    return field.type.get(instance.buffer, instance.byteOffset + field.offset);
-  } catch (err2) {
-    __fault(err2);
-  }
-}
-
 // ../../node_modules/memium/dist/primitives.js
 var __view__ = Symbol("DataView");
-function view(buffer) {
-  buffer[__view__] ??= new DataView(buffer);
-  return buffer[__view__];
+function view(buffer2) {
+  buffer2[__view__] ??= new DataView(buffer2);
+  return buffer2[__view__];
 }
 var int8 = {
   name: "int8",
   size: 1,
   array: Int8Array,
-  get: (buffer, offset) => view(buffer).getInt8(offset),
-  set: (buffer, offset, value) => view(buffer).setInt8(offset, value)
+  get: (buffer2, offset) => view(buffer2).getInt8(offset),
+  set: (buffer2, offset, value) => view(buffer2).setInt8(offset, value)
 };
 var uint8 = {
   name: "uint8",
   size: 1,
   array: Uint8Array,
-  get: (buffer, offset) => view(buffer).getUint8(offset),
-  set: (buffer, offset, value) => view(buffer).setUint8(offset, value)
+  get: (buffer2, offset) => view(buffer2).getUint8(offset),
+  set: (buffer2, offset, value) => view(buffer2).setUint8(offset, value)
 };
 var int16 = {
   name: "int16",
   size: 2,
   array: Int16Array,
-  get: (buffer, offset) => view(buffer).getInt16(offset, true),
-  set: (buffer, offset, value) => view(buffer).setInt16(offset, value, true)
+  get: (buffer2, offset) => view(buffer2).getInt16(offset, true),
+  set: (buffer2, offset, value) => view(buffer2).setInt16(offset, value, true)
 };
 var uint16 = {
   name: "uint16",
   size: 2,
   array: Uint16Array,
-  get: (buffer, offset) => view(buffer).getUint16(offset, true),
-  set: (buffer, offset, value) => view(buffer).setUint16(offset, value, true)
+  get: (buffer2, offset) => view(buffer2).getUint16(offset, true),
+  set: (buffer2, offset, value) => view(buffer2).setUint16(offset, value, true)
 };
 var int32 = {
   name: "int32",
   size: 4,
   array: Int32Array,
-  get: (buffer, offset) => view(buffer).getInt32(offset, true),
-  set: (buffer, offset, value) => view(buffer).setInt32(offset, value, true)
+  get: (buffer2, offset) => view(buffer2).getInt32(offset, true),
+  set: (buffer2, offset, value) => view(buffer2).setInt32(offset, value, true)
 };
 var uint32 = {
   name: "uint32",
   size: 4,
   array: Uint32Array,
-  get: (buffer, offset) => view(buffer).getUint32(offset, true),
-  set: (buffer, offset, value) => view(buffer).setUint32(offset, value, true)
+  get: (buffer2, offset) => view(buffer2).getUint32(offset, true),
+  set: (buffer2, offset, value) => view(buffer2).setUint32(offset, value, true)
 };
 var int64 = {
   name: "int64",
   size: 8,
   array: BigInt64Array,
-  get: (buffer, offset) => view(buffer).getBigInt64(offset, true),
-  set: (buffer, offset, value) => view(buffer).setBigInt64(offset, value, true)
+  get: (buffer2, offset) => view(buffer2).getBigInt64(offset, true),
+  set: (buffer2, offset, value) => view(buffer2).setBigInt64(offset, value, true)
 };
 var uint64 = {
   name: "uint64",
   size: 8,
   array: BigUint64Array,
-  get: (buffer, offset) => view(buffer).getBigUint64(offset, true),
-  set: (buffer, offset, value) => view(buffer).setBigUint64(offset, value, true)
+  get: (buffer2, offset) => view(buffer2).getBigUint64(offset, true),
+  set: (buffer2, offset, value) => view(buffer2).setBigUint64(offset, value, true)
 };
 var float32 = {
   name: "float32",
   size: 4,
   array: Float32Array,
-  get: (buffer, offset) => view(buffer).getFloat32(offset, true),
-  set: (buffer, offset, value) => view(buffer).setFloat32(offset, value, true)
+  get: (buffer2, offset) => view(buffer2).getFloat32(offset, true),
+  set: (buffer2, offset, value) => view(buffer2).setFloat32(offset, value, true)
 };
 var float64 = {
   name: "float64",
   size: 8,
   array: Float64Array,
-  get: (buffer, offset) => view(buffer).getFloat64(offset, true),
-  set: (buffer, offset, value) => view(buffer).setFloat64(offset, value, true)
+  get: (buffer2, offset) => view(buffer2).getFloat64(offset, true),
+  set: (buffer2, offset, value) => view(buffer2).setFloat64(offset, value, true)
 };
 var types2 = {
   int8,
@@ -8918,6 +8977,294 @@ function normalize(type) {
   return type == "char" ? "uint8" : type.toLowerCase();
 }
 
+// ../../node_modules/memium/dist/fields.internal.js
+function _isBuilder(init) {
+  return (typeof init == "object" || typeof init == "function") && init !== null && "toInit" in init && typeof init.toInit == "function";
+}
+function _parseConfig(init) {
+  if (_isBuilder(init))
+    return init.toInit();
+  if (isType(init))
+    return { type: init };
+  return init;
+}
+function init(_name, init2, extraOpts = {}) {
+  if (!_name)
+    throw withErrno("EINVAL", "Invalid name for struct field");
+  if (typeof _name == "symbol")
+    console.warn("Symbol used for struct field name will be coerced to string: " + _name.toString());
+  const name = _name.toString();
+  const opt = Object.assign(_parseConfig(init2), extraOpts);
+  if (!isType(opt.type))
+    throw withErrno("EINVAL", `Invalid type for struct field "${name}"`);
+  const countedBy = !opt.countedBy ? "" : ` counted_by(${typeof opt.countedBy == "string" ? opt.countedBy : "<function>"})`;
+  return {
+    name,
+    offset: 0,
+    type: opt.type,
+    countedBy: opt.countedBy,
+    alignment: opt.align ?? opt.type.size,
+    decl: opt.type instanceof ArrayType ? `${opt.typeName ?? opt.type.type.name} ${name}[${opt.type.length}]${countedBy}` : `${opt.typeName ?? opt.type.name} ${name}`,
+    littleEndian: !opt.bigEndian
+  };
+}
+function __fault(err2, offset) {
+  if (!(err2 instanceof Error) || err2.message.toLowerCase() !== "offset is outside the bounds of the dataview")
+    throw err2;
+  const ex = withErrno("EFAULT", `Segmentation fault (at 0x${offset.toString(16)})`);
+  Error.captureStackTrace(ex, __fault);
+  throw ex;
+}
+function isDynamicArray(instance, field) {
+  return field.type instanceof ArrayType && field.type.length == 0 && !!field.countedBy?.length && !!instance.constructor.isDynamic;
+}
+function _count(instance, field) {
+  let value = typeof field.countedBy == "function" ? field.countedBy(instance) : instance[field.countedBy];
+  if (typeof value == "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw withErrno("EOVERFLOW", "countedBy field value exceeds max safe integer");
+    }
+    value = Number(value);
+  }
+  if (typeof value != "number")
+    throw withErrno("EINVAL", "countedBy field value is not a number");
+  return value;
+}
+function dynamicArraySize(instance, field) {
+  let size = field.type.type.size * _count(instance, field);
+  if (isStructConstructor(field.type.type) && field.type.type.isDynamic) {
+    for (const item of instance[field.name]) {
+      size += dynamicStructSize(item);
+    }
+  }
+  return size;
+}
+var kOffsets = Symbol("kOffsets");
+function offsetOf(instance, targetField, cache) {
+  let { offset, name } = targetField;
+  instance[kOffsets] ||= Object.create(null);
+  const offsetCache = instance[kOffsets];
+  if (offsetCache[name] !== undefined) {
+    if (cache)
+      return offsetCache[name];
+    else
+      delete offsetCache[name];
+  }
+  const { fields } = instance.constructor;
+  const index = fields.indexOf(targetField);
+  for (const field of fields.slice(0, index)) {
+    if (isDynamicArray(instance, field)) {
+      offset += dynamicArraySize(instance, field);
+    }
+    const value = instance[field.name];
+    if (isStructInstance(value) && value.constructor.isDynamic) {
+      offset += dynamicStructSize(value);
+    }
+  }
+  if (cache)
+    offsetCache[name] = offset;
+  else {
+    for (const field of fields.slice(index))
+      if (offsetCache[field.name] !== undefined)
+        delete offsetCache[field.name];
+  }
+  return offset;
+}
+function set(instance, field, value, index) {
+  if (typeof value == "string")
+    value = value.charCodeAt(0);
+  const offset = instance.byteOffset + offsetOf(instance, field, false) + (index ?? 0) * field.type.size;
+  try {
+    field.type.set(instance.buffer, offset, value);
+    return;
+  } catch (err2) {
+    __fault(err2, offset);
+  }
+}
+function get(instance, field) {
+  let type = field.type;
+  if (isDynamicArray(instance, field)) {
+    const inner = field.type.type;
+    type = new ArrayType(inner, _count(instance, field));
+  }
+  const offset = instance.byteOffset + offsetOf(instance, field, true);
+  try {
+    return type.get(instance.buffer, offset);
+  } catch (err2) {
+    __fault(err2, offset);
+  }
+}
+
+// ../../node_modules/memium/dist/structs.shared.js
+function isStructInstance(arg) {
+  return typeof arg == "object" && arg !== null && "constructor" in arg && isStructConstructor(arg.constructor);
+}
+function isStructConstructor(arg) {
+  return typeof arg == "function" && "prototype" in arg && "fields" in arg && typeof arg.fields == "object" && isType(arg);
+}
+function dynamicStructSize(instance) {
+  let size = 0;
+  for (const field of instance.constructor.fields) {
+    const value = instance[field.name];
+    if (isDynamicArray(instance, field)) {
+      size += dynamicArraySize(instance, field);
+    }
+    if (isStructInstance(value) && value.constructor.isDynamic) {
+      size += dynamicStructSize(value);
+    }
+  }
+  return size;
+}
+
+// ../../node_modules/memium/dist/misc.js
+function static_sizeof(type) {
+  if (isType(type))
+    return type.size;
+  if (type === undefined || type === null)
+    return 0;
+  if (typeof type == "object" && isType(type.constructor))
+    return type.constructor.size;
+  if (Array.isArray(type)) {
+    let size = 0;
+    for (let i = 0;i < type.length; i++)
+      size += static_sizeof(type[i]);
+    return size;
+  }
+  if (typeof type == "string") {
+    checkValid(type);
+    return types2[normalize(type)].size;
+  }
+  throw new TypeError(`Unable to resolve size of \`${type.toString()}\``);
+}
+function sizeof(type) {
+  const size = static_sizeof(type);
+  if (isStructInstance(type) && type.constructor.isDynamic) {
+    return size + dynamicStructSize(type);
+  }
+  return size;
+}
+function offsetof(type, fieldName) {
+  let constructor;
+  if (isStructConstructor(type)) {
+    if (type.isDynamic)
+      throw withErrno("EINVAL", "Cannot get offset of field in dynamic struct from the constructor");
+    constructor = type;
+  } else if (isStructInstance(type))
+    constructor = type.constructor;
+  else
+    throw withErrno("EINVAL", "Type is not a struct or struct constructor");
+  const { fields } = constructor;
+  const field = fields.find((f) => f.name === fieldName);
+  if (!field)
+    throw withErrno("EINVAL", "Struct does not have field: " + fieldName);
+  return isStructConstructor(type) ? field.offset : offsetOf(type, field, true);
+}
+
+// ../../node_modules/memium/dist/array.js
+var _strictIndexes = false;
+function StructArray(type, __length) {
+  class StructArray2 extends DataView {
+    length;
+    type = type;
+    *[Symbol.iterator]() {
+      for (let i = 0;i < this.length; i++)
+        yield this[i];
+    }
+    _offsets = [0];
+    offsetOf(index) {
+      if (!type.isDynamic)
+        return index * type.size;
+      if (index < this._offsets.length)
+        return this._offsets[index];
+      for (let i = this._offsets.length;i <= index; i++) {
+        this._offsets[i] = this._offsets[i - 1] + sizeof(type.get(this.buffer, this.byteOffset + this._offsets[i - 1]));
+      }
+      return this._offsets[index];
+    }
+    constructor(lengthOrBuffer, byteOffset, byteLength) {
+      const buffer2 = typeof lengthOrBuffer === "object" ? lengthOrBuffer : new ArrayBuffer((lengthOrBuffer ?? 0) * type.size);
+      super(buffer2, byteOffset, byteLength);
+      this.length = typeof lengthOrBuffer === "number" ? lengthOrBuffer : type.isDynamic ? __length ?? _throw(`Unknown length of StructArray<${type.name}>`) : Math.floor(this.byteLength / type.size);
+      const offset = (i) => this.byteOffset + this.offsetOf(i);
+      return new Proxy(this, {
+        get(target, index) {
+          if (index in target)
+            return target[index];
+          const i = parseInt(index.toString());
+          if (!Number.isSafeInteger(i))
+            if (_strictIndexes)
+              throw withErrno("EINVAL", "Invalid index: " + index.toString());
+            else
+              return;
+          return type.get(target.buffer, offset(i));
+        },
+        set(target, index, value) {
+          const i = parseInt(index.toString());
+          if (!Number.isSafeInteger(i))
+            if (_strictIndexes)
+              throw withErrno("EINVAL", "Invalid index: " + index.toString());
+            else
+              return false;
+          type.set(target.buffer, offset(i), value);
+          return true;
+        }
+      });
+    }
+  }
+  for (const key of Object.getOwnPropertyNames(DataView.prototype)) {
+    if (!key.startsWith("get") && !key.startsWith("set"))
+      continue;
+    Object.defineProperty(StructArray2.prototype, key, {
+      enumerable: false,
+      configurable: false,
+      writable: false,
+      value: undefined
+    });
+  }
+  return StructArray2;
+}
+function _isStructConstructor(arg) {
+  return typeof arg == "function" && "prototype" in arg && "fields" in arg && typeof arg.fields == "object" && isType(arg);
+}
+
+class ArrayType {
+  type;
+  length;
+  name;
+  size;
+  __structArray;
+  __arrayType;
+  __isArrayType = true;
+  constructor(type, length) {
+    this.type = type;
+    this.length = length;
+    this.name = `${type.name}[${length}]`;
+    this.size = type.size * length;
+    this.array = StructArray(this);
+    this.__structArray = StructArray(type, length);
+    this.__arrayType = type.array ? type.array : this.__structArray;
+  }
+  get = (buffer2, offset) => {
+    if (isValid(this.type.name) && offset % this.type.size !== 0) {
+      return new this.__structArray(buffer2, offset, this.size);
+    }
+    return new this.__arrayType(buffer2, offset, this.size);
+  };
+  set = (buffer2, offset, value) => {
+    if (this.length)
+      for (let i = 0;i < this.length; i++) {
+        this.type.set(buffer2, offset + i * this.type.size, value[i]);
+      }
+    else {
+      let pointer = offset;
+      for (let i = 0;i < value.length; i++) {
+        this.type.set(buffer2, pointer, value[i]);
+        pointer += _isStructConstructor(this.type) && this.type.isDynamic ? sizeof(value[i]) : this.type.size;
+      }
+    }
+  };
+  array;
+}
 // ../../node_modules/memium/dist/decorators.js
 Symbol.metadata ??= Symbol.for("Symbol.metadata");
 function initMetadata(context) {
@@ -8928,19 +9275,19 @@ function initMetadata(context) {
   };
   return context.metadata.structInit;
 }
-function struct(name, ...options) {
+function struct(...options) {
   const opts = options.reduce((acc, opt) => ({ ...acc, ...opt }), {});
   if (typeof this == "object")
     Object.assign(opts, this);
   return function __decorateStruct(target, context) {
-    const init = initMetadata(context);
+    const init2 = initMetadata(context);
     let fieldAlignment = 1;
-    const fields = {};
+    const fields = [];
     let size = 0;
     const align = (to) => {
       size = Math.ceil(size / to) * to;
     };
-    for (const field of init.fields) {
+    for (const field of init2.fields) {
       if (!opts.isPacked)
         align(field.alignment);
       if (opts.isUnion)
@@ -8949,20 +9296,32 @@ function struct(name, ...options) {
         field.offset = size;
         size += field.type.size;
       }
-      fields[field.name] = field;
+      fields.push(field);
       fieldAlignment = Math.max(fieldAlignment, field.alignment);
     }
     opts.alignment ??= fieldAlignment;
     if (!opts.isPacked)
       align(opts.alignment);
-    context.metadata.struct = {
-      fields,
-      size,
-      alignment: opts.isPacked ? 1 : opts.alignment,
-      isUnion: opts.isUnion ?? false
-    };
 
     class _struct extends target {
+      static name = target.name;
+      static size = size;
+      static alignment = opts.alignment;
+      static isUnion = !!opts.isUnion;
+      static isDynamic = !!opts.isDynamic;
+      static fields = fields;
+      static get(buffer2, offset) {
+        return new this(buffer2, offset);
+      }
+      static set(buffer2, offset, value) {
+        const source = new Uint8Array(value.buffer, value.byteOffset, this.size);
+        const target2 = new Uint8Array(buffer2, offset, this.size);
+        if (value.buffer === buffer2 && value.byteOffset === offset)
+          return;
+        for (let i = 0;i < this.size; i++)
+          target2[i] = source[i];
+      }
+      static [Symbol.toStringTag] = `[struct ${target.name}]`;
       constructor(...args) {
         if (!args.length)
           args = [new ArrayBuffer(size), 0, size];
@@ -8972,39 +9331,19 @@ function struct(name, ...options) {
             enumerable: true,
             configurable: true,
             get() {
-              return __fieldGet(this, field);
+              return get(this, field);
             },
             set(value) {
-              __fieldSet(this, field, value);
+              set(this, field, value);
             }
           });
         }
       }
     }
-    const fix = (value) => ({
-      writable: false,
-      enumerable: false,
-      configurable: false,
-      value
-    });
-    Object.defineProperties(_struct, {
-      name: fix(name),
-      size: fix(size),
-      alignment: fix(opts.alignment),
-      isUnion: fix(!!opts.isUnion),
-      fields: fix(fields),
-      get: fix((buffer, offset) => new _struct(buffer, offset)),
-      set: fix((buffer, offset, value) => {
-        const source = new Uint8Array(value.buffer, value.byteOffset, size);
-        const target2 = new Uint8Array(buffer, offset, size);
-        if (value.buffer === buffer && value.byteOffset === offset)
-          return;
-        for (let i = 0;i < size; i++)
-          target2[i] = source[i];
-      }),
-      [Symbol.toStringTag]: fix(`[struct ${name}]`)
+    context.addInitializer(function() {
+      Object.defineProperty(_struct, "name", { value: target.name });
+      registerType(_struct);
     });
-    registerType(_struct);
     return _struct;
   };
 }
@@ -9016,15 +9355,15 @@ function field(type, opt = {}) {
   return function __decorateField(value, context) {
     if (context.kind != "accessor")
       throw withErrno("EINVAL", "Field must be an accessor");
-    const init = initMetadata(context);
-    const field2 = __fieldInit(context.name, type, opt);
-    init.fields.push(field2);
+    const init2 = initMetadata(context);
+    const field2 = init(context.name, type, opt);
+    init2.fields.push(field2);
     return {
       get() {
-        return __fieldGet(this, field2);
+        return get(this, field2);
       },
       set(value2) {
-        __fieldSet(this, field2, value2);
+        set(this, field2, value2);
       }
     };
   };
@@ -9043,10 +9382,40 @@ function $from(t) {
 $from.typed = function(t) {
   return t;
 };
-// ../../node_modules/memium/dist/structs.js
-function isStructConstructor(arg) {
-  return typeof arg == "function" && "prototype" in arg && "fields" in arg && typeof arg.fields == "object" && isType(arg);
+// ../../node_modules/memium/dist/fields.js
+class FieldBuilder {
+  type;
+  init;
+  constructor(type, init2) {
+    this.type = type;
+    this.init = init2;
+    const _toArray = (length) => {
+      return new FieldBuilder(new ArrayType(type, length), init2);
+    };
+    Object.setPrototypeOf(_toArray, new.target.prototype);
+    Object.assign(_toArray, { type, init: init2 });
+    return _toArray;
+  }
+  align(align) {
+    return new FieldBuilder(this.type, { ...this.init, align });
+  }
+  countedBy(countedBy) {
+    return new FieldBuilder(this.type, { ...this.init, countedBy });
+  }
+  bigEndian() {
+    return new FieldBuilder(this.type, { ...this.init, bigEndian: true });
+  }
+  toInit() {
+    return { type: this.type, ...this.init };
+  }
+  $type() {
+    return new FieldBuilder(this.type, this.init);
+  }
 }
+function array2(type, length = 0) {
+  return new FieldBuilder(new ArrayType(type, length), {});
+}
+// ../../node_modules/memium/dist/structs.js
 function struct2(structName, fieldDecls, ...options) {
   const opts = options.reduce((acc, opt) => ({ ...acc, ...opt }), {});
   if (typeof this == "object")
@@ -9056,11 +9425,11 @@ function struct2(structName, fieldDecls, ...options) {
   const align = (to) => {
     size = Math.ceil(size / to) * to;
   };
-  const fields = Object.create(null);
-  for (const [name, init] of Object.entries(fieldDecls)) {
+  const fields = [];
+  for (const [name, init2] of Object.entries(fieldDecls)) {
     if (typeof name == "number")
       throw new TypeError("Field names can not be numbers");
-    const field2 = __fieldInit(name, init);
+    const field2 = init(name, init2);
     if (!opts.isPacked)
       align(field2.alignment);
     if (opts.isUnion)
@@ -9069,26 +9438,43 @@ function struct2(structName, fieldDecls, ...options) {
       field2.offset = size;
       size += field2.type.size;
     }
-    fields[field2.name] = field2;
+    fields.push(field2);
     fieldAlignment = Math.max(fieldAlignment, field2.alignment);
   }
   opts.alignment ??= fieldAlignment;
   if (!opts.isPacked)
     align(opts.alignment);
 
-  class __struct extends DataView {
+  class _struct extends DataView {
     static name = structName;
-    constructor(buffer = new ArrayBuffer(size), byteOffset, byteLength) {
-      super(buffer, byteOffset, byteLength ?? size);
-      for (const field2 of Object.values(fields)) {
+    static size = size;
+    static alignment = opts.alignment;
+    static isUnion = !!opts.isUnion;
+    static isDynamic = !!opts.isDynamic;
+    static fields = fields;
+    static get(buffer2, offset) {
+      return new this(buffer2, offset);
+    }
+    static set(buffer2, offset, value) {
+      const source = new Uint8Array(value.buffer, value.byteOffset, this.size);
+      const target = new Uint8Array(buffer2, offset, this.size);
+      if (value.buffer === buffer2 && value.byteOffset === offset)
+        return;
+      for (let i = 0;i < this.size; i++)
+        target[i] = source[i];
+    }
+    static [Symbol.toStringTag] = `[struct ${structName}]`;
+    constructor(buffer2 = new ArrayBuffer(size), byteOffset, byteLength) {
+      super(buffer2, byteOffset, byteLength ?? buffer2.byteLength - (byteOffset ?? 0));
+      for (const field2 of Object.values(this.constructor.fields ?? fields)) {
         Object.defineProperty(this, field2.name, {
           enumerable: true,
           configurable: true,
           get() {
-            return __fieldGet(this, field2);
+            return get(this, field2);
           },
           set(value) {
-            __fieldSet(this, field2, value);
+            set(this, field2, value);
           }
         });
       }
@@ -9097,129 +9483,63 @@ function struct2(structName, fieldDecls, ...options) {
   for (const key of Object.getOwnPropertyNames(DataView.prototype)) {
     if (!key.startsWith("get") && !key.startsWith("set"))
       continue;
-    Object.defineProperty(__struct.prototype, key, {
+    Object.defineProperty(_struct.prototype, key, {
       enumerable: false,
       configurable: false,
       writable: false,
       value: undefined
     });
   }
-  const _struct = __struct;
-  const fix = (value) => ({
-    writable: false,
-    enumerable: false,
-    configurable: false,
-    value
-  });
-  Object.defineProperties(_struct, {
-    size: fix(size),
-    alignment: fix(opts.alignment),
-    isUnion: fix(!!opts.isUnion),
-    fields: fix(fields),
-    get: fix((buffer, offset) => new _struct(buffer, offset)),
-    set: fix((buffer, offset, value) => {
-      const source = new Uint8Array(value.buffer, value.byteOffset, size);
-      const target = new Uint8Array(buffer, offset, size);
-      if (value.buffer === buffer && value.byteOffset === offset)
-        return;
-      for (let i = 0;i < size; i++)
-        target[i] = source[i];
-    }),
-    [Symbol.toStringTag]: fix(`[struct ${structName}]`)
-  });
   registerType(_struct);
   return _struct;
 }
 struct2.extend = function(base, structName, fieldDecls, ...options) {
-  return struct2(structName, { ...base.fields, ...fieldDecls }, ...options);
-};
-struct2.packed = struct2.bind({ isPacked: true });
-struct2.align = function(alignment) {
-  return struct2.bind({ alignment });
-};
-var types4 = Object.fromEntries(Object.entries(rawTypes).map(([typeName, type]) => [
-  typeName,
-  new FieldBuilder(type, { typeName })
-]));
-
-// ../../node_modules/memium/dist/misc.js
-function sizeof(type) {
-  if (isType(type))
-    return type.size;
-  if (type === undefined || type === null)
-    return 0;
-  if (typeof type == "object" && isType(type.constructor))
-    return type.constructor.size;
-  if (Array.isArray(type)) {
-    let size = 0;
-    for (let i = 0;i < type.length; i++)
-      size += sizeof(type[i]);
-    return size;
-  }
-  if (typeof type == "string") {
-    checkValid(type);
-    return types2[normalize(type)].size;
-  }
-  throw new TypeError(`Unable to resolve size of \`${type.toString()}\``);
-}
-function offsetof(type, fieldName) {
-  let constructor;
-  if (isStructConstructor(type))
-    constructor = type;
-  else if (isStructConstructor(type.constructor))
-    constructor = type.constructor;
-  else
-    throw withErrno("EINVAL", "Type is not a struct or struct constructor");
-  const { fields } = constructor;
-  if (!(fieldName in fields))
-    throw withErrno("EINVAL", "Struct does not have field: " + fieldName);
-  return fields[fieldName].offset;
-}
-// ../../node_modules/utilium/dist/buffer.js
-function extendBuffer(buffer, newByteLength) {
-  if (buffer.byteLength >= newByteLength)
-    return buffer;
-  if (ArrayBuffer.isView(buffer)) {
-    const newBuffer = extendBuffer(buffer.buffer, newByteLength);
-    return new buffer.constructor(newBuffer, buffer.byteOffset, newByteLength);
-  }
-  const isShared = typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
-  if (buffer.maxByteLength > newByteLength) {
-    isShared ? buffer.grow(newByteLength) : buffer.resize(newByteLength);
-    return buffer;
-  }
-  if (isShared) {
-    const newBuffer = new SharedArrayBuffer(newByteLength);
-    new Uint8Array(newBuffer).set(new Uint8Array(buffer));
-    return newBuffer;
-  }
-  try {
-    return buffer.transfer(newByteLength);
-  } catch {
-    const newBuffer = new ArrayBuffer(newByteLength);
-    new Uint8Array(newBuffer).set(new Uint8Array(buffer));
-    return newBuffer;
-  }
-}
-class BufferView extends DataView {
-  constructor(_buffer, _byteOffset, _byteLength) {
-    const { buffer, byteOffset, byteLength } = new Uint8Array(_buffer, _byteOffset, _byteLength);
-    super(buffer, byteOffset, byteLength);
+  const opts = options.reduce((acc, opt) => ({ ...acc, ...opt }), {});
+  if (typeof this == "object")
+    Object.assign(opts, this);
+  let fieldAlignment = 1;
+  let size = base.size;
+  const align = (to) => {
+    size = Math.ceil(size / to) * to;
+  };
+  const fields = base.fields;
+  for (const [name, init2] of Object.entries(fieldDecls)) {
+    if (typeof name == "number")
+      throw new TypeError("Field names can not be numbers");
+    const field2 = init(name, init2);
+    if (!opts.isPacked)
+      align(field2.alignment);
+    if (opts.isUnion)
+      size = Math.max(size, field2.type.size);
+    else {
+      field2.offset = size;
+      size += field2.type.size;
+    }
+    fields.push(field2);
+    fieldAlignment = Math.max(fieldAlignment, field2.alignment);
   }
-}
-for (const key of Object.getOwnPropertyNames(DataView.prototype)) {
-  if (!key.startsWith("get") && !key.startsWith("set"))
-    continue;
-  Object.defineProperty(BufferView.prototype, key, {
-    value: () => {
-      throw new ReferenceError("Do not use DataView methods on a BufferView.");
-    },
-    writable: false,
-    enumerable: false,
-    configurable: false
-  });
-}
+  opts.alignment ??= fieldAlignment;
+  if (!opts.isPacked)
+    align(opts.alignment);
 
+  class _struct extends base {
+    static name = structName;
+    static size = size;
+    static alignment = opts.alignment;
+    static isUnion = !!opts.isUnion;
+    static isDynamic = !!opts.isDynamic;
+    static fields = fields;
+    static [Symbol.toStringTag] = `[struct ${structName}]`;
+  }
+  registerType(_struct);
+  return _struct;
+};
+struct2.packed = struct2.bind({ isPacked: true });
+struct2.align = function(alignment) {
+  return struct2.bind({ alignment });
+};
+struct2.dynamic = struct2.bind({ isDynamic: true });
+var types4 = Object.fromEntries(Object.entries(rawTypes).map(([typeName, type]) => [typeName, new FieldBuilder(type, { typeName })]));
 // ../../node_modules/@zenfs/core/dist/utils.js
 function decodeDirListing(data) {
   return JSON.parse(decodeUTF8(data), (k, v) => k == "" ? v : typeof v == "string" ? BigInt(v).toString(16).slice(0, Math.min(v.length, 8)) : v);
@@ -9280,7 +9600,9 @@ function normalizeOptions(options, encoding = "utf8", flag, mode = 0) {
   };
 }
 function globToRegex(pattern) {
-  pattern = pattern.replace(/([.?+^$(){}|[\]/])/g, "$1").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+  const GLOBSTAR = "\x00GS\x00";
+  const STAR = "\x00S\x00";
+  pattern = pattern.replace(/\*\*/g, GLOBSTAR).replace(/\*/g, STAR).replace(/[.+^$(){}|[\]\\]/g, "\\$&").replace(/\?/g, ".").replaceAll("/" + GLOBSTAR + "/", "(?:/.*)?/").replaceAll(GLOBSTAR, ".*").replaceAll(STAR, "[^/]*");
   return new RegExp(`^${pattern}$`);
 }
 function _tempDirName(prefix) {
@@ -9754,7 +10076,7 @@ var rootIno = 0;
 var maxDynamicData = 3968;
 var Attribute = (() => {
   var _a, _b;
-  let _classDecorators = [struct.packed("Attribute")];
+  let _classDecorators = [struct.packed()];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -9783,8 +10105,8 @@ var Attribute = (() => {
       Attribute2 = _classThis = _classDescriptor.value;
       if (_metadata)
         Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-      __runInitializers(_classThis, _classExtraInitializers);
     }
+    static name = "Attribute";
     #keySize_accessor_storage = __runInitializers(this, _keySize_initializers, undefined);
     get keySize() {
       return this.#keySize_accessor_storage;
@@ -9825,12 +10147,15 @@ var Attribute = (() => {
       super(...arguments);
       __runInitializers(this, _valueSize_extraInitializers);
     }
+    static {
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
   };
   return Attribute2 = _classThis;
 })();
 var Attributes = (() => {
   var _a;
-  let _classDecorators = [struct.packed("Attributes")];
+  let _classDecorators = [struct.packed()];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -9852,8 +10177,8 @@ var Attributes = (() => {
       Attributes2 = _classThis = _classDescriptor.value;
       if (_metadata)
         Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-      __runInitializers(_classThis, _classExtraInitializers);
     }
+    static name = "Attributes";
     #size_accessor_storage = __runInitializers(this, _size_initializers, undefined);
     get size() {
       return this.#size_accessor_storage;
@@ -9960,6 +10285,9 @@ var Attributes = (() => {
       super(...arguments);
       __runInitializers(this, _size_extraInitializers);
     }
+    static {
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
   };
   return Attributes2 = _classThis;
 })();
@@ -10002,7 +10330,7 @@ var InodeFlags;
 })(InodeFlags || (InodeFlags = {}));
 var Inode = (() => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
-  let _classDecorators = [struct.packed("Inode")];
+  let _classDecorators = [struct.packed()];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -10150,8 +10478,8 @@ var Inode = (() => {
       Inode2 = _classThis = _classDescriptor.value;
       if (_metadata)
         Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-      __runInitializers(_classThis, _classExtraInitializers);
     }
+    static name = "Inode";
     constructor(...args) {
       let data = {};
       if (typeof args[0] === "object" && args[0] !== null && !ArrayBuffer.isView(args[0])) {
@@ -10341,6 +10669,9 @@ var Inode = (() => {
         this.ctimeMs = Date.now();
       return hasChanged;
     }
+    static {
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
   };
   return Inode2 = _classThis;
 })();
@@ -10554,9 +10885,9 @@ class FileSystem {
         const { start = 0, end = size } = options;
         for (let offset = start;offset < end; offset += _chunkSize) {
           const bytesRead = offset + _chunkSize > end ? end - offset : _chunkSize;
-          const buffer = new Uint8Array(bytesRead);
-          await this.read(path, buffer, offset, offset + bytesRead).catch(controller.error.bind(controller));
-          controller.enqueue(buffer);
+          const buffer2 = new Uint8Array(bytesRead);
+          await this.read(path, buffer2, offset, offset + bytesRead).catch(controller.error.bind(controller));
+          controller.enqueue(buffer2);
         }
         controller.close();
       },
@@ -10583,160 +10914,6 @@ class FileSystem {
   }
 }
 
-// ../../node_modules/utilium/dist/cache.js
-class Resource {
-  id;
-  _size;
-  options;
-  regions = [];
-  get size() {
-    return this._size;
-  }
-  set size(value) {
-    if (value >= this._size) {
-      this._size = value;
-      return;
-    }
-    this._size = value;
-    for (let i = this.regions.length - 1;i >= 0; i--) {
-      const region = this.regions[i];
-      if (region.offset >= value) {
-        this.regions.splice(i, 1);
-        continue;
-      }
-      const maxLength = value - region.offset;
-      if (region.data.byteLength > maxLength) {
-        region.data = region.data.subarray(0, maxLength);
-      }
-      region.ranges = region.ranges.filter((range) => range.start < value).map((range) => {
-        if (range.end > value) {
-          return { start: range.start, end: value };
-        }
-        return range;
-      });
-    }
-  }
-  constructor(id, _size, options, resources) {
-    this.id = id;
-    this._size = _size;
-    this.options = options;
-    options.sparse ??= true;
-    if (!options.sparse)
-      this.regions.push({ offset: 0, data: new Uint8Array(_size), ranges: [] });
-    resources?.set(id, this);
-  }
-  collect() {
-    if (!this.options.sparse)
-      return;
-    const { regionGapThreshold = 4095 } = this.options;
-    for (let i = 0;i < this.regions.length - 1; ) {
-      const current = this.regions[i];
-      const next = this.regions[i + 1];
-      if (next.offset - (current.offset + current.data.byteLength) > regionGapThreshold) {
-        i++;
-        continue;
-      }
-      current.ranges.push(...next.ranges);
-      current.ranges.sort((a, b) => a.start - b.start);
-      current.ranges = current.ranges.reduce((acc, range) => {
-        if (!acc.length || acc.at(-1).end < range.start) {
-          acc.push(range);
-        } else {
-          acc.at(-1).end = Math.max(acc.at(-1).end, range.end);
-        }
-        return acc;
-      }, []);
-      current.data = extendBuffer(current.data, next.offset + next.data.byteLength);
-      current.data.set(next.data, next.offset - current.offset);
-      this.regions.splice(i + 1, 1);
-    }
-  }
-  missing(start, end) {
-    const missingRanges = [];
-    for (const region of this.regions) {
-      if (region.offset >= end)
-        break;
-      for (const range of region.ranges) {
-        if (range.end <= start)
-          continue;
-        if (range.start >= end)
-          break;
-        if (range.start > start) {
-          missingRanges.push({ start, end: Math.min(range.start, end) });
-        }
-        if (range.end > start)
-          start = Math.max(start, range.end);
-        if (start >= end)
-          break;
-      }
-      if (start >= end)
-        break;
-    }
-    if (start < end)
-      missingRanges.push({ start, end });
-    return missingRanges;
-  }
-  cached(start, end) {
-    const cachedRanges = [];
-    for (const region of this.regions) {
-      if (region.offset >= end)
-        break;
-      for (const range of region.ranges) {
-        if (range.end <= start)
-          continue;
-        if (range.start >= end)
-          break;
-        cachedRanges.push({
-          start: Math.max(start, range.start),
-          end: Math.min(end, range.end)
-        });
-      }
-    }
-    cachedRanges.sort((a, b) => a.start - b.start);
-    const merged = [];
-    for (const curr of cachedRanges) {
-      const last = merged.at(-1);
-      if (last && curr.start <= last.end) {
-        last.end = Math.max(last.end, curr.end);
-      } else {
-        merged.push(curr);
-      }
-    }
-    return merged;
-  }
-  regionAt(offset) {
-    if (!this.regions.length)
-      return;
-    for (const region of this.regions) {
-      if (region.offset > offset)
-        break;
-      if (offset >= region.offset && offset < region.offset + region.data.byteLength)
-        return region;
-    }
-  }
-  add(data, offset) {
-    const end = offset + data.byteLength;
-    const region = this.regionAt(offset);
-    if (region) {
-      region.data = extendBuffer(region.data, end);
-      region.data.set(data, offset);
-      region.ranges.push({ start: offset, end });
-      region.ranges.sort((a, b) => a.start - b.start);
-      this.collect();
-      return this;
-    }
-    const newRegion = { data, offset, ranges: [{ start: offset, end }] };
-    const insertIndex = this.regions.findIndex((region2) => region2.offset > offset);
-    if (insertIndex == -1) {
-      this.regions.push(newRegion);
-    } else {
-      this.regions.splice(insertIndex, 0, newRegion);
-    }
-    this.collect();
-    return this;
-  }
-}
-
 // ../../node_modules/@zenfs/core/dist/polyfills.js
 Promise.withResolvers ??= (warn("Using a polyfill of Promise.withResolvers"), function() {
   let _resolve, _reject;
@@ -10866,13 +11043,13 @@ class WrappedTransaction {
   }
   async set(id, view2, offset = 0) {
     await this.markModified(id, offset, view2.byteLength);
-    const buffer = view2 instanceof Uint8Array ? view2 : new Uint8Array(view2.buffer, view2.byteOffset, view2.byteLength);
-    await this.raw.set(id, buffer, offset);
+    const buffer2 = view2 instanceof Uint8Array ? view2 : new Uint8Array(view2.buffer, view2.byteOffset, view2.byteLength);
+    await this.raw.set(id, buffer2, offset);
   }
   setSync(id, view2, offset = 0) {
     this.markModifiedSync(id, offset, view2.byteLength);
-    const buffer = view2 instanceof Uint8Array ? view2 : new Uint8Array(view2.buffer, view2.byteOffset, view2.byteLength);
-    this.raw.setSync(id, buffer, offset);
+    const buffer2 = view2 instanceof Uint8Array ? view2 : new Uint8Array(view2.buffer, view2.byteOffset, view2.byteLength);
+    this.raw.setSync(id, buffer2, offset);
   }
   async remove(id) {
     await this.markModified(id, 0, undefined);
@@ -11455,7 +11632,7 @@ class StoreFS extends FileSystem {
       __disposeResources(env_14);
     }
   }
-  async read(path, buffer, offset, end) {
+  async read(path, buffer2, offset, end) {
     const env_15 = { stack: [], error: undefined, hasError: false };
     try {
       const tx = __addDisposableResource(env_15, this.transaction(), true);
@@ -11464,9 +11641,9 @@ class StoreFS extends FileSystem {
         return;
       const data = await tx.get(inode.data, offset, end) ?? _throw(withErrno("ENODATA"));
       const _ = tx.flag("partial") ? data : data.subarray(offset, end);
-      if (_.byteLength > buffer.byteLength)
-        err(`Trying to place ${_.byteLength} bytes into a ${buffer.byteLength} byte buffer on read`);
-      buffer.set(_);
+      if (_.byteLength > buffer2.byteLength)
+        err(`Trying to place ${_.byteLength} bytes into a ${buffer2.byteLength} byte buffer on read`);
+      buffer2.set(_);
     } catch (e_15) {
       env_15.error = e_15;
       env_15.hasError = true;
@@ -11476,7 +11653,7 @@ class StoreFS extends FileSystem {
         await result_8;
     }
   }
-  readSync(path, buffer, offset, end) {
+  readSync(path, buffer2, offset, end) {
     const env_16 = { stack: [], error: undefined, hasError: false };
     try {
       const tx = __addDisposableResource(env_16, this.transaction(), false);
@@ -11485,9 +11662,9 @@ class StoreFS extends FileSystem {
         return;
       const data = tx.getSync(inode.data, offset, end) ?? _throw(withErrno("ENODATA"));
       const _ = tx.flag("partial") ? data : data.subarray(offset, end);
-      if (_.byteLength > buffer.byteLength)
-        err(`Trying to place ${_.byteLength} bytes into a ${buffer.byteLength} byte buffer on read`);
-      buffer.set(_);
+      if (_.byteLength > buffer2.byteLength)
+        err(`Trying to place ${_.byteLength} bytes into a ${buffer2.byteLength} byte buffer on read`);
+      buffer2.set(_);
     } catch (e_16) {
       env_16.error = e_16;
       env_16.hasError = true;
@@ -11500,13 +11677,13 @@ class StoreFS extends FileSystem {
     try {
       const tx = __addDisposableResource(env_17, this.transaction(), true);
       const inode = await this.findInode(tx, path);
-      let buffer = data;
+      let buffer2 = data;
       if (!tx.flag("partial")) {
-        buffer = extendBuffer(await tx.get(inode.data) ?? new Uint8Array, offset + data.byteLength);
-        buffer.set(data, offset);
+        buffer2 = extendBuffer(await tx.get(inode.data) ?? new Uint8Array, offset + data.byteLength);
+        buffer2.set(data, offset);
         offset = 0;
       }
-      await tx.set(inode.data, buffer, offset);
+      await tx.set(inode.data, buffer2, offset);
       this._add(inode.ino, path);
       await tx.commit();
     } catch (e_17) {
@@ -11523,13 +11700,13 @@ class StoreFS extends FileSystem {
     try {
       const tx = __addDisposableResource(env_18, this.transaction(), false);
       const inode = this.findInodeSync(tx, path);
-      let buffer = data;
+      let buffer2 = data;
       if (!tx.flag("partial")) {
-        buffer = extendBuffer(tx.getSync(inode.data) ?? new Uint8Array, offset + data.byteLength);
-        buffer.set(data, offset);
+        buffer2 = extendBuffer(tx.getSync(inode.data) ?? new Uint8Array, offset + data.byteLength);
+        buffer2.set(data, offset);
         offset = 0;
       }
-      tx.setSync(inode.data, buffer, offset);
+      tx.setSync(inode.data, buffer2, offset);
       this._add(inode.ino, path);
       tx.commitSync();
     } catch (e_18) {
@@ -11968,16 +12145,16 @@ class DeviceFS extends StoreFS {
     const lastDev = Array.from(this.devices.values()).at(-1);
     while (this.store.has(ino) || lastDev?.inode.ino == ino)
       ino++;
-    const init = driver.init?.(ino, options);
+    const init2 = driver.init?.(ino, options);
     const dev = {
       data: {},
       minor: 0,
       major: 0,
-      ...omit(init ?? {}, "metadata"),
+      ...omit(init2 ?? {}, "metadata"),
       driver,
       inode: new Inode({
         mode: S_IFCHR | 438,
-        ...init?.metadata
+        ...init2?.metadata
       })
     };
     const path = "/" + (dev.name || driver.name) + (driver.singleton ? "" : this.devicesWithDriver(driver).length);
@@ -12118,21 +12295,21 @@ class DeviceFS extends StoreFS {
     }
     return super.syncSync();
   }
-  async read(path, buffer, offset, end) {
+  async read(path, buffer2, offset, end) {
     const device = this.devices.get(path);
     if (!device) {
-      await super.read(path, buffer, offset, end);
+      await super.read(path, buffer2, offset, end);
       return;
     }
-    device.driver.read(device, buffer, offset, end);
+    device.driver.read(device, buffer2, offset, end);
   }
-  readSync(path, buffer, offset, end) {
+  readSync(path, buffer2, offset, end) {
     const device = this.devices.get(path);
     if (!device) {
-      super.readSync(path, buffer, offset, end);
+      super.readSync(path, buffer2, offset, end);
       return;
     }
-    device.driver.read(device, buffer, offset, end);
+    device.driver.read(device, buffer2, offset, end);
   }
   async write(path, data, offset) {
     const device = this.devices.get(path);
@@ -12169,8 +12346,8 @@ var zeroDevice = {
   init() {
     return { major: 1, minor: 5 };
   },
-  read(device, buffer, offset, end) {
-    buffer.fill(0, offset, end);
+  read(device, buffer2, offset, end) {
+    buffer2.fill(0, offset, end);
   },
   write() {
     return;
@@ -12182,8 +12359,8 @@ var fullDevice = {
   init() {
     return { major: 1, minor: 7 };
   },
-  read(device, buffer, offset, end) {
-    buffer.fill(0, offset, end);
+  read(device, buffer2, offset, end) {
+    buffer2.fill(0, offset, end);
   },
   write() {
     throw withErrno("ENOSPC");
@@ -12195,9 +12372,9 @@ var randomDevice = {
   init() {
     return { major: 1, minor: 8 };
   },
-  read(device, buffer) {
-    for (let i = 0;i < buffer.length; i++) {
-      buffer[i] = Math.floor(Math.random() * 256);
+  read(device, buffer2) {
+    for (let i = 0;i < buffer2.length; i++) {
+      buffer2[i] = Math.floor(Math.random() * 256);
     }
   },
   write() {
@@ -12213,8 +12390,8 @@ var consoleDevice = {
   read() {
     return emptyBuffer;
   },
-  write(device, buffer, offset) {
-    const text = decodeUTF8(buffer);
+  write(device, buffer2, offset) {
+    const text = decodeUTF8(buffer2);
     device.data.output(text, offset);
   }
 };
@@ -12230,7 +12407,7 @@ __export(exports_promises, {
   truncate: () => truncate,
   symlink: () => symlink,
   statfs: () => statfs,
-  stat: () => stat,
+  stat: () => stat3,
   rmdir: () => rmdir,
   rm: () => rm,
   rename: () => rename3,
@@ -12367,7 +12544,7 @@ class Handle {
     if (this._isSync)
       this.syncSync();
   }
-  writeSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+  writeSync(buffer2, offset = 0, length = buffer2.byteLength - offset, position = this.position) {
     if (this.closed)
       throw UV("EBADF", "write", this.path);
     if (!(this.flag & O_WRONLY || this.flag & O_RDWR))
@@ -12378,7 +12555,7 @@ class Handle {
       throw UV("EPERM", "write", this.path);
     this.dirty = true;
     const end = position + length;
-    const slice = buffer.subarray(offset, offset + length);
+    const slice = buffer2.subarray(offset, offset + length);
     if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size)
       this.inode.size = end;
     this.inode.mtimeMs = Date.now();
@@ -12389,7 +12566,7 @@ class Handle {
       this.syncSync();
     return slice.byteLength;
   }
-  readSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+  readSync(buffer2, offset = 0, length = buffer2.byteLength - offset, position = this.position) {
     if (this.closed)
       throw UV("EBADF", "read", this.path);
     if (this.flag & O_WRONLY)
@@ -12403,7 +12580,7 @@ class Handle {
       end = position + Math.max(this.inode.size - position, 0);
     }
     this._position = end;
-    const uint82 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const uint82 = new Uint8Array(buffer2.buffer, buffer2.byteOffset, buffer2.byteLength);
     this.fs.readSync(this.internalPath, uint82.subarray(offset, offset + length), position, end);
     if (this._isSync)
       this.syncSync();
@@ -12485,7 +12662,7 @@ class Handle {
     if (this._isSync)
       await this.sync();
   }
-  async write(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+  async write(buffer2, offset = 0, length = buffer2.byteLength - offset, position = this.position) {
     if (this.closed)
       throw UV("EBADF", "write", this.path);
     if (!(this.flag & O_WRONLY || this.flag & O_RDWR))
@@ -12496,7 +12673,7 @@ class Handle {
       throw UV("EPERM", "write", this.path);
     this.dirty = true;
     const end = position + length;
-    const slice = buffer.subarray(offset, offset + length);
+    const slice = buffer2.subarray(offset, offset + length);
     if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size)
       this.inode.size = end;
     this.inode.mtimeMs = Date.now();
@@ -12507,7 +12684,7 @@ class Handle {
       await this.sync();
     return slice.byteLength;
   }
-  async read(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+  async read(buffer2, offset = 0, length = buffer2.byteLength - offset, position = this.position) {
     if (this.closed)
       throw UV("EBADF", "read", this.path);
     if (this.flag & O_WRONLY)
@@ -12521,7 +12698,7 @@ class Handle {
       end = position + Math.max(this.inode.size - position, 0);
     }
     this._position = end;
-    const uint82 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const uint82 = new Uint8Array(buffer2.buffer, buffer2.byteOffset, buffer2.byteLength);
     await this.fs.read(this.internalPath, uint82.subarray(offset, offset + length), position, end);
     if (this._isSync)
       await this.sync();
@@ -12761,7 +12938,7 @@ function resolve2($, path, preserveSymlinks, extra) {
     const target2 = resolve.call($, dirname(path), readlink.call($, path));
     return resolve2($, target2, preserveSymlinks, extra);
   } catch (e) {
-    setUVMessage(Object.assign(e, { syscall: "stat", path }));
+    setUVMessage(Object.assign(e, { syscall: "stat", path, ...extra }));
     if (preserveSymlinks)
       throw e;
   }
@@ -12775,7 +12952,7 @@ function resolve2($, path, preserveSymlinks, extra) {
   } catch (e) {
     if (e.code === "ENOENT")
       return { ...resolved, fullPath: path };
-    throw setUVMessage(Object.assign(e, { syscall: "stat", path: maybePath }));
+    throw setUVMessage(Object.assign(e, { syscall: "stat", path: maybePath, ...extra }));
   }
   if (!isSymbolicLink(stats)) {
     return { ...resolved, fullPath: maybePath, stats };
@@ -12962,6 +13139,28 @@ function link(target, link2) {
   }
   return fs.linkSync(resolved, dst.path);
 }
+function stat(path, lstat) {
+  path = normalizePath.call(this, path);
+  const extra = { syscall: lstat ? "lstat" : "stat", path };
+  let stats;
+  if (!lstat)
+    stats = resolve2(this, path, false, extra).stats;
+  else {
+    const { base, dir } = parse(path);
+    const { fs, path: parent } = resolve2(this, dir, false, extra);
+    try {
+      stats = fs.statSync(base ? join(parent, base) : parent);
+    } catch (e) {
+      setUVMessage(Object.assign(e, extra));
+      throw e;
+    }
+  }
+  if (!stats)
+    throw UV("ENOENT", extra);
+  if (checkAccess && !hasAccess(this, stats, R_OK))
+    throw UV("EACCES", extra);
+  return stats;
+}
 
 // ../../node_modules/@zenfs/core/dist/node/dir.js
 init_buffer();
@@ -13168,25 +13367,11 @@ function existsSync(path) {
   }
 }
 function statSync(path, options) {
-  path = normalizePath(path);
-  const { fs, path: resolved } = resolve2(this, path);
-  let stats;
-  try {
-    stats = fs.statSync(resolved);
-  } catch (e) {
-    throw setUVMessage(Object.assign(e, { path }));
-  }
-  if (checkAccess && !hasAccess(this, stats, R_OK))
-    throw UV("EACCES", { syscall: "stat", path });
+  const stats = stat.call(this, path, false);
   return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 function lstatSync(path, options) {
-  path = normalizePath(path);
-  const { base, dir } = parse(path);
-  const { fs, path: parent } = resolve2(this, dir);
-  const stats = wrap(fs, "statSync", path)(base ? join(parent, base) : parent);
-  if (checkAccess && !hasAccess(this, stats, R_OK))
-    throw UV("EACCES", { syscall: "lstat", path });
+  const stats = stat.call(this, path, true);
   return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 function truncateSync(path, len2 = 0) {
@@ -13312,26 +13497,26 @@ function fdatasyncSync(fd) {
   fromFD(this, fd).datasyncSync();
 }
 function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
-  let buffer, offset, length, position;
+  let buffer2, offset, length, position;
   if (typeof data === "string") {
     position = typeof posOrOff === "number" ? posOrOff : null;
     const encoding = typeof lenOrEnc === "string" ? lenOrEnc : "utf8";
     offset = 0;
-    buffer = Buffer.from(data, encoding);
-    length = buffer.byteLength;
+    buffer2 = Buffer.from(data, encoding);
+    length = buffer2.byteLength;
   } else {
-    buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    buffer2 = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
     offset = posOrOff;
     length = lenOrEnc;
     position = typeof pos === "number" ? pos : null;
   }
   const file = fromFD(this, fd);
   position ??= file.position;
-  const bytesWritten = file.writeSync(buffer, offset, length, position);
+  const bytesWritten = file.writeSync(buffer2, offset, length, position);
   emitChange(this, "change", file.path);
   return bytesWritten;
 }
-function readSync(fd, buffer, options, length, position) {
+function readSync(fd, buffer2, options, length, position) {
   const file = fromFD(this, fd);
   const offset = typeof options == "object" ? options.offset : options;
   if (typeof options == "object") {
@@ -13343,7 +13528,7 @@ function readSync(fd, buffer, options, length, position) {
   if (typeof position == "bigint")
     position = Number(position);
   position = Number.isSafeInteger(position) ? position : file.position;
-  return file.readSync(buffer, offset, length, position);
+  return file.readSync(buffer2, offset, length, position);
 }
 function fchownSync(fd, uid, gid) {
   fromFD(this, fd).chownSync(uid, gid);
@@ -13527,16 +13712,16 @@ function copyFileSync(source, destination, flags) {
 function readvSync(fd, buffers, position) {
   const file = fromFD(this, fd);
   let bytesRead = 0;
-  for (const buffer of buffers) {
-    bytesRead += file.readSync(buffer, 0, buffer.byteLength, position + bytesRead);
+  for (const buffer2 of buffers) {
+    bytesRead += file.readSync(buffer2, 0, buffer2.byteLength, position + bytesRead);
   }
   return bytesRead;
 }
 function writevSync(fd, buffers, position) {
   const file = fromFD(this, fd);
   let bytesWritten = 0;
-  for (const buffer of buffers) {
-    bytesWritten += file.writeSync(new Uint8Array(buffer.buffer), 0, buffer.byteLength, position + bytesWritten);
+  for (const buffer2 of buffers) {
+    bytesWritten += file.writeSync(new Uint8Array(buffer2.buffer), 0, buffer2.byteLength, position + bytesWritten);
   }
   return bytesWritten;
 }
@@ -13585,23 +13770,35 @@ function statfsSync(path, options) {
 function globSync(pattern2, options = {}) {
   pattern2 = Array.isArray(pattern2) ? pattern2 : [pattern2];
   const { cwd = "/", withFileTypes = false, exclude = () => false } = options;
-  const regexPatterns = pattern2.map(globToRegex);
+  const normalizedPatterns = pattern2.map((p) => p.replace(/^\/+/g, ""));
+  const hasGlobStar = normalizedPatterns.some((p) => p.includes("**"));
+  const patternBases = normalizedPatterns.map((p) => {
+    const firstGlob = p.search(/[*?[\]{]/);
+    if (firstGlob === -1)
+      return p;
+    const lastSlash = p.lastIndexOf("/", firstGlob);
+    return lastSlash === -1 ? "" : p.slice(0, lastSlash);
+  });
+  const regexPatterns = normalizedPatterns.map(globToRegex);
   const results = [];
   function recursiveList(dir) {
     const entries2 = readdirSync(dir, { withFileTypes, encoding: "utf8" });
     for (const entry of entries2) {
-      const fullPath = withFileTypes ? join(entry.parentPath, entry.name) : dir + "/" + entry;
+      const fullPath = join(dir, withFileTypes ? entry.name : entry);
       if (typeof exclude != "function" ? exclude.some((p) => matchesGlob(p, fullPath)) : exclude(withFileTypes ? entry : fullPath))
         continue;
-      if (statSync(fullPath).isDirectory() && regexPatterns.some((pattern3) => pattern3.source.includes(".*"))) {
-        recursiveList(fullPath);
+      const relativePath = fullPath.replace(/^\/+/g, "");
+      if (statSync(fullPath).isDirectory()) {
+        if (hasGlobStar || patternBases.some((base) => relativePath === base || base.startsWith(relativePath + "/"))) {
+          recursiveList(fullPath);
+        }
       }
-      if (regexPatterns.some((pattern3) => pattern3.test(fullPath.replace(/^\/+/g, "")))) {
-        results.push(withFileTypes ? entry : fullPath.replace(/^\/+/g, ""));
+      if (regexPatterns.some((rx) => rx.test(relativePath))) {
+        results.push(withFileTypes ? entry : relativePath);
       }
     }
   }
-  recursiveList(cwd);
+  recursiveList(cwd instanceof URL ? cwd.pathname : cwd);
   return results;
 }
 
@@ -13761,7 +13958,7 @@ async function resolve3($, path, preserveSymlinks, extra) {
   const stats = await resolved.fs.stat(resolved.path).catch((e) => {
     if (e.code == "ENOENT")
       return;
-    throw setUVMessage(Object.assign(e, { syscall: "stat", path: maybePath }));
+    throw setUVMessage(Object.assign(e, { syscall: "stat", path: maybePath, ...extra }));
   });
   if (!stats)
     return { ...resolved, fullPath: path };
@@ -13939,6 +14136,23 @@ async function link2(target, link3) {
   }
   return await fs.link(resolved, dst.path);
 }
+async function stat2(path, lstat) {
+  path = normalizePath.call(this, path);
+  const extra = { syscall: lstat ? "lstat" : "stat", path };
+  let stats;
+  if (!lstat)
+    stats = (await resolve3(this, path, false, extra)).stats;
+  else {
+    const { base, dir } = parse(path);
+    const { fs, path: parent } = await resolve3(this, dir, false, extra);
+    stats = await fs.stat(base ? join(parent, base) : parent).catch(rethrow(extra));
+  }
+  if (!stats)
+    throw UV("ENOENT", extra);
+  if (checkAccess && !hasAccess(this, stats, R_OK))
+    throw UV("EACCES", extra);
+  return stats;
+}
 
 // ../../node_modules/@zenfs/core/dist/node/readline.js
 class Interface extends import__.default {
@@ -14546,27 +14760,27 @@ class FileHandle {
     await this.vfs.write(encodedData, 0, encodedData.length);
     this._emitChange();
   }
-  async read(buffer, offset, length, position) {
+  async read(buffer2, offset, length, position) {
     if (typeof offset == "object" && offset != null) {
       position = offset.position;
       length = offset.length;
       offset = offset.offset;
     }
-    if (!ArrayBuffer.isView(buffer) && typeof buffer == "object") {
-      position = buffer.position;
-      length = buffer.length;
-      offset = buffer.offset;
-      buffer = buffer.buffer;
+    if (!ArrayBuffer.isView(buffer2) && typeof buffer2 == "object") {
+      position = buffer2.position;
+      length = buffer2.length;
+      offset = buffer2.offset;
+      buffer2 = buffer2.buffer;
     }
     if (position && position > Number.MAX_SAFE_INTEGER)
       throw UV("EINVAL");
     if (typeof position == "bigint")
       position = Number(position);
     position = Number.isSafeInteger(position) ? position : this.vfs.position;
-    buffer ||= new Uint8Array(this.vfs.inode.size);
+    buffer2 ||= new Uint8Array(this.vfs.inode.size);
     offset ??= 0;
-    const bytesRead = await this.vfs.read(buffer, offset, length ?? buffer.byteLength - offset, position);
-    return { bytesRead, buffer };
+    const bytesRead = await this.vfs.read(buffer2, offset, length ?? buffer2.byteLength - offset, position);
+    return { bytesRead, buffer: buffer2 };
   }
   async readFile(_options) {
     const options = normalizeOptions(_options, null, "r", 292);
@@ -14576,8 +14790,8 @@ class FileHandle {
     const { size } = await this.stat();
     const data = new Uint8Array(size);
     await this.vfs.read(data, 0, size, 0);
-    const buffer = Buffer.from(data);
-    return options.encoding ? buffer.toString(options.encoding) : buffer;
+    const buffer2 = Buffer.from(data);
+    return options.encoding ? buffer2.toString(options.encoding) : buffer2;
   }
   readableWebStream(options = {}) {
     if (this.vfs.isClosed)
@@ -14607,7 +14821,7 @@ class FileHandle {
     return opts?.bigint ? new BigIntStats(this.vfs.inode) : new Stats(this.vfs.inode);
   }
   async write(data, options, lenOrEnc, position) {
-    let buffer, offset, length;
+    let buffer2, offset, length;
     if (typeof options == "object" && options != null) {
       lenOrEnc = options.length;
       position = options.position;
@@ -14616,16 +14830,16 @@ class FileHandle {
     if (typeof data === "string") {
       position = typeof options === "number" ? options : null;
       offset = 0;
-      buffer = Buffer.from(data, typeof lenOrEnc === "string" ? lenOrEnc : "utf8");
-      length = buffer.length;
+      buffer2 = Buffer.from(data, typeof lenOrEnc === "string" ? lenOrEnc : "utf8");
+      length = buffer2.length;
     } else {
-      buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+      buffer2 = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
       offset = options ?? 0;
-      length = typeof lenOrEnc == "number" ? lenOrEnc : buffer.byteLength;
+      length = typeof lenOrEnc == "number" ? lenOrEnc : buffer2.byteLength;
       position = typeof position === "number" ? position : null;
     }
     position ??= this.vfs.position;
-    const bytesWritten = await this.vfs.write(buffer, offset, length, position);
+    const bytesWritten = await this.vfs.write(buffer2, offset, length, position);
     this._emitChange();
     return { buffer: data, bytesWritten };
   }
@@ -14646,8 +14860,8 @@ class FileHandle {
     if (typeof position == "number")
       this.vfs.position = position;
     let bytesWritten = 0;
-    for (const buffer of buffers) {
-      bytesWritten += (await this.write(buffer)).bytesWritten;
+    for (const buffer2 of buffers) {
+      bytesWritten += (await this.write(buffer2)).bytesWritten;
     }
     return { bytesWritten, buffers };
   }
@@ -14655,8 +14869,8 @@ class FileHandle {
     if (typeof position == "number")
       this.vfs.position = position;
     let bytesRead = 0;
-    for (const buffer of buffers) {
-      bytesRead += (await this.read(buffer)).bytesRead;
+    for (const buffer2 of buffers) {
+      bytesRead += (await this.read(buffer2)).bytesRead;
     }
     return { bytesRead, buffers };
   }
@@ -14690,23 +14904,12 @@ async function exists(path) {
     throw e;
   }
 }
-async function stat(path, options) {
-  path = normalizePath(path);
-  const { fs, path: resolved } = await resolve3(this, path);
-  const $ex = { syscall: "stat", path };
-  const stats = await fs.stat(resolved).catch(rethrow($ex));
-  if (checkAccess && !hasAccess(this, stats, R_OK))
-    throw UV("EACCES", $ex);
+async function stat3(path, options) {
+  const stats = await stat2.call(this, path, false);
   return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 async function lstat(path, options) {
-  path = normalizePath(path);
-  const $ex = { syscall: "lstat", path };
-  const { base, dir } = parse(path);
-  const { fs, path: parent } = await resolve3(this, dir);
-  const stats = await fs.stat(base ? join(parent, base) : parent).catch(rethrow($ex));
-  if (checkAccess && !hasAccess(this, stats, R_OK))
-    throw UV("EACCES", $ex);
+  const stats = await stat2.call(this, path, true);
   return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 async function truncate(path, len2 = 0) {
@@ -15006,7 +15209,7 @@ function watch(filename, options = {}) {
 async function access(path, mode = F_OK) {
   if (!checkAccess)
     return;
-  const stats = await stat.call(this, path);
+  const stats = await stat3.call(this, path);
   if (!stats.hasAccess(mode, this))
     throw UV("EACCES", "access", path.toString());
 }
@@ -15110,22 +15313,34 @@ async function statfs(path, opts) {
 function glob(pattern2, opt) {
   pattern2 = Array.isArray(pattern2) ? pattern2 : [pattern2];
   const { cwd = "/", withFileTypes = false, exclude = () => false } = opt || {};
-  const regexPatterns = pattern2.map(globToRegex);
+  const normalizedPatterns = pattern2.map((p) => p.replace(/^\/+/g, ""));
+  const hasGlobStar = normalizedPatterns.some((p) => p.includes("**"));
+  const patternBases = normalizedPatterns.map((p) => {
+    const firstGlob = p.search(/[*?[\]{]/);
+    if (firstGlob === -1)
+      return p;
+    const lastSlash = p.lastIndexOf("/", firstGlob);
+    return lastSlash === -1 ? "" : p.slice(0, lastSlash);
+  });
+  const regexPatterns = normalizedPatterns.map(globToRegex);
   async function* recursiveList(dir) {
     const entries2 = await readdir2(dir, { withFileTypes, encoding: "utf8" });
     for (const entry of entries2) {
-      const fullPath = withFileTypes ? join(entry.parentPath, entry.name) : dir + "/" + entry;
+      const fullPath = join(dir, withFileTypes ? entry.name : entry);
       if (typeof exclude != "function" ? exclude.some((p) => matchesGlob(p, fullPath)) : exclude(withFileTypes ? entry : fullPath))
         continue;
-      if ((await stat(fullPath)).isDirectory() && regexPatterns.some((pattern3) => pattern3.source.includes(".*"))) {
-        yield* recursiveList(fullPath);
+      const relativePath = fullPath.replace(/^\/+/g, "");
+      if ((await stat3(fullPath)).isDirectory()) {
+        if (hasGlobStar || patternBases.some((base) => relativePath === base || base.startsWith(relativePath + "/"))) {
+          yield* recursiveList(fullPath);
+        }
       }
-      if (regexPatterns.some((pattern3) => pattern3.test(fullPath.replace(/^\/+/g, "")))) {
-        yield withFileTypes ? entry : fullPath.replace(/^\/+/g, "");
+      if (regexPatterns.some((rx) => rx.test(relativePath))) {
+        yield withFileTypes ? entry : relativePath;
       }
     }
   }
-  return recursiveList(cwd);
+  return recursiveList(cwd instanceof URL ? cwd.pathname : cwd);
 }
 
 // ../../node_modules/@zenfs/core/dist/config.js
@@ -15178,7 +15393,7 @@ async function mountWithMkdir(path, fs) {
     mount(path, fs);
     return;
   }
-  const stats = await stat(path).catch(() => null);
+  const stats = await stat3(path).catch(() => null);
   if (!stats) {
     await mkdir3(path, { recursive: true });
   } else if (!stats.isDirectory()) {
@@ -15219,7 +15434,7 @@ async function configure2(configuration) {
   if (configuration.defaultDirectories) {
     for (const dir of _defaultDirectories) {
       if (await exists(dir)) {
-        const stats = await stat(dir);
+        const stats = await stat3(dir);
         if (!stats.isDirectory())
           exports_log.warn("Default directory exists but is not a directory: " + dir);
       } else
@@ -15233,8 +15448,8 @@ var journalOperations = new Set(["delete"]);
 var maxOpLength = Math.max(...journalOperations.values().map((op) => op.length));
 // ../../node_modules/utilium/dist/requests.js
 var resourcesCache = new Map;
-async function _fetch(input, init = {}, bodyOptional = false) {
-  const response = await fetch(input, init).catch((error2) => {
+async function _fetch(input, init2 = {}, bodyOptional = false) {
+  const response = await fetch(input, init2).catch((error2) => {
     throw { tag: "fetch", message: error2.message };
   });
   if (!response.ok)
@@ -15246,10 +15461,10 @@ async function _fetch(input, init = {}, bodyOptional = false) {
   });
   return { response, data: raw ? new Uint8Array(raw) : undefined };
 }
-async function get(url, options, init = {}) {
-  const req = new Request(url, init);
+async function get2(url, options, init2 = {}) {
+  const req = new Request(url, init2);
   if (typeof options.start != "number" || typeof options.end != "number") {
-    const { data } = await _fetch(url, init);
+    const { data } = await _fetch(url, init2);
     new Resource(url, data.byteLength, options, resourcesCache).add(data, 0);
     return data;
   }
@@ -15310,14 +15525,14 @@ function getCached(url, options) {
   }
   return { data, missing: cache.missing(start, end) };
 }
-async function set(url, data, options, init = {}) {
+async function set2(url, data, options, init2 = {}) {
   if (!resourcesCache.has(url)) {
     new Resource(url, options.size ?? data.byteLength, options, resourcesCache);
   }
   const resource = resourcesCache.get(url);
   const { offset = 0, method = "POST" } = options;
   if (!options.cacheOnly) {
-    const headers = new Headers(init.headers || {});
+    const headers = new Headers(init2.headers || {});
     if (!headers.get("Content-Type")) {
       headers.set("Content-Type", "application/octet-stream");
     }
@@ -15328,7 +15543,7 @@ async function set(url, data, options, init = {}) {
       headers.set("Content-Range", `bytes ${start}-${end}/${total}`);
     }
     await _fetch(new Request(url, {
-      ...init,
+      ...init2,
       method,
       headers,
       body: data.buffer instanceof ArrayBuffer ? data : Uint8Array.from(data)
@@ -15336,9 +15551,9 @@ async function set(url, data, options, init = {}) {
   }
   resource.add(data, offset);
 }
-async function remove(url, options = {}, init = {}) {
+async function remove(url, options = {}, init2 = {}) {
   if (!options.cacheOnly)
-    await _fetch(new Request(url, init), { method: "DELETE" }, true);
+    await _fetch(new Request(url, init2), { method: "DELETE" }, true);
   resourcesCache.delete(url);
 }
 
@@ -15564,20 +15779,20 @@ class FetchFS extends IndexFS {
   removeSync(path) {
     this._async(remove(this.baseUrl + path, { warn, cacheOnly: !this.remoteWrite }, this.requestInit));
   }
-  async read(path, buffer, offset = 0, end) {
+  async read(path, buffer2, offset = 0, end) {
     const inode = this.index.get(path);
     if (!inode)
       throw withErrno("ENOENT");
     if (end - offset == 0)
       return;
-    const data = await get(this.baseUrl + path, { start: offset, end, size: inode.size, warn }, this.requestInit).catch(parseError).catch(() => {
+    const data = await get2(this.baseUrl + path, { start: offset, end, size: inode.size, warn }, this.requestInit).catch(parseError).catch(() => {
       return;
     });
     if (!data)
       throw withErrno("ENODATA");
-    buffer.set(data);
+    buffer2.set(data);
   }
-  readSync(path, buffer, offset = 0, end) {
+  readSync(path, buffer2, offset = 0, end) {
     const inode = this.index.get(path);
     if (!inode)
       throw withErrno("ENOENT");
@@ -15587,24 +15802,24 @@ class FetchFS extends IndexFS {
     if (!data)
       throw withErrno("ENODATA");
     if (missing.length) {
-      this._async(get(this.baseUrl + path, { start: offset, end, size: inode.size, warn }));
+      this._async(get2(this.baseUrl + path, { start: offset, end, size: inode.size, warn }));
       throw withErrno("EAGAIN");
     }
-    buffer.set(data);
+    buffer2.set(data);
   }
   async write(path, data, offset) {
     const inode = this.index.get(path);
     if (!inode)
       throw withErrno("ENOENT");
     inode.update({ mtimeMs: Date.now(), size: Math.max(inode.size, data.byteLength + offset) });
-    await set(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError);
+    await set2(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError);
   }
   writeSync(path, data, offset) {
     const inode = this.index.get(path);
     if (!inode)
       throw withErrno("ENOENT");
     inode.update({ mtimeMs: Date.now(), size: Math.max(inode.size, data.byteLength + offset) });
-    this._async(set(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError));
+    this._async(set2(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError));
   }
 }
 // ../../node_modules/@zenfs/core/dist/backends/passthrough.js
@@ -15921,14 +16136,14 @@ function Async(FS) {
       this.checkSync();
       return this._sync.existsSync(path);
     }
-    readSync(path, buffer, offset, end) {
+    readSync(path, buffer2, offset, end) {
       this.checkSync();
-      this._sync.readSync(path, buffer, offset, end);
+      this._sync.readSync(path, buffer2, offset, end);
     }
-    writeSync(path, buffer, offset) {
+    writeSync(path, buffer2, offset) {
       this.checkSync();
-      this._sync.writeSync(path, buffer, offset);
-      this._async(() => this.write(path, buffer, offset));
+      this._sync.writeSync(path, buffer2, offset);
+      this._async(() => this.write(path, buffer2, offset));
     }
     streamWrite(path, options) {
       this.checkSync();
@@ -15951,9 +16166,9 @@ function Async(FS) {
       const stats = await this.stat(path);
       if (!isDirectory(stats)) {
         this._sync.createFileSync(path, stats);
-        const buffer = new Uint8Array(stats.size);
-        await this.read(path, buffer, 0, stats.size);
-        this._sync.writeSync(path, buffer, 0);
+        const buffer2 = new Uint8Array(stats.size);
+        await this.read(path, buffer2, 0, stats.size);
+        this._sync.writeSync(path, buffer2, 0);
         this._sync.touchSync(path, stats);
         return;
       }
@@ -16075,30 +16290,13 @@ class PortFS extends Async(FileSystem) {
   link(srcpath, dstpath) {
     return this.rpc("link", srcpath, dstpath);
   }
-  async read(path, buffer, start, end) {
-    buffer.set(await this.rpc("read", path, buffer, start, end));
+  async read(path, buffer2, start, end) {
+    buffer2.set(await this.rpc("read", path, buffer2, start, end));
   }
-  write(path, buffer, offset) {
-    return this.rpc("write", path, buffer, offset);
-  }
-}
-// ../../node_modules/utilium/dist/checksum.js
-var crc32cTable = new Uint32Array(256);
-for (let i2 = 0;i2 < 256; i2++) {
-  let value = i2;
-  for (let j = 0;j < 8; j++) {
-    value = value & 1 ? 2197175160 ^ value >>> 1 : value >>> 1;
-  }
-  crc32cTable[i2] = value;
-}
-function crc32c(data) {
-  let crc = 4294967295;
-  for (let i2 = 0;i2 < data.length; i2++) {
-    crc = crc >>> 8 ^ crc32cTable[(crc ^ data[i2]) & 255];
+  write(path, buffer2, offset) {
+    return this.rpc("write", path, buffer2, offset);
   }
-  return (crc ^ 4294967295) >>> 0;
 }
-
 // ../../node_modules/@zenfs/core/dist/backends/single_buffer.js
 var __esDecorate2 = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
   function accept(f) {
@@ -16196,7 +16394,7 @@ var { format: format2 } = new Intl.NumberFormat("en-US", {
 });
 var MetadataEntry = (() => {
   var _a, _b, _c, _d;
-  let _classDecorators = [struct.packed("MetadataEntry")];
+  let _classDecorators = [struct.packed()];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -16239,8 +16437,8 @@ var MetadataEntry = (() => {
       MetadataEntry2 = _classThis = _classDescriptor.value;
       if (_metadata)
         Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-      __runInitializers2(_classThis, _classExtraInitializers);
     }
+    static name = "MetadataEntry";
     #id_accessor_storage = __runInitializers2(this, _id_initializers, undefined);
     get id() {
       return this.#id_accessor_storage;
@@ -16276,6 +16474,9 @@ var MetadataEntry = (() => {
       super(...arguments);
       __runInitializers2(this, _size_extraInitializers);
     }
+    static {
+      __runInitializers2(_classThis, _classExtraInitializers);
+    }
   };
   return MetadataEntry2 = _classThis;
 })();
@@ -16283,7 +16484,7 @@ var entries_per_block = 255;
 var max_lock_attempts = 5;
 var MetadataBlock = (() => {
   var _a, _b, _c, _d;
-  let _classDecorators = [struct.packed("MetadataBlock")];
+  let _classDecorators = [struct.packed()];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -16312,7 +16513,7 @@ var MetadataBlock = (() => {
       _checksum_decorators = [(_a = types3).uint32.bind(_a)];
       _timestamp_decorators = [(_b = types3).uint64.bind(_b)];
       _previous_offset_decorators = [(_c = types3).uint32.bind(_c)];
-      _items_decorators = [field(array(MetadataEntry, entries_per_block))];
+      _items_decorators = [field(array2(MetadataEntry, entries_per_block))];
       _locked_decorators = [(_d = types3).int32.bind(_d)];
       __esDecorate2(this, null, _checksum_decorators, { kind: "accessor", name: "checksum", static: false, private: false, access: { has: (obj) => ("checksum" in obj), get: (obj) => obj.checksum, set: (obj, value) => {
         obj.checksum = value;
@@ -16334,7 +16535,8 @@ var MetadataBlock = (() => {
       if (_metadata)
         Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
     }
-    static lockIndex = offsetof(MetadataBlock2, "locked") / Int32Array.BYTES_PER_ELEMENT;
+    static name = "MetadataBlock";
+    static lockIndex;
     #checksum_accessor_storage = __runInitializers2(this, _checksum_initializers, undefined);
     get checksum() {
       return this.#checksum_accessor_storage;
@@ -16432,11 +16634,12 @@ var MetadataBlock = (() => {
   };
   return MetadataBlock2 = _classThis;
 })();
+Object.assign(MetadataBlock, { lockIndex: offsetof(MetadataBlock, "locked") / Int32Array.BYTES_PER_ELEMENT });
 var sb_magic = 1651715706;
 var usedBytes = 2;
 var SuperBlock = (() => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-  let _classDecorators = [struct.packed("Superblock")];
+  let _classDecorators = [struct.packed()];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -16542,8 +16745,8 @@ var SuperBlock = (() => {
       SuperBlock2 = _classThis = _classDescriptor.value;
       if (_metadata)
         Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-      __runInitializers2(_classThis, _classExtraInitializers);
     }
+    static name = "SuperBlock";
     constructor(...args) {
       super(...args);
       __runInitializers2(this, __padding_extraInitializers);
@@ -16565,11 +16768,11 @@ var SuperBlock = (() => {
         _update(md);
         return;
       }
-      if (this.checksum !== checksum(this))
+      if (this.checksum !== checksum2(this))
         throw crit(withErrno("EIO", "sbfs: checksum mismatch for super block"));
       this.metadata = new MetadataBlock(this.buffer, this.metadata_offset);
-      if (this.metadata.checksum !== checksum(this.metadata))
-        throw crit(withErrno("EIO", `sbfs: checksum mismatch for metadata block (saved ${hex(this.metadata.checksum)}, computed ${hex(checksum(this.metadata))})`));
+      if (this.metadata.checksum !== checksum2(this.metadata))
+        throw crit(withErrno("EIO", `sbfs: checksum mismatch for metadata block (saved ${hex(this.metadata.checksum)}, computed ${hex(checksum2(this.metadata))})`));
       if (this.inode_format != _inode_version)
         throw crit(withErrno("EIO", "sbfs: inode format mismatch"));
       if (this.metadata_block_size != sizeof(MetadataBlock))
@@ -16698,10 +16901,13 @@ var SuperBlock = (() => {
       }
       return true;
     }
+    static {
+      __runInitializers2(_classThis, _classExtraInitializers);
+    }
   };
   return SuperBlock2 = _classThis;
 })();
-function checksum(value) {
+function checksum2(value) {
   let length = sizeof(value) - 4;
   if (value instanceof MetadataBlock)
     length -= Int32Array.BYTES_PER_ELEMENT;
@@ -16710,7 +16916,7 @@ function checksum(value) {
 function _update(value) {
   if (value instanceof MetadataBlock)
     value.timestamp = BigInt(Date.now());
-  value.checksum = checksum(value);
+  value.checksum = checksum2(value);
 }
 // ../../node_modules/@zenfs/core/dist/node/async.js
 init_buffer();
@@ -16728,9 +16934,9 @@ function rename4(oldPath, newPath, cb = nop) {
 function exists2(path, cb = nop) {
   exists.call(this, path).then(cb).catch(() => cb(false));
 }
-function stat2(path, options, callback = nop) {
+function stat4(path, options, callback = nop) {
   callback = typeof options == "function" ? options : callback;
-  stat.call(this, path, typeof options != "function" ? options : {}).then((stats) => callback(null, stats)).catch(callback);
+  stat3.call(this, path, typeof options != "function" ? options : {}).then((stats) => callback(null, stats)).catch(callback);
 }
 function lstat2(path, options, callback = nop) {
   callback = typeof options == "function" ? options : callback;
@@ -16784,7 +16990,7 @@ function fdatasync(fd, cb = nop) {
   new FileHandle(this, fd).datasync().then(() => cb(null)).catch(cb);
 }
 function write2(fd, data, cbPosOff, cbLenEnc, cbPosEnc, cb = nop) {
-  let buffer, offset, length, position, encoding;
+  let buffer2, offset, length, position, encoding;
   const handle = new FileHandle(this, fd);
   if (typeof data === "string") {
     encoding = "utf8";
@@ -16802,22 +17008,22 @@ function write2(fd, data, cbPosOff, cbLenEnc, cbPosEnc, cb = nop) {
         cb(withErrno("EINVAL"));
         return;
     }
-    buffer = Buffer.from(data);
+    buffer2 = Buffer.from(data);
     offset = 0;
-    length = buffer.length;
+    length = buffer2.length;
     const _cb = cb;
-    handle.write(buffer, offset, length, position).then(({ bytesWritten }) => _cb(null, bytesWritten, buffer.toString(encoding))).catch(_cb);
+    handle.write(buffer2, offset, length, position).then(({ bytesWritten }) => _cb(null, bytesWritten, buffer2.toString(encoding))).catch(_cb);
   } else {
-    buffer = Buffer.from(data.buffer);
+    buffer2 = Buffer.from(data.buffer);
     offset = cbPosOff;
     length = cbLenEnc;
     position = typeof cbPosEnc === "number" ? cbPosEnc : null;
     const _cb = typeof cbPosEnc === "function" ? cbPosEnc : cb;
-    handle.write(buffer, offset, length, position).then(({ bytesWritten }) => _cb(null, bytesWritten, buffer)).catch(_cb);
+    handle.write(buffer2, offset, length, position).then(({ bytesWritten }) => _cb(null, bytesWritten, buffer2)).catch(_cb);
   }
 }
-function read2(fd, buffer, offset, length, position, cb = nop) {
-  new FileHandle(this, fd).read(buffer, offset, length, position).then(({ bytesRead, buffer: buffer2 }) => cb(null, bytesRead, buffer2)).catch(cb);
+function read2(fd, buffer2, offset, length, position, cb = nop) {
+  new FileHandle(this, fd).read(buffer2, offset, length, position).then(({ bytesRead, buffer: buffer3 }) => cb(null, bytesRead, buffer3)).catch(cb);
 }
 function fchown(fd, uid, gid, cb = nop) {
   new FileHandle(this, fd).chown(uid, gid).then(() => cb(null)).catch(cb);
@@ -16971,9 +17177,9 @@ function statfs2(path, options, callback = nop) {
 }
 async function openAsBlob(path, options) {
   const handle = await open3.call(this, path.toString(), "r");
-  const buffer = await handle.readFile();
+  const buffer2 = await handle.readFile();
   await handle.close();
-  return new Blob([buffer], options);
+  return new Blob([buffer2], options);
 }
 function glob2(pattern2, options, callback = nop) {
   callback = typeof options == "function" ? options : callback;
@@ -16985,20 +17191,20 @@ init_buffer();
 var exports_xattr = {};
 __export(exports_xattr, {
   setSync: () => setSync,
-  set: () => set2,
+  set: () => set3,
   removeSync: () => removeSync,
   remove: () => remove2,
   listSync: () => listSync,
   list: () => list2,
   getSync: () => getSync,
-  get: () => get2
+  get: () => get3
 });
 var _allowedRestrictedNames = [];
 function checkName($, name, path, syscall) {
   if (!name.startsWith("user.") && !_allowedRestrictedNames.includes(name))
     throw UV("ENOTSUP", syscall, path);
 }
-async function get2(path, name, opt = {}) {
+async function get3(path, name, opt = {}) {
   path = normalizePath(path);
   const { fs: fs2, path: resolved } = resolveMount(path, this);
   checkName(this, name, path, "xattr.get");
@@ -17009,8 +17215,8 @@ async function get2(path, name, opt = {}) {
   const value = inode.attributes.get(name);
   if (!value)
     throw UV("ENODATA", "xattr.get", path);
-  const buffer = Buffer.from(value);
-  return opt.encoding == "buffer" || !opt.encoding ? buffer : buffer.toString(opt.encoding);
+  const buffer2 = Buffer.from(value);
+  return opt.encoding == "buffer" || !opt.encoding ? buffer2 : buffer2.toString(opt.encoding);
 }
 function getSync(path, name, opt = {}) {
   path = normalizePath(path);
@@ -17028,10 +17234,10 @@ function getSync(path, name, opt = {}) {
   const value = inode.attributes.get(name);
   if (!value)
     throw UV("ENODATA", "xattr.get", path);
-  const buffer = Buffer.from(value);
-  return opt.encoding == "buffer" || !opt.encoding ? buffer : buffer.toString(opt.encoding);
+  const buffer2 = Buffer.from(value);
+  return opt.encoding == "buffer" || !opt.encoding ? buffer2 : buffer2.toString(opt.encoding);
 }
-async function set2(path, name, value, opt = {}) {
+async function set3(path, name, value, opt = {}) {
   path = normalizePath(path);
   const { fs: fs2, path: resolved } = resolveMount(path, this);
   checkName(this, name, path, "xattr.set");
@@ -17229,11 +17435,11 @@ function Sync(FS) {
     async sync() {
       return this.syncSync();
     }
-    async read(path, buffer, offset, end) {
-      return this.readSync(path, buffer, offset, end);
+    async read(path, buffer2, offset, end) {
+      return this.readSync(path, buffer2, offset, end);
     }
-    async write(path, buffer, offset) {
-      return this.writeSync(path, buffer, offset);
+    async write(path, buffer2, offset) {
+      return this.writeSync(path, buffer2, offset);
     }
   }
   return SyncFS;
@@ -17263,7 +17469,7 @@ __export(exports_compat, {
   statfsSync: () => statfsSync,
   statfs: () => statfs2,
   statSync: () => statSync,
-  stat: () => stat2,
+  stat: () => stat4,
   rmdirSync: () => rmdirSync,
   rmdir: () => rmdir2,
   rmSync: () => rmSync,
@@ -17428,7 +17634,7 @@ var XFlag;
 })(XFlag || (XFlag = {}));
 var fsxattr = (() => {
   var _a, _b, _c, _d, _e;
-  let _classDecorators = [struct("fsxattr")];
+  let _classDecorators = [struct()];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -17485,8 +17691,8 @@ var fsxattr = (() => {
       fsxattr2 = _classThis = _classDescriptor.value;
       if (_metadata)
         Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-      __runInitializers3(_classThis, _classExtraInitializers);
     }
+    static name = "fsxattr";
     #xflags_accessor_storage = __runInitializers3(this, _xflags_initializers, undefined);
     get xflags() {
       return this.#xflags_accessor_storage;
@@ -17543,6 +17749,9 @@ var fsxattr = (() => {
           this.xflags |= XFlag[name];
       }
     }
+    static {
+      __runInitializers3(_classThis, _classExtraInitializers);
+    }
   };
   return fsxattr2 = _classThis;
 })();
@@ -17689,7 +17898,7 @@ function ioctlSync(path, command, ...args) {
 // ../../node_modules/@zenfs/core/package.json
 var package_default = {
   name: "@zenfs/core",
-  version: "2.5.0",
+  version: "2.5.6",
   description: "A filesystem, anywhere",
   funding: {
     type: "individual",
@@ -17760,26 +17969,24 @@ var package_default = {
     prepublishOnly: "npm run build"
   },
   dependencies: {
-    "@types/node": "^24.1.0",
+    "@types/node": "^25.2.0",
     buffer: "^6.0.3",
     eventemitter3: "^5.0.1",
     kerium: "^1.3.4",
-    memium: "^0.3.10",
+    memium: "^0.4.0",
     "readable-stream": "^4.5.2",
-    utilium: "^2.5.0"
+    utilium: "^3.0.0"
   },
   devDependencies: {
-    "@eslint/js": "^9.8.0",
-    "@octokit/action": "^7.0.0",
-    "@types/eslint__js": "^8.42.3",
-    c8: "^10.1.2",
+    "@octokit/action": "^8.0.4",
+    c8: "^10.1.3",
     eslint: "^9.15.0",
-    globals: "^16.0.0",
+    globals: "^17.3.0",
     prettier: "^3.2.5",
     tsx: "^4.19.1",
-    typedoc: "^0.28.0",
-    typescript: "^5.7.2",
-    "typescript-eslint": "^8.16.0"
+    typedoc: "^0.28.18",
+    typescript: "^6.0.0",
+    "typescript-eslint": "^8.58.0"
   }
 };
 
@@ -17854,14 +18061,14 @@ function convertException(ex, path) {
 }
 
 // ../../node_modules/@zenfs/dom/dist/access.js
-function _isShared(buffer) {
-  return typeof buffer == "object" && buffer !== null && buffer.constructor.name == "SharedArrayBuffer";
-}
-function isResizable(buffer) {
-  if (buffer instanceof ArrayBuffer)
-    return buffer.resizable;
-  if (_isShared(buffer))
-    return buffer.growable;
+function _isShared(buffer2) {
+  return typeof buffer2 == "object" && buffer2 !== null && buffer2.constructor.name == "SharedArrayBuffer";
+}
+function isResizable(buffer2) {
+  if (buffer2 instanceof ArrayBuffer)
+    return buffer2.resizable;
+  if (_isShared(buffer2))
+    return buffer2.growable;
   return false;
 }
 function isKind(handle, kind) {
@@ -17949,7 +18156,7 @@ class WebAccessFS extends Async(IndexFS) {
   removeSync() {
     throw exports_log.crit(withErrno("ENOSYS"));
   }
-  async read(path, buffer, offset, end) {
+  async read(path, buffer2, offset, end) {
     if (end <= offset)
       return;
     const handle = await this.get("file", path);
@@ -17962,13 +18169,13 @@ class WebAccessFS extends Async(IndexFS) {
         `path: ${path}`
       ].join(`
 ` + " ".repeat(24))));
-    buffer.set(new Uint8Array(data, offset, end - offset));
+    buffer2.set(new Uint8Array(data, offset, end - offset));
   }
-  async write(path, buffer, offset) {
-    if (isResizable(buffer.buffer) || _isShared(buffer.buffer)) {
-      const newBuffer = new Uint8Array(new ArrayBuffer(buffer.byteLength), buffer.byteOffset, buffer.byteLength);
-      newBuffer.set(buffer);
-      buffer = newBuffer;
+  async write(path, buffer2, offset) {
+    if (isResizable(buffer2.buffer) || _isShared(buffer2.buffer)) {
+      const newBuffer = new Uint8Array(new ArrayBuffer(buffer2.byteLength), buffer2.byteOffset, buffer2.byteLength);
+      newBuffer.set(buffer2);
+      buffer2 = newBuffer;
     }
     const inode2 = this.index.get(path);
     if (!inode2)
@@ -17996,7 +18203,7 @@ class WebAccessFS extends Async(IndexFS) {
     } catch {
       await writable.write({ type: "seek", position: offset });
     }
-    await writable.write(buffer);
+    await writable.write(buffer2);
     await writable.close();
     const { size, lastModified } = await handle.getFile();
     inode2.update({ size, mtimeMs: lastModified });
@@ -18287,14 +18494,14 @@ class XMLFS extends Sync(FileSystem) {
     set_stats(node, metadata);
   }
   syncSync() {}
-  readSync(path, buffer, offset, end) {
+  readSync(path, buffer2, offset, end) {
     const node = this.get("read", path);
     const raw = encodeASCII(node.textContent.slice(offset, end));
-    buffer.set(raw);
+    buffer2.set(raw);
   }
-  writeSync(path, buffer, offset) {
+  writeSync(path, buffer2, offset) {
     const node = this.get("write", path);
-    const data = decodeASCII(buffer);
+    const data = decodeASCII(buffer2);
     const after = node.textContent.slice(offset + data.length);
     node.textContent = node.textContent.slice(0, offset) + data + after;
   }