@donezone/cli 0.1.49 → 0.1.51

package/dist/index.js

@@ -22578,256 +22578,588 @@ var require_fast_decode_uri_component = __commonJS((exports, module) => {
   module.exports = decodeURIComponent2;
 });
 
-// ../../node_modules/strtok3/lib/stream/Errors.js
-var defaultMessages = "End-Of-Stream", EndOfStreamError, AbortError;
-var init_Errors = __esm(() => {
-  EndOfStreamError = class EndOfStreamError extends Error {
-    constructor() {
-      super(defaultMessages);
-      this.name = "EndOfStreamError";
-    }
-  };
-  AbortError = class AbortError extends Error {
-    constructor(message = "The operation was aborted") {
-      super(message);
-      this.name = "AbortError";
-    }
-  };
+// ../../node_modules/ieee754/index.js
+var init_ieee754 = __esm(() => {
+  /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 });
 
-// ../../node_modules/strtok3/lib/stream/Deferred.js
-class Deferred {
-  constructor() {
-    this.resolve = () => null;
-    this.reject = () => null;
-    this.promise = new Promise((resolve3, reject) => {
-      this.reject = reject;
-      this.resolve = resolve3;
-    });
+// ../../node_modules/@borewit/text-codec/lib/index.js
+function utf8Decoder() {
+  if (typeof globalThis.TextDecoder === "undefined")
+    return;
+  return _utf8Decoder !== null && _utf8Decoder !== undefined ? _utf8Decoder : _utf8Decoder = new globalThis.TextDecoder("utf-8");
+}
+function textDecode(bytes2, encoding = "utf-8") {
+  switch (encoding.toLowerCase()) {
+    case "utf-8":
+    case "utf8": {
+      const dec = utf8Decoder();
+      return dec ? dec.decode(bytes2) : decodeUTF8(bytes2);
+    }
+    case "utf-16le":
+      return decodeUTF16LE(bytes2);
+    case "us-ascii":
+    case "ascii":
+      return decodeASCII(bytes2);
+    case "latin1":
+    case "iso-8859-1":
+      return decodeLatin1(bytes2);
+    case "windows-1252":
+      return decodeWindows1252(bytes2);
+    default:
+      throw new RangeError(`Encoding '${encoding}' not supported`);
   }
 }
-
-// ../../node_modules/strtok3/lib/stream/AbstractStreamReader.js
-class AbstractStreamReader {
-  constructor() {
-    this.endOfStream = false;
-    this.interrupted = false;
-    this.peekQueue = [];
+function flushChunk(parts, chunk) {
+  if (chunk.length === 0)
+    return;
+  parts.push(String.fromCharCode.apply(null, chunk));
+  chunk.length = 0;
+}
+function pushCodeUnit(parts, chunk, codeUnit) {
+  chunk.push(codeUnit);
+  if (chunk.length >= CHUNK)
+    flushChunk(parts, chunk);
+}
+function pushCodePoint(parts, chunk, cp) {
+  if (cp <= 65535) {
+    pushCodeUnit(parts, chunk, cp);
+    return;
   }
-  async peek(uint8Array, mayBeLess = false) {
-    const bytesRead = await this.read(uint8Array, mayBeLess);
-    this.peekQueue.push(uint8Array.subarray(0, bytesRead));
-    return bytesRead;
+  cp -= 65536;
+  pushCodeUnit(parts, chunk, 55296 + (cp >> 10));
+  pushCodeUnit(parts, chunk, 56320 + (cp & 1023));
+}
+function decodeUTF8(bytes2) {
+  const parts = [];
+  const chunk = [];
+  let i = 0;
+  if (bytes2.length >= 3 && bytes2[0] === 239 && bytes2[1] === 187 && bytes2[2] === 191) {
+    i = 3;
   }
-  async read(buffer, mayBeLess = false) {
-    if (buffer.length === 0) {
-      return 0;
-    }
-    let bytesRead = this.readFromPeekBuffer(buffer);
-    if (!this.endOfStream) {
-      bytesRead += await this.readRemainderFromStream(buffer.subarray(bytesRead), mayBeLess);
+  while (i < bytes2.length) {
+    const b1 = bytes2[i];
+    if (b1 <= 127) {
+      pushCodeUnit(parts, chunk, b1);
+      i++;
+      continue;
     }
-    if (bytesRead === 0 && !mayBeLess) {
-      throw new EndOfStreamError;
+    if (b1 < 194 || b1 > 244) {
+      pushCodeUnit(parts, chunk, REPLACEMENT);
+      i++;
+      continue;
     }
-    return bytesRead;
-  }
-  readFromPeekBuffer(buffer) {
-    let remaining = buffer.length;
-    let bytesRead = 0;
-    while (this.peekQueue.length > 0 && remaining > 0) {
-      const peekData = this.peekQueue.pop();
-      if (!peekData)
-        throw new Error("peekData should be defined");
-      const lenCopy = Math.min(peekData.length, remaining);
-      buffer.set(peekData.subarray(0, lenCopy), bytesRead);
-      bytesRead += lenCopy;
-      remaining -= lenCopy;
-      if (lenCopy < peekData.length) {
-        this.peekQueue.push(peekData.subarray(lenCopy));
+    if (b1 <= 223) {
+      if (i + 1 >= bytes2.length) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const b22 = bytes2[i + 1];
+      if ((b22 & 192) !== 128) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
       }
+      const cp2 = (b1 & 31) << 6 | b22 & 63;
+      pushCodeUnit(parts, chunk, cp2);
+      i += 2;
+      continue;
     }
-    return bytesRead;
-  }
-  async readRemainderFromStream(buffer, mayBeLess) {
-    let bytesRead = 0;
-    while (bytesRead < buffer.length && !this.endOfStream) {
-      if (this.interrupted) {
-        throw new AbortError;
+    if (b1 <= 239) {
+      if (i + 2 >= bytes2.length) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
       }
-      const chunkLen = await this.readFromStream(buffer.subarray(bytesRead), mayBeLess);
-      if (chunkLen === 0)
-        break;
-      bytesRead += chunkLen;
+      const b22 = bytes2[i + 1];
+      const b32 = bytes2[i + 2];
+      const valid2 = (b22 & 192) === 128 && (b32 & 192) === 128 && !(b1 === 224 && b22 < 160) && !(b1 === 237 && b22 >= 160);
+      if (!valid2) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const cp2 = (b1 & 15) << 12 | (b22 & 63) << 6 | b32 & 63;
+      pushCodeUnit(parts, chunk, cp2);
+      i += 3;
+      continue;
     }
-    if (!mayBeLess && bytesRead < buffer.length) {
-      throw new EndOfStreamError;
+    if (i + 3 >= bytes2.length) {
+      pushCodeUnit(parts, chunk, REPLACEMENT);
+      i++;
+      continue;
     }
-    return bytesRead;
+    const b2 = bytes2[i + 1];
+    const b3 = bytes2[i + 2];
+    const b4 = bytes2[i + 3];
+    const valid = (b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128 && !(b1 === 240 && b2 < 144) && !(b1 === 244 && b2 > 143);
+    if (!valid) {
+      pushCodeUnit(parts, chunk, REPLACEMENT);
+      i++;
+      continue;
+    }
+    const cp = (b1 & 7) << 18 | (b2 & 63) << 12 | (b3 & 63) << 6 | b4 & 63;
+    pushCodePoint(parts, chunk, cp);
+    i += 4;
   }
+  flushChunk(parts, chunk);
+  return parts.join("");
 }
-var init_AbstractStreamReader = __esm(() => {
-  init_Errors();
-});
-
-// ../../node_modules/strtok3/lib/stream/StreamReader.js
-var StreamReader;
-var init_StreamReader = __esm(() => {
-  init_Errors();
-  init_AbstractStreamReader();
-  StreamReader = class StreamReader extends AbstractStreamReader {
-    constructor(s) {
-      super();
-      this.s = s;
-      this.deferred = null;
-      if (!s.read || !s.once) {
-        throw new Error("Expected an instance of stream.Readable");
-      }
-      this.s.once("end", () => {
-        this.endOfStream = true;
-        if (this.deferred) {
-          this.deferred.resolve(0);
+function decodeUTF16LE(bytes2) {
+  const parts = [];
+  const chunk = [];
+  const len = bytes2.length;
+  let i = 0;
+  while (i + 1 < len) {
+    const u1 = bytes2[i] | bytes2[i + 1] << 8;
+    i += 2;
+    if (u1 >= 55296 && u1 <= 56319) {
+      if (i + 1 < len) {
+        const u2 = bytes2[i] | bytes2[i + 1] << 8;
+        if (u2 >= 56320 && u2 <= 57343) {
+          pushCodeUnit(parts, chunk, u1);
+          pushCodeUnit(parts, chunk, u2);
+          i += 2;
+        } else {
+          pushCodeUnit(parts, chunk, REPLACEMENT);
         }
-      });
-      this.s.once("error", (err) => this.reject(err));
-      this.s.once("close", () => this.abort());
-    }
-    async readFromStream(buffer, mayBeLess) {
-      if (buffer.length === 0)
-        return 0;
-      const readBuffer = this.s.read(buffer.length);
-      if (readBuffer) {
-        buffer.set(readBuffer);
-        return readBuffer.length;
+      } else {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
       }
-      const request = {
-        buffer,
-        mayBeLess,
-        deferred: new Deferred
-      };
-      this.deferred = request.deferred;
-      this.s.once("readable", () => {
-        this.readDeferred(request);
-      });
-      return request.deferred.promise;
+      continue;
     }
-    readDeferred(request) {
-      const readBuffer = this.s.read(request.buffer.length);
-      if (readBuffer) {
-        request.buffer.set(readBuffer);
-        request.deferred.resolve(readBuffer.length);
-        this.deferred = null;
-      } else {
-        this.s.once("readable", () => {
-          this.readDeferred(request);
-        });
-      }
+    if (u1 >= 56320 && u1 <= 57343) {
+      pushCodeUnit(parts, chunk, REPLACEMENT);
+      continue;
     }
-    reject(err) {
-      this.interrupted = true;
-      if (this.deferred) {
-        this.deferred.reject(err);
-        this.deferred = null;
-      }
+    pushCodeUnit(parts, chunk, u1);
+  }
+  if (i < len) {
+    pushCodeUnit(parts, chunk, REPLACEMENT);
+  }
+  flushChunk(parts, chunk);
+  return parts.join("");
+}
+function decodeASCII(bytes2) {
+  const parts = [];
+  for (let i = 0;i < bytes2.length; i += CHUNK) {
+    const end = Math.min(bytes2.length, i + CHUNK);
+    const codes = new Array(end - i);
+    for (let j = i, k = 0;j < end; j++, k++) {
+      codes[k] = bytes2[j] & 127;
     }
-    async abort() {
-      this.reject(new AbortError);
+    parts.push(String.fromCharCode.apply(null, codes));
+  }
+  return parts.join("");
+}
+function decodeLatin1(bytes2) {
+  const parts = [];
+  for (let i = 0;i < bytes2.length; i += CHUNK) {
+    const end = Math.min(bytes2.length, i + CHUNK);
+    const codes = new Array(end - i);
+    for (let j = i, k = 0;j < end; j++, k++) {
+      codes[k] = bytes2[j];
     }
-    async close() {
-      return this.abort();
+    parts.push(String.fromCharCode.apply(null, codes));
+  }
+  return parts.join("");
+}
+function decodeWindows1252(bytes2) {
+  const parts = [];
+  let out = "";
+  for (let i = 0;i < bytes2.length; i++) {
+    const b = bytes2[i];
+    const extra = b >= 128 && b <= 159 ? WINDOWS_1252_EXTRA[b] : undefined;
+    out += extra !== null && extra !== undefined ? extra : String.fromCharCode(b);
+    if (out.length >= CHUNK) {
+      parts.push(out);
+      out = "";
     }
+  }
+  if (out)
+    parts.push(out);
+  return parts.join("");
+}
+var WINDOWS_1252_EXTRA, WINDOWS_1252_REVERSE, _utf8Decoder, CHUNK, REPLACEMENT = 65533;
+var init_lib = __esm(() => {
+  WINDOWS_1252_EXTRA = {
+    128: "\u20AC",
+    130: "\u201A",
+    131: "\u0192",
+    132: "\u201E",
+    133: "\u2026",
+    134: "\u2020",
+    135: "\u2021",
+    136: "\u02C6",
+    137: "\u2030",
+    138: "\u0160",
+    139: "\u2039",
+    140: "\u0152",
+    142: "\u017D",
+    145: "\u2018",
+    146: "\u2019",
+    147: "\u201C",
+    148: "\u201D",
+    149: "\u2022",
+    150: "\u2013",
+    151: "\u2014",
+    152: "\u02DC",
+    153: "\u2122",
+    154: "\u0161",
+    155: "\u203A",
+    156: "\u0153",
+    158: "\u017E",
+    159: "\u0178"
   };
+  WINDOWS_1252_REVERSE = {};
+  for (const [code, char] of Object.entries(WINDOWS_1252_EXTRA)) {
+    WINDOWS_1252_REVERSE[char] = Number.parseInt(code, 10);
+  }
+  CHUNK = 32 * 1024;
 });
 
-// ../../node_modules/strtok3/lib/stream/WebStreamReader.js
-var WebStreamReader;
-var init_WebStreamReader = __esm(() => {
-  init_AbstractStreamReader();
-  WebStreamReader = class WebStreamReader extends AbstractStreamReader {
-    constructor(reader) {
-      super();
-      this.reader = reader;
-    }
-    async abort() {
-      return this.close();
-    }
-    async close() {
-      this.reader.releaseLock();
+// ../../node_modules/token-types/lib/index.js
+function dv(array) {
+  return new DataView(array.buffer, array.byteOffset);
+}
+
+class StringType2 {
+  constructor(len, encoding) {
+    this.len = len;
+    this.encoding = encoding;
+  }
+  get(data, offset = 0) {
+    const bytes2 = data.subarray(offset, offset + this.len);
+    return textDecode(bytes2, this.encoding);
+  }
+}
+var UINT8, UINT16_LE, UINT16_BE, UINT32_LE, UINT32_BE, INT32_BE, UINT64_LE;
+var init_lib2 = __esm(() => {
+  init_ieee754();
+  init_lib();
+  UINT8 = {
+    len: 1,
+    get(array, offset) {
+      return dv(array).getUint8(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setUint8(offset, value);
+      return offset + 1;
     }
   };
-});
-
-// ../../node_modules/strtok3/lib/stream/WebStreamByobReader.js
-var WebStreamByobReader;
-var init_WebStreamByobReader = __esm(() => {
-  init_WebStreamReader();
-  WebStreamByobReader = class WebStreamByobReader extends WebStreamReader {
-    async readFromStream(buffer, mayBeLess) {
-      if (buffer.length === 0)
-        return 0;
-      const result = await this.reader.read(new Uint8Array(buffer.length), { min: mayBeLess ? undefined : buffer.length });
-      if (result.done) {
-        this.endOfStream = result.done;
-      }
-      if (result.value) {
-        buffer.set(result.value);
-        return result.value.length;
-      }
-      return 0;
+  UINT16_LE = {
+    len: 2,
+    get(array, offset) {
+      return dv(array).getUint16(offset, true);
+    },
+    put(array, offset, value) {
+      dv(array).setUint16(offset, value, true);
+      return offset + 2;
     }
   };
-});
-
-// ../../node_modules/strtok3/lib/stream/WebStreamDefaultReader.js
-var WebStreamDefaultReader;
-var init_WebStreamDefaultReader = __esm(() => {
-  init_Errors();
-  init_AbstractStreamReader();
-  WebStreamDefaultReader = class WebStreamDefaultReader extends AbstractStreamReader {
-    constructor(reader) {
-      super();
-      this.reader = reader;
-      this.buffer = null;
+  UINT16_BE = {
+    len: 2,
+    get(array, offset) {
+      return dv(array).getUint16(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setUint16(offset, value);
+      return offset + 2;
     }
-    writeChunk(target, chunk) {
-      const written = Math.min(chunk.length, target.length);
-      target.set(chunk.subarray(0, written));
-      if (written < chunk.length) {
-        this.buffer = chunk.subarray(written);
-      } else {
-        this.buffer = null;
-      }
-      return written;
+  };
+  UINT32_LE = {
+    len: 4,
+    get(array, offset) {
+      return dv(array).getUint32(offset, true);
+    },
+    put(array, offset, value) {
+      dv(array).setUint32(offset, value, true);
+      return offset + 4;
     }
-    async readFromStream(buffer, mayBeLess) {
-      if (buffer.length === 0)
-        return 0;
-      let totalBytesRead = 0;
-      if (this.buffer) {
-        totalBytesRead += this.writeChunk(buffer, this.buffer);
-      }
-      while (totalBytesRead < buffer.length && !this.endOfStream) {
-        const result = await this.reader.read();
-        if (result.done) {
-          this.endOfStream = true;
-          break;
-        }
-        if (result.value) {
-          totalBytesRead += this.writeChunk(buffer.subarray(totalBytesRead), result.value);
-        }
-      }
-      if (!mayBeLess && totalBytesRead === 0 && this.endOfStream) {
-        throw new EndOfStreamError;
-      }
-      return totalBytesRead;
+  };
+  UINT32_BE = {
+    len: 4,
+    get(array, offset) {
+      return dv(array).getUint32(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setUint32(offset, value);
+      return offset + 4;
     }
-    abort() {
-      this.interrupted = true;
-      return this.reader.cancel();
+  };
+  INT32_BE = {
+    len: 4,
+    get(array, offset) {
+      return dv(array).getInt32(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setInt32(offset, value);
+      return offset + 4;
     }
-    async close() {
-      await this.abort();
-      this.reader.releaseLock();
+  };
+  UINT64_LE = {
+    len: 8,
+    get(array, offset) {
+      return dv(array).getBigUint64(offset, true);
+    },
+    put(array, offset, value) {
+      dv(array).setBigUint64(offset, value, true);
+      return offset + 8;
+    }
+  };
+});
+
+// ../../node_modules/strtok3/lib/stream/Errors.js
+var defaultMessages = "End-Of-Stream", EndOfStreamError, AbortError;
+var init_Errors = __esm(() => {
+  EndOfStreamError = class EndOfStreamError extends Error {
+    constructor() {
+      super(defaultMessages);
+      this.name = "EndOfStreamError";
+    }
+  };
+  AbortError = class AbortError extends Error {
+    constructor(message = "The operation was aborted") {
+      super(message);
+      this.name = "AbortError";
+    }
+  };
+});
+
+// ../../node_modules/strtok3/lib/stream/Deferred.js
+class Deferred {
+  constructor() {
+    this.resolve = () => null;
+    this.reject = () => null;
+    this.promise = new Promise((resolve3, reject) => {
+      this.reject = reject;
+      this.resolve = resolve3;
+    });
+  }
+}
+
+// ../../node_modules/strtok3/lib/stream/AbstractStreamReader.js
+class AbstractStreamReader {
+  constructor() {
+    this.endOfStream = false;
+    this.interrupted = false;
+    this.peekQueue = [];
+  }
+  async peek(uint8Array, mayBeLess = false) {
+    const bytesRead = await this.read(uint8Array, mayBeLess);
+    this.peekQueue.push(uint8Array.subarray(0, bytesRead));
+    return bytesRead;
+  }
+  async read(buffer, mayBeLess = false) {
+    if (buffer.length === 0) {
+      return 0;
+    }
+    let bytesRead = this.readFromPeekBuffer(buffer);
+    if (!this.endOfStream) {
+      bytesRead += await this.readRemainderFromStream(buffer.subarray(bytesRead), mayBeLess);
+    }
+    if (bytesRead === 0 && !mayBeLess) {
+      throw new EndOfStreamError;
+    }
+    return bytesRead;
+  }
+  readFromPeekBuffer(buffer) {
+    let remaining = buffer.length;
+    let bytesRead = 0;
+    while (this.peekQueue.length > 0 && remaining > 0) {
+      const peekData = this.peekQueue.pop();
+      if (!peekData)
+        throw new Error("peekData should be defined");
+      const lenCopy = Math.min(peekData.length, remaining);
+      buffer.set(peekData.subarray(0, lenCopy), bytesRead);
+      bytesRead += lenCopy;
+      remaining -= lenCopy;
+      if (lenCopy < peekData.length) {
+        this.peekQueue.push(peekData.subarray(lenCopy));
+      }
+    }
+    return bytesRead;
+  }
+  async readRemainderFromStream(buffer, mayBeLess) {
+    let bytesRead = 0;
+    while (bytesRead < buffer.length && !this.endOfStream) {
+      if (this.interrupted) {
+        throw new AbortError;
+      }
+      const chunkLen = await this.readFromStream(buffer.subarray(bytesRead), mayBeLess);
+      if (chunkLen === 0)
+        break;
+      bytesRead += chunkLen;
+    }
+    if (!mayBeLess && bytesRead < buffer.length) {
+      throw new EndOfStreamError;
+    }
+    return bytesRead;
+  }
+}
+var init_AbstractStreamReader = __esm(() => {
+  init_Errors();
+});
+
+// ../../node_modules/strtok3/lib/stream/StreamReader.js
+var StreamReader;
+var init_StreamReader = __esm(() => {
+  init_Errors();
+  init_AbstractStreamReader();
+  StreamReader = class StreamReader extends AbstractStreamReader {
+    constructor(s) {
+      super();
+      this.s = s;
+      this.deferred = null;
+      if (!s.read || !s.once) {
+        throw new Error("Expected an instance of stream.Readable");
+      }
+      this.s.once("end", () => {
+        this.endOfStream = true;
+        if (this.deferred) {
+          this.deferred.resolve(0);
+        }
+      });
+      this.s.once("error", (err) => this.reject(err));
+      this.s.once("close", () => this.abort());
+    }
+    async readFromStream(buffer, mayBeLess) {
+      if (buffer.length === 0)
+        return 0;
+      const readBuffer = this.s.read(buffer.length);
+      if (readBuffer) {
+        buffer.set(readBuffer);
+        return readBuffer.length;
+      }
+      const request = {
+        buffer,
+        mayBeLess,
+        deferred: new Deferred
+      };
+      this.deferred = request.deferred;
+      this.s.once("readable", () => {
+        this.readDeferred(request);
+      });
+      return request.deferred.promise;
+    }
+    readDeferred(request) {
+      const readBuffer = this.s.read(request.buffer.length);
+      if (readBuffer) {
+        request.buffer.set(readBuffer);
+        request.deferred.resolve(readBuffer.length);
+        this.deferred = null;
+      } else {
+        this.s.once("readable", () => {
+          this.readDeferred(request);
+        });
+      }
+    }
+    reject(err) {
+      this.interrupted = true;
+      if (this.deferred) {
+        this.deferred.reject(err);
+        this.deferred = null;
+      }
+    }
+    async abort() {
+      this.reject(new AbortError);
+    }
+    async close() {
+      return this.abort();
+    }
+  };
+});
+
+// ../../node_modules/strtok3/lib/stream/WebStreamReader.js
+var WebStreamReader;
+var init_WebStreamReader = __esm(() => {
+  init_AbstractStreamReader();
+  WebStreamReader = class WebStreamReader extends AbstractStreamReader {
+    constructor(reader) {
+      super();
+      this.reader = reader;
+    }
+    async abort() {
+      return this.close();
+    }
+    async close() {
+      this.reader.releaseLock();
+    }
+  };
+});
+
+// ../../node_modules/strtok3/lib/stream/WebStreamByobReader.js
+var WebStreamByobReader;
+var init_WebStreamByobReader = __esm(() => {
+  init_WebStreamReader();
+  WebStreamByobReader = class WebStreamByobReader extends WebStreamReader {
+    async readFromStream(buffer, mayBeLess) {
+      if (buffer.length === 0)
+        return 0;
+      const result = await this.reader.read(new Uint8Array(buffer.length), { min: mayBeLess ? undefined : buffer.length });
+      if (result.done) {
+        this.endOfStream = result.done;
+      }
+      if (result.value) {
+        buffer.set(result.value);
+        return result.value.length;
+      }
+      return 0;
+    }
+  };
+});
+
+// ../../node_modules/strtok3/lib/stream/WebStreamDefaultReader.js
+var WebStreamDefaultReader;
+var init_WebStreamDefaultReader = __esm(() => {
+  init_Errors();
+  init_AbstractStreamReader();
+  WebStreamDefaultReader = class WebStreamDefaultReader extends AbstractStreamReader {
+    constructor(reader) {
+      super();
+      this.reader = reader;
+      this.buffer = null;
+    }
+    writeChunk(target, chunk) {
+      const written = Math.min(chunk.length, target.length);
+      target.set(chunk.subarray(0, written));
+      if (written < chunk.length) {
+        this.buffer = chunk.subarray(written);
+      } else {
+        this.buffer = null;
+      }
+      return written;
+    }
+    async readFromStream(buffer, mayBeLess) {
+      if (buffer.length === 0)
+        return 0;
+      let totalBytesRead = 0;
+      if (this.buffer) {
+        totalBytesRead += this.writeChunk(buffer, this.buffer);
+      }
+      while (totalBytesRead < buffer.length && !this.endOfStream) {
+        const result = await this.reader.read();
+        if (result.done) {
+          this.endOfStream = true;
+          break;
+        }
+        if (result.value) {
+          totalBytesRead += this.writeChunk(buffer.subarray(totalBytesRead), result.value);
+        }
+      }
+      if (!mayBeLess && totalBytesRead === 0 && this.endOfStream) {
+        throw new EndOfStreamError;
+      }
+      return totalBytesRead;
+    }
+    abort() {
+      this.interrupted = true;
+      return this.reader.cancel();
+    }
+    async close() {
+      await this.abort();
+      this.reader.releaseLock();
     }
   };
 });
@@ -23150,495 +23482,93 @@ var init_core = __esm(() => {
   init_AbstractTokenizer();
 });
 
-// ../../node_modules/strtok3/lib/FileTokenizer.js
-import { open as fsOpen } from "node:fs/promises";
-var FileTokenizer;
-var init_FileTokenizer = __esm(() => {
-  init_AbstractTokenizer();
-  init_stream();
-  FileTokenizer = class FileTokenizer extends AbstractTokenizer {
-    static async fromFile(sourceFilePath) {
-      const fileHandle = await fsOpen(sourceFilePath, "r");
-      const stat2 = await fileHandle.stat();
-      return new FileTokenizer(fileHandle, { fileInfo: { path: sourceFilePath, size: stat2.size } });
-    }
-    constructor(fileHandle, options) {
-      super(options);
-      this.fileHandle = fileHandle;
-      this.fileInfo = options.fileInfo;
+// ../../node_modules/ms/index.js
+var require_ms = __commonJS((exports, module) => {
+  function parse2(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
     }
-    async readBuffer(uint8Array, options) {
-      const normOptions = this.normalizeOptions(uint8Array, options);
-      this.position = normOptions.position;
-      if (normOptions.length === 0)
-        return 0;
-      const res = await this.fileHandle.read(uint8Array, 0, normOptions.length, normOptions.position);
-      this.position += res.bytesRead;
-      if (res.bytesRead < normOptions.length && (!options || !options.mayBeLess)) {
-        throw new EndOfStreamError;
-      }
-      return res.bytesRead;
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+    if (!match) {
+      return;
     }
-    async peekBuffer(uint8Array, options) {
-      const normOptions = this.normalizeOptions(uint8Array, options);
-      const res = await this.fileHandle.read(uint8Array, 0, normOptions.length, normOptions.position);
-      if (!normOptions.mayBeLess && res.bytesRead < normOptions.length) {
-        throw new EndOfStreamError;
-      }
-      return res.bytesRead;
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return;
     }
-    async close() {
-      await this.fileHandle.close();
-      return super.close();
+  }
+  function fmtShort(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return Math.round(ms / d) + "d";
     }
-    setPosition(position) {
-      this.position = position;
+    if (msAbs >= h) {
+      return Math.round(ms / h) + "h";
     }
-    supportsRandomAccess() {
-      return true;
+    if (msAbs >= m) {
+      return Math.round(ms / m) + "m";
     }
-  };
-});
-
-// ../../node_modules/strtok3/lib/index.js
-import { stat as fsStat } from "node:fs/promises";
-async function fromStream2(stream, options) {
-  const rst = fromStream(stream, options);
-  if (stream.path) {
-    const stat2 = await fsStat(stream.path);
-    rst.fileInfo.path = stream.path;
-    rst.fileInfo.size = stat2.size;
-  }
-  return rst;
-}
-var fromFile;
-var init_lib = __esm(() => {
-  init_core();
-  init_FileTokenizer();
-  init_FileTokenizer();
-  init_core();
-  fromFile = FileTokenizer.fromFile;
-});
-
-// ../../node_modules/ieee754/index.js
-var init_ieee754 = __esm(() => {
-  /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
-});
-
-// ../../node_modules/@borewit/text-codec/lib/index.js
-function utf8Decoder() {
-  if (typeof globalThis.TextDecoder === "undefined")
-    return;
-  return _utf8Decoder !== null && _utf8Decoder !== undefined ? _utf8Decoder : _utf8Decoder = new globalThis.TextDecoder("utf-8");
-}
-function textDecode(bytes2, encoding = "utf-8") {
-  switch (encoding.toLowerCase()) {
-    case "utf-8":
-    case "utf8": {
-      const dec = utf8Decoder();
-      return dec ? dec.decode(bytes2) : decodeUTF8(bytes2);
+    if (msAbs >= s) {
+      return Math.round(ms / s) + "s";
     }
-    case "utf-16le":
-      return decodeUTF16LE(bytes2);
-    case "us-ascii":
-    case "ascii":
-      return decodeASCII(bytes2);
-    case "latin1":
-    case "iso-8859-1":
-      return decodeLatin1(bytes2);
-    case "windows-1252":
-      return decodeWindows1252(bytes2);
-    default:
-      throw new RangeError(`Encoding '${encoding}' not supported`);
-  }
-}
-function flushChunk(parts, chunk) {
-  if (chunk.length === 0)
-    return;
-  parts.push(String.fromCharCode.apply(null, chunk));
-  chunk.length = 0;
-}
-function pushCodeUnit(parts, chunk, codeUnit) {
-  chunk.push(codeUnit);
-  if (chunk.length >= CHUNK)
-    flushChunk(parts, chunk);
-}
-function pushCodePoint(parts, chunk, cp) {
-  if (cp <= 65535) {
-    pushCodeUnit(parts, chunk, cp);
-    return;
-  }
-  cp -= 65536;
-  pushCodeUnit(parts, chunk, 55296 + (cp >> 10));
-  pushCodeUnit(parts, chunk, 56320 + (cp & 1023));
-}
-function decodeUTF8(bytes2) {
-  const parts = [];
-  const chunk = [];
-  let i = 0;
-  if (bytes2.length >= 3 && bytes2[0] === 239 && bytes2[1] === 187 && bytes2[2] === 191) {
-    i = 3;
+    return ms + "ms";
   }
-  while (i < bytes2.length) {
-    const b1 = bytes2[i];
-    if (b1 <= 127) {
-      pushCodeUnit(parts, chunk, b1);
-      i++;
-      continue;
-    }
-    if (b1 < 194 || b1 > 244) {
-      pushCodeUnit(parts, chunk, REPLACEMENT);
-      i++;
-      continue;
-    }
-    if (b1 <= 223) {
-      if (i + 1 >= bytes2.length) {
-        pushCodeUnit(parts, chunk, REPLACEMENT);
-        i++;
-        continue;
-      }
-      const b22 = bytes2[i + 1];
-      if ((b22 & 192) !== 128) {
-        pushCodeUnit(parts, chunk, REPLACEMENT);
-        i++;
-        continue;
-      }
-      const cp2 = (b1 & 31) << 6 | b22 & 63;
-      pushCodeUnit(parts, chunk, cp2);
-      i += 2;
-      continue;
+  function fmtLong(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return plural(ms, msAbs, d, "day");
     }
-    if (b1 <= 239) {
-      if (i + 2 >= bytes2.length) {
-        pushCodeUnit(parts, chunk, REPLACEMENT);
-        i++;
-        continue;
-      }
-      const b22 = bytes2[i + 1];
-      const b32 = bytes2[i + 2];
-      const valid2 = (b22 & 192) === 128 && (b32 & 192) === 128 && !(b1 === 224 && b22 < 160) && !(b1 === 237 && b22 >= 160);
-      if (!valid2) {
-        pushCodeUnit(parts, chunk, REPLACEMENT);
-        i++;
-        continue;
-      }
-      const cp2 = (b1 & 15) << 12 | (b22 & 63) << 6 | b32 & 63;
-      pushCodeUnit(parts, chunk, cp2);
-      i += 3;
-      continue;
+    if (msAbs >= h) {
+      return plural(ms, msAbs, h, "hour");
     }
-    if (i + 3 >= bytes2.length) {
-      pushCodeUnit(parts, chunk, REPLACEMENT);
-      i++;
-      continue;
+    if (msAbs >= m) {
+      return plural(ms, msAbs, m, "minute");
     }
-    const b2 = bytes2[i + 1];
-    const b3 = bytes2[i + 2];
-    const b4 = bytes2[i + 3];
-    const valid = (b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128 && !(b1 === 240 && b2 < 144) && !(b1 === 244 && b2 > 143);
-    if (!valid) {
-      pushCodeUnit(parts, chunk, REPLACEMENT);
-      i++;
-      continue;
+    if (msAbs >= s) {
+      return plural(ms, msAbs, s, "second");
     }
-    const cp = (b1 & 7) << 18 | (b2 & 63) << 12 | (b3 & 63) << 6 | b4 & 63;
-    pushCodePoint(parts, chunk, cp);
-    i += 4;
-  }
-  flushChunk(parts, chunk);
-  return parts.join("");
-}
-function decodeUTF16LE(bytes2) {
-  const parts = [];
-  const chunk = [];
-  const len = bytes2.length;
-  let i = 0;
-  while (i + 1 < len) {
-    const u1 = bytes2[i] | bytes2[i + 1] << 8;
-    i += 2;
-    if (u1 >= 55296 && u1 <= 56319) {
-      if (i + 1 < len) {
-        const u2 = bytes2[i] | bytes2[i + 1] << 8;
-        if (u2 >= 56320 && u2 <= 57343) {
-          pushCodeUnit(parts, chunk, u1);
-          pushCodeUnit(parts, chunk, u2);
-          i += 2;
-        } else {
-          pushCodeUnit(parts, chunk, REPLACEMENT);
-        }
-      } else {
-        pushCodeUnit(parts, chunk, REPLACEMENT);
-      }
-      continue;
-    }
-    if (u1 >= 56320 && u1 <= 57343) {
-      pushCodeUnit(parts, chunk, REPLACEMENT);
-      continue;
-    }
-    pushCodeUnit(parts, chunk, u1);
-  }
-  if (i < len) {
-    pushCodeUnit(parts, chunk, REPLACEMENT);
-  }
-  flushChunk(parts, chunk);
-  return parts.join("");
-}
-function decodeASCII(bytes2) {
-  const parts = [];
-  for (let i = 0;i < bytes2.length; i += CHUNK) {
-    const end = Math.min(bytes2.length, i + CHUNK);
-    const codes = new Array(end - i);
-    for (let j = i, k = 0;j < end; j++, k++) {
-      codes[k] = bytes2[j] & 127;
-    }
-    parts.push(String.fromCharCode.apply(null, codes));
-  }
-  return parts.join("");
-}
-function decodeLatin1(bytes2) {
-  const parts = [];
-  for (let i = 0;i < bytes2.length; i += CHUNK) {
-    const end = Math.min(bytes2.length, i + CHUNK);
-    const codes = new Array(end - i);
-    for (let j = i, k = 0;j < end; j++, k++) {
-      codes[k] = bytes2[j];
-    }
-    parts.push(String.fromCharCode.apply(null, codes));
-  }
-  return parts.join("");
-}
-function decodeWindows1252(bytes2) {
-  const parts = [];
-  let out = "";
-  for (let i = 0;i < bytes2.length; i++) {
-    const b = bytes2[i];
-    const extra = b >= 128 && b <= 159 ? WINDOWS_1252_EXTRA[b] : undefined;
-    out += extra !== null && extra !== undefined ? extra : String.fromCharCode(b);
-    if (out.length >= CHUNK) {
-      parts.push(out);
-      out = "";
-    }
-  }
-  if (out)
-    parts.push(out);
-  return parts.join("");
-}
-var WINDOWS_1252_EXTRA, WINDOWS_1252_REVERSE, _utf8Decoder, CHUNK, REPLACEMENT = 65533;
-var init_lib2 = __esm(() => {
-  WINDOWS_1252_EXTRA = {
-    128: "\u20AC",
-    130: "\u201A",
-    131: "\u0192",
-    132: "\u201E",
-    133: "\u2026",
-    134: "\u2020",
-    135: "\u2021",
-    136: "\u02C6",
-    137: "\u2030",
-    138: "\u0160",
-    139: "\u2039",
-    140: "\u0152",
-    142: "\u017D",
-    145: "\u2018",
-    146: "\u2019",
-    147: "\u201C",
-    148: "\u201D",
-    149: "\u2022",
-    150: "\u2013",
-    151: "\u2014",
-    152: "\u02DC",
-    153: "\u2122",
-    154: "\u0161",
-    155: "\u203A",
-    156: "\u0153",
-    158: "\u017E",
-    159: "\u0178"
-  };
-  WINDOWS_1252_REVERSE = {};
-  for (const [code, char] of Object.entries(WINDOWS_1252_EXTRA)) {
-    WINDOWS_1252_REVERSE[char] = Number.parseInt(code, 10);
-  }
-  CHUNK = 32 * 1024;
-});
-
-// ../../node_modules/token-types/lib/index.js
-function dv(array) {
-  return new DataView(array.buffer, array.byteOffset);
-}
-
-class StringType2 {
-  constructor(len, encoding) {
-    this.len = len;
-    this.encoding = encoding;
-  }
-  get(data, offset = 0) {
-    const bytes2 = data.subarray(offset, offset + this.len);
-    return textDecode(bytes2, this.encoding);
-  }
-}
-var UINT8, UINT16_LE, UINT16_BE, UINT32_LE, UINT32_BE, INT32_BE, UINT64_LE;
-var init_lib3 = __esm(() => {
-  init_ieee754();
-  init_lib2();
-  UINT8 = {
-    len: 1,
-    get(array, offset) {
-      return dv(array).getUint8(offset);
-    },
-    put(array, offset, value) {
-      dv(array).setUint8(offset, value);
-      return offset + 1;
-    }
-  };
-  UINT16_LE = {
-    len: 2,
-    get(array, offset) {
-      return dv(array).getUint16(offset, true);
-    },
-    put(array, offset, value) {
-      dv(array).setUint16(offset, value, true);
-      return offset + 2;
-    }
-  };
-  UINT16_BE = {
-    len: 2,
-    get(array, offset) {
-      return dv(array).getUint16(offset);
-    },
-    put(array, offset, value) {
-      dv(array).setUint16(offset, value);
-      return offset + 2;
-    }
-  };
-  UINT32_LE = {
-    len: 4,
-    get(array, offset) {
-      return dv(array).getUint32(offset, true);
-    },
-    put(array, offset, value) {
-      dv(array).setUint32(offset, value, true);
-      return offset + 4;
-    }
-  };
-  UINT32_BE = {
-    len: 4,
-    get(array, offset) {
-      return dv(array).getUint32(offset);
-    },
-    put(array, offset, value) {
-      dv(array).setUint32(offset, value);
-      return offset + 4;
-    }
-  };
-  INT32_BE = {
-    len: 4,
-    get(array, offset) {
-      return dv(array).getInt32(offset);
-    },
-    put(array, offset, value) {
-      dv(array).setInt32(offset, value);
-      return offset + 4;
-    }
-  };
-  UINT64_LE = {
-    len: 8,
-    get(array, offset) {
-      return dv(array).getBigUint64(offset, true);
-    },
-    put(array, offset, value) {
-      dv(array).setBigUint64(offset, value, true);
-      return offset + 8;
-    }
-  };
-});
-
-// ../../node_modules/ms/index.js
-var require_ms = __commonJS((exports, module) => {
-  function parse2(str) {
-    str = String(str);
-    if (str.length > 100) {
-      return;
-    }
-    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
-    if (!match) {
-      return;
-    }
-    var n = parseFloat(match[1]);
-    var type = (match[2] || "ms").toLowerCase();
-    switch (type) {
-      case "years":
-      case "year":
-      case "yrs":
-      case "yr":
-      case "y":
-        return n * y;
-      case "weeks":
-      case "week":
-      case "w":
-        return n * w;
-      case "days":
-      case "day":
-      case "d":
-        return n * d;
-      case "hours":
-      case "hour":
-      case "hrs":
-      case "hr":
-      case "h":
-        return n * h;
-      case "minutes":
-      case "minute":
-      case "mins":
-      case "min":
-      case "m":
-        return n * m;
-      case "seconds":
-      case "second":
-      case "secs":
-      case "sec":
-      case "s":
-        return n * s;
-      case "milliseconds":
-      case "millisecond":
-      case "msecs":
-      case "msec":
-      case "ms":
-        return n;
-      default:
-        return;
-    }
-  }
-  function fmtShort(ms) {
-    var msAbs = Math.abs(ms);
-    if (msAbs >= d) {
-      return Math.round(ms / d) + "d";
-    }
-    if (msAbs >= h) {
-      return Math.round(ms / h) + "h";
-    }
-    if (msAbs >= m) {
-      return Math.round(ms / m) + "m";
-    }
-    if (msAbs >= s) {
-      return Math.round(ms / s) + "s";
-    }
-    return ms + "ms";
-  }
-  function fmtLong(ms) {
-    var msAbs = Math.abs(ms);
-    if (msAbs >= d) {
-      return plural(ms, msAbs, d, "day");
-    }
-    if (msAbs >= h) {
-      return plural(ms, msAbs, h, "hour");
-    }
-    if (msAbs >= m) {
-      return plural(ms, msAbs, m, "minute");
-    }
-    if (msAbs >= s) {
-      return plural(ms, msAbs, s, "second");
-    }
-    return ms + " ms";
+    return ms + " ms";
   }
   function plural(ms, msAbs, n, name) {
     var isPlural = msAbs >= n * 1.5;
@@ -24182,7 +24112,7 @@ var require_src = __commonJS((exports, module) => {
 // ../../node_modules/@tokenizer/inflate/lib/ZipToken.js
 var Signature, DataDescriptor, LocalFileHeaderToken, EndOfCentralDirectoryRecordToken, FileHeader;
 var init_ZipToken = __esm(() => {
-  init_lib3();
+  init_lib2();
   Signature = {
     LocalFileHeader: 67324752,
     DataDescriptor: 134695760,
@@ -24459,7 +24389,7 @@ class ZipHandler {
 }
 var import_debug, debug, syncBufferSize, ddSignatureArray, eocdSignatureBytes;
 var init_ZipHandler = __esm(() => {
-  init_lib3();
+  init_lib2();
   import_debug = __toESM(require_src(), 1);
   init_ZipToken();
   debug = import_debug.default("tokenizer:inflate");
@@ -24490,11 +24420,42 @@ class GzipHandler {
 }
 
 // ../../node_modules/@tokenizer/inflate/lib/index.js
-var init_lib4 = __esm(() => {
+var init_lib3 = __esm(() => {
   init_ZipHandler();
 });
 
 // ../../node_modules/uint8array-extras/index.js
+function isType(value, typeConstructor, typeStringified) {
+  if (!value) {
+    return false;
+  }
+  if (value.constructor === typeConstructor) {
+    return true;
+  }
+  return objectToString.call(value) === typeStringified;
+}
+function isUint8Array(value) {
+  return isType(value, Uint8Array, uint8ArrayStringified);
+}
+function assertUint8Array(value) {
+  if (!isUint8Array(value)) {
+    throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``);
+  }
+}
+function concatUint8Arrays(arrays, totalLength) {
+  if (arrays.length === 0) {
+    return new Uint8Array(0);
+  }
+  totalLength ??= arrays.reduce((accumulator, currentValue) => accumulator + currentValue.length, 0);
+  const returnValue = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const array of arrays) {
+    assertUint8Array(array);
+    returnValue.set(array, offset);
+    offset += array.length;
+  }
+  return returnValue;
+}
 function getUintBE(view) {
   const { byteLength } = view;
   if (byteLength === 6) {
@@ -24516,8 +24477,9 @@ function getUintBE(view) {
     return view.getUint8(0);
   }
 }
-var cachedDecoders, cachedEncoder, byteToHexLookupTable;
+var objectToString, uint8ArrayStringified = "[object Uint8Array]", cachedDecoders, cachedEncoder, byteToHexLookupTable;
 var init_uint8array_extras = __esm(() => {
+  objectToString = Object.prototype.toString;
   cachedDecoders = {
     utf8: new globalThis.TextDecoder("utf8")
   };
@@ -24525,7 +24487,7 @@ var init_uint8array_extras = __esm(() => {
   byteToHexLookupTable = Array.from({ length: 256 }, (_, index) => index.toString(16).padStart(2, "0"));
 });
 
-// ../../node_modules/file-type/util.js
+// ../../node_modules/file-type/source/tokens.js
 function stringToBytes(string, encoding) {
   if (encoding === "utf-16le") {
     const bytes2 = [];
@@ -24546,7 +24508,7 @@ function stringToBytes(string, encoding) {
   return [...string].map((character) => character.charCodeAt(0));
 }
 function tarHeaderChecksumMatches(arrayBuffer, offset = 0) {
-  const readSum = Number.parseInt(new StringType2(6).get(arrayBuffer, 148).replace(/\0.*$/, "").trim(), 8);
+  const readSum = Number.parseInt(new StringType2(6).get(arrayBuffer, 148).replace(/\0.*$/v, "").trim(), 8);
   if (Number.isNaN(readSum)) {
     return false;
   }
@@ -24560,15 +24522,15 @@ function tarHeaderChecksumMatches(arrayBuffer, offset = 0) {
   return readSum === sum;
 }
 var uint32SyncSafeToken;
-var init_util = __esm(() => {
-  init_lib3();
+var init_tokens = __esm(() => {
+  init_lib2();
   uint32SyncSafeToken = {
-    get: (buffer, offset) => buffer[offset + 3] & 127 | buffer[offset + 2] << 7 | buffer[offset + 1] << 14 | buffer[offset] << 21,
+    get: (buffer, offset) => buffer[offset + 3] & 127 | (buffer[offset + 2] & 127) << 7 | (buffer[offset + 1] & 127) << 14 | (buffer[offset] & 127) << 21,
     len: 4
   };
 });
 
-// ../../node_modules/file-type/supported.js
+// ../../node_modules/file-type/source/supported.js
 var extensions, mimeTypes;
 var init_supported = __esm(() => {
   extensions = [
@@ -24751,7 +24713,10 @@ var init_supported = __esm(() => {
     "ppsx",
     "tar.gz",
     "reg",
-    "dat"
+    "dat",
+    "key",
+    "numbers",
+    "pages"
   ];
   mimeTypes = [
     "image/jpeg",
@@ -24834,7 +24799,7 @@ var init_supported = __esm(() => {
     "application/x-unix-archive",
     "application/x-rpm",
     "application/x-compress",
-    "application/x-lzip",
+    "application/lzip",
     "application/x-cfb",
     "application/x-mie",
     "application/mxf",
@@ -24863,8 +24828,8 @@ var init_supported = __esm(() => {
     "model/gltf-binary",
     "application/vnd.tcpdump.pcap",
     "audio/x-dsf",
-    "application/x.ms.shortcut",
-    "application/x.apple.alias",
+    "application/x-ms-shortcut",
+    "application/x-ft-apple.alias",
     "audio/x-voc",
     "audio/vnd.dolby.dd-raw",
     "audio/x-m4a",
@@ -24904,10 +24869,10 @@ var init_supported = __esm(() => {
     "application/x-ace-compressed",
     "application/avro",
     "application/vnd.iccprofile",
-    "application/x.autodesk.fbx",
+    "application/x-ft-fbx",
     "application/vnd.visio",
     "application/vnd.android.package-archive",
-    "application/vnd.google.draco",
+    "application/x-ft-draco",
     "application/x-lz4",
     "application/vnd.openxmlformats-officedocument.presentationml.template",
     "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
@@ -24928,168 +24893,953 @@ var init_supported = __esm(() => {
     "application/x-spss-sav",
     "application/x-ms-regedit",
     "application/x-ft-windows-registry-hive",
-    "application/x-jmp-data"
+    "application/x-jmp-data",
+    "application/vnd.apple.keynote",
+    "application/vnd.apple.numbers",
+    "application/vnd.apple.pages"
   ];
 });
 
-// ../../node_modules/file-type/core.js
-function patchWebByobTokenizerClose(tokenizer) {
-  const streamReader = tokenizer?.streamReader;
-  if (streamReader?.constructor?.name !== "WebStreamByobReader") {
-    return tokenizer;
+// ../../node_modules/file-type/source/parser.js
+function getSafeBound(value, maximum, reason) {
+  if (!Number.isFinite(value) || value < 0 || value > maximum) {
+    throw new ParserHardLimitError(`${reason} has invalid size ${value} (maximum ${maximum} bytes)`);
+  }
+  return value;
+}
+async function safeIgnore(tokenizer, length, { maximumLength = maximumUntrustedSkipSizeInBytes, reason = "skip" } = {}) {
+  const safeLength = getSafeBound(length, maximumLength, reason);
+  await tokenizer.ignore(safeLength);
+}
+async function safeReadBuffer(tokenizer, buffer, options, { maximumLength = buffer.length, reason = "read" } = {}) {
+  const length = options?.length ?? buffer.length;
+  const safeLength = getSafeBound(length, maximumLength, reason);
+  return tokenizer.readBuffer(buffer, {
+    ...options,
+    length: safeLength
+  });
+}
+function checkBytes(buffer, headers, options) {
+  options = {
+    offset: 0,
+    ...options
+  };
+  for (const [index, header] of headers.entries()) {
+    if (options.mask) {
+      if (header !== (options.mask[index] & buffer[index + options.offset])) {
+        return false;
+      }
+    } else if (header !== buffer[index + options.offset]) {
+      return false;
+    }
   }
-  const { reader } = streamReader;
-  const cancelAndRelease = async () => {
-    await reader.cancel();
+  return true;
+}
+function hasUnknownFileSize(tokenizer) {
+  const fileSize = tokenizer.fileInfo.size;
+  return !Number.isFinite(fileSize) || fileSize === Number.MAX_SAFE_INTEGER;
+}
+function hasExceededUnknownSizeScanBudget(tokenizer, startOffset, maximumBytes) {
+  return hasUnknownFileSize(tokenizer) && tokenizer.position - startOffset > maximumBytes;
+}
+var maximumUntrustedSkipSizeInBytes, ParserHardLimitError;
+var init_parser = __esm(() => {
+  maximumUntrustedSkipSizeInBytes = 16 * 1024 * 1024;
+  ParserHardLimitError = class ParserHardLimitError extends Error {
+  };
+});
+
+// ../../node_modules/file-type/source/detectors/zip.js
+async function decompressDeflateRawWithLimit(data, { maximumLength = maximumZipEntrySizeInBytes } = {}) {
+  const input = new ReadableStream({
+    start(controller) {
+      controller.enqueue(data);
+      controller.close();
+    }
+  });
+  const output2 = input.pipeThrough(new DecompressionStream("deflate-raw"));
+  const reader = output2.getReader();
+  const chunks = [];
+  let totalLength = 0;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      totalLength += value.length;
+      if (totalLength > maximumLength) {
+        await reader.cancel();
+        throw new Error(`ZIP entry decompressed data exceeds ${maximumLength} bytes`);
+      }
+      chunks.push(value);
+    }
+  } finally {
     reader.releaseLock();
+  }
+  const uncompressedData = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    uncompressedData.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return uncompressedData;
+}
+function mergeByteChunks(chunks, totalLength) {
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return merged;
+}
+function getMaximumZipBufferedReadLength(tokenizer) {
+  const fileSize = tokenizer.fileInfo.size;
+  const remainingBytes = Number.isFinite(fileSize) ? Math.max(0, fileSize - tokenizer.position) : Number.MAX_SAFE_INTEGER;
+  return Math.min(remainingBytes, maximumZipBufferedReadSizeInBytes);
+}
+function isRecoverableZipError(error) {
+  if (error instanceof EndOfStreamError) {
+    return true;
+  }
+  if (error instanceof ParserHardLimitError) {
+    return true;
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if (recoverableZipErrorMessages.has(error.message)) {
+    return true;
+  }
+  if (recoverableZipErrorCodes.has(error.code)) {
+    return true;
+  }
+  for (const prefix of recoverableZipErrorMessagePrefixes) {
+    if (error.message.startsWith(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
+function canReadZipEntryForDetection(zipHeader, maximumSize = maximumZipEntrySizeInBytes) {
+  const sizes = [zipHeader.compressedSize, zipHeader.uncompressedSize];
+  for (const size of sizes) {
+    if (!Number.isFinite(size) || size < 0 || size > maximumSize) {
+      return false;
+    }
+  }
+  return true;
+}
+function createIWorkZipDetectionState() {
+  return {
+    hasDocumentEntry: false,
+    hasMasterSlideEntry: false,
+    hasTablesEntry: false,
+    hasCalculationEngineEntry: false
   };
-  streamReader.close = cancelAndRelease;
-  streamReader.abort = async () => {
-    streamReader.interrupted = true;
-    await cancelAndRelease();
+}
+function updateIWorkZipDetectionStateFromFilename(iWorkState, filename) {
+  if (filename === "Index/Document.iwa") {
+    iWorkState.hasDocumentEntry = true;
+  }
+  if (filename.startsWith("Index/MasterSlide")) {
+    iWorkState.hasMasterSlideEntry = true;
+  }
+  if (filename.startsWith("Index/Tables/")) {
+    iWorkState.hasTablesEntry = true;
+  }
+  if (filename === "Index/CalculationEngine.iwa") {
+    iWorkState.hasCalculationEngineEntry = true;
+  }
+}
+function getIWorkFileTypeFromZipEntries(iWorkState) {
+  if (!iWorkState.hasDocumentEntry) {
+    return;
+  }
+  if (iWorkState.hasMasterSlideEntry) {
+    return { ext: "key", mime: "application/vnd.apple.keynote" };
+  }
+  if (iWorkState.hasTablesEntry) {
+    return { ext: "numbers", mime: "application/vnd.apple.numbers" };
+  }
+  return { ext: "pages", mime: "application/vnd.apple.pages" };
+}
+function getFileTypeFromMimeType(mimeType) {
+  mimeType = mimeType.toLowerCase();
+  switch (mimeType) {
+    case "application/epub+zip":
+      return { ext: "epub", mime: mimeType };
+    case "application/vnd.oasis.opendocument.text":
+      return { ext: "odt", mime: mimeType };
+    case "application/vnd.oasis.opendocument.text-template":
+      return { ext: "ott", mime: mimeType };
+    case "application/vnd.oasis.opendocument.spreadsheet":
+      return { ext: "ods", mime: mimeType };
+    case "application/vnd.oasis.opendocument.spreadsheet-template":
+      return { ext: "ots", mime: mimeType };
+    case "application/vnd.oasis.opendocument.presentation":
+      return { ext: "odp", mime: mimeType };
+    case "application/vnd.oasis.opendocument.presentation-template":
+      return { ext: "otp", mime: mimeType };
+    case "application/vnd.oasis.opendocument.graphics":
+      return { ext: "odg", mime: mimeType };
+    case "application/vnd.oasis.opendocument.graphics-template":
+      return { ext: "otg", mime: mimeType };
+    case "application/vnd.openxmlformats-officedocument.presentationml.slideshow":
+      return { ext: "ppsx", mime: mimeType };
+    case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+      return { ext: "xlsx", mime: mimeType };
+    case "application/vnd.ms-excel.sheet.macroenabled":
+      return { ext: "xlsm", mime: "application/vnd.ms-excel.sheet.macroenabled.12" };
+    case "application/vnd.openxmlformats-officedocument.spreadsheetml.template":
+      return { ext: "xltx", mime: mimeType };
+    case "application/vnd.ms-excel.template.macroenabled":
+      return { ext: "xltm", mime: "application/vnd.ms-excel.template.macroenabled.12" };
+    case "application/vnd.ms-powerpoint.slideshow.macroenabled":
+      return { ext: "ppsm", mime: "application/vnd.ms-powerpoint.slideshow.macroenabled.12" };
+    case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+      return { ext: "docx", mime: mimeType };
+    case "application/vnd.ms-word.document.macroenabled":
+      return { ext: "docm", mime: "application/vnd.ms-word.document.macroenabled.12" };
+    case "application/vnd.openxmlformats-officedocument.wordprocessingml.template":
+      return { ext: "dotx", mime: mimeType };
+    case "application/vnd.ms-word.template.macroenabledtemplate":
+      return { ext: "dotm", mime: "application/vnd.ms-word.template.macroenabled.12" };
+    case "application/vnd.openxmlformats-officedocument.presentationml.template":
+      return { ext: "potx", mime: mimeType };
+    case "application/vnd.ms-powerpoint.template.macroenabled":
+      return { ext: "potm", mime: "application/vnd.ms-powerpoint.template.macroenabled.12" };
+    case "application/vnd.openxmlformats-officedocument.presentationml.presentation":
+      return { ext: "pptx", mime: mimeType };
+    case "application/vnd.ms-powerpoint.presentation.macroenabled":
+      return { ext: "pptm", mime: "application/vnd.ms-powerpoint.presentation.macroenabled.12" };
+    case "application/vnd.ms-visio.drawing":
+      return { ext: "vsdx", mime: "application/vnd.visio" };
+    case "application/vnd.ms-package.3dmanufacturing-3dmodel+xml":
+      return { ext: "3mf", mime: "model/3mf" };
+    default:
+  }
+}
+function createOpenXmlZipDetectionState() {
+  return {
+    hasContentTypesEntry: false,
+    hasParsedContentTypesEntry: false,
+    isParsingContentTypes: false,
+    hasUnparseableContentTypes: false,
+    hasWordDirectory: false,
+    hasPresentationDirectory: false,
+    hasSpreadsheetDirectory: false,
+    hasThreeDimensionalModelEntry: false
   };
-  return tokenizer;
 }
-function getSafeBound(value, maximum, reason) {
-  if (!Number.isFinite(value) || value < 0 || value > maximum) {
-    throw new ParserHardLimitError(`${reason} has invalid size ${value} (maximum ${maximum} bytes)`);
+function updateOpenXmlZipDetectionStateFromFilename(openXmlState, filename) {
+  if (filename.startsWith("word/")) {
+    openXmlState.hasWordDirectory = true;
+  }
+  if (filename.startsWith("ppt/")) {
+    openXmlState.hasPresentationDirectory = true;
+  }
+  if (filename.startsWith("xl/")) {
+    openXmlState.hasSpreadsheetDirectory = true;
+  }
+  if (filename.startsWith("3D/") && filename.endsWith(".model")) {
+    openXmlState.hasThreeDimensionalModelEntry = true;
+  }
+}
+function getOpenXmlFileTypeFromDirectoryNames(openXmlState) {
+  if (openXmlState.hasWordDirectory) {
+    return {
+      ext: "docx",
+      mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    };
+  }
+  if (openXmlState.hasPresentationDirectory) {
+    return {
+      ext: "pptx",
+      mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    };
+  }
+  if (openXmlState.hasSpreadsheetDirectory) {
+    return {
+      ext: "xlsx",
+      mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    };
+  }
+  if (openXmlState.hasThreeDimensionalModelEntry) {
+    return {
+      ext: "3mf",
+      mime: "model/3mf"
+    };
   }
-  return value;
 }
-async function safeIgnore(tokenizer, length, { maximumLength = maximumUntrustedSkipSizeInBytes, reason = "skip" } = {}) {
-  const safeLength = getSafeBound(length, maximumLength, reason);
-  await tokenizer.ignore(safeLength);
+function getOpenXmlFileTypeFromZipEntries(openXmlState) {
+  if (!openXmlState.hasContentTypesEntry || openXmlState.hasUnparseableContentTypes || openXmlState.isParsingContentTypes || openXmlState.hasParsedContentTypesEntry) {
+    return;
+  }
+  return getOpenXmlFileTypeFromDirectoryNames(openXmlState);
 }
-async function safeReadBuffer(tokenizer, buffer, options, { maximumLength = buffer.length, reason = "read" } = {}) {
-  const length = options?.length ?? buffer.length;
-  const safeLength = getSafeBound(length, maximumLength, reason);
-  return tokenizer.readBuffer(buffer, {
-    ...options,
-    length: safeLength
-  });
+function getOpenXmlMimeTypeFromContentTypesXml(xmlContent) {
+  const endPosition = xmlContent.indexOf('.main+xml"');
+  if (endPosition === -1) {
+    const mimeType = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml";
+    if (xmlContent.includes(`ContentType="${mimeType}"`)) {
+      return mimeType;
+    }
+    return;
+  }
+  const truncatedContent = xmlContent.slice(0, endPosition);
+  const firstQuotePosition = truncatedContent.lastIndexOf('"');
+  return truncatedContent.slice(firstQuotePosition + 1);
 }
-async function decompressDeflateRawWithLimit(data, { maximumLength = maximumZipEntrySizeInBytes } = {}) {
-  const input = new ReadableStream({
-    start(controller) {
-      controller.enqueue(data);
-      controller.close();
+function findZipDataDescriptorOffset(buffer, bytesConsumed) {
+  if (buffer.length < zipDataDescriptorLengthInBytes) {
+    return -1;
+  }
+  const lastPossibleDescriptorOffset = buffer.length - zipDataDescriptorLengthInBytes;
+  for (let index = 0;index <= lastPossibleDescriptorOffset; index++) {
+    if (UINT32_LE.get(buffer, index) === zipDataDescriptorSignature && UINT32_LE.get(buffer, index + 8) === bytesConsumed + index) {
+      return index;
     }
-  });
-  const output2 = input.pipeThrough(new DecompressionStream("deflate-raw"));
-  const reader = output2.getReader();
+  }
+  return -1;
+}
+async function readZipDataDescriptorEntryWithLimit(zipHandler, { shouldBuffer, maximumLength = maximumZipEntrySizeInBytes } = {}) {
+  const { syncBuffer } = zipHandler;
+  const { length: syncBufferLength } = syncBuffer;
   const chunks = [];
-  let totalLength = 0;
+  let bytesConsumed = 0;
+  for (;; ) {
+    const length = await zipHandler.tokenizer.peekBuffer(syncBuffer, { mayBeLess: true });
+    const dataDescriptorOffset = findZipDataDescriptorOffset(syncBuffer.subarray(0, length), bytesConsumed);
+    const retainedLength = dataDescriptorOffset >= 0 ? 0 : length === syncBufferLength ? Math.min(zipDataDescriptorOverlapLengthInBytes, length - 1) : 0;
+    const chunkLength = dataDescriptorOffset >= 0 ? dataDescriptorOffset : length - retainedLength;
+    if (chunkLength === 0) {
+      break;
+    }
+    bytesConsumed += chunkLength;
+    if (bytesConsumed > maximumLength) {
+      throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+    }
+    if (shouldBuffer) {
+      const data = new Uint8Array(chunkLength);
+      await zipHandler.tokenizer.readBuffer(data);
+      chunks.push(data);
+    } else {
+      await zipHandler.tokenizer.ignore(chunkLength);
+    }
+    if (dataDescriptorOffset >= 0) {
+      break;
+    }
+  }
+  if (!hasUnknownFileSize(zipHandler.tokenizer)) {
+    zipHandler.knownSizeDescriptorScannedBytes += bytesConsumed;
+  }
+  if (!shouldBuffer) {
+    return;
+  }
+  return mergeByteChunks(chunks, bytesConsumed);
+}
+function getRemainingZipScanBudget(zipHandler, startOffset) {
+  if (hasUnknownFileSize(zipHandler.tokenizer)) {
+    return Math.max(0, maximumUntrustedSkipSizeInBytes - (zipHandler.tokenizer.position - startOffset));
+  }
+  return Math.max(0, maximumZipEntrySizeInBytes - zipHandler.knownSizeDescriptorScannedBytes);
+}
+async function readZipEntryData(zipHandler, zipHeader, { shouldBuffer, maximumDescriptorLength = maximumZipEntrySizeInBytes } = {}) {
+  if (zipHeader.dataDescriptor && zipHeader.compressedSize === 0) {
+    return readZipDataDescriptorEntryWithLimit(zipHandler, {
+      shouldBuffer,
+      maximumLength: maximumDescriptorLength
+    });
+  }
+  if (!shouldBuffer) {
+    await safeIgnore(zipHandler.tokenizer, zipHeader.compressedSize, {
+      maximumLength: hasUnknownFileSize(zipHandler.tokenizer) ? maximumZipEntrySizeInBytes : zipHandler.tokenizer.fileInfo.size,
+      reason: "ZIP entry compressed data"
+    });
+    return;
+  }
+  const maximumLength = getMaximumZipBufferedReadLength(zipHandler.tokenizer);
+  if (!Number.isFinite(zipHeader.compressedSize) || zipHeader.compressedSize < 0 || zipHeader.compressedSize > maximumLength) {
+    throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+  }
+  const fileData = new Uint8Array(zipHeader.compressedSize);
+  await zipHandler.tokenizer.readBuffer(fileData);
+  return fileData;
+}
+async function detectZip(tokenizer) {
+  let fileType;
+  const openXmlState = createOpenXmlZipDetectionState();
+  const iWorkState = createIWorkZipDetectionState();
   try {
-    for (;; ) {
-      const { done, value } = await reader.read();
-      if (done) {
+    await new ZipHandler(tokenizer).unzip((zipHeader) => {
+      updateOpenXmlZipDetectionStateFromFilename(openXmlState, zipHeader.filename);
+      updateIWorkZipDetectionStateFromFilename(iWorkState, zipHeader.filename);
+      if (iWorkState.hasDocumentEntry && (iWorkState.hasMasterSlideEntry || iWorkState.hasTablesEntry)) {
+        fileType = getIWorkFileTypeFromZipEntries(iWorkState);
+        return { stop: true };
+      }
+      const isOpenXmlContentTypesEntry = zipHeader.filename === "[Content_Types].xml";
+      const openXmlFileTypeFromEntries = getOpenXmlFileTypeFromZipEntries(openXmlState);
+      if (!isOpenXmlContentTypesEntry && openXmlFileTypeFromEntries) {
+        fileType = openXmlFileTypeFromEntries;
+        return {
+          stop: true
+        };
+      }
+      switch (zipHeader.filename) {
+        case "META-INF/mozilla.rsa":
+          fileType = {
+            ext: "xpi",
+            mime: "application/x-xpinstall"
+          };
+          return {
+            stop: true
+          };
+        case "META-INF/MANIFEST.MF":
+          fileType = {
+            ext: "jar",
+            mime: "application/java-archive"
+          };
+          return {
+            stop: true
+          };
+        case "mimetype":
+          if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) {
+            return {};
+          }
+          return {
+            async handler(fileData) {
+              const mimeType = new TextDecoder("utf-8").decode(fileData).trim();
+              fileType = getFileTypeFromMimeType(mimeType);
+            },
+            stop: true
+          };
+        case "[Content_Types].xml": {
+          openXmlState.hasContentTypesEntry = true;
+          if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) {
+            openXmlState.hasUnparseableContentTypes = true;
+            return {};
+          }
+          openXmlState.isParsingContentTypes = true;
+          return {
+            async handler(fileData) {
+              const xmlContent = new TextDecoder("utf-8").decode(fileData);
+              const mimeType = getOpenXmlMimeTypeFromContentTypesXml(xmlContent);
+              if (mimeType) {
+                fileType = getFileTypeFromMimeType(mimeType);
+              }
+              openXmlState.hasParsedContentTypesEntry = true;
+              openXmlState.isParsingContentTypes = false;
+            },
+            stop: true
+          };
+        }
+        default:
+          if (/classes\d*\.dex/v.test(zipHeader.filename)) {
+            fileType = {
+              ext: "apk",
+              mime: "application/vnd.android.package-archive"
+            };
+            return { stop: true };
+          }
+          return {};
+      }
+    });
+  } catch (error) {
+    if (!isRecoverableZipError(error)) {
+      throw error;
+    }
+    if (openXmlState.isParsingContentTypes) {
+      openXmlState.isParsingContentTypes = false;
+      openXmlState.hasUnparseableContentTypes = true;
+    }
+    if (!fileType && error instanceof EndOfStreamError && !openXmlState.hasContentTypesEntry) {
+      fileType = getOpenXmlFileTypeFromDirectoryNames(openXmlState);
+    }
+  }
+  const iWorkFileType = hasUnknownFileSize(tokenizer) && iWorkState.hasDocumentEntry && !iWorkState.hasMasterSlideEntry && !iWorkState.hasTablesEntry && !iWorkState.hasCalculationEngineEntry ? undefined : getIWorkFileTypeFromZipEntries(iWorkState);
+  return fileType ?? getOpenXmlFileTypeFromZipEntries(openXmlState) ?? iWorkFileType ?? {
+    ext: "zip",
+    mime: "application/zip"
+  };
+}
+var maximumZipEntrySizeInBytes, maximumZipEntryCount = 1024, maximumZipBufferedReadSizeInBytes, maximumZipTextEntrySizeInBytes, recoverableZipErrorMessages, recoverableZipErrorMessagePrefixes, recoverableZipErrorCodes, zipDataDescriptorSignature = 134695760, zipDataDescriptorLengthInBytes = 16, zipDataDescriptorOverlapLengthInBytes;
+var init_zip = __esm(() => {
+  init_lib2();
+  init_core();
+  init_lib3();
+  init_parser();
+  maximumZipEntrySizeInBytes = 1024 * 1024;
+  maximumZipBufferedReadSizeInBytes = 2 ** 31 - 1;
+  maximumZipTextEntrySizeInBytes = maximumZipEntrySizeInBytes;
+  recoverableZipErrorMessages = new Set([
+    "Unexpected signature",
+    "Encrypted ZIP",
+    "Expected Central-File-Header signature"
+  ]);
+  recoverableZipErrorMessagePrefixes = [
+    "ZIP entry count exceeds ",
+    "Unsupported ZIP compression method:",
+    "ZIP entry compressed data exceeds ",
+    "ZIP entry decompressed data exceeds ",
+    "Expected data-descriptor-signature at position "
+  ];
+  recoverableZipErrorCodes = new Set([
+    "Z_BUF_ERROR",
+    "Z_DATA_ERROR",
+    "ERR_INVALID_STATE"
+  ]);
+  zipDataDescriptorOverlapLengthInBytes = zipDataDescriptorLengthInBytes - 1;
+  ZipHandler.prototype.inflate = async function(zipHeader, fileData, callback) {
+    if (zipHeader.compressedMethod === 0) {
+      return callback(fileData);
+    }
+    if (zipHeader.compressedMethod !== 8) {
+      throw new Error(`Unsupported ZIP compression method: ${zipHeader.compressedMethod}`);
+    }
+    const uncompressedData = await decompressDeflateRawWithLimit(fileData, { maximumLength: maximumZipEntrySizeInBytes });
+    return callback(uncompressedData);
+  };
+  ZipHandler.prototype.unzip = async function(fileCallback) {
+    let stop = false;
+    let zipEntryCount = 0;
+    const zipScanStart = this.tokenizer.position;
+    this.knownSizeDescriptorScannedBytes = 0;
+    do {
+      if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, maximumUntrustedSkipSizeInBytes)) {
+        throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
+      }
+      const zipHeader = await this.readLocalFileHeader();
+      if (!zipHeader) {
         break;
       }
-      totalLength += value.length;
-      if (totalLength > maximumLength) {
-        await reader.cancel();
-        throw new Error(`ZIP entry decompressed data exceeds ${maximumLength} bytes`);
+      zipEntryCount++;
+      if (zipEntryCount > maximumZipEntryCount) {
+        throw new Error(`ZIP entry count exceeds ${maximumZipEntryCount}`);
+      }
+      const next = fileCallback(zipHeader);
+      stop = Boolean(next.stop);
+      await this.tokenizer.ignore(zipHeader.extraFieldLength);
+      const fileData = await readZipEntryData(this, zipHeader, {
+        shouldBuffer: Boolean(next.handler),
+        maximumDescriptorLength: Math.min(maximumZipEntrySizeInBytes, getRemainingZipScanBudget(this, zipScanStart))
+      });
+      if (next.handler) {
+        await this.inflate(zipHeader, fileData, next.handler);
+      }
+      if (zipHeader.dataDescriptor) {
+        const dataDescriptor = new Uint8Array(zipDataDescriptorLengthInBytes);
+        await this.tokenizer.readBuffer(dataDescriptor);
+        if (UINT32_LE.get(dataDescriptor, 0) !== zipDataDescriptorSignature) {
+          throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - dataDescriptor.length}`);
+        }
+      }
+      if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, maximumUntrustedSkipSizeInBytes)) {
+        throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
+      }
+    } while (!stop);
+  };
+});
+
+// ../../node_modules/file-type/source/detectors/ebml.js
+async function detectEbml(tokenizer) {
+  async function readField() {
+    const msb = await tokenizer.peekNumber(UINT8);
+    let mask = 128;
+    let ic = 0;
+    while ((msb & mask) === 0 && mask !== 0) {
+      ++ic;
+      mask >>= 1;
+    }
+    const id = new Uint8Array(ic + 1);
+    await safeReadBuffer(tokenizer, id, undefined, {
+      maximumLength: id.length,
+      reason: "EBML field"
+    });
+    return id;
+  }
+  async function readElement() {
+    const idField = await readField();
+    const lengthField = await readField();
+    lengthField[0] ^= 128 >> lengthField.length - 1;
+    const nrLength = Math.min(6, lengthField.length);
+    const idView = new DataView(idField.buffer);
+    const lengthView = new DataView(lengthField.buffer, lengthField.length - nrLength, nrLength);
+    return {
+      id: getUintBE(idView),
+      len: getUintBE(lengthView)
+    };
+  }
+  async function readChildren(children) {
+    let ebmlElementCount = 0;
+    while (children > 0) {
+      ebmlElementCount++;
+      if (ebmlElementCount > maximumEbmlElementCount) {
+        return;
+      }
+      if (hasExceededUnknownSizeScanBudget(tokenizer, ebmlScanStart, maximumUntrustedSkipSizeInBytes)) {
+        return;
+      }
+      const previousPosition = tokenizer.position;
+      const element = await readElement();
+      if (element.id === 17026) {
+        if (element.len > maximumEbmlDocumentTypeSizeInBytes) {
+          return;
+        }
+        const documentTypeLength = getSafeBound(element.len, maximumEbmlDocumentTypeSizeInBytes, "EBML DocType");
+        const rawValue = await tokenizer.readToken(new StringType2(documentTypeLength));
+        return rawValue.replaceAll(/\0.*$/gv, "");
+      }
+      if (hasUnknownFileSize(tokenizer) && (!Number.isFinite(element.len) || element.len < 0 || element.len > maximumEbmlElementPayloadSizeInBytes)) {
+        return;
+      }
+      await safeIgnore(tokenizer, element.len, {
+        maximumLength: hasUnknownFileSize(tokenizer) ? maximumEbmlElementPayloadSizeInBytes : tokenizer.fileInfo.size,
+        reason: "EBML payload"
+      });
+      --children;
+      if (tokenizer.position <= previousPosition) {
+        return;
       }
-      chunks.push(value);
     }
-  } finally {
-    reader.releaseLock();
-  }
-  const uncompressedData = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    uncompressedData.set(chunk, offset);
-    offset += chunk.length;
-  }
-  return uncompressedData;
-}
-function findZipDataDescriptorOffset(buffer, bytesConsumed) {
-  if (buffer.length < zipDataDescriptorLengthInBytes) {
-    return -1;
   }
-  const lastPossibleDescriptorOffset = buffer.length - zipDataDescriptorLengthInBytes;
-  for (let index = 0;index <= lastPossibleDescriptorOffset; index++) {
-    if (UINT32_LE.get(buffer, index) === zipDataDescriptorSignature && UINT32_LE.get(buffer, index + 8) === bytesConsumed + index) {
-      return index;
-    }
+  const rootElement = await readElement();
+  const ebmlScanStart = tokenizer.position;
+  const documentType = await readChildren(rootElement.len);
+  switch (documentType) {
+    case "webm":
+      return {
+        ext: "webm",
+        mime: "video/webm"
+      };
+    case "matroska":
+      return {
+        ext: "mkv",
+        mime: "video/matroska"
+      };
+    default:
   }
-  return -1;
 }
+var maximumEbmlDocumentTypeSizeInBytes = 64, maximumEbmlElementPayloadSizeInBytes, maximumEbmlElementCount = 256;
+var init_ebml = __esm(() => {
+  init_lib2();
+  init_uint8array_extras();
+  init_parser();
+  maximumEbmlElementPayloadSizeInBytes = 1024 * 1024;
+});
+
+// ../../node_modules/file-type/source/detectors/png.js
 function isPngAncillaryChunk(type) {
   return (type.codePointAt(0) & 32) !== 0;
 }
-function mergeByteChunks(chunks, totalLength) {
-  const merged = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    merged.set(chunk, offset);
-    offset += chunk.length;
+async function detectPng(tokenizer) {
+  const pngFileType = {
+    ext: "png",
+    mime: "image/png"
+  };
+  const apngFileType = {
+    ext: "apng",
+    mime: "image/apng"
+  };
+  await tokenizer.ignore(8);
+  async function readChunkHeader() {
+    return {
+      length: await tokenizer.readToken(INT32_BE),
+      type: await tokenizer.readToken(new StringType2(4, "latin1"))
+    };
   }
-  return merged;
-}
-async function readZipDataDescriptorEntryWithLimit(zipHandler, { shouldBuffer, maximumLength = maximumZipEntrySizeInBytes } = {}) {
-  const { syncBuffer } = zipHandler;
-  const { length: syncBufferLength } = syncBuffer;
-  const chunks = [];
-  let bytesConsumed = 0;
-  for (;; ) {
-    const length = await zipHandler.tokenizer.peekBuffer(syncBuffer, { mayBeLess: true });
-    const dataDescriptorOffset = findZipDataDescriptorOffset(syncBuffer.subarray(0, length), bytesConsumed);
-    const retainedLength = dataDescriptorOffset >= 0 ? 0 : length === syncBufferLength ? Math.min(zipDataDescriptorOverlapLengthInBytes, length - 1) : 0;
-    const chunkLength = dataDescriptorOffset >= 0 ? dataDescriptorOffset : length - retainedLength;
-    if (chunkLength === 0) {
+  const isUnknownPngStream = hasUnknownFileSize(tokenizer);
+  const pngScanStart = tokenizer.position;
+  let pngChunkCount = 0;
+  let hasSeenImageHeader = false;
+  do {
+    pngChunkCount++;
+    if (pngChunkCount > maximumPngChunkCount) {
       break;
     }
-    bytesConsumed += chunkLength;
-    if (bytesConsumed > maximumLength) {
-      throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+    if (hasExceededUnknownSizeScanBudget(tokenizer, pngScanStart, maximumPngStreamScanBudgetInBytes)) {
+      break;
     }
-    if (shouldBuffer) {
-      const data = new Uint8Array(chunkLength);
-      await zipHandler.tokenizer.readBuffer(data);
-      chunks.push(data);
-    } else {
-      await zipHandler.tokenizer.ignore(chunkLength);
+    const previousPosition = tokenizer.position;
+    const chunk = await readChunkHeader();
+    if (chunk.length < 0) {
+      return;
     }
-    if (dataDescriptorOffset >= 0) {
+    if (chunk.type === "IHDR") {
+      if (chunk.length !== 13) {
+        return;
+      }
+      hasSeenImageHeader = true;
+    }
+    switch (chunk.type) {
+      case "IDAT":
+        return pngFileType;
+      case "acTL":
+        return apngFileType;
+      default:
+        if (!hasSeenImageHeader && chunk.type !== "CgBI") {
+          return;
+        }
+        if (isUnknownPngStream && chunk.length > maximumPngChunkSizeInBytes) {
+          return hasSeenImageHeader && isPngAncillaryChunk(chunk.type) ? pngFileType : undefined;
+        }
+        try {
+          await safeIgnore(tokenizer, chunk.length + 4, {
+            maximumLength: isUnknownPngStream ? maximumPngChunkSizeInBytes + 4 : tokenizer.fileInfo.size,
+            reason: "PNG chunk payload"
+          });
+        } catch (error) {
+          if (!isUnknownPngStream && (error instanceof ParserHardLimitError || error instanceof EndOfStreamError)) {
+            return pngFileType;
+          }
+          throw error;
+        }
+    }
+    if (tokenizer.position <= previousPosition) {
       break;
     }
+  } while (tokenizer.position + 8 < tokenizer.fileInfo.size);
+  return pngFileType;
+}
+var maximumPngChunkCount = 512, maximumPngStreamScanBudgetInBytes, maximumPngChunkSizeInBytes;
+var init_png = __esm(() => {
+  init_lib2();
+  init_core();
+  init_parser();
+  maximumPngStreamScanBudgetInBytes = 16 * 1024 * 1024;
+  maximumPngChunkSizeInBytes = 1024 * 1024;
+});
+
+// ../../node_modules/file-type/source/detectors/asf.js
+async function detectAsf(tokenizer) {
+  let isMalformedAsf = false;
+  try {
+    async function readHeader() {
+      const guid = new Uint8Array(16);
+      await safeReadBuffer(tokenizer, guid, undefined, {
+        maximumLength: guid.length,
+        reason: "ASF header GUID"
+      });
+      return {
+        id: guid,
+        size: Number(await tokenizer.readToken(UINT64_LE))
+      };
+    }
+    await safeIgnore(tokenizer, 30, {
+      maximumLength: 30,
+      reason: "ASF header prelude"
+    });
+    const isUnknownFileSize = hasUnknownFileSize(tokenizer);
+    const asfHeaderScanStart = tokenizer.position;
+    let asfHeaderObjectCount = 0;
+    while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
+      asfHeaderObjectCount++;
+      if (asfHeaderObjectCount > maximumAsfHeaderObjectCount) {
+        break;
+      }
+      if (hasExceededUnknownSizeScanBudget(tokenizer, asfHeaderScanStart, maximumUntrustedSkipSizeInBytes)) {
+        break;
+      }
+      const previousPosition = tokenizer.position;
+      const header = await readHeader();
+      let payload = header.size - 24;
+      if (!Number.isFinite(payload) || payload < 0) {
+        isMalformedAsf = true;
+        break;
+      }
+      if (checkBytes(header.id, [145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101])) {
+        const typeId = new Uint8Array(16);
+        payload -= await safeReadBuffer(tokenizer, typeId, undefined, {
+          maximumLength: typeId.length,
+          reason: "ASF stream type GUID"
+        });
+        if (checkBytes(typeId, [64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
+          return {
+            ext: "asf",
+            mime: "audio/x-ms-asf"
+          };
+        }
+        if (checkBytes(typeId, [192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
+          return {
+            ext: "asf",
+            mime: "video/x-ms-asf"
+          };
+        }
+        break;
+      }
+      if (isUnknownFileSize && payload > maximumAsfHeaderPayloadSizeInBytes) {
+        isMalformedAsf = true;
+        break;
+      }
+      await safeIgnore(tokenizer, payload, {
+        maximumLength: isUnknownFileSize ? maximumAsfHeaderPayloadSizeInBytes : tokenizer.fileInfo.size,
+        reason: "ASF header payload"
+      });
+      if (tokenizer.position <= previousPosition) {
+        isMalformedAsf = true;
+        break;
+      }
+    }
+  } catch (error) {
+    if (error instanceof EndOfStreamError || error instanceof ParserHardLimitError) {
+      if (hasUnknownFileSize(tokenizer)) {
+        isMalformedAsf = true;
+      }
+    } else {
+      throw error;
+    }
   }
-  if (!hasUnknownFileSize(zipHandler.tokenizer)) {
-    zipHandler.knownSizeDescriptorScannedBytes += bytesConsumed;
-  }
-  if (!shouldBuffer) {
+  if (isMalformedAsf) {
     return;
   }
-  return mergeByteChunks(chunks, bytesConsumed);
+  return {
+    ext: "asf",
+    mime: "application/vnd.ms-asf"
+  };
 }
-function getRemainingZipScanBudget(zipHandler, startOffset) {
-  if (hasUnknownFileSize(zipHandler.tokenizer)) {
-    return Math.max(0, maximumUntrustedSkipSizeInBytes - (zipHandler.tokenizer.position - startOffset));
+var maximumAsfHeaderObjectCount = 512, maximumAsfHeaderPayloadSizeInBytes;
+var init_asf = __esm(() => {
+  init_lib2();
+  init_core();
+  init_parser();
+  maximumAsfHeaderPayloadSizeInBytes = 1024 * 1024;
+});
+
+// ../../node_modules/strtok3/lib/FileTokenizer.js
+import { open as fsOpen } from "node:fs/promises";
+var FileTokenizer;
+var init_FileTokenizer = __esm(() => {
+  init_AbstractTokenizer();
+  init_stream();
+  FileTokenizer = class FileTokenizer extends AbstractTokenizer {
+    static async fromFile(sourceFilePath) {
+      const fileHandle = await fsOpen(sourceFilePath, "r");
+      const stat2 = await fileHandle.stat();
+      return new FileTokenizer(fileHandle, { fileInfo: { path: sourceFilePath, size: stat2.size } });
+    }
+    constructor(fileHandle, options) {
+      super(options);
+      this.fileHandle = fileHandle;
+      this.fileInfo = options.fileInfo;
+    }
+    async readBuffer(uint8Array, options) {
+      const normOptions = this.normalizeOptions(uint8Array, options);
+      this.position = normOptions.position;
+      if (normOptions.length === 0)
+        return 0;
+      const res = await this.fileHandle.read(uint8Array, 0, normOptions.length, normOptions.position);
+      this.position += res.bytesRead;
+      if (res.bytesRead < normOptions.length && (!options || !options.mayBeLess)) {
+        throw new EndOfStreamError;
+      }
+      return res.bytesRead;
+    }
+    async peekBuffer(uint8Array, options) {
+      const normOptions = this.normalizeOptions(uint8Array, options);
+      const res = await this.fileHandle.read(uint8Array, 0, normOptions.length, normOptions.position);
+      if (!normOptions.mayBeLess && res.bytesRead < normOptions.length) {
+        throw new EndOfStreamError;
+      }
+      return res.bytesRead;
+    }
+    async close() {
+      await this.fileHandle.close();
+      return super.close();
+    }
+    setPosition(position) {
+      this.position = position;
+    }
+    supportsRandomAccess() {
+      return true;
+    }
+  };
+});
+
+// ../../node_modules/strtok3/lib/index.js
+var exports_lib2 = {};
+__export(exports_lib2, {
+  fromWebStream: () => fromWebStream,
+  fromStream: () => fromStream2,
+  fromFile: () => fromFile,
+  fromBuffer: () => fromBuffer,
+  fromBlob: () => fromBlob,
+  FileTokenizer: () => FileTokenizer,
+  EndOfStreamError: () => EndOfStreamError,
+  AbstractTokenizer: () => AbstractTokenizer,
+  AbortError: () => AbortError
+});
+import { stat as fsStat } from "node:fs/promises";
+async function fromStream2(stream, options) {
+  const rst = fromStream(stream, options);
+  if (stream.path) {
+    const stat2 = await fsStat(stream.path);
+    rst.fileInfo.path = stream.path;
+    rst.fileInfo.size = stat2.size;
   }
-  return Math.max(0, maximumZipEntrySizeInBytes - zipHandler.knownSizeDescriptorScannedBytes);
+  return rst;
 }
-async function readZipEntryData(zipHandler, zipHeader, { shouldBuffer, maximumDescriptorLength = maximumZipEntrySizeInBytes } = {}) {
-  if (zipHeader.dataDescriptor && zipHeader.compressedSize === 0) {
-    return readZipDataDescriptorEntryWithLimit(zipHandler, {
-      shouldBuffer,
-      maximumLength: maximumDescriptorLength
-    });
+var fromFile;
+var init_lib4 = __esm(() => {
+  init_core();
+  init_FileTokenizer();
+  init_FileTokenizer();
+  init_core();
+  fromFile = FileTokenizer.fromFile;
+});
+
+// ../../node_modules/file-type/source/index.js
+var exports_source = {};
+__export(exports_source, {
+  supportedMimeTypes: () => supportedMimeTypes,
+  supportedExtensions: () => supportedExtensions,
+  reasonableDetectionSizeInBytes: () => reasonableDetectionSizeInBytes,
+  normalizeSampleSize: () => normalizeSampleSize,
+  fileTypeStream: () => fileTypeStream,
+  fileTypeFromTokenizer: () => fileTypeFromTokenizer,
+  fileTypeFromStream: () => fileTypeFromStream,
+  fileTypeFromFile: () => fileTypeFromFile,
+  fileTypeFromBuffer: () => fileTypeFromBuffer,
+  fileTypeFromBlob: () => fileTypeFromBlob,
+  FileTypeParser: () => FileTypeParser
+});
+function normalizeSampleSize(sampleSize) {
+  if (!Number.isFinite(sampleSize)) {
+    return reasonableDetectionSizeInBytes;
   }
-  if (!shouldBuffer) {
-    await safeIgnore(zipHandler.tokenizer, zipHeader.compressedSize, {
-      maximumLength: hasUnknownFileSize(zipHandler.tokenizer) ? maximumZipEntrySizeInBytes : zipHandler.tokenizer.fileInfo.size,
-      reason: "ZIP entry compressed data"
-    });
-    return;
+  return Math.max(1, Math.trunc(sampleSize));
+}
+function normalizeMpegOffsetTolerance(mpegOffsetTolerance) {
+  if (!Number.isFinite(mpegOffsetTolerance)) {
+    return 0;
   }
-  const maximumLength = getMaximumZipBufferedReadLength(zipHandler.tokenizer);
-  if (!Number.isFinite(zipHeader.compressedSize) || zipHeader.compressedSize < 0 || zipHeader.compressedSize > maximumLength) {
-    throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+  return Math.max(0, Math.min(maximumMpegOffsetTolerance, Math.trunc(mpegOffsetTolerance)));
+}
+function getKnownFileSizeOrMaximum(fileSize) {
+  if (!Number.isFinite(fileSize)) {
+    return Number.MAX_SAFE_INTEGER;
   }
-  const fileData = new Uint8Array(zipHeader.compressedSize);
-  await zipHandler.tokenizer.readBuffer(fileData);
-  return fileData;
+  return Math.max(0, fileSize);
+}
+function toDefaultStream(stream) {
+  return stream.pipeThrough(new TransformStream);
+}
+function readWithSignal(reader, signal) {
+  if (signal === undefined) {
+    return reader.read();
+  }
+  signal.throwIfAborted();
+  return Promise.race([
+    reader.read(),
+    new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => {
+        reject(signal.reason);
+        reader.cancel(signal.reason).catch(() => {
+        });
+      }, { once: true });
+    })
+  ]);
 }
 function createByteLimitedReadableStream(stream, maximumBytes) {
   const reader = stream.getReader();
@@ -25132,325 +25882,24 @@ function createByteLimitedReadableStream(stream, maximumBytes) {
     }
   });
 }
+async function fileTypeFromStream(stream, options) {
+  return new FileTypeParser(options).fromStream(stream);
+}
 async function fileTypeFromBuffer(input, options) {
   return new FileTypeParser(options).fromBuffer(input);
 }
 async function fileTypeFromBlob(blob, options) {
   return new FileTypeParser(options).fromBlob(blob);
 }
-function getFileTypeFromMimeType(mimeType) {
-  mimeType = mimeType.toLowerCase();
-  switch (mimeType) {
-    case "application/epub+zip":
-      return {
-        ext: "epub",
-        mime: mimeType
-      };
-    case "application/vnd.oasis.opendocument.text":
-      return {
-        ext: "odt",
-        mime: mimeType
-      };
-    case "application/vnd.oasis.opendocument.text-template":
-      return {
-        ext: "ott",
-        mime: mimeType
-      };
-    case "application/vnd.oasis.opendocument.spreadsheet":
-      return {
-        ext: "ods",
-        mime: mimeType
-      };
-    case "application/vnd.oasis.opendocument.spreadsheet-template":
-      return {
-        ext: "ots",
-        mime: mimeType
-      };
-    case "application/vnd.oasis.opendocument.presentation":
-      return {
-        ext: "odp",
-        mime: mimeType
-      };
-    case "application/vnd.oasis.opendocument.presentation-template":
-      return {
-        ext: "otp",
-        mime: mimeType
-      };
-    case "application/vnd.oasis.opendocument.graphics":
-      return {
-        ext: "odg",
-        mime: mimeType
-      };
-    case "application/vnd.oasis.opendocument.graphics-template":
-      return {
-        ext: "otg",
-        mime: mimeType
-      };
-    case "application/vnd.openxmlformats-officedocument.presentationml.slideshow":
-      return {
-        ext: "ppsx",
-        mime: mimeType
-      };
-    case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
-      return {
-        ext: "xlsx",
-        mime: mimeType
-      };
-    case "application/vnd.ms-excel.sheet.macroenabled":
-      return {
-        ext: "xlsm",
-        mime: "application/vnd.ms-excel.sheet.macroenabled.12"
-      };
-    case "application/vnd.openxmlformats-officedocument.spreadsheetml.template":
-      return {
-        ext: "xltx",
-        mime: mimeType
-      };
-    case "application/vnd.ms-excel.template.macroenabled":
-      return {
-        ext: "xltm",
-        mime: "application/vnd.ms-excel.template.macroenabled.12"
-      };
-    case "application/vnd.ms-powerpoint.slideshow.macroenabled":
-      return {
-        ext: "ppsm",
-        mime: "application/vnd.ms-powerpoint.slideshow.macroenabled.12"
-      };
-    case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
-      return {
-        ext: "docx",
-        mime: mimeType
-      };
-    case "application/vnd.ms-word.document.macroenabled":
-      return {
-        ext: "docm",
-        mime: "application/vnd.ms-word.document.macroenabled.12"
-      };
-    case "application/vnd.openxmlformats-officedocument.wordprocessingml.template":
-      return {
-        ext: "dotx",
-        mime: mimeType
-      };
-    case "application/vnd.ms-word.template.macroenabledtemplate":
-      return {
-        ext: "dotm",
-        mime: "application/vnd.ms-word.template.macroenabled.12"
-      };
-    case "application/vnd.openxmlformats-officedocument.presentationml.template":
-      return {
-        ext: "potx",
-        mime: mimeType
-      };
-    case "application/vnd.ms-powerpoint.template.macroenabled":
-      return {
-        ext: "potm",
-        mime: "application/vnd.ms-powerpoint.template.macroenabled.12"
-      };
-    case "application/vnd.openxmlformats-officedocument.presentationml.presentation":
-      return {
-        ext: "pptx",
-        mime: mimeType
-      };
-    case "application/vnd.ms-powerpoint.presentation.macroenabled":
-      return {
-        ext: "pptm",
-        mime: "application/vnd.ms-powerpoint.presentation.macroenabled.12"
-      };
-    case "application/vnd.ms-visio.drawing":
-      return {
-        ext: "vsdx",
-        mime: "application/vnd.visio"
-      };
-    case "application/vnd.ms-package.3dmanufacturing-3dmodel+xml":
-      return {
-        ext: "3mf",
-        mime: "model/3mf"
-      };
-    default:
-  }
-}
-function _check(buffer, headers, options) {
-  options = {
-    offset: 0,
-    ...options
-  };
-  for (const [index, header] of headers.entries()) {
-    if (options.mask) {
-      if (header !== (options.mask[index] & buffer[index + options.offset])) {
-        return false;
-      }
-    } else if (header !== buffer[index + options.offset]) {
-      return false;
-    }
-  }
-  return true;
-}
-function normalizeSampleSize(sampleSize) {
-  if (!Number.isFinite(sampleSize)) {
-    return reasonableDetectionSizeInBytes;
-  }
-  return Math.max(1, Math.trunc(sampleSize));
-}
-function readByobReaderWithSignal(reader, buffer, signal) {
-  if (signal === undefined) {
-    return reader.read(buffer);
-  }
-  signal.throwIfAborted();
-  return new Promise((resolve3, reject) => {
-    const cleanup = () => {
-      signal.removeEventListener("abort", onAbort);
-    };
-    const onAbort = () => {
-      const abortReason = signal.reason;
-      cleanup();
-      (async () => {
-        try {
-          await reader.cancel(abortReason);
-        } catch {
-        }
-      })();
-      reject(abortReason);
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    (async () => {
-      try {
-        const result = await reader.read(buffer);
-        cleanup();
-        resolve3(result);
-      } catch (error) {
-        cleanup();
-        reject(error);
-      }
-    })();
-  });
-}
-function normalizeMpegOffsetTolerance(mpegOffsetTolerance) {
-  if (!Number.isFinite(mpegOffsetTolerance)) {
-    return 0;
-  }
-  return Math.max(0, Math.min(maximumMpegOffsetTolerance, Math.trunc(mpegOffsetTolerance)));
-}
-function getKnownFileSizeOrMaximum(fileSize) {
-  if (!Number.isFinite(fileSize)) {
-    return Number.MAX_SAFE_INTEGER;
-  }
-  return Math.max(0, fileSize);
-}
-function hasUnknownFileSize(tokenizer) {
-  const fileSize = tokenizer.fileInfo.size;
-  return !Number.isFinite(fileSize) || fileSize === Number.MAX_SAFE_INTEGER;
-}
-function hasExceededUnknownSizeScanBudget(tokenizer, startOffset, maximumBytes) {
-  return hasUnknownFileSize(tokenizer) && tokenizer.position - startOffset > maximumBytes;
-}
-function getMaximumZipBufferedReadLength(tokenizer) {
-  const fileSize = tokenizer.fileInfo.size;
-  const remainingBytes = Number.isFinite(fileSize) ? Math.max(0, fileSize - tokenizer.position) : Number.MAX_SAFE_INTEGER;
-  return Math.min(remainingBytes, maximumZipBufferedReadSizeInBytes);
-}
-function isRecoverableZipError(error) {
-  if (error instanceof EndOfStreamError) {
-    return true;
-  }
-  if (error instanceof ParserHardLimitError) {
-    return true;
-  }
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  if (recoverableZipErrorMessages.has(error.message)) {
-    return true;
-  }
-  if (recoverableZipErrorCodes.has(error.code)) {
-    return true;
-  }
-  for (const prefix of recoverableZipErrorMessagePrefixes) {
-    if (error.message.startsWith(prefix)) {
-      return true;
-    }
-  }
-  return false;
-}
-function canReadZipEntryForDetection(zipHeader, maximumSize = maximumZipEntrySizeInBytes) {
-  const sizes = [zipHeader.compressedSize, zipHeader.uncompressedSize];
-  for (const size of sizes) {
-    if (!Number.isFinite(size) || size < 0 || size > maximumSize) {
-      return false;
-    }
-  }
-  return true;
-}
-function createOpenXmlZipDetectionState() {
-  return {
-    hasContentTypesEntry: false,
-    hasParsedContentTypesEntry: false,
-    isParsingContentTypes: false,
-    hasUnparseableContentTypes: false,
-    hasWordDirectory: false,
-    hasPresentationDirectory: false,
-    hasSpreadsheetDirectory: false,
-    hasThreeDimensionalModelEntry: false
-  };
-}
-function updateOpenXmlZipDetectionStateFromFilename(openXmlState, filename) {
-  if (filename.startsWith("word/")) {
-    openXmlState.hasWordDirectory = true;
-  }
-  if (filename.startsWith("ppt/")) {
-    openXmlState.hasPresentationDirectory = true;
-  }
-  if (filename.startsWith("xl/")) {
-    openXmlState.hasSpreadsheetDirectory = true;
-  }
-  if (filename.startsWith("3D/") && filename.endsWith(".model")) {
-    openXmlState.hasThreeDimensionalModelEntry = true;
-  }
-}
-function getOpenXmlFileTypeFromZipEntries(openXmlState) {
-  if (!openXmlState.hasContentTypesEntry || openXmlState.hasUnparseableContentTypes || openXmlState.isParsingContentTypes || openXmlState.hasParsedContentTypesEntry) {
-    return;
-  }
-  if (openXmlState.hasWordDirectory) {
-    return {
-      ext: "docx",
-      mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-    };
-  }
-  if (openXmlState.hasPresentationDirectory) {
-    return {
-      ext: "pptx",
-      mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-    };
-  }
-  if (openXmlState.hasSpreadsheetDirectory) {
-    return {
-      ext: "xlsx",
-      mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-    };
-  }
-  if (openXmlState.hasThreeDimensionalModelEntry) {
-    return {
-      ext: "3mf",
-      mime: "model/3mf"
-    };
-  }
-}
-function getOpenXmlMimeTypeFromContentTypesXml(xmlContent) {
-  const endPosition = xmlContent.indexOf('.main+xml"');
-  if (endPosition === -1) {
-    const mimeType = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml";
-    if (xmlContent.includes(`ContentType="${mimeType}"`)) {
-      return mimeType;
-    }
-    return;
-  }
-  const truncatedContent = xmlContent.slice(0, endPosition);
-  const firstQuotePosition = truncatedContent.lastIndexOf('"');
-  return truncatedContent.slice(firstQuotePosition + 1);
-}
 async function fileTypeFromTokenizer(tokenizer, options) {
   return new FileTypeParser(options).fromTokenizer(tokenizer);
 }
+async function fileTypeStream(webStream, options) {
+  return new FileTypeParser(options).toDetectionStream(webStream, options);
+}
+async function fileTypeFromFile(path, options) {
+  return new FileTypeParser(options).fromFile(path);
+}
 
 class FileTypeParser {
   constructor(options) {
@@ -25475,7 +25924,7 @@ class FileTypeParser {
     };
   }
   createTokenizerFromWebStream(stream) {
-    return patchWebByobTokenizerClose(fromWebStream(stream, this.getTokenizerOptions()));
+    return fromWebStream(toDefaultStream(stream), this.getTokenizerOptions());
   }
   async parseTokenizer(tokenizer, detectionReentryCount = 0) {
     this.detectionReentryCount = detectionReentryCount;
@@ -25528,31 +25977,76 @@ class FileTypeParser {
     const tokenizer = this.createTokenizerFromWebStream(stream);
     return this.fromTokenizer(tokenizer);
   }
+  async fromFile(path) {
+    this.options.signal?.throwIfAborted();
+    const [{ default: fsPromises }, { FileTokenizer: FileTokenizer2 }] = await Promise.all([
+      import("node:fs/promises"),
+      Promise.resolve().then(() => (init_lib4(), exports_lib2))
+    ]);
+    const fileHandle = await fsPromises.open(path, fsPromises.constants.O_RDONLY | fsPromises.constants.O_NONBLOCK);
+    const fileStat = await fileHandle.stat();
+    if (!fileStat.isFile()) {
+      await fileHandle.close();
+      return;
+    }
+    const tokenizer = new FileTokenizer2(fileHandle, {
+      ...this.getTokenizerOptions(),
+      fileInfo: { path, size: fileStat.size }
+    });
+    return this.fromTokenizer(tokenizer);
+  }
   async toDetectionStream(stream, options) {
+    this.options.signal?.throwIfAborted();
     const sampleSize = normalizeSampleSize(options?.sampleSize ?? reasonableDetectionSizeInBytes);
     let detectedFileType;
-    let firstChunk;
-    const reader = stream.getReader({ mode: "byob" });
+    let streamEnded = false;
+    const reader = stream.getReader();
+    const chunks = [];
+    let totalSize = 0;
     try {
-      const { value: chunk, done } = await readByobReaderWithSignal(reader, new Uint8Array(sampleSize), this.options.signal);
-      firstChunk = chunk;
-      if (!done && chunk) {
-        try {
-          detectedFileType = await this.fromBuffer(chunk.subarray(0, sampleSize));
-        } catch (error) {
-          if (!(error instanceof EndOfStreamError)) {
-            throw error;
-          }
-          detectedFileType = undefined;
+      while (totalSize < sampleSize) {
+        const { value, done } = await readWithSignal(reader, this.options.signal);
+        if (done || !value) {
+          streamEnded = true;
+          break;
+        }
+        chunks.push(value);
+        totalSize += value.length;
+      }
+      if (!streamEnded && totalSize === sampleSize) {
+        const { value, done } = await readWithSignal(reader, this.options.signal);
+        if (done || !value) {
+          streamEnded = true;
+        } else {
+          chunks.push(value);
+          totalSize += value.length;
         }
       }
-      firstChunk = chunk;
     } finally {
       reader.releaseLock();
     }
+    if (totalSize > 0) {
+      const sample = chunks.length === 1 ? chunks[0] : concatUint8Arrays(chunks);
+      try {
+        detectedFileType = await this.fromBuffer(sample.subarray(0, sampleSize));
+      } catch (error) {
+        if (!(error instanceof EndOfStreamError)) {
+          throw error;
+        }
+        detectedFileType = undefined;
+      }
+      if (!streamEnded && detectedFileType?.ext === "pages") {
+        detectedFileType = {
+          ext: "zip",
+          mime: "application/zip"
+        };
+      }
+    }
     const transformStream = new TransformStream({
-      async start(controller) {
-        controller.enqueue(firstChunk);
+      start(controller) {
+        for (const chunk of chunks) {
+          controller.enqueue(chunk);
+        }
       },
       transform(chunk, controller) {
         controller.enqueue(chunk);
@@ -25614,7 +26108,7 @@ class FileTypeParser {
     };
   }
   check(header, options) {
-    return _check(this.buffer, header, options);
+    return checkBytes(this.buffer, header, options);
   }
   checkString(header, options) {
     return this.check(stringToBytes(header, options?.encoding), options);
@@ -25813,127 +26307,43 @@ class FileTypeParser {
       };
     }
     if (this.check([80, 75, 3, 4])) {
-      let fileType;
-      const openXmlState = createOpenXmlZipDetectionState();
-      try {
-        await new ZipHandler(tokenizer).unzip((zipHeader) => {
-          updateOpenXmlZipDetectionStateFromFilename(openXmlState, zipHeader.filename);
-          const isOpenXmlContentTypesEntry = zipHeader.filename === "[Content_Types].xml";
-          const openXmlFileTypeFromEntries = getOpenXmlFileTypeFromZipEntries(openXmlState);
-          if (!isOpenXmlContentTypesEntry && openXmlFileTypeFromEntries) {
-            fileType = openXmlFileTypeFromEntries;
-            return {
-              stop: true
-            };
-          }
-          switch (zipHeader.filename) {
-            case "META-INF/mozilla.rsa":
-              fileType = {
-                ext: "xpi",
-                mime: "application/x-xpinstall"
-              };
-              return {
-                stop: true
-              };
-            case "META-INF/MANIFEST.MF":
-              fileType = {
-                ext: "jar",
-                mime: "application/java-archive"
-              };
-              return {
-                stop: true
-              };
-            case "mimetype":
-              if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) {
-                return {};
-              }
-              return {
-                async handler(fileData) {
-                  const mimeType = new TextDecoder("utf-8").decode(fileData).trim();
-                  fileType = getFileTypeFromMimeType(mimeType);
-                },
-                stop: true
-              };
-            case "[Content_Types].xml": {
-              openXmlState.hasContentTypesEntry = true;
-              if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) {
-                openXmlState.hasUnparseableContentTypes = true;
-                return {};
-              }
-              openXmlState.isParsingContentTypes = true;
-              return {
-                async handler(fileData) {
-                  const xmlContent = new TextDecoder("utf-8").decode(fileData);
-                  const mimeType = getOpenXmlMimeTypeFromContentTypesXml(xmlContent);
-                  if (mimeType) {
-                    fileType = getFileTypeFromMimeType(mimeType);
-                  }
-                  openXmlState.hasParsedContentTypesEntry = true;
-                  openXmlState.isParsingContentTypes = false;
-                },
-                stop: true
-              };
-            }
-            default:
-              if (/classes\d*\.dex/.test(zipHeader.filename)) {
-                fileType = {
-                  ext: "apk",
-                  mime: "application/vnd.android.package-archive"
-                };
-                return { stop: true };
-              }
-              return {};
-          }
-        });
-      } catch (error) {
-        if (!isRecoverableZipError(error)) {
-          throw error;
-        }
-        if (openXmlState.isParsingContentTypes) {
-          openXmlState.isParsingContentTypes = false;
-          openXmlState.hasUnparseableContentTypes = true;
-        }
-      }
-      return fileType ?? getOpenXmlFileTypeFromZipEntries(openXmlState) ?? {
-        ext: "zip",
-        mime: "application/zip"
-      };
+      return detectZip(tokenizer);
     }
     if (this.checkString("OggS")) {
       await tokenizer.ignore(28);
       const type = new Uint8Array(8);
       await tokenizer.readBuffer(type);
-      if (_check(type, [79, 112, 117, 115, 72, 101, 97, 100])) {
+      if (checkBytes(type, [79, 112, 117, 115, 72, 101, 97, 100])) {
         return {
           ext: "opus",
           mime: "audio/ogg; codecs=opus"
         };
       }
-      if (_check(type, [128, 116, 104, 101, 111, 114, 97])) {
+      if (checkBytes(type, [128, 116, 104, 101, 111, 114, 97])) {
         return {
           ext: "ogv",
           mime: "video/ogg"
         };
       }
-      if (_check(type, [1, 118, 105, 100, 101, 111, 0])) {
+      if (checkBytes(type, [1, 118, 105, 100, 101, 111, 0])) {
         return {
           ext: "ogm",
           mime: "video/ogg"
         };
       }
-      if (_check(type, [127, 70, 76, 65, 67])) {
+      if (checkBytes(type, [127, 70, 76, 65, 67])) {
         return {
           ext: "oga",
           mime: "audio/ogg"
         };
       }
-      if (_check(type, [83, 112, 101, 101, 120, 32, 32])) {
+      if (checkBytes(type, [83, 112, 101, 101, 120, 32, 32])) {
         return {
           ext: "spx",
           mime: "audio/ogg"
         };
       }
-      if (_check(type, [1, 118, 111, 114, 98, 105, 115])) {
+      if (checkBytes(type, [1, 118, 111, 114, 98, 105, 115])) {
         return {
           ext: "ogg",
           mime: "audio/ogg"
@@ -25983,7 +26393,7 @@ class FileTypeParser {
     if (this.checkString("LZIP")) {
       return {
         ext: "lz",
-        mime: "application/x-lzip"
+        mime: "application/lzip"
       };
     }
     if (this.checkString("fLaC")) {
@@ -26035,83 +26445,7 @@ class FileTypeParser {
       };
     }
     if (this.check([26, 69, 223, 163])) {
-      async function readField() {
-        const msb = await tokenizer.peekNumber(UINT8);
-        let mask = 128;
-        let ic = 0;
-        while ((msb & mask) === 0 && mask !== 0) {
-          ++ic;
-          mask >>= 1;
-        }
-        const id = new Uint8Array(ic + 1);
-        await safeReadBuffer(tokenizer, id, undefined, {
-          maximumLength: id.length,
-          reason: "EBML field"
-        });
-        return id;
-      }
-      async function readElement() {
-        const idField = await readField();
-        const lengthField = await readField();
-        lengthField[0] ^= 128 >> lengthField.length - 1;
-        const nrLength = Math.min(6, lengthField.length);
-        const idView = new DataView(idField.buffer);
-        const lengthView = new DataView(lengthField.buffer, lengthField.length - nrLength, nrLength);
-        return {
-          id: getUintBE(idView),
-          len: getUintBE(lengthView)
-        };
-      }
-      async function readChildren(children) {
-        let ebmlElementCount = 0;
-        while (children > 0) {
-          ebmlElementCount++;
-          if (ebmlElementCount > maximumEbmlElementCount) {
-            return;
-          }
-          if (hasExceededUnknownSizeScanBudget(tokenizer, ebmlScanStart, maximumUntrustedSkipSizeInBytes)) {
-            return;
-          }
-          const previousPosition = tokenizer.position;
-          const element = await readElement();
-          if (element.id === 17026) {
-            if (element.len > maximumEbmlDocumentTypeSizeInBytes) {
-              return;
-            }
-            const documentTypeLength = getSafeBound(element.len, maximumEbmlDocumentTypeSizeInBytes, "EBML DocType");
-            const rawValue = await tokenizer.readToken(new StringType2(documentTypeLength));
-            return rawValue.replaceAll(/\00.*$/g, "");
-          }
-          if (hasUnknownFileSize(tokenizer) && (!Number.isFinite(element.len) || element.len < 0 || element.len > maximumEbmlElementPayloadSizeInBytes)) {
-            return;
-          }
-          await safeIgnore(tokenizer, element.len, {
-            maximumLength: hasUnknownFileSize(tokenizer) ? maximumEbmlElementPayloadSizeInBytes : tokenizer.fileInfo.size,
-            reason: "EBML payload"
-          });
-          --children;
-          if (tokenizer.position <= previousPosition) {
-            return;
-          }
-        }
-      }
-      const rootElement = await readElement();
-      const ebmlScanStart = tokenizer.position;
-      const documentType = await readChildren(rootElement.len);
-      switch (documentType) {
-        case "webm":
-          return {
-            ext: "webm",
-            mime: "video/webm"
-          };
-        case "matroska":
-          return {
-            ext: "mkv",
-            mime: "video/matroska"
-          };
-        default:
-          return;
-      }
+      return detectEbml(tokenizer);
     }
     if (this.checkString("SQLi")) {
       return {
@@ -26215,7 +26549,7 @@ class FileTypeParser {
         mime: "audio/amr"
       };
     }
-    if (this.checkString("{\\rtf")) {
+    if (this.checkString(String.raw`{\rtf`)) {
       return {
         ext: "rtf",
         mime: "application/rtf"
@@ -26284,7 +26618,7 @@ class FileTypeParser {
     if (this.checkString("DRACO")) {
       return {
         ext: "drc",
-        mime: "application/vnd.google.draco"
+        mime: "application/x-ft-draco"
       };
     }
     if (this.check([253, 55, 122, 88, 90, 0])) {
@@ -26319,7 +26653,7 @@ class FileTypeParser {
     }
     if (this.checkString("AC")) {
       const version = new StringType2(4, "latin1").get(this.buffer, 2);
-      if (version.match("^d*") && version >= 1000 && version <= 1050) {
+      if (/^\d+$/v.test(version) && version >= 1000 && version <= 1050) {
         return {
           ext: "dwg",
           mime: "image/vnd.dwg"
@@ -26359,73 +26693,7 @@ class FileTypeParser {
       };
     }
     if (this.check([137, 80, 78, 71, 13, 10, 26, 10])) {
-      const pngFileType = {
-        ext: "png",
-        mime: "image/png"
-      };
-      const apngFileType = {
-        ext: "apng",
-        mime: "image/apng"
-      };
-      await tokenizer.ignore(8);
-      async function readChunkHeader() {
-        return {
-          length: await tokenizer.readToken(INT32_BE),
-          type: await tokenizer.readToken(new StringType2(4, "latin1"))
-        };
-      }
-      const isUnknownPngStream = hasUnknownFileSize(tokenizer);
-      const pngScanStart = tokenizer.position;
-      let pngChunkCount = 0;
-      let hasSeenImageHeader = false;
-      do {
-        pngChunkCount++;
-        if (pngChunkCount > maximumPngChunkCount) {
-          break;
-        }
-        if (hasExceededUnknownSizeScanBudget(tokenizer, pngScanStart, maximumPngStreamScanBudgetInBytes)) {
-          break;
-        }
-        const previousPosition = tokenizer.position;
-        const chunk = await readChunkHeader();
-        if (chunk.length < 0) {
-          return;
-        }
-        if (chunk.type === "IHDR") {
-          if (chunk.length !== 13) {
-            return;
-          }
-          hasSeenImageHeader = true;
-        }
-        switch (chunk.type) {
-          case "IDAT":
-            return pngFileType;
-          case "acTL":
-            return apngFileType;
-          default:
-            if (!hasSeenImageHeader && chunk.type !== "CgBI") {
-              return;
-            }
-            if (isUnknownPngStream && chunk.length > maximumPngChunkSizeInBytes) {
-              return hasSeenImageHeader && isPngAncillaryChunk(chunk.type) ? pngFileType : undefined;
-            }
-            try {
-              await safeIgnore(tokenizer, chunk.length + 4, {
-                maximumLength: isUnknownPngStream ? maximumPngChunkSizeInBytes + 4 : tokenizer.fileInfo.size,
-                reason: "PNG chunk payload"
-              });
-            } catch (error) {
-              if (!isUnknownPngStream && (error instanceof ParserHardLimitError || error instanceof EndOfStreamError)) {
-                return pngFileType;
-              }
-              throw error;
-            }
-        }
-        if (tokenizer.position <= previousPosition) {
-          break;
-        }
-      } while (tokenizer.position + 8 < tokenizer.fileInfo.size);
-      return pngFileType;
+      return detectPng(tokenizer);
     }
     if (this.check([65, 82, 82, 79, 87, 49, 0, 0])) {
       return {
@@ -26544,90 +26812,7 @@ class FileTypeParser {
       };
     }
     if (this.check([48, 38, 178, 117, 142, 102, 207, 17, 166, 217])) {
-      let isMalformedAsf = false;
-      try {
-        async function readHeader() {
-          const guid = new Uint8Array(16);
-          await safeReadBuffer(tokenizer, guid, undefined, {
-            maximumLength: guid.length,
-            reason: "ASF header GUID"
-          });
-          return {
-            id: guid,
-            size: Number(await tokenizer.readToken(UINT64_LE))
-          };
-        }
-        await safeIgnore(tokenizer, 30, {
-          maximumLength: 30,
-          reason: "ASF header prelude"
-        });
-        const isUnknownFileSize = hasUnknownFileSize(tokenizer);
-        const asfHeaderScanStart = tokenizer.position;
-        let asfHeaderObjectCount = 0;
-        while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
-          asfHeaderObjectCount++;
-          if (asfHeaderObjectCount > maximumAsfHeaderObjectCount) {
-            break;
-          }
-          if (hasExceededUnknownSizeScanBudget(tokenizer, asfHeaderScanStart, maximumUntrustedSkipSizeInBytes)) {
-            break;
-          }
-          const previousPosition = tokenizer.position;
-          const header = await readHeader();
-          let payload = header.size - 24;
-          if (!Number.isFinite(payload) || payload < 0) {
-            isMalformedAsf = true;
-            break;
-          }
-          if (_check(header.id, [145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101])) {
-            const typeId = new Uint8Array(16);
-            payload -= await safeReadBuffer(tokenizer, typeId, undefined, {
-              maximumLength: typeId.length,
-              reason: "ASF stream type GUID"
-            });
-            if (_check(typeId, [64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
-              return {
-                ext: "asf",
-                mime: "audio/x-ms-asf"
-              };
-            }
-            if (_check(typeId, [192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
-              return {
-                ext: "asf",
-                mime: "video/x-ms-asf"
-              };
-            }
-            break;
-          }
-          if (isUnknownFileSize && payload > maximumAsfHeaderPayloadSizeInBytes) {
-            isMalformedAsf = true;
-            break;
-          }
-          await safeIgnore(tokenizer, payload, {
-            maximumLength: isUnknownFileSize ? maximumAsfHeaderPayloadSizeInBytes : tokenizer.fileInfo.size,
-            reason: "ASF header payload"
-          });
-          if (tokenizer.position <= previousPosition) {
-            isMalformedAsf = true;
-            break;
-          }
-        }
-      } catch (error) {
-        if (error instanceof EndOfStreamError || error instanceof ParserHardLimitError) {
-          if (hasUnknownFileSize(tokenizer)) {
-            isMalformedAsf = true;
-          }
-        } else {
-          throw error;
-        }
-      }
-      if (isMalformedAsf) {
-        return;
-      }
-      return {
-        ext: "asf",
-        mime: "application/vnd.ms-asf"
-      };
+      return detectAsf(tokenizer);
     }
     if (this.check([171, 75, 84, 88, 32, 49, 49, 187, 13, 10, 26, 10])) {
       return {
@@ -26802,19 +26987,19 @@ class FileTypeParser {
     if (this.check([76, 0, 0, 0, 1, 20, 2, 0, 0, 0, 0, 0, 192, 0, 0, 0, 0, 0, 0, 70])) {
       return {
         ext: "lnk",
-        mime: "application/x.ms.shortcut"
+        mime: "application/x-ms-shortcut"
       };
     }
     if (this.check([98, 111, 111, 107, 0, 0, 0, 0, 109, 97, 114, 107, 0, 0, 0, 0])) {
       return {
         ext: "alias",
-        mime: "application/x.apple.alias"
+        mime: "application/x-ft-apple.alias"
       };
     }
     if (this.checkString("Kaydara FBX Binary  \0")) {
       return {
         ext: "fbx",
-        mime: "application/x.autodesk.fbx"
+        mime: "application/x-ft-fbx"
       };
     }
     if (this.check([76, 80], { offset: 34 }) && (this.check([0, 0, 1], { offset: 8 }) || this.check([1, 0, 2], { offset: 8 }) || this.check([2, 0, 2], { offset: 8 }))) {
@@ -27032,234 +27217,28 @@ class FileTypeParser {
     }
   }
 }
-var reasonableDetectionSizeInBytes = 4100, maximumMpegOffsetTolerance, maximumZipEntrySizeInBytes, maximumZipEntryCount = 1024, maximumZipBufferedReadSizeInBytes, maximumUntrustedSkipSizeInBytes, maximumUnknownSizePayloadProbeSizeInBytes, maximumZipTextEntrySizeInBytes, maximumNestedGzipDetectionSizeInBytes, maximumNestedGzipProbeDepth = 1, unknownSizeGzipProbeTimeoutInMilliseconds = 100, maximumId3HeaderSizeInBytes, maximumEbmlDocumentTypeSizeInBytes = 64, maximumEbmlElementPayloadSizeInBytes, maximumEbmlElementCount = 256, maximumPngChunkCount = 512, maximumPngStreamScanBudgetInBytes, maximumAsfHeaderObjectCount = 512, maximumTiffTagCount = 512, maximumDetectionReentryCount = 256, maximumPngChunkSizeInBytes, maximumAsfHeaderPayloadSizeInBytes, maximumTiffStreamIfdOffsetInBytes, maximumTiffIfdOffsetInBytes, recoverableZipErrorMessages, recoverableZipErrorMessagePrefixes, recoverableZipErrorCodes, ParserHardLimitError, zipDataDescriptorSignature = 134695760, zipDataDescriptorLengthInBytes = 16, zipDataDescriptorOverlapLengthInBytes, supportedExtensions, supportedMimeTypes;
-var init_core2 = __esm(() => {
-  init_lib3();
+var reasonableDetectionSizeInBytes = 4100, maximumMpegOffsetTolerance, maximumNestedGzipDetectionSizeInBytes, maximumNestedGzipProbeDepth = 1, unknownSizeGzipProbeTimeoutInMilliseconds = 100, maximumId3HeaderSizeInBytes, maximumTiffTagCount = 512, maximumDetectionReentryCount = 256, maximumTiffStreamIfdOffsetInBytes, maximumTiffIfdOffsetInBytes, supportedExtensions, supportedMimeTypes;
+var init_source = __esm(() => {
+  init_lib2();
   init_core();
-  init_lib4();
+  init_lib3();
   init_uint8array_extras();
-  init_util();
+  init_tokens();
   init_supported();
+  init_parser();
+  init_zip();
+  init_ebml();
+  init_png();
+  init_asf();
   maximumMpegOffsetTolerance = reasonableDetectionSizeInBytes - 2;
-  maximumZipEntrySizeInBytes = 1024 * 1024;
-  maximumZipBufferedReadSizeInBytes = 2 ** 31 - 1;
-  maximumUntrustedSkipSizeInBytes = 16 * 1024 * 1024;
-  maximumUnknownSizePayloadProbeSizeInBytes = maximumZipEntrySizeInBytes;
-  maximumZipTextEntrySizeInBytes = maximumZipEntrySizeInBytes;
   maximumNestedGzipDetectionSizeInBytes = maximumUntrustedSkipSizeInBytes;
   maximumId3HeaderSizeInBytes = maximumUntrustedSkipSizeInBytes;
-  maximumEbmlElementPayloadSizeInBytes = maximumUnknownSizePayloadProbeSizeInBytes;
-  maximumPngStreamScanBudgetInBytes = maximumUntrustedSkipSizeInBytes;
-  maximumPngChunkSizeInBytes = maximumUnknownSizePayloadProbeSizeInBytes;
-  maximumAsfHeaderPayloadSizeInBytes = maximumUnknownSizePayloadProbeSizeInBytes;
-  maximumTiffStreamIfdOffsetInBytes = maximumUnknownSizePayloadProbeSizeInBytes;
+  maximumTiffStreamIfdOffsetInBytes = 1024 * 1024;
   maximumTiffIfdOffsetInBytes = maximumUntrustedSkipSizeInBytes;
-  recoverableZipErrorMessages = new Set([
-    "Unexpected signature",
-    "Encrypted ZIP",
-    "Expected Central-File-Header signature"
-  ]);
-  recoverableZipErrorMessagePrefixes = [
-    "ZIP entry count exceeds ",
-    "Unsupported ZIP compression method:",
-    "ZIP entry compressed data exceeds ",
-    "ZIP entry decompressed data exceeds ",
-    "Expected data-descriptor-signature at position "
-  ];
-  recoverableZipErrorCodes = new Set([
-    "Z_BUF_ERROR",
-    "Z_DATA_ERROR",
-    "ERR_INVALID_STATE"
-  ]);
-  ParserHardLimitError = class ParserHardLimitError extends Error {
-  };
-  zipDataDescriptorOverlapLengthInBytes = zipDataDescriptorLengthInBytes - 1;
-  ZipHandler.prototype.inflate = async function(zipHeader, fileData, callback) {
-    if (zipHeader.compressedMethod === 0) {
-      return callback(fileData);
-    }
-    if (zipHeader.compressedMethod !== 8) {
-      throw new Error(`Unsupported ZIP compression method: ${zipHeader.compressedMethod}`);
-    }
-    const uncompressedData = await decompressDeflateRawWithLimit(fileData, { maximumLength: maximumZipEntrySizeInBytes });
-    return callback(uncompressedData);
-  };
-  ZipHandler.prototype.unzip = async function(fileCallback) {
-    let stop = false;
-    let zipEntryCount = 0;
-    const zipScanStart = this.tokenizer.position;
-    this.knownSizeDescriptorScannedBytes = 0;
-    do {
-      if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, maximumUntrustedSkipSizeInBytes)) {
-        throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
-      }
-      const zipHeader = await this.readLocalFileHeader();
-      if (!zipHeader) {
-        break;
-      }
-      zipEntryCount++;
-      if (zipEntryCount > maximumZipEntryCount) {
-        throw new Error(`ZIP entry count exceeds ${maximumZipEntryCount}`);
-      }
-      const next = fileCallback(zipHeader);
-      stop = Boolean(next.stop);
-      await this.tokenizer.ignore(zipHeader.extraFieldLength);
-      const fileData = await readZipEntryData(this, zipHeader, {
-        shouldBuffer: Boolean(next.handler),
-        maximumDescriptorLength: Math.min(maximumZipEntrySizeInBytes, getRemainingZipScanBudget(this, zipScanStart))
-      });
-      if (next.handler) {
-        await this.inflate(zipHeader, fileData, next.handler);
-      }
-      if (zipHeader.dataDescriptor) {
-        const dataDescriptor = new Uint8Array(zipDataDescriptorLengthInBytes);
-        await this.tokenizer.readBuffer(dataDescriptor);
-        if (UINT32_LE.get(dataDescriptor, 0) !== zipDataDescriptorSignature) {
-          throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - dataDescriptor.length}`);
-        }
-      }
-      if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, maximumUntrustedSkipSizeInBytes)) {
-        throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
-      }
-    } while (!stop);
-  };
   supportedExtensions = new Set(extensions);
   supportedMimeTypes = new Set(mimeTypes);
 });
 
-// ../../node_modules/file-type/index.js
-var exports_file_type = {};
-__export(exports_file_type, {
-  supportedMimeTypes: () => supportedMimeTypes,
-  supportedExtensions: () => supportedExtensions,
-  fileTypeStream: () => fileTypeStream,
-  fileTypeFromTokenizer: () => fileTypeFromTokenizer,
-  fileTypeFromStream: () => fileTypeFromStream,
-  fileTypeFromFile: () => fileTypeFromFile,
-  fileTypeFromBuffer: () => fileTypeFromBuffer,
-  fileTypeFromBlob: () => fileTypeFromBlob,
-  FileTypeParser: () => FileTypeParser2
-});
-import { ReadableStream as WebReadableStream } from "node:stream/web";
-import { pipeline, PassThrough, Readable } from "node:stream";
-import fs from "node:fs/promises";
-import { constants as fileSystemConstants } from "node:fs";
-function isTokenizerStreamBoundsError(error) {
-  if (!(error instanceof RangeError) || error.message !== "offset is out of bounds" || typeof error.stack !== "string") {
-    return false;
-  }
-  return /strtok3[/\\]lib[/\\]stream[/\\]/.test(error.stack);
-}
-async function fileTypeFromFile(path, options) {
-  return new FileTypeParser2(options).fromFile(path, options);
-}
-async function fileTypeFromStream(stream, options) {
-  return new FileTypeParser2(options).fromStream(stream);
-}
-async function fileTypeStream(readableStream, options = {}) {
-  return new FileTypeParser2(options).toDetectionStream(readableStream, options);
-}
-var FileTypeParser2;
-var init_file_type = __esm(() => {
-  init_lib();
-  init_core2();
-  init_core2();
-  FileTypeParser2 = class FileTypeParser2 extends FileTypeParser {
-    async fromStream(stream) {
-      this.options.signal?.throwIfAborted();
-      const tokenizer = await (stream instanceof WebReadableStream ? this.createTokenizerFromWebStream(stream) : fromStream2(stream, this.getTokenizerOptions()));
-      try {
-        return await super.fromTokenizer(tokenizer);
-      } catch (error) {
-        if (isTokenizerStreamBoundsError(error)) {
-          return;
-        }
-        throw error;
-      } finally {
-        if (stream instanceof Readable && !stream.destroyed) {
-          stream.destroy();
-        }
-      }
-    }
-    async fromFile(path) {
-      this.options.signal?.throwIfAborted();
-      const fileHandle = await fs.open(path, fileSystemConstants.O_RDONLY | fileSystemConstants.O_NONBLOCK);
-      const fileStat = await fileHandle.stat();
-      if (!fileStat.isFile()) {
-        await fileHandle.close();
-        return;
-      }
-      const tokenizer = new FileTokenizer(fileHandle, {
-        ...this.getTokenizerOptions(),
-        fileInfo: {
-          path,
-          size: fileStat.size
-        }
-      });
-      return super.fromTokenizer(tokenizer);
-    }
-    async toDetectionStream(readableStream, options = {}) {
-      if (!(readableStream instanceof Readable)) {
-        return super.toDetectionStream(readableStream, options);
-      }
-      const { sampleSize = reasonableDetectionSizeInBytes } = options;
-      const { signal } = this.options;
-      const normalizedSampleSize = normalizeSampleSize(sampleSize);
-      signal?.throwIfAborted();
-      return new Promise((resolve3, reject) => {
-        let isSettled = false;
-        const cleanup = () => {
-          readableStream.off("error", onError);
-          readableStream.off("readable", onReadable);
-          signal?.removeEventListener("abort", onAbort);
-        };
-        const settle = (callback, value) => {
-          if (isSettled) {
-            return;
-          }
-          isSettled = true;
-          cleanup();
-          callback(value);
-        };
-        const onError = (error) => {
-          settle(reject, error);
-        };
-        const onAbort = () => {
-          if (!readableStream.destroyed) {
-            readableStream.destroy();
-          }
-          settle(reject, signal.reason);
-        };
-        const onReadable = () => {
-          (async () => {
-            try {
-              const pass = new PassThrough;
-              const outputStream = pipeline ? pipeline(readableStream, pass, () => {
-              }) : readableStream.pipe(pass);
-              const chunk = readableStream.read(normalizedSampleSize) ?? readableStream.read() ?? new Uint8Array(0);
-              try {
-                pass.fileType = await this.fromBuffer(chunk);
-              } catch (error) {
-                if (error instanceof EndOfStreamError) {
-                  pass.fileType = undefined;
-                } else {
-                  settle(reject, error);
-                }
-              }
-              settle(resolve3, outputStream);
-            } catch (error) {
-              settle(reject, error);
-            }
-          })();
-        };
-        readableStream.on("error", onError);
-        readableStream.once("readable", onReadable);
-        signal?.addEventListener("abort", onAbort, { once: true });
-      });
-    }
-  };
-});
-
 // ../../node_modules/cookie/dist/index.js
 var require_dist3 = __commonJS((exports) => {
   function parseCookie(str, options) {
@@ -27511,7 +27490,7 @@ var import_chokidar = __toESM(require_chokidar(), 1);
 var import_picocolors = __toESM(require_picocolors(), 1);
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
-import * as fs2 from "node:fs/promises";
+import * as fs from "node:fs/promises";
 import path from "node:path";
 import { TextDecoder as TextDecoder2 } from "node:util";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -37016,7 +36995,7 @@ var _fileTypeFromBlobWarn = false;
 var warnIfFileTypeIsNotInstalled = () => {
   _fileTypeFromBlobWarn || (console.warn("[Elysia] Attempt to validate file type without 'file-type'. This may lead to security risks. We recommend installing 'file-type' to properly validate file extension."), _fileTypeFromBlobWarn = true);
 };
-var loadFileType = async () => Promise.resolve().then(() => (init_file_type(), exports_file_type)).then((x) => (_fileTypeFromBlob = x.fileTypeFromBlob, _fileTypeFromBlob)).catch(warnIfFileTypeIsNotInstalled);
+var loadFileType = async () => Promise.resolve().then(() => (init_source(), exports_source)).then((x) => (_fileTypeFromBlob = x.fileTypeFromBlob, _fileTypeFromBlob)).catch(warnIfFileTypeIsNotInstalled);
 var _fileTypeFromBlob;
 var fileTypeFromBlob2 = (file) => _fileTypeFromBlob ? _fileTypeFromBlob(file) : loadFileType().then((mod) => {
   if (mod)
@@ -44294,7 +44273,7 @@ async function handleBuild(options) {
     const entryPath = path.resolve(manifestInfo.manifestDir, contract.entry);
     const outFilePath = path.resolve(manifestInfo.manifestDir, contract.outFile);
     await ensureEntryExists(entryPath, contract.name);
-    await fs2.mkdir(path.dirname(outFilePath), { recursive: true });
+    await fs.mkdir(path.dirname(outFilePath), { recursive: true });
     const relEntry = path.relative(process.cwd(), entryPath) || entryPath;
     const relOutFile = path.relative(process.cwd(), outFilePath) || outFilePath;
     console.log(`- bundling ${contract.name} (${relEntry})`);
@@ -44312,7 +44291,7 @@ async function handleBuild(options) {
 async function handlePublish(options) {
   const scriptPath = path.resolve(process.cwd(), options.script);
   await ensureFileExists(scriptPath, "script");
-  const script = await fs2.readFile(scriptPath, "utf8");
+  const script = await fs.readFile(scriptPath, "utf8");
   const msg = options.msg ? await loadMsgPayload(options.msg) : undefined;
   const baseUrl = resolveDoneHttpBase(options.http);
   const backend = new DoneBackendClient({ baseUrl });
@@ -44336,7 +44315,7 @@ async function detectWorkspace(root) {
   if (!existsSync2(configPath)) {
     return null;
   }
-  const configRaw = await fs2.readFile(configPath, "utf8");
+  const configRaw = await fs.readFile(configPath, "utf8");
   const config2 = JSON.parse(configRaw);
   const configuredManifestPath = config2.contractsFile ? path.isAbsolute(config2.contractsFile) ? config2.contractsFile : path.resolve(root, config2.contractsFile) : path.join(root, "done.json");
   const fallbackManifestPath = path.join(root, "done.json");
@@ -44344,7 +44323,7 @@ async function detectWorkspace(root) {
   if (!manifestPath) {
     return null;
   }
-  const manifestRaw = await fs2.readFile(manifestPath, "utf8");
+  const manifestRaw = await fs.readFile(manifestPath, "utf8");
   const manifest = JSON.parse(manifestRaw);
   return { root, manifestPath, configPath, manifest, config: config2 };
 }
@@ -44377,7 +44356,7 @@ async function findWorkspace(startDir) {
 async function readManifest(manifestPath) {
   let raw;
   try {
-    raw = await fs2.readFile(manifestPath, "utf8");
+    raw = await fs.readFile(manifestPath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new Error(`Could not find ${manifestPath}. Pass a valid --contracts path or run from a Done workspace.`);
@@ -44401,7 +44380,7 @@ async function scaffoldWorkspace(rawName, options) {
   await prepareTargetDir(targetDir, options.force === true);
   const localTemplatePath = await resolveLocalTemplate(templateRef);
   if (localTemplatePath) {
-    await fs2.cp(localTemplatePath, targetDir, { recursive: true });
+    await fs.cp(localTemplatePath, targetDir, { recursive: true });
   } else {
     await runCommand("git", ["clone", "--depth", "1", templateRef, targetDir]);
   }
@@ -44433,7 +44412,7 @@ async function scaffoldContract(workspace, rawName, options) {
   const contractsDir = resolveContractsDir(workspace.root, workspace.config.contractsDir);
   const contractDir = path.join(contractsDir, slug);
   await ensureDirAvailable(contractDir, options.force === true);
-  await fs2.mkdir(path.join(contractDir, "src"), { recursive: true });
+  await fs.mkdir(path.join(contractDir, "src"), { recursive: true });
   const pkgJsonPath = path.join(contractDir, "package.json");
   const pkgJson = {
     name: slug,
@@ -44506,7 +44485,7 @@ export default Done.serve()
     },
   );
 `;
-  await fs2.writeFile(path.join(contractDir, "src", "index.ts"), contractSource, "utf8");
+  await fs.writeFile(path.join(contractDir, "src", "index.ts"), contractSource, "utf8");
   workspace.manifest.contracts ??= [];
   const contractDirRel = normalizeJsonPath(path.relative(workspace.root, contractDir));
   const entry = ensureDotSlash(`${contractDirRel}/src/index.ts`);
@@ -44537,7 +44516,7 @@ export default Done.serve()
 async function resolveLocalTemplate(reference) {
   const potentialPath = path.isAbsolute(reference) ? reference : path.resolve(process.cwd(), reference);
   try {
-    const stats = await fs2.stat(potentialPath);
+    const stats = await fs.stat(potentialPath);
     if (stats.isDirectory()) {
       return potentialPath;
     }
@@ -44552,7 +44531,7 @@ async function prepareTargetDir(targetDir, force) {
   if (!force) {
     throw new Error(`Directory '${path.relative(process.cwd(), targetDir) || targetDir}' already exists. Use --force to overwrite.`);
   }
-  await fs2.rm(targetDir, { recursive: true, force: true });
+  await fs.rm(targetDir, { recursive: true, force: true });
 }
 async function ensureDirAvailable(targetDir, force) {
   if (!existsSync2(targetDir)) {
@@ -44561,10 +44540,10 @@ async function ensureDirAvailable(targetDir, force) {
   if (!force) {
     throw new Error(`Directory '${path.relative(process.cwd(), targetDir) || targetDir}' already exists. Use --force to overwrite.`);
   }
-  await fs2.rm(targetDir, { recursive: true, force: true });
+  await fs.rm(targetDir, { recursive: true, force: true });
 }
 async function removeGitFolder(targetDir) {
-  await fs2.rm(path.join(targetDir, ".git"), { recursive: true, force: true });
+  await fs.rm(path.join(targetDir, ".git"), { recursive: true, force: true });
 }
 function resolveContractsDir(root, configured) {
   if (!configured) {
@@ -44577,7 +44556,7 @@ function resolveContractsDir(root, configured) {
 }
 async function updatePackageJson(file2, mutator) {
   try {
-    const current = JSON.parse(await fs2.readFile(file2, "utf8"));
+    const current = JSON.parse(await fs.readFile(file2, "utf8"));
     mutator(current);
     await writeJson(file2, current);
   } catch (error) {
@@ -44625,7 +44604,7 @@ async function syncWorkspaceDependencyVersions(targetDir) {
 async function updateContractDependencyVersions(contractsDir) {
   let entries;
   try {
-    entries = await fs2.readdir(contractsDir, { withFileTypes: true });
+    entries = await fs.readdir(contractsDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -44678,7 +44657,7 @@ function escapeRegExp(value) {
 }
 async function ensureEntryExists(entryPath, contractName) {
   try {
-    const stats = await fs2.stat(entryPath);
+    const stats = await fs.stat(entryPath);
     if (!stats.isFile()) {
       const relPath = path.relative(process.cwd(), entryPath) || entryPath;
       throw new Error(`Entry path for contract '${contractName}' is not a file (${relPath})`);
@@ -44693,7 +44672,7 @@ async function ensureEntryExists(entryPath, contractName) {
 }
 async function ensureFileExists(filePath, label) {
   try {
-    const stats = await fs2.stat(filePath);
+    const stats = await fs.stat(filePath);
     if (!stats.isFile()) {
       throw new Error(`The ${label} path is not a file (${filePath})`);
     }
@@ -44707,7 +44686,7 @@ async function ensureFileExists(filePath, label) {
 async function loadMsgPayload(input) {
   const potentialPath = path.resolve(process.cwd(), input);
   if (await pathExists(potentialPath)) {
-    const raw = await fs2.readFile(potentialPath, "utf8");
+    const raw = await fs.readFile(potentialPath, "utf8");
     return JSON.parse(raw);
   }
   return JSON.parse(input);
@@ -44717,7 +44696,7 @@ function resolveDoneHttpBase(override) {
 }
 async function pathExists(candidate) {
   try {
-    await fs2.access(candidate);
+    await fs.access(candidate);
     return true;
   } catch {
     return false;
@@ -44746,7 +44725,7 @@ async function runBunBuild(entryPath, outFilePath) {
       throw new Error("Bun.build did not emit an output file");
     }
     const bundledSource = await output2.text();
-    await fs2.writeFile(outFilePath, bundledSource);
+    await fs.writeFile(outFilePath, bundledSource);
     return;
   }
   await runBunCliBuild(entryPath, outFilePath);
@@ -44807,7 +44786,7 @@ function toContractName(slug) {
 }
 async function writeJson(file2, data) {
   const json = JSON.stringify(data, null, 2);
-  await fs2.writeFile(file2, `${json}\n`, "utf8");
+  await fs.writeFile(file2, `${json}\n`, "utf8");
 }
 function describeStorageEntry(entry) {
   const valueBase64 = entry.value ?? "";
@@ -44914,15 +44893,15 @@ function resolveDevConfig(workspace) {
   };
 }
 async function writeDevEnvFile(file2, entries) {
-  await fs2.mkdir(path.dirname(file2), { recursive: true });
+  await fs.mkdir(path.dirname(file2), { recursive: true });
   const lines = ["# generated by done dev", `# ${new Date().toISOString()}`];
   for (const key of Object.keys(entries).sort()) {
     lines.push(`${key}=${entries[key]}`);
   }
-  await fs2.writeFile(file2, `${lines.join("\n")}\n`, "utf8");
+  await fs.writeFile(file2, `${lines.join("\n")}\n`, "utf8");
 }
 async function readDevEnvFile(file2) {
-  const data = await fs2.readFile(file2, "utf8");
+  const data = await fs.readFile(file2, "utf8");
   const entries = {};
   for (const line of data.split(/\r?\n/)) {
     if (!line || line.startsWith("#"))
@@ -44936,7 +44915,7 @@ async function readDevEnvFile(file2) {
 }
 async function readStorageSnapshot(file2) {
   try {
-    const raw = await fs2.readFile(file2, "utf8");
+    const raw = await fs.readFile(file2, "utf8");
     return JSON.parse(raw);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -45188,7 +45167,7 @@ class DoneDevOrchestrator {
   }
   async buildBundle(contract, initial, reason) {
     await ensureEntryExists(contract.entryPath, contract.name);
-    await fs2.mkdir(path.dirname(contract.outFilePath), { recursive: true });
+    await fs.mkdir(path.dirname(contract.outFilePath), { recursive: true });
     const startedAt = Date.now();
     const label = initial ? "Building" : "Rebuilding";
     this.logInfo(`${label} ${contract.name}${reason ? ` (${reason})` : ""}`);
@@ -45272,7 +45251,7 @@ class DoneDevOrchestrator {
   async publishContract(contract) {
     if (!this.chain || !contract.address)
       return;
-    const script = await fs2.readFile(contract.outFilePath, "utf8");
+    const script = await fs.readFile(contract.outFilePath, "utf8");
     const execResult = this.chain.execute(contract.address, {
       publish_code: {
         script,
@@ -45308,7 +45287,7 @@ class DoneDevOrchestrator {
       entries: entries.map(describeStorageEntry)
     };
     const storageDir = path.join(this.options.workspace.root, ".done", "storage");
-    await fs2.mkdir(storageDir, { recursive: true });
+    await fs.mkdir(storageDir, { recursive: true });
     const filePath = path.join(storageDir, `${contract.slug}.json`);
     await writeJson(filePath, snapshot);
   }